···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       


     

       
7
       
 
       
  cfg = config.programs._1password-gui;

     
···

       
9
       
 
       
in

     

       
10
       
 
       
{

     

       
11
       
 
       
  imports = [

     

       
12
       
-
       
    (mkRemovedOptionModule [ "programs" "_1password-gui" "gid" ] ''

     

       
13
       
 
       
      A preallocated GID will be used instead.

     

       
14
       
 
       
    '')

     

       
15
       
 
       
  ];

     

       
16
       
 
       


     

       
17
       
 
       
  options = {

     

       
18
       
 
       
    programs._1password-gui = {

     

       
19
       
-
       
      enable = mkEnableOption "the 1Password GUI application";

     

       
20
       
 
       


     

       
21
       
-
       
      polkitPolicyOwners = mkOption {

     

       
22
       
-
       
        type = types.listOf types.str;

     

       
23
       
 
       
        default = [ ];

     

       
24
       
-
       
        example = literalExpression ''["user1" "user2" "user3"]'';

     

       
25
       
 
       
        description = ''

     

       
26
       
 
       
          A list of users who should be able to integrate 1Password with polkit-based authentication mechanisms.

     

       
27
       
 
       
        '';

     

       
28
       
 
       
      };

     

       
29
       
 
       


     

       
30
       
-
       
      package = mkPackageOption pkgs "1Password GUI" {

     

       
31
       
 
       
        default = [ "_1password-gui" ];

     

       
32
       
 
       
      };

     

       
33
       
 
       
    };

     
···

       
39
       
 
       
        polkitPolicyOwners = cfg.polkitPolicyOwners;

     

       
40
       
 
       
      };

     

       
41
       
 
       
    in

     

       
42
       
-
       
    mkIf cfg.enable {

     

       
43
       
 
       
      environment.systemPackages = [ package ];

     

       
44
       
 
       
      users.groups.onepassword.gid = config.ids.gids.onepassword;

     

       
45
       
 
       


     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       


     

       
5
       
 
       
  cfg = config.programs._1password-gui;

     
···

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  imports = [

     

       
10
       
+
       
    (lib.mkRemovedOptionModule [ "programs" "_1password-gui" "gid" ] ''

     

       
11
       
 
       
      A preallocated GID will be used instead.

     

       
12
       
 
       
    '')

     

       
13
       
 
       
  ];

     

       
14
       
 
       


     

       
15
       
 
       
  options = {

     

       
16
       
 
       
    programs._1password-gui = {

     

       
17
       
+
       
      enable = lib.mkEnableOption "the 1Password GUI application";

     

       
18
       
 
       


     

       
19
       
+
       
      polkitPolicyOwners = lib.mkOption {

     

       
20
       
+
       
        type = lib.types.listOf lib.types.str;

     

       
21
       
 
       
        default = [ ];

     

       
22
       
+
       
        example = lib.literalExpression ''["user1" "user2" "user3"]'';

     

       
23
       
 
       
        description = ''

     

       
24
       
 
       
          A list of users who should be able to integrate 1Password with polkit-based authentication mechanisms.

     

       
25
       
 
       
        '';

     

       
26
       
 
       
      };

     

       
27
       
 
       


     

       
28
       
+
       
      package = lib.mkPackageOption pkgs "1Password GUI" {

     

       
29
       
 
       
        default = [ "_1password-gui" ];

     

       
30
       
 
       
      };

     

       
31
       
 
       
    };

     
···

       
37
       
 
       
        polkitPolicyOwners = cfg.polkitPolicyOwners;

     

       
38
       
 
       
      };

     

       
39
       
 
       
    in

     

       
40
       
+
       
    lib.mkIf cfg.enable {

     

       
41
       
 
       
      environment.systemPackages = [ package ];

     

       
42
       
 
       
      users.groups.onepassword.gid = config.ids.gids.onepassword;

     

       
43
       
 
       


     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       


     

       
7
       
 
       
  cfg = config.programs._1password;

     
···

       
9
       
 
       
in

     

       
10
       
 
       
{

     

       
11
       
 
       
  imports = [

     

       
12
       
-
       
    (mkRemovedOptionModule [ "programs" "_1password" "gid" ] ''

     

       
13
       
 
       
      A preallocated GID will be used instead.

     

       
14
       
 
       
    '')

     

       
15
       
 
       
  ];

     

       
16
       
 
       


     

       
17
       
 
       
  options = {

     

       
18
       
 
       
    programs._1password = {

     

       
19
       
-
       
      enable = mkEnableOption "the 1Password CLI tool";

     

       
20
       
 
       


     

       
21
       
-
       
      package = mkPackageOption pkgs "1Password CLI" {

     

       
22
       
 
       
        default = [ "_1password" ];

     

       
23
       
 
       
      };

     

       
24
       
 
       
    };

     

       
25
       
 
       
  };

     

       
26
       
 
       


     

       
27
       
-
       
  config = mkIf cfg.enable {

     

       
28
       
 
       
    environment.systemPackages = [ cfg.package ];

     

       
29
       
 
       
    users.groups.onepassword-cli.gid = config.ids.gids.onepassword-cli;

     

       
30
       
 
       


     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       


     

       
5
       
 
       
  cfg = config.programs._1password;

     
···

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  imports = [

     

       
10
       
+
       
    (lib.mkRemovedOptionModule [ "programs" "_1password" "gid" ] ''

     

       
11
       
 
       
      A preallocated GID will be used instead.

     

       
12
       
 
       
    '')

     

       
13
       
 
       
  ];

     

       
14
       
 
       


     

       
15
       
 
       
  options = {

     

       
16
       
 
       
    programs._1password = {

     

       
17
       
+
       
      enable = lib.mkEnableOption "the 1Password CLI tool";

     

       
18
       
 
       


     

       
19
       
+
       
      package = lib.mkPackageOption pkgs "1Password CLI" {

     

       
20
       
 
       
        default = [ "_1password" ];

     

       
21
       
 
       
      };

     

       
22
       
 
       
    };

     

       
23
       
 
       
  };

     

       
24
       
 
       


     

       
25
       
+
       
  config = lib.mkIf cfg.enable {

     

       
26
       
 
       
    environment.systemPackages = [ cfg.package ];

     

       
27
       
 
       
    users.groups.onepassword-cli.gid = config.ids.gids.onepassword-cli;

     

       
28
       
 
       


     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
{

     

       
6
       
-
       
  meta.maintainers = [ maintainers.mic92 ];

     

       
7
       
 
       


     

       
8
       
 
       
  ###### interface

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    programs.adb = {

     

       
11
       
-
       
      enable = mkOption {

     

       
12
       
 
       
        default = false;

     

       
13
       
-
       
        type = types.bool;

     

       
14
       
 
       
        description = ''

     

       
15
       
 
       
          Whether to configure system to use Android Debug Bridge (adb).

     

       
16
       
 
       
          To grant access to a user, it must be part of adbusers group:

     
···

       
21
       
 
       
  };

     

       
22
       
 
       


     

       
23
       
 
       
  ###### implementation

     

       
24
       
-
       
  config = mkIf config.programs.adb.enable {

     

       
25
       
 
       
    services.udev.packages = [ pkgs.android-udev-rules ];

     

       
26
       
 
       
    environment.systemPackages = [ pkgs.android-tools ];

     

       
27
       
 
       
    users.groups.adbusers = {};

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
{

     

       
4
       
+
       
  meta.maintainers = [ lib.maintainers.mic92 ];

     

       
5
       
 
       


     

       
6
       
 
       
  ###### interface

     

       
7
       
 
       
  options = {

     

       
8
       
 
       
    programs.adb = {

     

       
9
       
+
       
      enable = lib.mkOption {

     

       
10
       
 
       
        default = false;

     

       
11
       
+
       
        type = lib.types.bool;

     

       
12
       
 
       
        description = ''

     

       
13
       
 
       
          Whether to configure system to use Android Debug Bridge (adb).

     

       
14
       
 
       
          To grant access to a user, it must be part of adbusers group:

     
···

       
19
       
 
       
  };

     

       
20
       
 
       


     

       
21
       
 
       
  ###### implementation

     

       
22
       
+
       
  config = lib.mkIf config.programs.adb.enable {

     

       
23
       
 
       
    services.udev.packages = [ pkgs.android-udev-rules ];

     

       
24
       
 
       
    environment.systemPackages = [ pkgs.android-tools ];

     

       
25
       
 
       
    users.groups.adbusers = {};

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.alvr;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    programs.alvr = {

     

       
11
       
-
       
      enable = mkEnableOption "ALVR, the VR desktop streamer";

     

       
12
       
 
       


     

       
13
       
-
       
      package = mkPackageOption pkgs "alvr" { };

     

       
14
       
 
       


     

       
15
       
-
       
      openFirewall = mkOption {

     

       
16
       
-
       
        type = types.bool;

     

       
17
       
 
       
        default = false;

     

       
18
       
 
       
        description = ''

     

       
19
       
 
       
          Whether to open the default ports in the firewall for the ALVR server.

     
···

       
22
       
 
       
    };

     

       
23
       
 
       
  };

     

       
24
       
 
       


     

       
25
       
-
       
  config = mkIf cfg.enable {

     

       
26
       
 
       
    environment.systemPackages = [ cfg.package ];

     

       
27
       
 
       


     

       
28
       
-
       
    networking.firewall = mkIf cfg.openFirewall {

     

       
29
       
 
       
      allowedTCPPorts = [ 9943 9944 ];

     

       
30
       
 
       
      allowedUDPPorts = [ 9943 9944 ];

     

       
31
       
 
       
    };

     

       
32
       
 
       
  };

     

       
33
       
 
       


     

       
34
       
-
       
  meta.maintainers = with maintainers; [ passivelemon ];

     

       
35
       
 
       
}

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.alvr;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options = {

     

       
8
       
 
       
    programs.alvr = {

     

       
9
       
+
       
      enable = lib.mkEnableOption "ALVR, the VR desktop streamer";

     

       
10
       
 
       


     

       
11
       
+
       
      package = lib.mkPackageOption pkgs "alvr" { };

     

       
12
       
 
       


     

       
13
       
+
       
      openFirewall = lib.mkOption {

     

       
14
       
+
       
        type = lib.types.bool;

     

       
15
       
 
       
        default = false;

     

       
16
       
 
       
        description = ''

     

       
17
       
 
       
          Whether to open the default ports in the firewall for the ALVR server.

     
···

       
20
       
 
       
    };

     

       
21
       
 
       
  };

     

       
22
       
 
       


     

       
23
       
+
       
  config = lib.mkIf cfg.enable {

     

       
24
       
 
       
    environment.systemPackages = [ cfg.package ];

     

       
25
       
 
       


     

       
26
       
+
       
    networking.firewall = lib.mkIf cfg.openFirewall {

     

       
27
       
 
       
      allowedTCPPorts = [ 9943 9944 ];

     

       
28
       
 
       
      allowedUDPPorts = [ 9943 9944 ];

     

       
29
       
 
       
    };

     

       
30
       
 
       
  };

     

       
31
       
 
       


     

       
32
       
+
       
  meta.maintainers = with lib.maintainers; [ passivelemon ];

     

       
33
       
 
       
}

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
{

     

       
6
       
 
       
  options = {

     

       
7
       
 
       
    programs.appgate-sdp = {

     

       
8
       
-
       
      enable = mkEnableOption "the AppGate SDP VPN client";

     

       
9
       
 
       
    };

     

       
10
       
 
       
  };

     

       
11
       
 
       


     

       
12
       
-
       
  config = mkIf config.programs.appgate-sdp.enable {

     

       
13
       
 
       
    boot.kernelModules = [ "tun" ];

     

       
14
       
 
       
    environment.systemPackages = [ pkgs.appgate-sdp ];

     

       
15
       
 
       
    services.dbus.packages = [ pkgs.appgate-sdp ];

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
{

     

       
4
       
 
       
  options = {

     

       
5
       
 
       
    programs.appgate-sdp = {

     

       
6
       
+
       
      enable = lib.mkEnableOption "the AppGate SDP VPN client";

     

       
7
       
 
       
    };

     

       
8
       
 
       
  };

     

       
9
       
 
       


     

       
10
       
+
       
  config = lib.mkIf config.programs.appgate-sdp.enable {

     

       
11
       
 
       
    boot.kernelModules = [ "tun" ];

     

       
12
       
 
       
    environment.systemPackages = [ pkgs.appgate-sdp ];

     

       
13
       
 
       
    services.dbus.packages = [ pkgs.appgate-sdp ];

     

···

       
2
       
 
       


     

       
3
       
 
       
{ config, lib, pkgs, ... }:

     

       
4
       
 
       


     

       
5
       
-
       
with lib;

     

       
6
       
-
       


     

       
7
       
 
       
let cfg = config.programs.atop;

     

       
8
       
 
       


     

       
9
       
 
       
in

     
···

       
14
       
 
       


     

       
15
       
 
       
    programs.atop = rec {

     

       
16
       
 
       


     

       
17
       
-
       
      enable = mkEnableOption "Atop, a tool for monitoring system resources";

     

       
18
       
 
       


     

       
19
       
-
       
      package = mkPackageOption pkgs "atop" { };

     

       
20
       
 
       


     

       
21
       
 
       
      netatop = {

     

       
22
       
-
       
        enable = mkOption {

     

       
23
       
-
       
          type = types.bool;

     

       
24
       
 
       
          default = false;

     

       
25
       
 
       
          description = ''

     

       
26
       
 
       
            Whether to install and enable the netatop kernel module.

     

       
27
       
 
       
            Note: this sets the kernel taint flag "O" for loading out-of-tree modules.

     

       
28
       
 
       
          '';

     

       
29
       
 
       
        };

     

       
30
       
-
       
        package = mkOption {

     

       
31
       
-
       
          type = types.package;

     

       
32
       
 
       
          default = config.boot.kernelPackages.netatop;

     

       
33
       
-
       
          defaultText = literalExpression "config.boot.kernelPackages.netatop";

     

       
34
       
 
       
          description = ''

     

       
35
       
 
       
            Which package to use for netatop.

     

       
36
       
 
       
          '';

     

       
37
       
 
       
        };

     

       
38
       
 
       
      };

     

       
39
       
 
       


     

       
40
       
-
       
      atopgpu.enable = mkOption {

     

       
41
       
-
       
        type = types.bool;

     

       
42
       
 
       
        default = false;

     

       
43
       
 
       
        description = ''

     

       
44
       
 
       
          Whether to install and enable the atopgpud daemon to get information about

     
···

       
46
       
 
       
        '';

     

       
47
       
 
       
      };

     

       
48
       
 
       


     

       
49
       
-
       
      setuidWrapper.enable = mkOption {

     

       
50
       
-
       
        type = types.bool;

     

       
51
       
 
       
        default = false;

     

       
52
       
 
       
        description = ''

     

       
53
       
 
       
          Whether to install a setuid wrapper for Atop. This is required to use some of

     
···

       
56
       
 
       
        '';

     

       
57
       
 
       
      };

     

       
58
       
 
       


     

       
59
       
-
       
      atopService.enable = mkOption {

     

       
60
       
-
       
        type = types.bool;

     

       
61
       
 
       
        default = true;

     

       
62
       
 
       
        description = ''

     

       
63
       
 
       
          Whether to enable the atop service responsible for storing statistics for

     

       
64
       
 
       
          long-term analysis.

     

       
65
       
 
       
        '';

     

       
66
       
 
       
      };

     

       
67
       
-
       
      atopRotateTimer.enable = mkOption {

     

       
68
       
-
       
        type = types.bool;

     

       
69
       
 
       
        default = true;

     

       
70
       
 
       
        description = ''

     

       
71
       
 
       
          Whether to enable the atop-rotate timer, which restarts the atop service

     

       
72
       
 
       
          daily to make sure the data files are rotate.

     

       
73
       
 
       
        '';

     

       
74
       
 
       
      };

     

       
75
       
-
       
      atopacctService.enable = mkOption {

     

       
76
       
-
       
        type = types.bool;

     

       
77
       
 
       
        default = true;

     

       
78
       
 
       
        description = ''

     

       
79
       
 
       
          Whether to enable the atopacct service which manages process accounting.

     
···

       
81
       
 
       
          two refresh intervals.

     

       
82
       
 
       
        '';

     

       
83
       
 
       
      };

     

       
84
       
-
       
      settings = mkOption {

     

       
85
       
-
       
        type = types.attrs;

     

       
86
       
 
       
        default = { };

     

       
87
       
 
       
        example = {

     

       
88
       
 
       
          flags = "a1f";

     
···

       
95
       
 
       
    };

     

       
96
       
 
       
  };

     

       
97
       
 
       


     

       
98
       
-
       
  config = mkIf cfg.enable (

     

       
99
       
 
       
    let

     

       
100
       
 
       
      atop =

     

       
101
       
 
       
        if cfg.atopgpu.enable then

     
···

       
104
       
 
       
          cfg.package;

     

       
105
       
 
       
    in

     

       
106
       
 
       
    {

     

       
107
       
-
       
      environment.etc = mkIf (cfg.settings != { }) {

     

       
108
       
-
       
        atoprc.text = concatStrings

     

       
109
       
-
       
          (mapAttrsToList

     

       
110
       
 
       
            (n: v: ''

     

       
111
       
-
       
              ${n} ${toString v}

     

       
112
       
 
       
            '')

     

       
113
       
 
       
            cfg.settings);

     

       
114
       
 
       
      };

     
···

       
122
       
 
       
              wantedBy = [ (if type == "services" then "multi-user.target" else if type == "timers" then "timers.target" else null) ];

     

       
123
       
 
       
            };

     

       
124
       
 
       
          };

     

       
125
       
-
       
          mkService = mkSystemd "services";

     

       
126
       
-
       
          mkTimer = mkSystemd "timers";

     

       
127
       
 
       
        in

     

       
128
       
 
       
        {

     

       
129
       
 
       
          packages = [ atop (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

     

···

       
2
       
 
       


     

       
3
       
 
       
{ config, lib, pkgs, ... }:

     

       
4
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
let cfg = config.programs.atop;

     

       
6
       
 
       


     

       
7
       
 
       
in

     
···

       
12
       
 
       


     

       
13
       
 
       
    programs.atop = rec {

     

       
14
       
 
       


     

       
15
       
+
       
      enable = lib.mkEnableOption "Atop, a tool for monitoring system resources";

     

       
16
       
 
       


     

       
17
       
+
       
      package = lib.mkPackageOption pkgs "atop" { };

     

       
18
       
 
       


     

       
19
       
 
       
      netatop = {

     

       
20
       
+
       
        enable = lib.mkOption {

     

       
21
       
+
       
          type = lib.types.bool;

     

       
22
       
 
       
          default = false;

     

       
23
       
 
       
          description = ''

     

       
24
       
 
       
            Whether to install and enable the netatop kernel module.

     

       
25
       
 
       
            Note: this sets the kernel taint flag "O" for loading out-of-tree modules.

     

       
26
       
 
       
          '';

     

       
27
       
 
       
        };

     

       
28
       
+
       
        package = lib.mkOption {

     

       
29
       
+
       
          type = lib.types.package;

     

       
30
       
 
       
          default = config.boot.kernelPackages.netatop;

     

       
31
       
+
       
          defaultText = lib.literalExpression "config.boot.kernelPackages.netatop";

     

       
32
       
 
       
          description = ''

     

       
33
       
 
       
            Which package to use for netatop.

     

       
34
       
 
       
          '';

     

       
35
       
 
       
        };

     

       
36
       
 
       
      };

     

       
37
       
 
       


     

       
38
       
+
       
      atopgpu.enable = lib.mkOption {

     

       
39
       
+
       
        type = lib.types.bool;

     

       
40
       
 
       
        default = false;

     

       
41
       
 
       
        description = ''

     

       
42
       
 
       
          Whether to install and enable the atopgpud daemon to get information about

     
···

       
44
       
 
       
        '';

     

       
45
       
 
       
      };

     

       
46
       
 
       


     

       
47
       
+
       
      setuidWrapper.enable = lib.mkOption {

     

       
48
       
+
       
        type = lib.types.bool;

     

       
49
       
 
       
        default = false;

     

       
50
       
 
       
        description = ''

     

       
51
       
 
       
          Whether to install a setuid wrapper for Atop. This is required to use some of

     
···

       
54
       
 
       
        '';

     

       
55
       
 
       
      };

     

       
56
       
 
       


     

       
57
       
+
       
      atopService.enable = lib.mkOption {

     

       
58
       
+
       
        type = lib.types.bool;

     

       
59
       
 
       
        default = true;

     

       
60
       
 
       
        description = ''

     

       
61
       
 
       
          Whether to enable the atop service responsible for storing statistics for

     

       
62
       
 
       
          long-term analysis.

     

       
63
       
 
       
        '';

     

       
64
       
 
       
      };

     

       
65
       
+
       
      atopRotateTimer.enable = lib.mkOption {

     

       
66
       
+
       
        type = lib.types.bool;

     

       
67
       
 
       
        default = true;

     

       
68
       
 
       
        description = ''

     

       
69
       
 
       
          Whether to enable the atop-rotate timer, which restarts the atop service

     

       
70
       
 
       
          daily to make sure the data files are rotate.

     

       
71
       
 
       
        '';

     

       
72
       
 
       
      };

     

       
73
       
+
       
      atopacctService.enable = lib.mkOption {

     

       
74
       
+
       
        type = lib.types.bool;

     

       
75
       
 
       
        default = true;

     

       
76
       
 
       
        description = ''

     

       
77
       
 
       
          Whether to enable the atopacct service which manages process accounting.

     
···

       
79
       
 
       
          two refresh intervals.

     

       
80
       
 
       
        '';

     

       
81
       
 
       
      };

     

       
82
       
+
       
      settings = lib.mkOption {

     

       
83
       
+
       
        type = lib.types.attrs;

     

       
84
       
 
       
        default = { };

     

       
85
       
 
       
        example = {

     

       
86
       
 
       
          flags = "a1f";

     
···

       
93
       
 
       
    };

     

       
94
       
 
       
  };

     

       
95
       
 
       


     

       
96
       
+
       
  config = lib.mkIf cfg.enable (

     

       
97
       
 
       
    let

     

       
98
       
 
       
      atop =

     

       
99
       
 
       
        if cfg.atopgpu.enable then

     
···

       
102
       
 
       
          cfg.package;

     

       
103
       
 
       
    in

     

       
104
       
 
       
    {

     

       
105
       
+
       
      environment.etc = lib.mkIf (cfg.settings != { }) {

     

       
106
       
+
       
        atoprc.text = lib.concatStrings

     

       
107
       
+
       
          (lib.mapAttrsToList

     

       
108
       
 
       
            (n: v: ''

     

       
109
       
+
       
              ${n} ${builtins.toString v}

     

       
110
       
 
       
            '')

     

       
111
       
 
       
            cfg.settings);

     

       
112
       
 
       
      };

     
···

       
120
       
 
       
              wantedBy = [ (if type == "services" then "multi-user.target" else if type == "timers" then "timers.target" else null) ];

     

       
121
       
 
       
            };

     

       
122
       
 
       
          };

     

       
123
       
+
       
          mkService = lib.mkSystemd "services";

     

       
124
       
+
       
          mkTimer = lib.mkSystemd "timers";

     

       
125
       
 
       
        in

     

       
126
       
 
       
        {

     

       
127
       
 
       
          packages = [ atop (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg  = config.programs.ausweisapp;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options.programs.ausweisapp = {

     

       
10
       
-
       
    enable = mkEnableOption "AusweisApp";

     

       
11
       
 
       


     

       
12
       
-
       
    openFirewall = mkOption {

     

       
13
       
 
       
      description = ''

     

       
14
       
 
       
        Whether to open the required firewall ports for the Smartphone as Card Reader (SaC) functionality of AusweisApp.

     

       
15
       
 
       
      '';

     
···

       
18
       
 
       
    };

     

       
19
       
 
       
  };

     

       
20
       
 
       


     

       
21
       
-
       
  config = mkIf cfg.enable {

     

       
22
       
 
       
    environment.systemPackages = with pkgs; [ ausweisapp ];

     

       
23
       
 
       
    networking.firewall.allowedUDPPorts = lib.optionals cfg.openFirewall [ 24727 ];

     

       
24
       
 
       
  };

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg  = config.programs.ausweisapp;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options.programs.ausweisapp = {

     

       
8
       
+
       
    enable = lib.mkEnableOption "AusweisApp";

     

       
9
       
 
       


     

       
10
       
+
       
    openFirewall = lib.mkOption {

     

       
11
       
 
       
      description = ''

     

       
12
       
 
       
        Whether to open the required firewall ports for the Smartphone as Card Reader (SaC) functionality of AusweisApp.

     

       
13
       
 
       
      '';

     
···

       
16
       
 
       
    };

     

       
17
       
 
       
  };

     

       
18
       
 
       


     

       
19
       
+
       
  config = lib.mkIf cfg.enable {

     

       
20
       
 
       
    environment.systemPackages = with pkgs; [ ausweisapp ];

     

       
21
       
 
       
    networking.firewall.allowedUDPPorts = lib.optionals cfg.openFirewall [ 24727 ];

     

       
22
       
 
       
  };

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.autojump;

     

       
7
       
 
       
  prg = config.programs;

     
···

       
10
       
 
       
  options = {

     

       
11
       
 
       
    programs.autojump = {

     

       
12
       
 
       


     

       
13
       
-
       
      enable = mkOption {

     

       
14
       
-
       
        type = types.bool;

     

       
15
       
 
       
        default = false;

     

       
16
       
 
       
        description = ''

     

       
17
       
 
       
          Whether to enable autojump.

     
···

       
22
       
 
       


     

       
23
       
 
       
  ###### implementation

     

       
24
       
 
       


     

       
25
       
-
       
  config = mkIf cfg.enable {

     

       
26
       
 
       
    environment.pathsToLink = [ "/share/autojump" ];

     

       
27
       
 
       
    environment.systemPackages = [ pkgs.autojump ];

     

       
28
       
 
       


     

       
29
       
 
       
    programs.bash.interactiveShellInit = "source ${pkgs.autojump}/share/autojump/autojump.bash";

     

       
30
       
-
       
    programs.zsh.interactiveShellInit = mkIf prg.zsh.enable "source ${pkgs.autojump}/share/autojump/autojump.zsh";

     

       
31
       
-
       
    programs.fish.interactiveShellInit = mkIf prg.fish.enable "source ${pkgs.autojump}/share/autojump/autojump.fish";

     

       
32
       
 
       
  };

     

       
33
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.autojump;

     

       
5
       
 
       
  prg = config.programs;

     
···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    programs.autojump = {

     

       
10
       
 
       


     

       
11
       
+
       
      enable = lib.mkOption {

     

       
12
       
+
       
        type = lib.types.bool;

     

       
13
       
 
       
        default = false;

     

       
14
       
 
       
        description = ''

     

       
15
       
 
       
          Whether to enable autojump.

     
···

       
20
       
 
       


     

       
21
       
 
       
  ###### implementation

     

       
22
       
 
       


     

       
23
       
+
       
  config = lib.mkIf cfg.enable {

     

       
24
       
 
       
    environment.pathsToLink = [ "/share/autojump" ];

     

       
25
       
 
       
    environment.systemPackages = [ pkgs.autojump ];

     

       
26
       
 
       


     

       
27
       
 
       
    programs.bash.interactiveShellInit = "source ${pkgs.autojump}/share/autojump/autojump.bash";

     

       
28
       
+
       
    programs.zsh.interactiveShellInit = lib.mkIf prg.zsh.enable "source ${pkgs.autojump}/share/autojump/autojump.zsh";

     

       
29
       
+
       
    programs.fish.interactiveShellInit = lib.mkIf prg.fish.enable "source ${pkgs.autojump}/share/autojump/autojump.fish";

     

       
30
       
 
       
  };

     

       
31
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let cfg = config.programs.bandwhich;

     

       
6
       
 
       
in {

     

       
7
       
-
       
  meta.maintainers = with maintainers; [ Br1ght0ne ];

     

       
8
       
 
       


     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    programs.bandwhich = {

     

       
11
       
-
       
      enable = mkOption {

     

       
12
       
-
       
        type = types.bool;

     

       
13
       
 
       
        default = false;

     

       
14
       
 
       
        description = ''

     

       
15
       
 
       
          Whether to add bandwhich to the global environment and configure a

     
···

       
19
       
 
       
    };

     

       
20
       
 
       
  };

     

       
21
       
 
       


     

       
22
       
-
       
  config = mkIf cfg.enable {

     

       
23
       
 
       
    environment.systemPackages = with pkgs; [ bandwhich ];

     

       
24
       
 
       
    security.wrappers.bandwhich = {

     

       
25
       
 
       
      owner = "root";

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let cfg = config.programs.bandwhich;

     

       
4
       
 
       
in {

     

       
5
       
+
       
  meta.maintainers = with lib.maintainers; [ Br1ght0ne ];

     

       
6
       
 
       


     

       
7
       
 
       
  options = {

     

       
8
       
 
       
    programs.bandwhich = {

     

       
9
       
+
       
      enable = lib.mkOption {

     

       
10
       
+
       
        type = lib.types.bool;

     

       
11
       
 
       
        default = false;

     

       
12
       
 
       
        description = ''

     

       
13
       
 
       
          Whether to add bandwhich to the global environment and configure a

     
···

       
17
       
 
       
    };

     

       
18
       
 
       
  };

     

       
19
       
 
       


     

       
20
       
+
       
  config = lib.mkIf cfg.enable {

     

       
21
       
 
       
    environment.systemPackages = with pkgs; [ bandwhich ];

     

       
22
       
 
       
    security.wrappers.bandwhich = {

     

       
23
       
 
       
      owner = "root";

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  prg = config.programs;

     

       
7
       
 
       
  cfg = prg.bash-my-aws;

     
···

       
13
       
 
       
  {

     

       
14
       
 
       
    options = {

     

       
15
       
 
       
      programs.bash-my-aws = {

     

       
16
       
-
       
        enable = mkEnableOption "bash-my-aws";

     

       
17
       
 
       
      };

     

       
18
       
 
       
    };

     

       
19
       
 
       


     

       
20
       
-
       
    config = mkIf cfg.enable {

     

       
21
       
 
       
      environment.systemPackages = with pkgs; [ bash-my-aws ];

     

       
22
       
 
       


     

       
23
       
 
       
      programs.bash.interactiveShellInit = initScript;

     

···

       
1
       
 
       
{ config, pkgs, lib, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  prg = config.programs;

     

       
5
       
 
       
  cfg = prg.bash-my-aws;

     
···

       
11
       
 
       
  {

     

       
12
       
 
       
    options = {

     

       
13
       
 
       
      programs.bash-my-aws = {

     

       
14
       
+
       
        enable = lib.mkEnableOption "bash-my-aws";

     

       
15
       
 
       
      };

     

       
16
       
 
       
    };

     

       
17
       
 
       


     

       
18
       
+
       
    config = lib.mkIf cfg.enable {

     

       
19
       
 
       
      environment.systemPackages = with pkgs; [ bash-my-aws ];

     

       
20
       
 
       


     

       
21
       
 
       
      programs.bash.interactiveShellInit = initScript;

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  enable = config.programs.bash.enableCompletion;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options = {

     

       
10
       
-
       
    programs.bash.enableCompletion = mkEnableOption "Bash completion for all interactive bash shells" // {

     

       
11
       
 
       
      default = true;

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

       
15
       
-
       
  config = mkIf enable {

     

       
16
       
 
       
    programs.bash.promptPluginInit = ''

     

       
17
       
 
       
      # Check whether we're running a version of Bash that has support for

     

       
18
       
 
       
      # programmable completion. If we do, enable all modules installed in

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  enable = config.programs.bash.enableCompletion;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options = {

     

       
8
       
+
       
    programs.bash.enableCompletion = lib.mkEnableOption "Bash completion for all interactive bash shells" // {

     

       
9
       
 
       
      default = true;

     

       
10
       
 
       
    };

     

       
11
       
 
       
  };

     

       
12
       
 
       


     

       
13
       
+
       
  config = lib.mkIf enable {

     

       
14
       
 
       
    programs.bash.promptPluginInit = ''

     

       
15
       
 
       
      # Check whether we're running a version of Bash that has support for

     

       
16
       
 
       
      # programmable completion. If we do, enable all modules installed in

     

···

       
3
       
 
       


     

       
4
       
 
       
{ config, lib, pkgs, ... }:

     

       
5
       
 
       


     

       
6
       
-
       
with lib;

     

       
7
       
-
       


     

       
8
       
 
       
let

     

       
9
       
 
       


     

       
10
       
 
       
  cfge = config.environment;

     

       
11
       
 
       


     

       
12
       
 
       
  cfg = config.programs.bash;

     

       
13
       
 
       


     

       
14
       
-
       
  bashAliases = concatStringsSep "\n" (

     

       
15
       
-
       
    mapAttrsFlatten (k: v: "alias -- ${k}=${escapeShellArg v}")

     

       
16
       
-
       
      (filterAttrs (k: v: v != null) cfg.shellAliases)

     

       
17
       
 
       
  );

     

       
18
       
 
       


     

       
19
       
 
       
in

     

       
20
       
 
       


     

       
21
       
 
       
{

     

       
22
       
 
       
  imports = [

     

       
23
       
-
       
    (mkRemovedOptionModule [ "programs" "bash" "enable" ] "")

     

       
24
       
 
       
  ];

     

       
25
       
 
       


     

       
26
       
 
       
  options = {

     
···

       
28
       
 
       
    programs.bash = {

     

       
29
       
 
       


     

       
30
       
 
       
      /*

     

       
31
       
-
       
      enable = mkOption {

     

       
32
       
 
       
        default = true;

     

       
33
       
 
       
        description = ''

     

       
34
       
 
       
          Whenever to configure Bash as an interactive shell.

     
···

       
38
       
 
       
          set this variable if you have another shell configured

     

       
39
       
 
       
          with NixOS.

     

       
40
       
 
       
        '';

     

       
41
       
-
       
        type = types.bool;

     

       
42
       
 
       
      };

     

       
43
       
 
       
      */

     

       
44
       
 
       


     

       
45
       
-
       
      shellAliases = mkOption {

     

       
46
       
 
       
        default = {};

     

       
47
       
 
       
        description = ''

     

       
48
       
 
       
          Set of aliases for bash shell, which overrides {option}`environment.shellAliases`.

     

       
49
       
 
       
          See {option}`environment.shellAliases` for an option format description.

     

       
50
       
 
       
        '';

     

       
51
       
-
       
        type = with types; attrsOf (nullOr (either str path));

     

       
52
       
 
       
      };

     

       
53
       
 
       


     

       
54
       
-
       
      shellInit = mkOption {

     

       
55
       
 
       
        default = "";

     

       
56
       
 
       
        description = ''

     

       
57
       
 
       
          Shell script code called during bash shell initialisation.

     

       
58
       
 
       
        '';

     

       
59
       
-
       
        type = types.lines;

     

       
60
       
 
       
      };

     

       
61
       
 
       


     

       
62
       
-
       
      loginShellInit = mkOption {

     

       
63
       
 
       
        default = "";

     

       
64
       
 
       
        description = ''

     

       
65
       
 
       
          Shell script code called during login bash shell initialisation.

     

       
66
       
 
       
        '';

     

       
67
       
-
       
        type = types.lines;

     

       
68
       
 
       
      };

     

       
69
       
 
       


     

       
70
       
-
       
      interactiveShellInit = mkOption {

     

       
71
       
 
       
        default = "";

     

       
72
       
 
       
        description = ''

     

       
73
       
 
       
          Shell script code called during interactive bash shell initialisation.

     

       
74
       
 
       
        '';

     

       
75
       
-
       
        type = types.lines;

     

       
76
       
 
       
      };

     

       
77
       
 
       


     

       
78
       
-
       
      promptInit = mkOption {

     

       
79
       
 
       
        default = ''

     

       
80
       
 
       
          # Provide a nice prompt if the terminal supports it.

     

       
81
       
 
       
          if [ "$TERM" != "dumb" ] || [ -n "$INSIDE_EMACS" ]; then

     
···

       
95
       
 
       
        description = ''

     

       
96
       
 
       
          Shell script code used to initialise the bash prompt.

     

       
97
       
 
       
        '';

     

       
98
       
-
       
        type = types.lines;

     

       
99
       
 
       
      };

     

       
100
       
 
       


     

       
101
       
-
       
      promptPluginInit = mkOption {

     

       
102
       
 
       
        default = "";

     

       
103
       
 
       
        description = ''

     

       
104
       
 
       
          Shell script code used to initialise bash prompt plugins.

     

       
105
       
 
       
        '';

     

       
106
       
-
       
        type = types.lines;

     

       
107
       
 
       
        internal = true;

     

       
108
       
 
       
      };

     

       
109
       
 
       


     
···

       
111
       
 
       


     

       
112
       
 
       
  };

     

       
113
       
 
       


     

       
114
       
-
       
  config = /* mkIf cfg.enable */ {

     

       
115
       
 
       


     

       
116
       
 
       
    programs.bash = {

     

       
117
       
 
       


     

       
118
       
-
       
      shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;

     

       
119
       
 
       


     

       
120
       
 
       
      shellInit = ''

     

       
121
       
 
       
        if [ -z "$__NIXOS_SET_ENVIRONMENT_DONE" ]; then

     
···

       
196
       
 
       


     

       
197
       
 
       
    # Configuration for readline in bash. We use "option default"

     

       
198
       
 
       
    # priority to allow user override using both .text and .source.

     

       
199
       
-
       
    environment.etc.inputrc.source = mkOptionDefault ./inputrc;

     

       
200
       
 
       


     

       
201
       
-
       
    users.defaultUserShell = mkDefault pkgs.bashInteractive;

     

       
202
       
 
       


     

       
203
       
-
       
    environment.pathsToLink = optionals cfg.enableCompletion [

     

       
204
       
 
       
      "/etc/bash_completion.d"

     

       
205
       
 
       
      "/share/bash-completion"

     

       
206
       
 
       
    ];

     

···

       
3
       
 
       


     

       
4
       
 
       
{ config, lib, pkgs, ... }:

     

       
5
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
let

     

       
7
       
 
       


     

       
8
       
 
       
  cfge = config.environment;

     

       
9
       
 
       


     

       
10
       
 
       
  cfg = config.programs.bash;

     

       
11
       
 
       


     

       
12
       
+
       
  bashAliases = builtins.concatStringsSep "\n" (

     

       
13
       
+
       
    lib.mapAttrsFlatten (k: v: "alias -- ${k}=${lib.escapeShellArg v}")

     

       
14
       
+
       
      (lib.filterAttrs (k: v: v != null) cfg.shellAliases)

     

       
15
       
 
       
  );

     

       
16
       
 
       


     

       
17
       
 
       
in

     

       
18
       
 
       


     

       
19
       
 
       
{

     

       
20
       
 
       
  imports = [

     

       
21
       
+
       
    (lib.mkRemovedOptionModule [ "programs" "bash" "enable" ] "")

     

       
22
       
 
       
  ];

     

       
23
       
 
       


     

       
24
       
 
       
  options = {

     
···

       
26
       
 
       
    programs.bash = {

     

       
27
       
 
       


     

       
28
       
 
       
      /*

     

       
29
       
+
       
      enable = lib.mkOption {

     

       
30
       
 
       
        default = true;

     

       
31
       
 
       
        description = ''

     

       
32
       
 
       
          Whenever to configure Bash as an interactive shell.

     
···

       
36
       
 
       
          set this variable if you have another shell configured

     

       
37
       
 
       
          with NixOS.

     

       
38
       
 
       
        '';

     

       
39
       
+
       
        type = lib.types.bool;

     

       
40
       
 
       
      };

     

       
41
       
 
       
      */

     

       
42
       
 
       


     

       
43
       
+
       
      shellAliases = lib.mkOption {

     

       
44
       
 
       
        default = {};

     

       
45
       
 
       
        description = ''

     

       
46
       
 
       
          Set of aliases for bash shell, which overrides {option}`environment.shellAliases`.

     

       
47
       
 
       
          See {option}`environment.shellAliases` for an option format description.

     

       
48
       
 
       
        '';

     

       
49
       
+
       
        type = with lib.types; attrsOf (nullOr (either str path));

     

       
50
       
 
       
      };

     

       
51
       
 
       


     

       
52
       
+
       
      shellInit = lib.mkOption {

     

       
53
       
 
       
        default = "";

     

       
54
       
 
       
        description = ''

     

       
55
       
 
       
          Shell script code called during bash shell initialisation.

     

       
56
       
 
       
        '';

     

       
57
       
+
       
        type = lib.types.lines;

     

       
58
       
 
       
      };

     

       
59
       
 
       


     

       
60
       
+
       
      loginShellInit = lib.mkOption {

     

       
61
       
 
       
        default = "";

     

       
62
       
 
       
        description = ''

     

       
63
       
 
       
          Shell script code called during login bash shell initialisation.

     

       
64
       
 
       
        '';

     

       
65
       
+
       
        type = lib.types.lines;

     

       
66
       
 
       
      };

     

       
67
       
 
       


     

       
68
       
+
       
      interactiveShellInit = lib.mkOption {

     

       
69
       
 
       
        default = "";

     

       
70
       
 
       
        description = ''

     

       
71
       
 
       
          Shell script code called during interactive bash shell initialisation.

     

       
72
       
 
       
        '';

     

       
73
       
+
       
        type = lib.types.lines;

     

       
74
       
 
       
      };

     

       
75
       
 
       


     

       
76
       
+
       
      promptInit = lib.mkOption {

     

       
77
       
 
       
        default = ''

     

       
78
       
 
       
          # Provide a nice prompt if the terminal supports it.

     

       
79
       
 
       
          if [ "$TERM" != "dumb" ] || [ -n "$INSIDE_EMACS" ]; then

     
···

       
93
       
 
       
        description = ''

     

       
94
       
 
       
          Shell script code used to initialise the bash prompt.

     

       
95
       
 
       
        '';

     

       
96
       
+
       
        type = lib.types.lines;

     

       
97
       
 
       
      };

     

       
98
       
 
       


     

       
99
       
+
       
      promptPluginInit = lib.mkOption {

     

       
100
       
 
       
        default = "";

     

       
101
       
 
       
        description = ''

     

       
102
       
 
       
          Shell script code used to initialise bash prompt plugins.

     

       
103
       
 
       
        '';

     

       
104
       
+
       
        type = lib.types.lines;

     

       
105
       
 
       
        internal = true;

     

       
106
       
 
       
      };

     

       
107
       
 
       


     
···

       
109
       
 
       


     

       
110
       
 
       
  };

     

       
111
       
 
       


     

       
112
       
+
       
  config = /* lib.mkIf cfg.enable */ {

     

       
113
       
 
       


     

       
114
       
 
       
    programs.bash = {

     

       
115
       
 
       


     

       
116
       
+
       
      shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;

     

       
117
       
 
       


     

       
118
       
 
       
      shellInit = ''

     

       
119
       
 
       
        if [ -z "$__NIXOS_SET_ENVIRONMENT_DONE" ]; then

     
···

       
194
       
 
       


     

       
195
       
 
       
    # Configuration for readline in bash. We use "option default"

     

       
196
       
 
       
    # priority to allow user override using both .text and .source.

     

       
197
       
+
       
    environment.etc.inputrc.source = lib.mkOptionDefault ./inputrc;

     

       
198
       
 
       


     

       
199
       
+
       
    users.defaultUserShell = lib.mkDefault pkgs.bashInteractive;

     

       
200
       
 
       


     

       
201
       
+
       
    environment.pathsToLink = lib.optionals cfg.enableCompletion [

     

       
202
       
 
       
      "/etc/bash_completion.d"

     

       
203
       
 
       
      "/share/bash-completion"

     

       
204
       
 
       
    ];

     

···

       
1
       
 
       
{ lib, config, pkgs, ... }:

     

       
2
       
-
       
with lib;

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.bash.blesh;

     

       
5
       
 
       
in {

     

       
6
       
 
       
  options = {

     

       
7
       
-
       
    programs.bash.blesh.enable = mkEnableOption "blesh, a full-featured line editor written in pure Bash";

     

       
8
       
 
       
  };

     

       
9
       
 
       


     

       
10
       
-
       
  config = mkIf cfg.enable {

     

       
11
       
-
       
    programs.bash.interactiveShellInit = mkBefore ''

     

       
12
       
 
       
      source ${pkgs.blesh}/share/blesh/ble.sh

     

       
13
       
 
       
    '';

     

       
14
       
 
       
  };

     

       
15
       
-
       
  meta.maintainers = with maintainers; [ laalsaas ];

     

       
16
       
 
       
}

     

···

       
1
       
 
       
{ lib, config, pkgs, ... }:

     

       
0
       
 
       

     

       
2
       
 
       
let

     

       
3
       
 
       
  cfg = config.programs.bash.blesh;

     

       
4
       
 
       
in {

     

       
5
       
 
       
  options = {

     

       
6
       
+
       
    programs.bash.blesh.enable = lib.mkEnableOption "blesh, a full-featured line editor written in pure Bash";

     

       
7
       
 
       
  };

     

       
8
       
 
       


     

       
9
       
+
       
  config = lib.mkIf cfg.enable {

     

       
10
       
+
       
    programs.bash.interactiveShellInit = lib.mkBefore ''

     

       
11
       
 
       
      source ${pkgs.blesh}/share/blesh/ble.sh

     

       
12
       
 
       
    '';

     

       
13
       
 
       
  };

     

       
14
       
+
       
  meta.maintainers = with lib.maintainers; [ laalsaas ];

     

       
15
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  enable = config.programs.bash.enableLsColors;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options = {

     

       
10
       
-
       
    programs.bash.enableLsColors = mkEnableOption "extra colors in directory listings" // {

     

       
11
       
 
       
      default = true;

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

       
15
       
-
       
  config = mkIf enable {

     

       
16
       
 
       
    programs.bash.promptPluginInit = ''

     

       
17
       
 
       
      eval "$(${pkgs.coreutils}/bin/dircolors -b)"

     

       
18
       
 
       
    '';

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  enable = config.programs.bash.enableLsColors;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options = {

     

       
8
       
+
       
    programs.bash.enableLsColors = lib.mkEnableOption "extra colors in directory listings" // {

     

       
9
       
 
       
      default = true;

     

       
10
       
 
       
    };

     

       
11
       
 
       
  };

     

       
12
       
 
       


     

       
13
       
+
       
  config = lib.mkIf enable {

     

       
14
       
 
       
    programs.bash.promptPluginInit = ''

     

       
15
       
 
       
      eval "$(${pkgs.coreutils}/bin/dircolors -b)"

     

       
16
       
 
       
    '';

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.bash.undistractMe;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    programs.bash.undistractMe = {

     

       
11
       
-
       
      enable = mkEnableOption "notifications when long-running terminal commands complete";

     

       
12
       
 
       


     

       
13
       
-
       
      playSound = mkEnableOption "notification sounds when long-running terminal commands complete";

     

       
14
       
 
       


     

       
15
       
-
       
      timeout = mkOption {

     

       
16
       
 
       
        default = 10;

     

       
17
       
 
       
        description = ''

     

       
18
       
 
       
          Number of seconds it would take for a command to be considered long-running.

     

       
19
       
 
       
        '';

     

       
20
       
-
       
        type = types.int;

     

       
21
       
 
       
      };

     

       
22
       
 
       
    };

     

       
23
       
 
       
  };

     

       
24
       
 
       


     

       
25
       
-
       
  config = mkIf cfg.enable {

     

       
26
       
 
       
    programs.bash.promptPluginInit = ''

     

       
27
       
-
       
      export LONG_RUNNING_COMMAND_TIMEOUT=${toString cfg.timeout}

     

       
28
       
 
       
      export UDM_PLAY_SOUND=${if cfg.playSound then "1" else "0"}

     

       
29
       
 
       
      . "${pkgs.undistract-me}/etc/profile.d/undistract-me.sh"

     

       
30
       
 
       
    '';

     

       
31
       
 
       
  };

     

       
32
       
 
       


     

       
33
       
 
       
  meta = {

     

       
34
       
-
       
    maintainers = with maintainers; [ kira-bruneau ];

     

       
35
       
 
       
  };

     

       
36
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.bash.undistractMe;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options = {

     

       
8
       
 
       
    programs.bash.undistractMe = {

     

       
9
       
+
       
      enable = lib.mkEnableOption "notifications when long-running terminal commands complete";

     

       
10
       
 
       


     

       
11
       
+
       
      playSound = lib.mkEnableOption "notification sounds when long-running terminal commands complete";

     

       
12
       
 
       


     

       
13
       
+
       
      timeout = lib.mkOption {

     

       
14
       
 
       
        default = 10;

     

       
15
       
 
       
        description = ''

     

       
16
       
 
       
          Number of seconds it would take for a command to be considered long-running.

     

       
17
       
 
       
        '';

     

       
18
       
+
       
        type = lib.types.int;

     

       
19
       
 
       
      };

     

       
20
       
 
       
    };

     

       
21
       
 
       
  };

     

       
22
       
 
       


     

       
23
       
+
       
  config = lib.mkIf cfg.enable {

     

       
24
       
 
       
    programs.bash.promptPluginInit = ''

     

       
25
       
+
       
      export LONG_RUNNING_COMMAND_TIMEOUT=${builtins.toString cfg.timeout}

     

       
26
       
 
       
      export UDM_PLAY_SOUND=${if cfg.playSound then "1" else "0"}

     

       
27
       
 
       
      . "${pkgs.undistract-me}/etc/profile.d/undistract-me.sh"

     

       
28
       
 
       
    '';

     

       
29
       
 
       
  };

     

       
30
       
 
       


     

       
31
       
 
       
  meta = {

     

       
32
       
+
       
    maintainers = with lib.maintainers; [ kira-bruneau ];

     

       
33
       
 
       
  };

     

       
34
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
{

     

       
6
       
 
       


     

       
7
       
-
       
  options.programs.browserpass.enable = mkEnableOption "Browserpass native messaging host";

     

       
8
       
 
       


     

       
9
       
-
       
  config = mkIf config.programs.browserpass.enable {

     

       
10
       
 
       
    environment.etc = let

     

       
11
       
 
       
      appId = "com.github.browserpass.native.json";

     

       
12
       
 
       
      source = part: "${pkgs.browserpass}/lib/browserpass/${part}/${appId}";

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
{

     

       
4
       
 
       


     

       
5
       
+
       
  options.programs.browserpass.enable = lib.mkEnableOption "Browserpass native messaging host";

     

       
6
       
 
       


     

       
7
       
+
       
  config = lib.mkIf config.programs.browserpass.enable {

     

       
8
       
 
       
    environment.etc = let

     

       
9
       
 
       
      appId = "com.github.browserpass.native.json";

     

       
10
       
 
       
      source = part: "${pkgs.browserpass}/lib/browserpass/${part}/${appId}";

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.calls;

     

       
7
       
 
       
in {

     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    programs.calls = {

     

       
10
       
-
       
      enable = mkEnableOption ''

     

       
11
       
 
       
        GNOME calls: a phone dialer and call handler

     

       
12
       
 
       
      '';

     

       
13
       
 
       
    };

     

       
14
       
 
       
  };

     

       
15
       
 
       


     

       
16
       
-
       
  config = mkIf cfg.enable {

     

       
17
       
 
       
    programs.dconf.enable = true;

     

       
18
       
 
       


     

       
19
       
 
       
    environment.systemPackages = [

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.calls;

     

       
5
       
 
       
in {

     

       
6
       
 
       
  options = {

     

       
7
       
 
       
    programs.calls = {

     

       
8
       
+
       
      enable = lib.mkEnableOption ''

     

       
9
       
 
       
        GNOME calls: a phone dialer and call handler

     

       
10
       
 
       
      '';

     

       
11
       
 
       
    };

     

       
12
       
 
       
  };

     

       
13
       
 
       


     

       
14
       
+
       
  config = lib.mkIf cfg.enable {

     

       
15
       
 
       
    programs.dconf.enable = true;

     

       
16
       
 
       


     

       
17
       
 
       
    environment.systemPackages = [

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let cfg = config.programs.cdemu;

     

       
6
       
 
       
in {

     

       
7
       
 
       


     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    programs.cdemu = {

     

       
10
       
-
       
      enable = mkOption {

     

       
11
       
-
       
        type = types.bool;

     

       
12
       
 
       
        default = false;

     

       
13
       
 
       
        description = ''

     

       
14
       
 
       
          {command}`cdemu` for members of

     

       
15
       
 
       
          {option}`programs.cdemu.group`.

     

       
16
       
 
       
        '';

     

       
17
       
 
       
      };

     

       
18
       
-
       
      group = mkOption {

     

       
19
       
-
       
        type = types.str;

     

       
20
       
 
       
        default = "cdrom";

     

       
21
       
 
       
        description = ''

     

       
22
       
 
       
          Group that users must be in to use {command}`cdemu`.

     

       
23
       
 
       
        '';

     

       
24
       
 
       
      };

     

       
25
       
-
       
      gui = mkOption {

     

       
26
       
-
       
        type = types.bool;

     

       
27
       
 
       
        default = true;

     

       
28
       
 
       
        description = ''

     

       
29
       
 
       
          Whether to install the {command}`cdemu` GUI (gCDEmu).

     

       
30
       
 
       
        '';

     

       
31
       
 
       
      };

     

       
32
       
-
       
      image-analyzer = mkOption {

     

       
33
       
-
       
        type = types.bool;

     

       
34
       
 
       
        default = true;

     

       
35
       
 
       
        description = ''

     

       
36
       
 
       
          Whether to install the image analyzer.

     
···

       
39
       
 
       
    };

     

       
40
       
 
       
  };

     

       
41
       
 
       


     

       
42
       
-
       
  config = mkIf cfg.enable {

     

       
43
       
 
       


     

       
44
       
 
       
    boot = {

     

       
45
       
 
       
      extraModulePackages = [ config.boot.kernelPackages.vhba ];

     
···

       
68
       
 
       


     

       
69
       
 
       
    environment.systemPackages =

     

       
70
       
 
       
      [ pkgs.cdemu-daemon pkgs.cdemu-client ]

     

       
71
       
-
       
      ++ optional cfg.gui pkgs.gcdemu

     

       
72
       
-
       
      ++ optional cfg.image-analyzer pkgs.image-analyzer;

     

       
73
       
 
       
  };

     

       
74
       
 
       


     

       
75
       
 
       
}

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let cfg = config.programs.cdemu;

     

       
4
       
 
       
in {

     

       
5
       
 
       


     

       
6
       
 
       
  options = {

     

       
7
       
 
       
    programs.cdemu = {

     

       
8
       
+
       
      enable = lib.mkOption {

     

       
9
       
+
       
        type = lib.types.bool;

     

       
10
       
 
       
        default = false;

     

       
11
       
 
       
        description = ''

     

       
12
       
 
       
          {command}`cdemu` for members of

     

       
13
       
 
       
          {option}`programs.cdemu.group`.

     

       
14
       
 
       
        '';

     

       
15
       
 
       
      };

     

       
16
       
+
       
      group = lib.mkOption {

     

       
17
       
+
       
        type = lib.types.str;

     

       
18
       
 
       
        default = "cdrom";

     

       
19
       
 
       
        description = ''

     

       
20
       
 
       
          Group that users must be in to use {command}`cdemu`.

     

       
21
       
 
       
        '';

     

       
22
       
 
       
      };

     

       
23
       
+
       
      gui = lib.mkOption {

     

       
24
       
+
       
        type = lib.types.bool;

     

       
25
       
 
       
        default = true;

     

       
26
       
 
       
        description = ''

     

       
27
       
 
       
          Whether to install the {command}`cdemu` GUI (gCDEmu).

     

       
28
       
 
       
        '';

     

       
29
       
 
       
      };

     

       
30
       
+
       
      image-analyzer = lib.mkOption {

     

       
31
       
+
       
        type = lib.types.bool;

     

       
32
       
 
       
        default = true;

     

       
33
       
 
       
        description = ''

     

       
34
       
 
       
          Whether to install the image analyzer.

     
···

       
37
       
 
       
    };

     

       
38
       
 
       
  };

     

       
39
       
 
       


     

       
40
       
+
       
  config = lib.mkIf cfg.enable {

     

       
41
       
 
       


     

       
42
       
 
       
    boot = {

     

       
43
       
 
       
      extraModulePackages = [ config.boot.kernelPackages.vhba ];

     
···

       
66
       
 
       


     

       
67
       
 
       
    environment.systemPackages =

     

       
68
       
 
       
      [ pkgs.cdemu-daemon pkgs.cdemu-client ]

     

       
69
       
+
       
      ++ lib.optional cfg.gui pkgs.gcdemu

     

       
70
       
+
       
      ++ lib.optional cfg.image-analyzer pkgs.image-analyzer;

     

       
71
       
 
       
  };

     

       
72
       
 
       


     

       
73
       
 
       
}

     

···

       
2
       
 
       


     

       
3
       
 
       
{ config, pkgs, lib, ... }:

     

       
4
       
 
       


     

       
5
       
-
       
with lib;

     

       
6
       
-
       


     

       
7
       
 
       
let

     

       
8
       
 
       


     

       
9
       
 
       
  cfg = config.programs.cfs-zen-tweaks;

     
···

       
13
       
 
       
{

     

       
14
       
 
       


     

       
15
       
 
       
  meta = {

     

       
16
       
-
       
    maintainers = with maintainers; [ mkg20001 ];

     

       
17
       
 
       
  };

     

       
18
       
 
       


     

       
19
       
 
       
  options = {

     

       
20
       
-
       
    programs.cfs-zen-tweaks.enable = mkEnableOption "CFS Zen Tweaks";

     

       
21
       
 
       
  };

     

       
22
       
 
       


     

       
23
       
-
       
  config = mkIf cfg.enable {

     

       
24
       
 
       
    systemd.packages = [ pkgs.cfs-zen-tweaks ];

     

       
25
       
 
       


     

       
26
       
 
       
    systemd.services.set-cfs-tweaks.wantedBy = [

     

···

       
2
       
 
       


     

       
3
       
 
       
{ config, pkgs, lib, ... }:

     

       
4
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
let

     

       
6
       
 
       


     

       
7
       
 
       
  cfg = config.programs.cfs-zen-tweaks;

     
···

       
11
       
 
       
{

     

       
12
       
 
       


     

       
13
       
 
       
  meta = {

     

       
14
       
+
       
    maintainers = with lib.maintainers; [ mkg20001 ];

     

       
15
       
 
       
  };

     

       
16
       
 
       


     

       
17
       
 
       
  options = {

     

       
18
       
+
       
    programs.cfs-zen-tweaks.enable = lib.mkEnableOption "CFS Zen Tweaks";

     

       
19
       
 
       
  };

     

       
20
       
 
       


     

       
21
       
+
       
  config = lib.mkIf cfg.enable {

     

       
22
       
 
       
    systemd.packages = [ pkgs.cfs-zen-tweaks ];

     

       
23
       
 
       


     

       
24
       
 
       
    systemd.services.set-cfs-tweaks.wantedBy = [

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.chromium;

     

       
7
       
 
       


     

       
8
       
-
       
  defaultProfile = filterAttrs (k: v: v != null) {

     

       
9
       
 
       
    HomepageLocation = cfg.homepageLocation;

     

       
10
       
 
       
    DefaultSearchProviderEnabled = cfg.defaultSearchProviderEnabled;

     

       
11
       
 
       
    DefaultSearchProviderSearchURL = cfg.defaultSearchProviderSearchURL;

     
···

       
19
       
 
       


     

       
20
       
 
       
  options = {

     

       
21
       
 
       
    programs.chromium = {

     

       
22
       
-
       
      enable = mkEnableOption "{command}`chromium` policies";

     

       
23
       
 
       


     

       
24
       
-
       
      enablePlasmaBrowserIntegration = mkEnableOption "Native Messaging Host for Plasma Browser Integration";

     

       
25
       
 
       


     

       
26
       
-
       
      plasmaBrowserIntegrationPackage = mkPackageOption pkgs [ "plasma5Packages" "plasma-browser-integration" ] { };

     

       
27
       
 
       


     

       
28
       
-
       
      extensions = mkOption {

     

       
29
       
-
       
        type = with types; nullOr (listOf str);

     

       
30
       
 
       
        description = ''

     

       
31
       
 
       
          List of chromium extensions to install.

     

       
32
       
 
       
          For list of plugins ids see id in url of extensions on

     
···

       
38
       
 
       
          for additional details.

     

       
39
       
 
       
        '';

     

       
40
       
 
       
        default = null;

     

       
41
       
-
       
        example = literalExpression ''

     

       
42
       
 
       
          [

     

       
43
       
 
       
            "chlffgpmiacpedhhbkiomidkjlcfhogd" # pushbullet

     

       
44
       
 
       
            "mbniclmhobmnbdlbpiphghaielnnpgdp" # lightshot

     
···

       
48
       
 
       
        '';

     

       
49
       
 
       
      };

     

       
50
       
 
       


     

       
51
       
-
       
      homepageLocation = mkOption {

     

       
52
       
-
       
        type = types.nullOr types.str;

     

       
53
       
 
       
        description = "Chromium default homepage";

     

       
54
       
 
       
        default = null;

     

       
55
       
 
       
        example = "https://nixos.org";

     

       
56
       
 
       
      };

     

       
57
       
 
       


     

       
58
       
-
       
      defaultSearchProviderEnabled = mkOption {

     

       
59
       
-
       
        type = types.nullOr types.bool;

     

       
60
       
 
       
        description = "Enable the default search provider.";

     

       
61
       
 
       
        default = null;

     

       
62
       
 
       
        example = true;

     

       
63
       
 
       
      };

     

       
64
       
 
       


     

       
65
       
-
       
      defaultSearchProviderSearchURL = mkOption {

     

       
66
       
-
       
        type = types.nullOr types.str;

     

       
67
       
 
       
        description = "Chromium default search provider url.";

     

       
68
       
 
       
        default = null;

     

       
69
       
 
       
        example = "https://encrypted.google.com/search?q={searchTerms}&{google:RLZ}{google:originalQueryForSuggestion}{google:assistedQueryStats}{google:searchFieldtrialParameter}{google:searchClient}{google:sourceId}{google:instantExtendedEnabledParameter}ie={inputEncoding}";

     

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
-
       
      defaultSearchProviderSuggestURL = mkOption {

     

       
73
       
-
       
        type = types.nullOr types.str;

     

       
74
       
 
       
        description = "Chromium default search provider url for suggestions.";

     

       
75
       
 
       
        default = null;

     

       
76
       
 
       
        example = "https://encrypted.google.com/complete/search?output=chrome&q={searchTerms}";

     

       
77
       
 
       
      };

     

       
78
       
 
       


     

       
79
       
-
       
      extraOpts = mkOption {

     

       
80
       
-
       
        type = types.attrs;

     

       
81
       
 
       
        description = ''

     

       
82
       
 
       
          Extra chromium policy options. A list of available policies

     

       
83
       
 
       
          can be found in the Chrome Enterprise documentation:

     
···

       
85
       
 
       
          Make sure the selected policy is supported on Linux and your browser version.

     

       
86
       
 
       
        '';

     

       
87
       
 
       
        default = {};

     

       
88
       
-
       
        example = literalExpression ''

     

       
89
       
 
       
          {

     

       
90
       
 
       
            "BrowserSignin" = 0;

     

       
91
       
 
       
            "SyncDisabled" = true;

     
···

       
99
       
 
       
        '';

     

       
100
       
 
       
      };

     

       
101
       
 
       


     

       
102
       
-
       
      initialPrefs = mkOption {

     

       
103
       
-
       
        type = types.attrs;

     

       
104
       
 
       
        description = ''

     

       
105
       
 
       
          Initial preferences are used to configure the browser for the first run.

     

       
106
       
 
       
          Unlike {option}`programs.chromium.extraOpts`, initialPrefs can be changed by users in the browser settings.

     
···

       
108
       
 
       
          <https://www.chromium.org/administrators/configuring-other-preferences/>

     

       
109
       
 
       
        '';

     

       
110
       
 
       
        default = {};

     

       
111
       
-
       
        example = literalExpression ''

     

       
112
       
 
       
          {

     

       
113
       
 
       
            "first_run_tabs" = [

     

       
114
       
 
       
              "https://nixos.org/"

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.chromium;

     

       
5
       
 
       


     

       
6
       
+
       
  defaultProfile = lib.filterAttrs (k: v: v != null) {

     

       
7
       
 
       
    HomepageLocation = cfg.homepageLocation;

     

       
8
       
 
       
    DefaultSearchProviderEnabled = cfg.defaultSearchProviderEnabled;

     

       
9
       
 
       
    DefaultSearchProviderSearchURL = cfg.defaultSearchProviderSearchURL;

     
···

       
17
       
 
       


     

       
18
       
 
       
  options = {

     

       
19
       
 
       
    programs.chromium = {

     

       
20
       
+
       
      enable = lib.mkEnableOption "{command}`chromium` policies";

     

       
21
       
 
       


     

       
22
       
+
       
      enablePlasmaBrowserIntegration = lib.mkEnableOption "Native Messaging Host for Plasma Browser Integration";

     

       
23
       
 
       


     

       
24
       
+
       
      plasmaBrowserIntegrationPackage = lib.mkPackageOption pkgs [ "plasma5Packages" "plasma-browser-integration" ] { };

     

       
25
       
 
       


     

       
26
       
+
       
      extensions = lib.mkOption {

     

       
27
       
+
       
        type = with lib.types; nullOr (listOf str);

     

       
28
       
 
       
        description = ''

     

       
29
       
 
       
          List of chromium extensions to install.

     

       
30
       
 
       
          For list of plugins ids see id in url of extensions on

     
···

       
36
       
 
       
          for additional details.

     

       
37
       
 
       
        '';

     

       
38
       
 
       
        default = null;

     

       
39
       
+
       
        example = lib.literalExpression ''

     

       
40
       
 
       
          [

     

       
41
       
 
       
            "chlffgpmiacpedhhbkiomidkjlcfhogd" # pushbullet

     

       
42
       
 
       
            "mbniclmhobmnbdlbpiphghaielnnpgdp" # lightshot

     
···

       
46
       
 
       
        '';

     

       
47
       
 
       
      };

     

       
48
       
 
       


     

       
49
       
+
       
      homepageLocation = lib.mkOption {

     

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

     

       
51
       
 
       
        description = "Chromium default homepage";

     

       
52
       
 
       
        default = null;

     

       
53
       
 
       
        example = "https://nixos.org";

     

       
54
       
 
       
      };

     

       
55
       
 
       


     

       
56
       
+
       
      defaultSearchProviderEnabled = lib.mkOption {

     

       
57
       
+
       
        type = lib.types.nullOr lib.types.bool;

     

       
58
       
 
       
        description = "Enable the default search provider.";

     

       
59
       
 
       
        default = null;

     

       
60
       
 
       
        example = true;

     

       
61
       
 
       
      };

     

       
62
       
 
       


     

       
63
       
+
       
      defaultSearchProviderSearchURL = lib.mkOption {

     

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

     

       
65
       
 
       
        description = "Chromium default search provider url.";

     

       
66
       
 
       
        default = null;

     

       
67
       
 
       
        example = "https://encrypted.google.com/search?q={searchTerms}&{google:RLZ}{google:originalQueryForSuggestion}{google:assistedQueryStats}{google:searchFieldtrialParameter}{google:searchClient}{google:sourceId}{google:instantExtendedEnabledParameter}ie={inputEncoding}";

     

       
68
       
 
       
      };

     

       
69
       
 
       


     

       
70
       
+
       
      defaultSearchProviderSuggestURL = lib.mkOption {

     

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

     

       
72
       
 
       
        description = "Chromium default search provider url for suggestions.";

     

       
73
       
 
       
        default = null;

     

       
74
       
 
       
        example = "https://encrypted.google.com/complete/search?output=chrome&q={searchTerms}";

     

       
75
       
 
       
      };

     

       
76
       
 
       


     

       
77
       
+
       
      extraOpts = lib.mkOption {

     

       
78
       
+
       
        type = lib.types.attrs;

     

       
79
       
 
       
        description = ''

     

       
80
       
 
       
          Extra chromium policy options. A list of available policies

     

       
81
       
 
       
          can be found in the Chrome Enterprise documentation:

     
···

       
83
       
 
       
          Make sure the selected policy is supported on Linux and your browser version.

     

       
84
       
 
       
        '';

     

       
85
       
 
       
        default = {};

     

       
86
       
+
       
        example = lib.literalExpression ''

     

       
87
       
 
       
          {

     

       
88
       
 
       
            "BrowserSignin" = 0;

     

       
89
       
 
       
            "SyncDisabled" = true;

     
···

       
97
       
 
       
        '';

     

       
98
       
 
       
      };

     

       
99
       
 
       


     

       
100
       
+
       
      initialPrefs = lib.mkOption {

     

       
101
       
+
       
        type = lib.types.attrs;

     

       
102
       
 
       
        description = ''

     

       
103
       
 
       
          Initial preferences are used to configure the browser for the first run.

     

       
104
       
 
       
          Unlike {option}`programs.chromium.extraOpts`, initialPrefs can be changed by users in the browser settings.

     
···

       
106
       
 
       
          <https://www.chromium.org/administrators/configuring-other-preferences/>

     

       
107
       
 
       
        '';

     

       
108
       
 
       
        default = {};

     

       
109
       
+
       
        example = lib.literalExpression ''

     

       
110
       
 
       
          {

     

       
111
       
 
       
            "first_run_tabs" = [

     

       
112
       
 
       
              "https://nixos.org/"

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
3
       
-
       
with lib;

     

       
4
       
-
       


     

       
5
       
 
       
let

     

       
6
       
 
       
  cfg = config.programs.cnping;

     

       
7
       
 
       
in

     

       
8
       
 
       
{

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    programs.cnping = {

     

       
11
       
-
       
      enable = mkEnableOption "a setcap wrapper for cnping";

     

       
12
       
 
       
    };

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

       
15
       
-
       
  config = mkIf cfg.enable {

     

       
16
       
 
       
    security.wrappers.cnping = {

     

       
17
       
 
       
      source = "${pkgs.cnping}/bin/cnping";

     

       
18
       
 
       
      capabilities = "cap_net_raw+ep";

     

···

       
1
       
 
       
{ config, lib, pkgs, ... }:

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       
let

     

       
4
       
 
       
  cfg = config.programs.cnping;

     

       
5
       
 
       
in

     

       
6
       
 
       
{

     

       
7
       
 
       
  options = {

     

       
8
       
 
       
    programs.cnping = {

     

       
9
       
+
       
      enable = lib.mkEnableOption "a setcap wrapper for cnping";

     

       
10
       
 
       
    };

     

       
11
       
 
       
  };

     

       
12
       
 
       


     

       
13
       
+
       
  config = lib.mkIf cfg.enable {

     

       
14
       
 
       
    security.wrappers.cnping = {

     

       
15
       
 
       
      source = "${pkgs.cnping}/bin/cnping";

     

       
16
       
 
       
      capabilities = "cap_net_raw+ep";