commit 451aeb81a698b86eddd93385d9073b96b72a163e · aylac.top/nixcfg-own-knot

+3 -3

flake.lock

···

       578
       578
        
           "secrets": {

     

       579
       579
        
             "flake": false,

     

       580
       580
        
             "locked": {

     

       581
       581
       -
               "lastModified": 1755232543,

     

       582
       582
       -
               "narHash": "sha256-yPznFCGxCUmrwoImFqJJTujHvxPkv7c6ghZ7Bb0bRHo=",

     

       581
       581
       +
               "lastModified": 1755237741,

     

       582
       582
       +
               "narHash": "sha256-C+CxCeKEIyqqa3LyAU6Eg0JSYiT+EH+DVMUJMBU5ymE=",

     

       583
       583
        
               "owner": "ayla6",

     

       584
       584
        
               "repo": "secrets",

     

       585
       585
       -
               "rev": "51f893aea0469b4a55a20580382426c967803415",

     

       585
       585
       +
               "rev": "bd19c1b8652e12d12580655fad000c44d7cad698",

     

       586
       586
        
               "type": "github"

     

       587
       587
        
             },

     

       588
       588
        
             "original": {

+9 -6

homes/ayla/default.nix

···

       14
       14
        
             home = {

     

       15
       15
        
               packages = with pkgs; [

     

       16
       16
        
                 rclone

     

       17
       17
       +
                 rclone-browser

     

       17
       18
        
               ];

     

       18
       19
        
       

     

       19
       20
        
               username = "ayla";

     

       21
       21
       +
               stateVersion = "25.05";

     

       20
       22
        
             };

     

       21
       23
        
       

     

       22
       24
        
             programs.home-manager.enable = true;

     
···

       30
       32
        
               programs = {

     

       31
       33
        
                 chromium.enable = true;

     

       32
       34
        
                 fastfetch.enable = true;

     

       33
       33
       -
                 firefox.enable = true;

     

       35
       35
       +
                 firefox = {

     

       36
       36
       +
                   enable = true;

     

       37
       37
       +
                   mode = "sidebar";

     

       38
       38
       +
                 };

     

       34
       39
        
                 git.enable = true;

     

       35
       40
        
                 micro.enable = true;

     

       36
       41
        
                 mpv.enable = true;

     
···

       44
       49
        
                 defaultApps = {

     

       45
       50
        
                   enable = true;

     

       46
       51
        
                   forceMimeAssociations = true;

     

       52
       52
       +
                   archiveViewer.package = pkgs.file-roller;

     

       47
       53
        
                   audioPlayer.package = config.programs.mpv.finalPackage;

     

       48
       54
        
                   videoPlayer.package = config.programs.mpv.finalPackage;

     

       49
       55
        
                   editor.package = pkgs.gnome-text-editor;

     
···

       65
       71
        
                 fonts.enable = false;

     

       66
       72
        
               };

     

       67
       73
        
             };

     

       74
       74
       +
       

     

       75
       75
       +
             systemd.user.startServices = true; # Needed for auto-mounting agenix secrets.

     

       68
       76
        
           }

     

       69
       77
        
       

     

       70
       78
        
           (lib.mkIf pkgs.stdenv.isLinux {

     
···

       119
       127
        
                 prismlauncher

     

       120
       128
        
                 mindustry

     

       121
       129
        
               ];

     

       122
       122
       -
       

     

       123
       123
       -
               stateVersion = "25.05";

     

       124
       124
       -
               username = "ayla";

     

       125
       130
        
             };

     

       126
       126
       -
       

     

       127
       127
       -
             systemd.user.startServices = true; # Needed for auto-mounting agenix secrets.

     

       128
       131
        
           })

     

       129
       132
        
         ];

     

       130
       133
        
       }

hosts/morgana/secrets.nix

···

       3
       3
        
           tailscaleAuthKey.file = "${self.inputs.secrets}/tailscale/auth.age";

     

       4
       4
        
           syncthingCert.file = "${self.inputs.secrets}/ayla/syncthing/morgana/cert.age";

     

       5
       5
        
           syncthingKey.file = "${self.inputs.secrets}/ayla/syncthing/morgana/key.age";

     

       6
       6
       +
           rclone.file = "${self.inputs.secrets}/rclone.age";

     

       6
       7
        
         };

     

       7
       8
        
       }

hosts/nanpi/services.nix

