Merge master into staging-next

nixos/doc/manual/release-notes/rl-2311.section.md

···
 
 - `util-linux` is now supported on Darwin and is no longer an alias to `unixtools`. Use the `unixtools.util-linux` package for access to the Apple variants of the utilities.
 
+- `fileSystems.<name>.autoFormat` now uses `systemd-makefs`, which does not accept formatting options. Therefore, `fileSystems.<name>.formatOptions` has been removed.
+
+- `fileSystems.<name>.autoResize` now uses `systemd-growfs` to resize the file system online in stage 2. This means that `f2fs` and `ext2` can no longer be auto resized, while `xfs` and `btrfs` now can be.
+
 ## Other Notable Changes {#sec-release-23.11-notable-changes}
 
 - The Cinnamon module now enables XDG desktop integration by default. If you are experiencing collisions related to xdg-desktop-portal-gtk you can safely remove `xdg.portal.extraPortals = [ pkgs.xdg-desktop-portal-gtk ];` from your NixOS configuration.

nixos/modules/system/boot/stage-1-init.sh

···
 
     checkFS "$device" "$fsType"
 
-    # Optionally resize the filesystem.
-    case $options in
-        *x-nixos.autoresize*)
-            if [ "$fsType" = ext2 -o "$fsType" = ext3 -o "$fsType" = ext4 ]; then
-                modprobe "$fsType"
-                echo "resizing $device..."
-                e2fsck -fp "$device"
-                resize2fs "$device"
-            elif [ "$fsType" = f2fs ]; then
-                echo "resizing $device..."
-                fsck.f2fs -fp "$device"
-                resize.f2fs "$device"
-            fi
-            ;;
-    esac
-
     # Create backing directories for overlayfs
     if [ "$fsType" = overlay ]; then
         for i in upper work; do

nixos/modules/system/boot/stage-1.nix

···
       copy_bin_and_libs ${pkgs.kmod}/bin/kmod
       ln -sf kmod $out/bin/modprobe
 
-      # Copy resize2fs if any ext* filesystems are to be resized
-      ${optionalString (any (fs: fs.autoResize && (lib.hasPrefix "ext" fs.fsType)) fileSystems) ''
-        # We need mke2fs in the initrd.
-        copy_bin_and_libs ${pkgs.e2fsprogs}/sbin/resize2fs
-      ''}
-
       # Copy multipath.
       ${optionalString config.services.multipath.enable ''
         copy_bin_and_libs ${config.services.multipath.package}/bin/multipath

nixos/modules/system/boot/systemd.nix

···
     systemd.services."systemd-backlight@".restartIfChanged = false;
     systemd.services."systemd-fsck@".restartIfChanged = false;
     systemd.services."systemd-fsck@".path = [ config.system.path ];
+    systemd.services."systemd-makefs@" = {
+      restartIfChanged = false;
+      path = [ pkgs.util-linux ] ++ config.system.fsPackages;
+      # Since there is no /etc/systemd/system/systemd-makefs@.service
+      # file, the units generated in /run/systemd/generator would
+      # override anything we put here. But by forcing the use of a
+      # drop-in in /etc, it does apply.
+      overrideStrategy = "asDropin";
+    };
     systemd.services.systemd-random-seed.restartIfChanged = false;
     systemd.services.systemd-remount-fs.restartIfChanged = false;
     systemd.services.systemd-update-utmp.restartIfChanged = false;

nixos/modules/system/boot/systemd/initrd.nix

···
     "systemd-ask-password-console.path"
     "systemd-ask-password-console.service"
     "systemd-fsck@.service"
-    "systemd-growfs@.service"
     "systemd-halt.service"
     "systemd-hibernate-resume@.service"
     "systemd-journald-audit.socket"
···
   fileSystems = filter utils.fsNeededForBoot config.system.build.fileSystems;
 
   needMakefs = lib.any (fs: fs.autoFormat) fileSystems;
-  needGrowfs = lib.any (fs: fs.autoResize) fileSystems;
 
   kernel-name = config.boot.kernelPackages.kernel.name or "kernel";
   modulesTree = config.system.modulesTree.override { name = kernel-name + "-modules"; };
···
       storePaths = [
         # systemd tooling
         "${cfg.package}/lib/systemd/systemd-fsck"
-        (lib.mkIf needGrowfs "${cfg.package}/lib/systemd/systemd-growfs")
         "${cfg.package}/lib/systemd/systemd-hibernate-resume"
         "${cfg.package}/lib/systemd/systemd-journald"
         (lib.mkIf needMakefs "${cfg.package}/lib/systemd/systemd-makefs")

nixos/modules/tasks/filesystems.nix

···
       };
 
       formatOptions = mkOption {
-        default = "";
-        type = types.str;
-        description = lib.mdDoc ''
-          If {option}`autoFormat` option is set specifies
-          extra options passed to mkfs.
-        '';
+        visible = false;
+        type = types.unspecified;
+        default = null;
       };
 
       autoResize = mkOption {
···
 
     };
 
-    config = let
-      defaultFormatOptions =
-        # -F needed to allow bare block device without partitions
-        if (builtins.substring 0 3 config.fsType) == "ext" then "-F"
-        # -q needed for non-interactive operations
-        else if config.fsType == "jfs" then "-q"
-        # (same here)
-        else if config.fsType == "reiserfs" then "-q"
-        else null;
-    in {
-      options = mkMerge [
-        (mkIf config.autoResize [ "x-nixos.autoresize" ])
-        (mkIf (utils.fsNeededForBoot config) [ "x-initrd.mount" ])
-      ];
-      formatOptions = mkIf (defaultFormatOptions != null) (mkDefault defaultFormatOptions);
-    };
+    config.options = mkMerge [
+      (mkIf config.autoResize [ "x-systemd.growfs" ])
+      (mkIf config.autoFormat [ "x-systemd.makefs" ])
+      (mkIf (utils.fsNeededForBoot config) [ "x-initrd.mount" ])
+    ];
 
   };
 