···

       46
       46
        
             };

     

       47
       47
        
           };

     

       48
       48
        
       

     

       49
       49
       +
           # it's failing to build because it can't download some stuff

     

       50
       50
       +
           # immich = {

     

       51
       51
       +
           #   enable = true;

     

       52
       52
       +
           #   host = "0.0.0.0";

     

       53
       53
       +
           #   mediaLocation = "${dataDirectory}/immich";

     

       54
       54
       +
           #   openFirewall = true;

     

       55
       55
       +
           #   inherit (config.mySnippets.tailnet.networkMap.immich) port;

     

       56
       56
       +
           # };

     

       57
       57
       +
       

     

       49
       58
        
           jellyfin = {

     

       50
       59
        
             enable = true;

     

       51
       60
        
             openFirewall = true;

modules/home/desktop/gnome/default.nix

···

       20
       20
        
                       or (lib.getExe config.programs.firefox.finalPackage);

     

       21
       21
        
                 fileManager = config.myHome.profiles.defaultApps.fileManager.exec or (lib.getExe pkgs.nautilus);

     

       22
       22
        
                 editor = config.myHome.profiles.defaultApps.editor.exec or (lib.getExe pkgs.gnome-text-editor);

     

       23
       23
       +
                 archiveViewer = config.myHome.profiles.defaultApps.archiveViewer.exec or (lib.getExe pkgs.file-roller);

     

       23
       24
        
               };

     

       24
       25
        
             in {

     

       25
       26
        
               "org/gnome/desktop/datetime".automatic-timezone = true;

+29 -6

modules/home/profiles/defaultApps/default.nix

···

       11
       11
        
           enable = lib.mkEnableOption "enforce default applications";

     

       12
       12
        
           forceMimeAssociations = lib.mkEnableOption "force mime associations for defaultApps";

     

       13
       13
        
       

     

       14
       14
       +
           archiveViewer = {

     

       15
       15
       +
             package = lib.mkOption {

     

       16
       16
       +
               type = lib.types.package;

     

       17
       17
       +
               default = pkgs.nemo;

     

       18
       18
       +
               description = "The default archive viewer package.";

     

       19
       19
       +
             };

     

       20
       20
       +
       

     

       21
       21
       +
             exec = lib.mkOption {

     

       22
       22
       +
               type = lib.types.str;

     

       23
       23
       +
               default = lib.getExe cfg.archiveViewer.package;

     

       24
       24
       +
               description = "The executable path for the default archive viewer.";

     

       25
       25
       +
             };

     

       26
       26
       +
           };

     

       27
       27
       +
       

     

       14
       28
        
           audioPlayer = {

     

       15
       29
        
             package = lib.mkOption {

     

       16
       30
        
               type = lib.types.package;

     
···

       169
       183
        
           };

     

       170
       184
        
       

     

       171
       185
        
           xdg = {

     

       172
       172
       -
             configFile."xfce4/helpers.rc".text = ''

     

       173
       173
       -
               FileManager=${builtins.baseNameOf cfg.fileManager.exec}

     

       174
       174
       -
               TerminalEmulator=${builtins.baseNameOf cfg.terminal.exec}

     

       175
       175
       -
               WebBrowser=${builtins.baseNameOf cfg.webBrowser.exec}

     

       176
       176
       -
             '';

     

       186
       186
       +
             configFile = {

     

       187
       187
       +
               "xfce4/helpers.rc".text = ''

     

       188
       188
       +
                 FileManager=${builtins.baseNameOf cfg.fileManager.exec}

     

       189
       189
       +
                 TerminalEmulator=${builtins.baseNameOf cfg.terminal.exec}

     

       190
       190
       +
                 WebBrowser=${builtins.baseNameOf cfg.webBrowser.exec}

     

       191
       191
       +
               '';

     

       192
       192
       +
               "mimeapps.list" = lib.mkIf cfg.forceMimeAssociations {

     

       193
       193
       +
                 force = true;

     

       194
       194
       +
               };

     

       195
       195
       +
             };

     

       177
       196
        
       

     

       178
       197
        
             mimeApps = lib.mkIf cfg.forceMimeAssociations {

     

       179
       198
        
               enable = true;

     
···

       195
       214
        
                 imageTypes = mkDefaults mimeTypes.imageFiles "defaultImageViewer.desktop";

     

       196
       215
        
       

     

       197
       216
        
                 videoTypes = mkDefaults mimeTypes.videoFiles "defaultVideoPlayer.desktop";

     

       217
       217
       +
       

     

       218
       218
       +
                 archiveTypes = mkDefaults mimeTypes.archiveFiles "defaultArchiveViewer.desktop";

     

       198
       219
        
               in

     

       199
       220
        
                 audioTypes

     

       200
       221
        
                 // browserTypes

     
···

       202
       223
        
                 // editorTypes

     

       203
       224
        
                 // folderTypes

     

       204
       225
        
                 // imageTypes

     

       205
       205
       -
                 // videoTypes;

     

       226
       226
       +
                 // videoTypes

     

       227
       227
       +
                 // archiveTypes;

     

       206
       228
        
             };

     

       207
       229
        
       

     

       208
       230
        
             desktopEntries = let

     
···

       225
       247
        
                 defaultPdfViewer = mkDefaultEntry "PDF Viewer" cfg.pdfViewer.exec;

     

       226
       248
        
                 defaultVideoPlayer = mkDefaultEntry "Video Player" cfg.videoPlayer.exec;

     

       227
       249
        
                 defaultWebBrowser = mkDefaultEntry "Web Browser" cfg.webBrowser.exec;

     

       250
       250
       +
                 defaultArchiveViewer = mkDefaultEntry "Archive Viewer" cfg.archiveViewer.exec;

     

       228
       251
        
               };

     

       229
       252
        
           };

     

       230
       253
        
         };

+22

modules/home/profiles/defaultApps/mimeTypes.nix

···

       217
       217
        
           "video/x-theora+ogg"

     

       218
       218
        
           "x-content/video-dvd"

     

       219
       219
        
         ];

     

       220
       220
       +
       

     

       221
       221
       +
         archiveFiles = [

     

       222
       222
       +
           "application/gzip"

     

       223
       223
       +
           "application/vnd.rar"

     

       224
       224
       +
           "application/x-7z-compressed"

     

       225
       225
       +
           "application/x-bzip"

     

       226
       226
       +
           "application/x-bzip2"

     

       227
       227
       +
           "application/x-compress"

     

       228
       228
       +
           "application/x-cpio"

     

       229
       229
       +
           "application/x-deb"

     

       230
       230
       +
           "application/x-gtar"

     

       231
       231
       +
           "application/x-gzip"

     

       232
       232
       +
           "application/x-lha"

     

       233
       233
       +
           "application/x-lzh"

     

       234
       234
       +
           "application/x-lzma"

     

       235
       235
       +
           "application/x-rar"

     

       236
       236
       +
           "application/x-rpm"

     

       237
       237
       +
           "application/x-tar"

     

       238
       238
       +
           "application/x-xz"

     

       239
       239
       +
           "application/x-zip-compressed"

     

       240
       240
       +
           "application/zip"

     

       241
       241
       +
         ];

     

       220
       242
        
       }

+121 -86

modules/home/programs/firefox/default.nix