···
       skipCheck = fs: fs.noCheck || fs.device == "none" || builtins.elem fs.fsType fsToSkipCheck || isBindMount fs;
       # https://wiki.archlinux.org/index.php/fstab#Filepath_spaces
       escape = string: builtins.replaceStrings [ " " "\t" ] [ "\\040" "\\011" ] string;
-    in fstabFileSystems: { rootPrefix ? "", extraOpts ? (fs: []) }: concatMapStrings (fs:
+    in fstabFileSystems: { rootPrefix ? "" }: concatMapStrings (fs:
       (optionalString (isBindMount fs) (escape rootPrefix))
       + (if fs.device != null then escape fs.device
          else if fs.label != null then "/dev/disk/by-label/${escape fs.label}"
          else throw "No device specified for mount point ‘${fs.mountPoint}’.")
       + " " + escape fs.mountPoint
       + " " + fs.fsType
-      + " " + escape (builtins.concatStringsSep "," (fs.options ++ (extraOpts fs)))
+      + " " + escape (builtins.concatStringsSep "," fs.options)
       + " 0 " + (if skipCheck fs then "0" else if fs.mountPoint == "/" then "1" else "2")
       + "\n"
     ) fstabFileSystems;
 
     initrdFstab = pkgs.writeText "initrd-fstab" (makeFstabEntries (filter utils.fsNeededForBoot fileSystems) {
       rootPrefix = "/sysroot";
-      extraOpts = fs:
-        (optional fs.autoResize "x-systemd.growfs")
-        ++ (optional fs.autoFormat "x-systemd.makefs");
     });
 
 in
···
 
     assertions = let
       ls = sep: concatMapStringsSep sep (x: x.mountPoint);
-      notAutoResizable = fs: fs.autoResize && !(hasPrefix "ext" fs.fsType || fs.fsType == "f2fs");
+      resizableFSes = [
+        "ext3"
+        "ext4"
+        "btrfs"
+        "xfs"
+      ];
+      notAutoResizable = fs: fs.autoResize && !(builtins.elem fs.fsType resizableFSes);
     in [
       { assertion = ! (fileSystems' ? cycle);
         message = "The ‘fileSystems’ option can't be topologically sorted: mountpoint dependency path ${ls " -> " fileSystems'.cycle} loops to ${ls ", " fileSystems'.loops}";
···
       { assertion = ! (any notAutoResizable fileSystems);
         message = let
           fs = head (filter notAutoResizable fileSystems);
-        in
-          "Mountpoint '${fs.mountPoint}': 'autoResize = true' is not supported for 'fsType = \"${fs.fsType}\"':${optionalString (fs.fsType == "auto") " fsType has to be explicitly set and"} only the ext filesystems and f2fs support it.";
+        in ''
+          Mountpoint '${fs.mountPoint}': 'autoResize = true' is not supported for 'fsType = "${fs.fsType}"'
+          ${optionalString (fs.fsType == "auto") "fsType has to be explicitly set and"}
+          only the following support it: ${lib.concatStringsSep ", " resizableFSes}.
+        '';
+      }
+      {
+        assertion = ! (any (fs: fs.formatOptions != null) fileSystems);
+        message = let
+          fs = head (filter (fs: fs.formatOptions != null) fileSystems);
+        in ''
+          'fileSystems.<name>.formatOptions' has been removed, since
+          systemd-makefs does not support any way to provide formatting
+          options.
+        '';
       }
     ];
 
···
         wants = [ "local-fs.target" "remote-fs.target" ];
       };
 
-    systemd.services =
-
-    # Emit systemd services to format requested filesystems.
-      let
-        formatDevice = fs:
-          let
-            mountPoint' = "${escapeSystemdPath fs.mountPoint}.mount";
-            device'  = escapeSystemdPath fs.device;
-            device'' = "${device'}.device";
-          in nameValuePair "mkfs-${device'}"
-          { description = "Initialisation of Filesystem ${fs.device}";
-            wantedBy = [ mountPoint' ];
-            before = [ mountPoint' "systemd-fsck@${device'}.service" ];
-            requires = [ device'' ];
-            after = [ device'' ];
-            path = [ pkgs.util-linux ] ++ config.system.fsPackages;
-            script =
-              ''
-                if ! [ -e "${fs.device}" ]; then exit 1; fi
-                # FIXME: this is scary.  The test could be more robust.
-                type=$(blkid -p -s TYPE -o value "${fs.device}" || true)
-                if [ -z "$type" ]; then
-                  echo "creating ${fs.fsType} filesystem on ${fs.device}..."
-                  mkfs.${fs.fsType} ${fs.formatOptions} "${fs.device}"
-                fi
-              '';
-            unitConfig.RequiresMountsFor = [ "${dirOf fs.device}" ];
-            unitConfig.DefaultDependencies = false; # needed to prevent a cycle
-            serviceConfig.Type = "oneshot";
-          };
-      in listToAttrs (map formatDevice (filter (fs: fs.autoFormat && !(utils.fsNeededForBoot fs)) fileSystems)) // {
+    systemd.services = {
     # Mount /sys/fs/pstore for evacuating panic logs and crashdumps from persistent storage onto the disk using systemd-pstore.
     # This cannot be done with the other special filesystems because the pstore module (which creates the mount point) is not loaded then.
         "mount-pstore" = {

nixos/modules/tasks/filesystems/f2fs.nix

···
 
     boot.initrd.extraUtilsCommands = mkIf (inInitrd && !config.boot.initrd.systemd.enable) ''
       copy_bin_and_libs ${pkgs.f2fs-tools}/sbin/fsck.f2fs
-      ${optionalString (any (fs: fs.autoResize) fileSystems) ''
-        # We need f2fs-tools' tools to resize filesystems
-        copy_bin_and_libs ${pkgs.f2fs-tools}/sbin/resize.f2fs
-      ''}
-
     '';
   };
 }

nixos/tests/fsck.nix

···
           else "fsck.ext4.*/dev/vda"}'")
 
     with subtest("mnt fs is fsckd"):
-        machine.succeed("journalctl -b | grep 'fsck.*/dev/vdb.*clean'")
+        machine.succeed("journalctl -b | grep 'fsck.*vdb.*clean'")
         machine.succeed(
             "grep 'Requires=[e-mail]' /run/systemd/generator/mnt.mount"
         )

pkgs/applications/emulators/blink/default.nix

···
     homepage = "https://github.com/jart/blink";
     license = lib.licenses.isc;
     maintainers = with lib.maintainers; [ t4ccer ];
+    platforms = lib.platforms.all;
   };
 })