···

       7
       7
        
       }: let

     

       8
       8
        
         engines = import ./engines.nix;

     

       9
       9
        
       in {

     

       10
       10
       -
         options.myHome.programs.firefox.enable = lib.mkEnableOption "firefox web browser";

     

       10
       10
       +
         options.myHome.programs.firefox = {

     

       11
       11
       +
           enable = lib.mkEnableOption "firefox web browser";

     

       12
       12
       +
           mode = lib.mkOption {

     

       13
       13
       +
             type = lib.types.enum ["onebar" "sidebar" "default"];

     

       14
       14
       +
             default = "onebar";

     

       15
       15
       +
             description = "Firefox UI mode";

     

       16
       16
       +
           };

     

       17
       17
       +
         };

     

       11
       18
        
       

     

       12
       12
       -
         config = lib.mkIf config.myHome.programs.firefox.enable {

     

       13
       13
       -
           programs.firefox = {

     

       14
       14
       -
             enable = true;

     

       15
       15
       -
             languagePacks = [

     

       16
       16
       -
               "en-GB"

     

       17
       17
       -
               "en"

     

       18
       18
       -
               "en-US"

     

       19
       19
       -
             ];

     

       19
       19
       +
         config.programs.firefox = lib.mkMerge [

     

       20
       20
       +
           (lib.mkIf

     

       21
       21
       +
             config.myHome.programs.firefox.enable

     

       22
       22
       +
             {

     

       23
       23
       +
               enable = true;

     

       24
       24
       +
               languagePacks = [

     

       25
       25
       +
                 "en-GB"

     

       26
       26
       +
                 "en"

     

       27
       27
       +
                 "en-US"

     

       28
       28
       +
               ];

     

       20
       29
        
       

     

       21
       21
       -
             profiles = {

     

       22
       22
       -
               default = {

     

       23
       23
       -
                 id = 0;

     

       24
       24
       -
                 isDefault = true;

     

       30
       30
       +
               profiles = {

     

       31
       31
       +
                 default = {

     

       32
       32
       +
                   id = 0;

     

       33
       33
       +
                   isDefault = true;

     

       25
       34
        
       

     

       26
       26
       -
                 extensions.packages = with pkgs.nur.repos.rycee.firefox-addons; [

     

       27
       27
       -
                   consent-o-matic

     

       28
       28
       -
                   ublock-origin

     

       29
       29
       -
                   aria2-integration

     

       30
       30
       -
                   adaptive-tab-bar-colour

     

       31
       31
       -
                   keepassxc-browser

     

       32
       32
       -
                   libredirect

     

       33
       33
       -
                   stylus

     

       34
       34
       -
                   violentmonkey

     

       35
       35
       -
                   ublacklist

     

       36
       36
       -
                   steam-database

     

       37
       37
       -
                   snowflake

     

       38
       38
       -
                   sponsorblock

     

       39
       39
       -
                   search-by-image

     

       40
       40
       -
                   ff2mpv

     

       41
       41
       -
                 ];

     

       35
       35
       +
                   extensions.packages = with pkgs.nur.repos.rycee.firefox-addons; [

     

       36
       36
       +
                     consent-o-matic

     

       37
       37
       +
                     ublock-origin

     

       38
       38
       +
                     aria2-integration

     

       39
       39
       +
                     adaptive-tab-bar-colour

     

       40
       40
       +
                     keepassxc-browser

     

       41
       41
       +
                     libredirect

     

       42
       42
       +
                     stylus

     

       43
       43
       +
                     violentmonkey

     

       44
       44
       +
                     ublacklist

     

       45
       45
       +
                     steam-database

     

       46
       46
       +
                     snowflake

     

       47
       47
       +
                     sponsorblock

     

       48
       48
       +
                     search-by-image

     

       49
       49
       +
                     ff2mpv

     

       50
       50
       +
                   ];

     

       42
       51
        
       

     

       43
       43
       -
                 search = {

     

       44
       44
       -
                   inherit engines;

     

       45
       45
       -
                   default = "Unduck";

     

       46
       46
       -
                   force = true;

     

       52
       52
       +
                   search = {

     

       53
       53
       +
                     inherit engines;

     

       54
       54
       +
                     default = "Unduck";

     

       55
       55
       +
                     force = true;

     

       47
       56
        
       

     

       48
       48
       -
                   order = [

     

       49
       49
       -
                     "Unduck"

     

       50
       50
       -
                     "Home Manager Options"

     

       51
       51
       -
                     "NixOS Wiki"

     

       52
       52
       -
                     "nixpkgs"

     

       53
       53
       -
                     "Wikipedia"

     

       54
       54
       -
                     "Wiktionary"

     

       55
       55
       -
                   ];

     

       57
       57
       +
                     order = [

     

       58
       58
       +
                       "Unduck"

     

       59
       59
       +
                       "Home Manager Options"

     

       60
       60
       +
                       "NixOS Wiki"

     

       61
       61
       +
                       "nixpkgs"

     

       62
       62
       +
                       "Wikipedia"

     

       63
       63
       +
                       "Wiktionary"

     

       64
       64
       +
                     ];

     

       65
       65
       +
                   };

     

       66
       66
       +
       

     

       67
       67
       +
                   settings =

     

       68
       68
       +
                     (import ./betterfox/fastfox.nix)

     

       69
       69
       +
                     // (import ./betterfox/peskyfox.nix)

     

       70
       70
       +
                     // (import ./betterfox/securefox.nix)

     

       71
       71
       +
                     // (import ./betterfox/smoothfox.nix)

     

       72
       72
       +
                     // {

     

       73
       73
       +
                       "browser.tabs.groups.enabled" = true;

     

       74
       74
       +
                       "browser.tabs.groups.smart.enabled" = true;

     

       75
       75
       +
                       "browser.toolbars.bookmarks.visibility" = "newtab";

     

       76
       76
       +
                       "svg.context-properties.content.enabled" = true;

     

       77
       77
       +
                       "browser.uidensity" = 1;

     

       78
       78
       +
                       "general.autoScroll" = true;

     

       79
       79
       +
                       "ui.key.menuAccessKeyFocuses" = false;

     

       80
       80
       +
                       "browser.search.separatePrivateDefault" = false;

     

       81
       81
       +
                       "media.videocontrols.picture-in-picture.video-toggle.enabled" = false;

     

       82
       82
       +
                       "browser.ml.chat.sidebar" = false;

     

       83
       83
       +
                     };

     

       84
       84
       +
       

     

       85
       85
       +
                   userContent = ''

     

       86
       86
       +
                     @font-face {

     

       87
       87
       +
                         font-family: "Segoe UI";

     

       88
       88
       +
                         src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       89
       89
       +
                     }

     

       90
       90
       +
                     @font-face {

     

       91
       91
       +
                         font-family: "system-ui";

     

       92
       92
       +
                         src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       93
       93
       +
                     }

     

       94
       94
       +
                     @font-face {

     

       95
       95
       +
                         font-family: "-apple-system";

     

       96
       96
       +
                         src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       97
       97
       +
                     }

     

       98
       98
       +
                     @font-face {

     

       99
       99
       +
                         font-family: "BlinkMacSystemFont";

     

       100
       100
       +
                         src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       101
       101
       +
                     }

     

       102
       102
       +
                   '';

     

       56
       103
        
                 };

     

       104
       104
       +
               };

     

       105
       105
       +
             })

     

       57
       106
        
       

     

       58
       58
       -
                 settings =

     

       59
       59
       -
                   (import ./betterfox/fastfox.nix)

     

       60
       60
       -
                   // (import ./betterfox/peskyfox.nix)

     

       61
       61
       -
                   // (import ./betterfox/securefox.nix)

     

       62
       62
       -
                   // (import ./betterfox/smoothfox.nix)

     

       63
       63
       -
                   // {

     

       64
       64
       -
                     "browser.tabs.groups.enabled" = true;

     

       65
       65
       -
                     "browser.tabs.groups.smart.enabled" = true;

     

       66
       66
       -
                     "browser.toolbars.bookmarks.visibility" = "newtab";

     

       67
       67
       -
                     "svg.context-properties.content.enabled" = true;

     

       68
       68
       -
                     "browser.uidensity" = 1;

     

       69
       69
       -
                     "general.autoScroll" = true;

     

       70
       70
       -
                     "ui.key.menuAccessKeyFocuses" = false;

     

       71
       71
       -
                     "browser.search.separatePrivateDefault" = false;

     

       72
       72
       -
                     "media.videocontrols.picture-in-picture.video-toggle.enabled" = false;

     

       73
       73
       -
       

     

       74
       74
       -
                     # OneBar settings

     

       75
       75
       -
                     "onebar.collapse-URLbar" = true;

     

       76
       76
       -
                     "onebar.conditional-navigation-buttons" = false;

     

       77
       77
       -
                     "onebar.hide-all-URLbar-icons" = true;

     

       78
       78
       -
                   };

     

       107
       107
       +
           (lib.mkIf

     

       108
       108
       +
             (config.myHome.programs.firefox.mode == "onebar")

     

       109
       109
       +
             {

     

       110
       110
       +
               profiles.default = {

     

       111
       111
       +
                 settings = {

     

       112
       112
       +
                   "onebar.collapse-URLbar" = true;

     

       113
       113
       +
                   "onebar.conditional-navigation-buttons" = false;

     

       114
       114
       +
                   "onebar.hide-all-URLbar-icons" = true;

     

       115
       115
       +
                 };

     

       79
       116
        
       

     

       80
       117
        
                 userChrome = builtins.readFile self.inputs.firefox-onebar;

     

       118
       118
       +
               };

     

       119
       119
       +
             })

     

       81
       120
        
       

     

       82
       82
       -
                 userContent = ''

     

       83
       83
       -
                   @font-face {

     

       84
       84
       -
                       font-family: "Segoe UI";

     

       85
       85
       -
                       src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       86
       86
       -
                   }

     

       87
       87
       -
                   @font-face {

     

       88
       88
       -
                       font-family: "system-ui";

     

       89
       89
       -
                       src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       90
       90
       -
                   }

     

       91
       91
       -
                   @font-face {

     

       92
       92
       -
                       font-family: "-apple-system";

     

       93
       93
       -
                       src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       94
       94
       -
                   }

     

       95
       95
       -
                   @font-face {

     

       96
       96
       -
                       font-family: "BlinkMacSystemFont";

     

       97
       97
       -
                       src: url("${pkgs.roboto-flex}/share/fonts/truetype/RobotoFlex[GRAD,XOPQ,XTRA,YOPQ,YTAS,YTDE,YTFI,YTLC,YTUC,opsz,slnt,wdth,wght].ttf");

     

       98
       98
       -
                   }

     

       99
       99
       -
                 '';

     

       121
       121
       +
           (lib.mkIf

     

       122
       122
       +
             (config.myHome.programs.firefox.mode == "sidebar")

     

       123
       123
       +
             {

     

       124
       124
       +
               profiles.default = {

     

       125
       125
       +
                 settings = {

     

       126
       126
       +
                   "sidebar.revamp" = true;

     

       127
       127
       +
                   "sidebar.verticalTabs" = true;

     

       128
       128
       +
                 };

     

       100
       129
        
               };

     

       101
       101
       -
               test = {

     

       102
       102
       -
                 id = 1;

     

       103
       103
       -
                 isDefault = false;

     

       130
       130
       +
             })

     

       131
       131
       +
       

     

       132
       132
       +
           (lib.mkIf

     

       133
       133
       +
             (config.myHome.programs.firefox.mode != "sidebar")

     

       134
       134
       +
             {

     

       135
       135
       +
               profiles.default = {

     

       136
       136
       +
                 settings = {

     

       137
       137
       +
                   "sidebar.revamp" = false;

     

       138
       138
       +
                   "sidebar.verticalTabs" = false;

     

       139
       139
       +
                 };

     

       104
       140
        
               };

     

       105
       105
       -
             };

     

       106
       106
       -
           };

     

       107
       107
       -
         };

     

       141
       141
       +
             })

     

       142
       142
       +
         ];

     

       108
       143
        
       }

+4 -2

modules/nixos/desktop/gnome/default.nix

···

       14
       14
        
           ];

     

       15
       15
        
       

     

       16
       16
        
           services = {

     

       17
       17
       -
             displayManager.gdm.enable = true;

     

       18
       17
        
             desktopManager.gnome.enable = true;

     

       19
       18
        
           };

     

       20
       19
        
       

     
···

       44
       43
        
             ];

     

       45
       44
        
           };

     

       46
       45
        
       

     

       47
       47
       -
           myNixOS.desktop.enable = true;

     

       46
       46
       +
           myNixOS = {

     

       47
       47
       +
             desktop.enable = true;

     

       48
       48
       +
             services.gdm.enable = true;

     

       49
       49
       +
           };

     

       48
       50
        
       

     

       49
       51
        
           #qt = {

     

       50
       52
        
           #  enable = true;

+38 -36

modules/nixos/profiles/backups/default.nix

···

       4
       4
        
         pkgs,

     

       5
       5
        
         ...

     

       6
       6
        
       }: let

     

       7
       7
       -
         backupDestination = "rclone:gdrive:/backups/${config.networking.hostName}";

     

       8
       8
       -
         mkRepo = service: "${backupDestination}/${service}";

     

       7
       7
       +
         backupDestinationA = "rclone:gdrive:/backups/${config.networking.hostName}";

     

       8
       8
       +
         mkRepoA = service: "${backupDestinationA}/${service}";

     

       9
       9
       +
         #backupDestinationB = "rclone:gdrive:/backups/${config.networking.hostName}";

     

       10
       10
       +
         #mkRepoB = service: "${backupDestinationB}/${service}";

     

       9
       11
        
         stop = service: "${pkgs.systemd}/bin/systemctl stop ${service}";

     

       10
       12
        
         start = service: "${pkgs.systemd}/bin/systemctl start ${service}";

     

       11
       13
        
       in {

     
···

       21
       23
        
                 backupCleanupCommand = start "audiobookshelf";

     

       22
       24
        
                 backupPrepareCommand = stop "audiobookshelf";

     

       23
       25
        
                 paths = [config.services.audiobookshelf.dataDir];

     

       24
       24
       -
                 repository = mkRepo "audiobookshelf";

     

       26
       26
       +
                 repository = mkRepoA "audiobookshelf";

     

       25
       27
        
               }

     

       26
       28
        
             );

     

       27
       29
        
       

     