pkgs/applications/misc/comodoro/default.nix

···
+{ lib
+, rustPlatform
+, fetchFromGitHub
+, stdenv
+, installShellFiles
+, installShellCompletions ? stdenv.hostPlatform == stdenv.buildPlatform
+, installManPages ? stdenv.hostPlatform == stdenv.buildPlatform
+, withTcp ? true
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "comodoro";
+  version = "0.0.8";
+
+  src = fetchFromGitHub {
+    owner = "soywod";
+    repo = "comodoro";
+    rev = "v${version}";
+    sha256 = "rGnVXyfWJkPHfpf1gRGbDJ6Y1ycKOOcCZ+Jx35fUo6M=";
+  };
+
+  cargoSha256 = "jpshuavywCLN03xD/gFgQeGbKtmHq5pULbxd+RUbaDk=";
+
+  nativeBuildInputs = lib.optional (installManPages || installShellCompletions) installShellFiles;
+
+  buildNoDefaultFeatures = true;
+  buildFeatures = lib.optional withTcp "tcp";
+
+  postInstall = lib.optionalString installManPages ''
+    mkdir -p $out/man
+    $out/bin/comodoro man $out/man
+    installManPage $out/man/*
+  '' + lib.optionalString installShellCompletions ''
+    installShellCompletion --cmd comodoro \
+      --bash <($out/bin/comodoro completion bash) \
+      --fish <($out/bin/comodoro completion fish) \
+      --zsh <($out/bin/comodoro completion zsh)
+  '';
+
+  meta = with lib; {
+    description = "CLI to manage your time.";
+    homepage = "https://pimalaya.org/comodoro/";
+    changelog = "https://github.com/soywod/comodoro/blob/v${version}/CHANGELOG.md";
+    license = licenses.mit;
+    maintainers = with maintainers; [ soywod ];
+  };
+}

pkgs/applications/misc/far2l/default.nix

···
 { lib, stdenv, fetchFromGitHub, makeWrapper, cmake, ninja, pkg-config, m4, bash
 , xdg-utils, zip, unzip, gzip, bzip2, gnutar, p7zip, xz
-, IOKit, Carbon, Cocoa, AudioToolbox, OpenGL
+, IOKit, Carbon, Cocoa, AudioToolbox, OpenGL, System
 , withTTYX ? true, libX11
 , withGUI ? true, wxGTK32
 , withUCD ? true, libuchardet
···
     ++ lib.optionals withNetRocks [ openssl libssh libnfs neon ]
     ++ lib.optional (withNetRocks && !stdenv.isDarwin) samba # broken on darwin
     ++ lib.optionals withPython (with python3Packages; [ python cffi debugpy pcpp ])
-    ++ lib.optionals stdenv.isDarwin [ IOKit Carbon Cocoa AudioToolbox OpenGL ];
+    ++ lib.optionals stdenv.isDarwin [ IOKit Carbon Cocoa AudioToolbox OpenGL System ];
 
   postPatch = ''
     patchShebangs python/src/prebuild.sh
···
       --replace '"/bin/bash"' '"${bash}/bin/bash"'
     substituteInPlace far2l/src/cfg/config.cpp \
       --replace '"/bin/bash"' '"${bash}/bin/bash"'
-  '' + lib.optionalString stdenv.isDarwin ''
-    substituteInPlace WinPort/src/Backend/WX/CMakeLists.txt \
-      --replace "-framework System" -lSystem
   '';
 
   cmakeFlags = lib.mapAttrsToList (k: v: "-D${k}=${if v then "yes" else "no"}") {

pkgs/data/icons/kora-icon-theme/default.nix

···
 
 stdenvNoCC.mkDerivation rec  {
   pname = "kora-icon-theme";
-  version = "1.5.6";
+  version = "1.5.7";
 
   src = fetchFromGitHub  {
     owner = "bikass";
     repo = "kora";
     rev = "v${version}";
-    sha256 = "sha256-vAeml+upESUVlJ95Rm0+vlZ+NQZWEZl00scDkb3W7Yo=";
+    sha256 = "sha256-VAlfrUWgxcG17ZTlA357gengXTilwuZOBscIzadAsaU=";
   };
 
   nativeBuildInputs = [

pkgs/data/misc/sing-geoip/default.nix

···
 let
   generator = buildGoModule rec {
     pname = "sing-geoip";
-    version = "unstable-2022-07-05";
+    version = "20230512";
 
     src = fetchFromGitHub {
       owner = "SagerNet";
       repo = pname;
-      rev = "2ced72c94da4c9259c40353c375319d9d28a78f3";
-      hash = "sha256-z8aP+OfTuzQNwOT3EEnI9uze/vbHTJLEiCPqIrnNUHw=";
+      rev = "refs/tags/${version}";
+      hash = "sha256-Zm+5N/37hoHpH/TLNJrHeaBXI8G1jEpM1jz6Um8edNE=";
     };
 
-    vendorHash = "sha256-lr0XMLFxJmLqIqCuGgmsFh324jmZVj71blmStMn41Rs=";
-
-    postPatch = ''
-      # The codes args should start from the third args
-      substituteInPlace main.go --replace "os.Args[2:]" "os.Args[3:]"
-    '';
+    vendorHash = "sha256-ejXAdsJwXhqet+Ca+pDLWwu0gex79VcIxW6rmhRnbTQ=";
 
     meta = with lib; {
       description = "GeoIP data for sing-box";

pkgs/development/interpreters/wasmtime/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "wasmtime";
-  version = "9.0.2";
+  version = "9.0.3";
 
   src = fetchFromGitHub {
     owner = "bytecodealliance";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-Fnc3iepxHr7WjorFoabHE6ZM/zK1T5W/gkxL+AEcVgU=";
+    hash = "sha256-b/GioFixPpbCUiYfOLwJ1NCsLGqIm+v9ODuq6kD8JeE=";
     fetchSubmodules = true;
   };
 
-  cargoHash = "sha256-7Q5aJU0sYzRLgjiSNLIrydYRJ3ozABjDo4VtmexS3po=";
+  cargoHash = "sha256-AYb6dbmvoFYbvgik9rdyOnxdHdnhR8thnrQShGxRLFA=";
 
   cargoBuildFlags = [ "--package" "wasmtime-cli" "--package" "wasmtime-c-api" ];
 

pkgs/development/libraries/faudio/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "faudio";
-  version = "23.05";
+  version = "23.06";
 
   src = fetchFromGitHub {
     owner = "FNA-XNA";
     repo = "FAudio";
     rev = version;
-    sha256 = "sha256-uZSKbLQ36Kw6useAKyDoxLKD1xtKbigq/ejWErxvkcE=";
+    sha256 = "sha256-V5t9YliyXxoWNnKwp3TTOCyCIzpcyg1X4DaI0WFlfeQ=";
   };
 
   nativeBuildInputs = [cmake];

pkgs/development/libraries/kde-frameworks/default.nix

···
                 homepage = meta.homepage or "https://kde.org";
                 license = meta.license or license;
                 maintainers = (meta.maintainers or []) ++ maintainers;
-                platforms = meta.platforms or lib.platforms.linux;
+                platforms = meta.platforms or lib.platforms.all;
               };
 
           in mkDerivation (args // {

pkgs/development/libraries/kde-frameworks/kauth/default.nix

···
 {
-  lib, mkDerivation, propagate,
+  lib, stdenv, mkDerivation, propagate,
   extra-cmake-modules, kcoreaddons, qttools,
-  enablePolkit ? true, polkit-qt
+  enablePolkit ? stdenv.isLinux, polkit-qt
 }:
 
 mkDerivation {

pkgs/development/libraries/kde-frameworks/kcoreaddons.nix

···
 {
-  mkDerivation, lib,
+  mkDerivation, lib, stdenv,
   extra-cmake-modules,
   qtbase, qttools, shared-mime-info
 }:
···
   postInstall = ''
     moveToOutput "mkspecs" "$dev"
   '';
+} // lib.optionalAttrs stdenv.isDarwin {
+  # https://invent.kde.org/frameworks/kcoreaddons/-/merge_requests/327
+  env.NIX_CFLAGS_COMPILE = "-DSOCK_CLOEXEC=0";
 })

pkgs/development/libraries/kde-frameworks/kdoctools/default.nix

···
 {
-  mkDerivation,
+  mkDerivation, lib, stdenv, fetchpatch,
   extra-cmake-modules, docbook_xml_dtd_45, docbook_xsl_ns,
   karchive, ki18n, qtbase,
   perl, perlPackages
···
   ];
   buildInputs = [ karchive ki18n ];
   outputs = [ "out" "dev" ];
-  patches = [ ./kdoctools-no-find-docbook-xml.patch ];
+  patches = [ ./kdoctools-no-find-docbook-xml.patch ]
+    # kf.doctools.core: Error: Could not find kdoctools catalogs
+    ++ lib.optionals stdenv.isDarwin [
+    (fetchpatch {
+      name = "kdoctools-relocate-datapath.patch";
+      url = "https://github.com/msys2/MINGW-packages/raw/0900785a1f4e4146ab9561fb92a1c70fa70fcfc4/mingw-w64-kdoctools-qt5/0001-kdoctools-relocate-datapath.patch";
+      hash = "sha256-MlokdrabXavWHGXYmdz9zZDJQIwAdNxebJBSAH2Z3vI=";
+    })
+  ];
   cmakeFlags = [
     "-DDocBookXML4_DTD_DIR=${docbook_xml_dtd_45}/xml/dtd/docbook"
     "-DDocBookXSL_DIR=${docbook_xsl_ns}/xml/xsl/docbook"

pkgs/development/libraries/kde-frameworks/ktexteditor.nix

···
 {
-  mkDerivation,
+  mkDerivation, lib, stdenv,
   extra-cmake-modules, perl,
   karchive, kconfig, kguiaddons, ki18n, kiconthemes, kio, kparts, libgit2,
   qtscript, qtxmlpatterns, sonnet, syntax-highlighting, qtquickcontrols,
   editorconfig-core-c
 }:
 
-mkDerivation {
+mkDerivation ({
   pname = "ktexteditor";
   nativeBuildInputs = [ extra-cmake-modules perl ];
   buildInputs = [
···
     editorconfig-core-c
   ];
   propagatedBuildInputs = [ kparts ];
-}
+} // lib.optionalAttrs stdenv.isDarwin {
+  postPatch = ''
+    substituteInPlace src/part/CMakeLists.txt \
+      --replace "kpart.desktop" "${kparts}/share/kservicetypes5/kpart.desktop"
+  '';
+})

pkgs/development/python-modules/django-stubs-ext/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-stubs-ext";
-  version = "4.2.0";
+  version = "4.2.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-d4nwyuynFS/vB61rlN7HMQoF0Ljat395eeGdsAN7USc=";
+    hash = "sha256-JpbW99hTg0GwYM/6lWXHLqeX6GZofgQLhtKcrYeZ5f4=";
   };
-
-  # setup.cfg tries to pull in nonexistent LICENSE.txt file
-  postPatch = "rm setup.cfg";
 
   propagatedBuildInputs = [
     django

pkgs/development/python-modules/pyipp/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyipp";
-  version = "0.13.0";
+  version = "0.14.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
    owner = "ctalkington";
    repo = "python-ipp";
    rev = version;
-   hash = "sha256-lVpXtPxZZCyWycmkXZTMo5WTPtlehNY5IX7tiyIb1uM=";
+   hash = "sha256-l8zDgqv8+9r15dt1YeuAYq2GCl9JsrtNRjPlQ9A7H9c=";
   };
 
   postPatch = ''

pkgs/development/tools/renderdoc/default.nix

···
 in
 mkDerivation rec {
   pname = "renderdoc";
-  version = "1.26";
+  version = "1.27";
 
   src = fetchFromGitHub {
     owner = "baldurk";
     repo = "renderdoc";
     rev = "v${version}";
-    sha256 = "sha256-z3qHW7hVde51TkRZO3Ld8DbUODa2Gbnh3zosW2O8eOQ=";
+    sha256 = "sha256-zkot9LbbZyzQ7CLSEVPsospAo9u7WR2VHjQdnpNiLR0=";
   };
 
   buildInputs = [

pkgs/os-specific/darwin/apple-sdk/default.nix

···
       '';
     });
 
+    System = lib.overrideDerivation super.System (drv: {
+      installPhase = ''
+        mkdir -p $out/Library/Frameworks/System.framework/Versions/B
+        ln -s $out/Library/Frameworks/System.framework/Versions/{B,Current}
+        ln -s ${pkgs.darwin.Libsystem}/lib/libSystem.B.tbd $out/Library/Frameworks/System.framework/Versions/B/System.tbd
+        ln -s $out/Library/Frameworks/System.framework/{Versions/Current/,}System.tbd
+      '';
+    });
+
     WebKit = lib.overrideDerivation super.WebKit (drv: {
       extraTBDFiles = [
         "Versions/A/Frameworks/WebCore.framework/Versions/A/WebCore.tbd"

pkgs/os-specific/darwin/apple-sdk/frameworks.nix

···
   SpriteKit               = {};
   StoreKit                = {};
   SyncServices            = {};
+  System                  = {};
   SystemConfiguration     = { inherit Security; };
   TWAIN                   = { inherit Carbon; };
   Tcl                     = {};

pkgs/os-specific/linux/intel-cmt-cat/default.nix

···
 { lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
-  version = "4.5.0";
+  version = "4.6.0";
   pname = "intel-cmt-cat";
 
   src = fetchFromGitHub {
     owner = "intel";
     repo = "intel-cmt-cat";
     rev = "v${version}";
-    sha256 = "sha256-gjJtwEDvPW0JDwlIUXSmv1wm4TknKsE/BLKHiqIgjho=";
+    sha256 = "sha256-Bw/WY30ytvwBo+OZ27WG2aY3YN9xczdjs4jcHR/Tv/w=";
   };
 
   enableParallelBuilding = true;

pkgs/servers/amqp/rabbitmq-server/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rabbitmq-server";
-  version = "3.11.10";
+  version = "3.12.0";
 
   # when updating, consider bumping elixir version in all-packages.nix
   src = fetchurl {
     url = "https://github.com/rabbitmq/rabbitmq-server/releases/download/v${version}/${pname}-${version}.tar.xz";
-    hash = "sha256-gZcUWN8SnCb93zUTqWDYtxUrT5655gfEnMax1NLHh+M=";
+    hash = "sha256-XHiFiKO4vi+gD2Cw6QnRCu5YHDKJviLETadmj1Vzr/Y=";
   };
 
   nativeBuildInputs = [ unzip xmlto docbook_xml_dtd_45 docbook_xsl zip rsync python3 ];

pkgs/servers/http/dufs/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dufs";
-  version = "0.33.0";
+  version = "0.34.1";
 
   src = fetchFromGitHub {
     owner = "sigoden";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ZcKNpKlyGMFPNiWA28zG5gh0gWxI4IKGP6vs9OBhxQU=";
+    sha256 = "sha256-WSTY9j7wfoAqovLb9reNe7LXTjy40QObJNfgiidOINQ=";
   };
 
-  cargoHash = "sha256-Ihq00dfjsJX2rNclfyYKp8a0U120+0YLZyvMO1yvBYw=";
+  cargoHash = "sha256-sQQUpbvr5IpsUTTznAfUJ5MvGh8rZ0tuZQkxMVpI2wM=";
 
   nativeBuildInputs = lib.optionals stdenv.isLinux [
     pkg-config

pkgs/servers/jackett/default.nix

···
 
 buildDotnetModule rec {
   pname = "jackett";
-  version = "0.21.114";
+  version = "0.21.128";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha512-CwK6nKsI9SrY9lE8THRVe+q0fMLxiLAdeCW7rewI2XtIeIDUy7kDYBujIlbxNdAjT+QgsN3E0oC/+nIyRqqFUg==";
+    hash = "sha512-22OiSh/jStVsA7ghjM+P+eVkViBFyhzNwhZbEIhWRlmpOaIC3NUSwMTKuZlq5I6J8Zc6gVW6kCOaKZoAWWWYfA==";
   };
 
   projectFile = "src/Jackett.Server/Jackett.Server.csproj";

pkgs/servers/photoprism/backend.nix

···
     substituteInPlace internal/commands/passwd.go --replace '/bin/stty' "${coreutils}/bin/stty"
   '';
 
-  vendorSha256 = "sha256-59ZwijPCcmhMPeh7v8EdqzraqRx+HhK6VnUk0JvAbbU=";
+  vendorSha256 = "sha256-jkBGFO18m5OyyMr8M7qeQHcHc9koLudGU5t8vFUBjuE=";
 
   subPackages = [ "cmd/photoprism" ];
 

pkgs/servers/photoprism/default.nix

···
-{ pkgs, lib, stdenv, fetchFromGitHub, fetchzip, darktable, rawtherapee, ffmpeg, libheif, exiftool, makeWrapper, testers }:
+{ pkgs, lib, stdenv, fetchFromGitHub, fetchzip, darktable, rawtherapee, ffmpeg, libheif, exiftool, imagemagick, makeWrapper, testers }:
 
 let
-  version = "221118-e58fee0fb";
+  version = "230603-378d4746a";
   pname = "photoprism";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "sha256-Bx9SJLK97uZ/k09LIj8dHwmRetg6krI5iO7mtojV3PU=";
+    sha256 = "sha256-lywVP4Vvq88g+Yk4BuzOaB+9EbWrxGgIF4lOPW33E1U=";
   };
 
   libtensorflow = pkgs.callPackage ./libtensorflow.nix { };
···
       --set PHOTOPRISM_RAWTHERAPEE_BIN ${rawtherapee}/bin/rawtherapee-cli \
       --set PHOTOPRISM_HEIFCONVERT_BIN ${libheif}/bin/heif-convert \
       --set PHOTOPRISM_FFMPEG_BIN ${ffmpeg}/bin/ffmpeg \
-      --set PHOTOPRISM_EXIFTOOL_BIN ${exiftool}/bin/exiftool
+      --set PHOTOPRISM_EXIFTOOL_BIN ${exiftool}/bin/exiftool \
+      --set PHOTOPRISM_IMAGEMAGICK_BIN ${imagemagick}/bin/convert
 
     # install frontend
     ln -s ${frontend}/assets/* ${assets_path}

pkgs/servers/photoprism/frontend.nix

···
     cd frontend
   '';
 
-  npmDepsHash = "sha256-NAtZ85WjiQn9w0B9Y78XL+tSsshHlaXS8+WtojFJmGg";
+  npmDepsHash = "sha256-lZpgv3YFF+b9nPJlbG2KdGYC5UMy+VnYqRgz7JLj85g=";
 
   installPhase = ''
     runHook preInstall

pkgs/tools/bluetooth/bluez-alsa/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "bluez-alsa";
-  version = "4.0.0";
+  version = "4.1.0";
 
   src = fetchFromGitHub {
     owner = "Arkq";
     repo = "bluez-alsa";
     rev = "v${version}";
-    sha256 = "sha256-Dp3O41nzo7j5rqxDEkR4bFPv0CNGOO4kWXAf8iy+jDg=";
+    sha256 = "sha256-qoG1hTVuSFbccfct9DqSI0BBPJwSFlhPPtv87ThtSBk=";
   };
 
   nativeBuildInputs = [ pkg-config autoreconfHook ];

pkgs/tools/networking/nebula/default.nix

···
 
 buildGoModule rec {
   pname = "nebula";
-  version = "1.7.1";
+  version = "1.7.2";
 
   src = fetchFromGitHub {
     owner = "slackhq";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-2FQ/mX1Y2UBl9SiIBVkll0W7P9RWAWJpQwEGKTtplrU=";
+    hash = "sha256-/kEXrcMFnrnnD+6754EDoOvn4czh0rJGEjlXkmCzb1w=";
   };
 
   vendorHash = "sha256-VZzSdl8R1y7rCF2vz7e+5nAkb3wlJymNWCXwZZUvg4A=";

pkgs/tools/networking/ocserv/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ocserv";
-  version = "1.1.6";
+  version = "1.1.7";
 
   src = fetchFromGitLab {
     owner = "openconnect";
     repo = "ocserv";
     rev = version;
-    sha256 = "sha256-1grRt0F/myVzK+DMSeK5K0Ui8bJANEtE6/6IY+ZbPAw=";
+    sha256 = "sha256-30S2puoL+5cBZ5nCKW2zvGPcnFvaKjRZVGKDC3E5XRk=";
   };
 
   nativeBuildInputs = [ autoreconfHook gperf pkg-config ronn ];

pkgs/tools/security/exploitdb/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "exploitdb";
-  version = "2023-06-03";
+  version = "2023-06-05";
 
   src = fetchFromGitLab {
     owner = "exploit-database";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-qyrQMNrCn6HaqMM1ikzx/KGquBOa71XNPHcu5aNnSYg=";
+    hash = "sha256-OhcYBct+ADyEk3VszQr/A+igB4mI/1BBedNzAfuHQ+k=";
   };
 
   nativeBuildInputs = [

pkgs/tools/system/monit/default.nix

···
   nativeBuildInputs = [ bison flex ] ++
     lib.optionals stdenv.hostPlatform.isDarwin [
       darwin.apple_sdk.frameworks.DiskArbitration
+      darwin.apple_sdk.frameworks.System
     ];
 
   buildInputs = [ zlib.dev libxcrypt ] ++
     lib.optionals useSSL [ openssl ] ++
     lib.optionals usePAM [ pam ];
-
-  preConfigure = lib.optionalString stdenv.hostPlatform.isDarwin ''
-    substituteInPlace configure --replace "-framework System" "-lSystem"
-  '';
 
   configureFlags = [
     (lib.withFeature usePAM "pam")

pkgs/tools/text/mdbook/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "mdbook";
-  version = "0.4.29";
+  version = "0.4.30";
 
   src = fetchFromGitHub {
     owner = "rust-lang";
     repo = "mdBook";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-81QU1FJ5f23OdS+bzMnHEMbwwzywU38Xoq3DEN0Kgpg=";
+    sha256 = "sha256-AKGvU8yEgUcLRaf+fPet1kv84m95qrO25P4izP1w9lg=";
   };
 
-  cargoHash = "sha256-SyDLC2x1hEyjt+GG50CblTGahJAkEZWkXSPyPvUJNgw=";
+  cargoHash = "sha256-Jg/+LAxgyGlVcqUdiHnZpwmTrtApWLXFhy0bNcNs0hM=";
 
   buildInputs = lib.optionals stdenv.isDarwin [ CoreServices ];
 

pkgs/top-level/all-packages.nix

···
 
   commix = callPackage ../tools/security/commix { };
 
+  comodoro = callPackage ../applications/misc/comodoro { };
+
   compdb = callPackage ../tools/misc/compdb { };
 
   conserver = callPackage ../tools/misc/conserver { };
···
 
   bless = callPackage ../applications/editors/bless { };
 
-  blink = callPackage ../applications/emulators/blink { };
+  blink = darwin.apple_sdk_11_0.callPackage ../applications/emulators/blink { };
 
   blink1-tool = callPackage ../tools/misc/blink1-tool { };
 
···
 
   sing-geosite = callPackage ../data/misc/sing-geosite { };
 
-  sing-geoip = callPackage ../data/misc/sing-geoip {
-    buildGoModule = buildGo119Module;
-  };
+  sing-geoip = callPackage ../data/misc/sing-geoip { };
 
   sipcalc = callPackage ../tools/networking/sipcalc { };
 
···
 
   far2l = callPackage ../applications/misc/far2l {
     stdenv = if stdenv.cc.isClang then llvmPackages.stdenv else stdenv;
-    inherit (darwin.apple_sdk.frameworks) IOKit Carbon Cocoa AudioToolbox OpenGL;
+    inherit (darwin.apple_sdk.frameworks) IOKit Carbon Cocoa AudioToolbox OpenGL System;
   };
 
   farbfeld = callPackage ../development/libraries/farbfeld { };