···

       31
       33
        
                 backupCleanupCommand = start "bazarr";

     

       32
       34
        
                 backupPrepareCommand = stop "bazarr";

     

       33
       35
        
                 paths = [config.services.bazarr.dataDir];

     

       34
       34
       -
                 repository = mkRepo "bazarr";

     

       36
       36
       +
                 repository = mkRepoA "bazarr";

     

       35
       37
        
               }

     

       36
       38
        
             );

     

       37
       39
        
       

     
···

       41
       43
        
                 backupCleanupCommand = start "couchdb";

     

       42
       44
        
                 backupPrepareCommand = stop "couchdb";

     

       43
       45
        
                 paths = [config.services.couchdb.databaseDir];

     

       44
       44
       -
                 repository = mkRepo "couchdb";

     

       46
       46
       +
                 repository = mkRepoA "couchdb";

     

       45
       47
        
               }

     

       46
       48
        
             );

     

       47
       49
        
       

     
···

       49
       51
        
               config.mySnippets.restic

     

       50
       52
        
               // {

     

       51
       53
        
                 paths = [config.services.forgejo.stateDir];

     

       52
       52
       -
                 repository = mkRepo "forgejo";

     

       54
       54
       +
                 repository = mkRepoA "forgejo";

     

       53
       55
        
               }

     

       54
       56
        
             );

     

       55
       57
        
       

     

       56
       56
       -
             immich = lib.mkIf config.services.immich.enable (

     

       57
       57
       -
               config.mySnippets.restic

     

       58
       58
       -
               // {

     

       59
       59
       -
                 backupCleanupCommand = start "immich-server";

     

       60
       60
       -
                 backupPrepareCommand = stop "immich-server";

     

       61
       61
       -
       

     

       62
       62
       -
                 paths = [

     

       63
       63
       -
                   "${config.services.immich.mediaLocation}/library"

     

       64
       64
       -
                   "${config.services.immich.mediaLocation}/profile"

     

       65
       65
       -
                   "${config.services.immich.mediaLocation}/upload"

     

       66
       66
       -
                   "${config.services.immich.mediaLocation}/backups"

     

       67
       67
       -
                 ];

     

       68
       68
       -
       

     

       69
       69
       -
                 repository = mkRepo "immich";

     

       70
       70
       -
               }

     

       71
       71
       -
             );

     

       58
       58
       +
             # immich = lib.mkIf config.services.immich.enable (

     

       59
       59
       +
             #   config.mySnippets.restic

     

       60
       60
       +
             #   // {

     

       61
       61
       +
             #     backupCleanupCommand = start "immich-server";

     

       62
       62
       +
             #     backupPrepareCommand = stop "immich-server";

     

       63
       63
       +
             #

     

       64
       64
       +
             #     paths = [

     

       65
       65
       +
             #       "${config.services.immich.mediaLocation}/library"

     

       66
       66
       +
             #       "${config.services.immich.mediaLocation}/profile"

     

       67
       67
       +
             #       "${config.services.immich.mediaLocation}/upload"

     

       68
       68
       +
             #       "${config.services.immich.mediaLocation}/backups"

     

       69
       69
       +
             #     ];

     

       70
       70
       +
             #

     

       71
       71
       +
             #     repository = mkRepoB "immich";

     

       72
       72
       +
             #   }

     

       73
       73
       +
             # );

     

       72
       74
        
       

     

       73
       75
        
             jellyfin = lib.mkIf config.services.jellyfin.enable (

     

       74
       76
        
               config.mySnippets.restic

     
···

       76
       78
        
                 backupCleanupCommand = start "jellyfin";

     

       77
       79
        
                 backupPrepareCommand = stop "jellyfin";

     

       78
       80
        
                 paths = [config.services.jellyfin.dataDir];

     

       79
       79
       -
                 repository = mkRepo "jellyfin";

     

       81
       81
       +
                 repository = mkRepoA "jellyfin";

     

       80
       82
        
               }

     

       81
       83
        
             );

     

       82
       84
        
       

     
···

       86
       88
        
                 backupCleanupCommand = start "lidarr";

     

       87
       89
        
                 backupPrepareCommand = stop "lidarr";

     

       88
       90
        
                 paths = [config.services.lidarr.dataDir];

     

       89
       89
       -
                 repository = mkRepo "lidarr";

     

       91
       91
       +
                 repository = mkRepoA "lidarr";

     

       90
       92
        
               }

     

       91
       93
        
             );

     

       92
       94
        
       

     
···

       96
       98
        
                 backupCleanupCommand = start "ombi";

     

       97
       99
        
                 backupPrepareCommand = stop "ombi";

     

       98
       100
        
                 paths = [config.services.ombi.dataDir];

     

       99
       99
       -
                 repository = mkRepo "ombi";

     

       101
       101
       +
                 repository = mkRepoA "ombi";

     

       100
       102
        
               }

     

       101
       103
        
             );

     

       102
       104
        
       

     
···

       106
       108
        
                 backupCleanupCommand = start "pds";

     

       107
       109
        
                 backupPrepareCommand = stop "pds";

     

       108
       110
        
                 paths = [config.services.pds.settings.PDS_DATA_DIRECTORY];

     

       109
       109
       -
                 repository = mkRepo "pds";

     

       111
       111
       +
                 repository = mkRepoA "pds";

     

       110
       112
        
               }

     

       111
       113
        
             );

     

       112
       114
        
       

     
···

       117
       119
        
                 backupPrepareCommand = stop "plex";

     

       118
       120
        
                 exclude = ["${config.services.plex.dataDir}/Plex Media Server/Plug-in Support/Databases"];

     

       119
       121
        
                 paths = [config.services.plex.dataDir];

     

       120
       120
       -
                 repository = mkRepo "plex";

     

       122
       122
       +
                 repository = mkRepoA "plex";

     

       121
       123
        
               }

     

       122
       124
        
             );

     

       123
       125
        
       

     
···

       125
       127
        
               config.mySnippets.restic

     

       126
       128
        
               // {

     

       127
       129
        
                 paths = [config.services.postgresql.dataDir];

     

       128
       128
       -
                 repository = mkRepo "postgresql";

     

       130
       130
       +
                 repository = mkRepoA "postgresql";

     

       129
       131
        
               }

     

       130
       132
        
             );

     

       131
       133
        
       

     
···

       135
       137
        
                 backupCleanupCommand = start "prowlarr";

     

       136
       138
        
                 backupPrepareCommand = stop "prowlarr";

     

       137
       139
        
                 paths = [config.services.prowlarr.dataDir];

     

       138
       138
       -
                 repository = mkRepo "prowlarr";

     

       140
       140
       +
                 repository = mkRepoA "prowlarr";

     

       139
       141
        
               }

     

       140
       142
        
             );

     

       141
       143
        
       

     
···

       145
       147
        
                 backupCleanupCommand = start "qbittorrent";

     

       146
       148
        
                 backupPrepareCommand = stop "qbittorrent";

     

       147
       149
        
                 paths = [config.myNixOS.services.qbittorrent.dataDir];

     

       148
       148
       -
                 repository = mkRepo "qbittorrent";

     

       150
       150
       +
                 repository = mkRepoA "qbittorrent";

     

       149
       151
        
               }

     

       150
       152
        
             );

     

       151
       153
        
       

     
···

       155
       157
        
                 backupCleanupCommand = start "radarr";

     

       156
       158
        
                 backupPrepareCommand = stop "radarr";

     

       157
       159
        
                 paths = [config.services.radarr.dataDir];

     

       158
       158
       -
                 repository = mkRepo "radarr";

     

       160
       160
       +
                 repository = mkRepoA "radarr";

     

       159
       161
        
               }

     

       160
       162
        
             );

     

       161
       163
        
       

     
···

       165
       167
        
                 backupCleanupCommand = start "readarr";

     

       166
       168
        
                 backupPrepareCommand = stop "readarr";

     

       167
       169
        
                 paths = [config.services.readarr.dataDir];

     

       168
       168
       -
                 repository = mkRepo "readarr";

     

       170
       170
       +
                 repository = mkRepoA "readarr";

     

       169
       171
        
               }

     

       170
       172
        
             );

     

       171
       173
        
       

     
···

       175
       177
        
                 backupCleanupCommand = start "sonarr";

     

       176
       178
        
                 backupPrepareCommand = stop "sonarr";

     

       177
       179
        
                 paths = [config.services.sonarr.dataDir];

     

       178
       178
       -
                 repository = mkRepo "sonarr";

     

       180
       180
       +
                 repository = mkRepoA "sonarr";

     

       179
       181
        
               }

     

       180
       182
        
             );

     

       181
       183
        
       

     
···

       185
       187
        
                 backupCleanupCommand = start "tautulli";

     

       186
       188
        
                 backupPrepareCommand = stop "tautulli";

     

       187
       189
        
                 paths = [config.services.tautulli.dataDir];

     

       188
       188
       -
                 repository = mkRepo "tautulli";

     

       190
       190
       +
                 repository = mkRepoA "tautulli";

     

       189
       191
        
               }

     

       190
       192
        
             );

     

       191
       193
        
       

     
···

       195
       197
        
                 backupCleanupCommand = start "uptime-kuma";

     

       196
       198
        
                 backupPrepareCommand = stop "uptime-kuma";

     

       197
       199
        
                 paths = ["/var/lib/uptime-kuma"];

     

       198
       198
       -
                 repository = mkRepo "uptime-kuma";

     

       200
       200
       +
                 repository = mkRepoA "uptime-kuma";

     

       199
       201
        
               }

     

       200
       202
        
             );

     

       201
       203
        
       

     
···

       205
       207
        
                 backupCleanupCommand = start "vaultwarden";

     

       206
       208
        
                 backupPrepareCommand = stop "vaultwarden";

     

       207
       209
        
                 paths = ["/var/lib/vaultwarden"];

     

       208
       208
       -
                 repository = mkRepo "vaultwarden";

     

       210
       210
       +
                 repository = mkRepoA "vaultwarden";

     

       209
       211
        
               }

     

       210
       212
        
             );

     

       211
       213
        
           };

+4 -1

modules/nixos/programs/lanzaboote/default.nix

···

       17
       17
        
               sortKey = "lanza";

     

       18
       18
        
             };

     

       19
       19
        
       

     

       20
       20
       -
             loader.systemd-boot.enable = lib.mkForce false;

     

       20
       20
       +
             loader = {

     

       21
       21
       +
               systemd-boot.enable = lib.mkForce false;

     

       22
       22
       +
               timeout = lib.mkDefault 5;

     

       23
       23
       +
             };

     

       21
       24
        
           };

     

       22
       25
        
       

     

       23
       26
        
           environment.systemPackages = [pkgs.sbctl];

modules/nixos/programs/systemd-boot/default.nix

···

       16
       16
        
                 enable = lib.mkDefault true;

     

       17
       17
        
                 configurationLimit = lib.mkDefault 10;

     

       18
       18
        
               };

     

       19
       19
       +
       

     

       20
       20
       +
               timeout = lib.mkDefault 5;

     

       19
       21
        
             };

     

       20
       22
        
           };

     

       21
       23
        
         };

modules/nixos/services/default.nix

···

       6
       6
        
           ./syncthing

     

       7
       7
        
           ./caddy

     

       8
       8
        
           ./qbittorrent

     

       9
       9
       +
           ./gdm

     

       9
       10
        
         ];

     

       10
       11
        
       }

+48

modules/nixos/services/gdm/default.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         ...

     

       5
       5
       +
       }: {

     

       6
       6
       +
         options.myNixOS.services.gdm = {

     

       7
       7
       +
           enable = lib.mkEnableOption "use the gnome display manager";

     

       8
       8
       +
       

     

       9
       9
       +
           autoLogin = lib.mkOption {

     

       10
       10
       +
             description = "User to autologin.";

     

       11
       11
       +
             default = null;

     

       12
       12
       +
             type = lib.types.nullOr lib.types.str;

     

       13
       13
       +
           };

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         config = lib.mkIf config.myNixOS.services.gdm.enable {

     

       17
       17
       +
           programs.dconf.profiles.gdm.databases = [

     

       18
       18
       +
             {

     

       19
       19
       +
               settings = {

     

       20
       20
       +
                 "org/gnome/desktop/peripherals/keyboard" = {

     

       21
       21
       +
                   numlock-state = true;

     

       22
       22
       +
                   remember-numlock-state = true;

     

       23
       23
       +
                 };

     

       24
       24
       +
       

     

       25
       25
       +
                 "org/gnome/desktop/peripherals/touchpad" = {

     

       26
       26
       +
                   tap-to-click = true;

     

       27
       27
       +
                 };

     

       28
       28
       +
               };

     

       29
       29
       +
             }

     

       30
       30
       +
           ];

     

       31
       31
       +
       

     

       32
       32
       +
           security.pam.services.gdm = {

     

       33
       33
       +
             enableGnomeKeyring = true;

     

       34
       34
       +
             gnupg.enable = true;

     

       35
       35
       +
           };

     

       36
       36
       +
       

     

       37
       37
       +
           services = {

     

       38
       38
       +
             displayManager = {

     

       39
       39
       +
               autoLogin = lib.mkIf (config.myNixOS.services.gdm.autoLogin != null) {

     

       40
       40
       +
                 enable = true;

     

       41
       41
       +
                 user = config.myNixOS.services.gdm.autoLogin;

     

       42
       42
       +
               };

     

       43
       43
       +
       

     

       44
       44
       +
               gdm.enable = true;

     

       45
       45
       +
             };

     

       46
       46
       +
           };

     

       47
       47
       +
         };

     

       48
       48
       +
       }

modules/snippets/tailnet/default.nix

···

       26
       26
        
                 port = 8096;

     

       27
       27
        
                 vHost = "jellyfin.${config.mySnippets.tailnet.name}";

     

       28
       28
        
               };

     

       29
       29
       +
       

     

       30
       30
       +
               immich = {

     

       31
       31
       +
                 hostName = "nanpi";

     

       32
       32
       +
                 port = 2283;

     

       33
       33
       +
                 vHost = "immich.${config.mySnippets.tailnet.name}";

     

       34
       34
       +
               };

     

       29
       35
        
             };

     

       30
       36
        
           };

     

       31
       37
        
         };