tobias/nixpkgs
1
0
Fork 0
mirror of https://github.com/NixOS/nixpkgs.git synced 2025-11-09 16:18:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge staging-next into staging

Browse source
This commit is contained in:
nixpkgs-ci[bot] 2025-11-08 20:24:57 +00:00 committed by GitHub
parent 62d942010e 00d4ea150f
commit 0109503c5c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
98 changed files with 1471 additions and 3335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
doc/release-notes/rl-2511.section.md
View file

@ -250,6 +250,8 @@
- [private-gpt](https://github.com/zylon-ai/private-gpt) service has been removed by lack of maintenance upstream.
- `rabbitmq-server` has been updated from 4.0.9 to 4.1.4. The 4.1.0 release includes breaking changes. For more information read the [changelog of 4.1.0](https://github.com/rabbitmq/rabbitmq-server/releases/tag/v4.1.0)
- `lxde` scope has been removed, and its packages have been moved the top-level.
- `pulsemeeter` has been updated to `2.0.0`. The configuration file from older versions has to be deleted. For more information and instructions see the [v2.0.0 changelog entry](https://github.com/theRealCarneiro/pulsemeeter/releases/tag/v2.0.0).

4
nixos/doc/manual/release-notes/rl-2511.section.md
View file

@ -203,6 +203,8 @@
- `boot.enableContainers` is only turned on when a declarative NixOS container is defined in `containers`.
If you use the `nixos-container` tool for imperative container management, set `boot.enableContainers = true;` explicitly.
- `services.parsoid` and the `nodePackages.parsoid` package have been removed, as the JavaScript-based version this module uses is not compatible with modern MediaWiki versions.
- `virtualisation.lxd` has been removed due to lack of Nixpkgs maintenance. Users can migrate to `virtualisation.incus`, a fork of LXD, as a replacement. See [Incus migration documentation](https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/) for migration information.
- `virtualisation.libvirtd` now uses OVMF images shipped with QEMU for UEFI machines. `virtualisation.libvirtd.qemu.ovmf` has been removed.
@ -285,6 +287,8 @@
- `services.gateone` has been removed as the package was removed such that it does not work.
- `services.quorum` has been removed as the `quorum` package was broken and abandoned upstream.
- `teleport` has been upgraded from major version 17 to major version 18.
Refer to [upstream upgrade instructions](https://goteleport.com/docs/upgrading/overview/)
and [release notes for v18](https://goteleport.com/docs/changelog/#1800-070325).

2
nixos/modules/module-list.nix
View file

@ -903,7 +903,6 @@
./services/misc/packagekit.nix
./services/misc/paisa.nix
./services/misc/paperless.nix
./services/misc/parsoid.nix
./services/misc/persistent-evdev.nix
./services/misc/pghero.nix
./services/misc/pinchflat.nix
@ -1321,7 +1320,6 @@
./services/networking/pyload.nix
./services/networking/quassel.nix
./services/networking/quicktun.nix
./services/networking/quorum.nix
./services/networking/r53-ddns.nix
./services/networking/radicale.nix
./services/networking/radvd.nix

7
nixos/modules/rename.nix
View file

@ -234,6 +234,10 @@ in
(mkRemovedOptionModule [ "services" "pantheon" "files" ] ''
This module was removed, please add pkgs.pantheon.elementary-files to environment.systemPackages directly.
'')
(mkRemovedOptionModule [ "services" "parsoid" ] ''
The Javascript version of Parsoid configured through this module does not work with modern MediaWiki versions,
and has been deprecated by upstream, so it has been removed. MediaWiki comes with a new PHP-based parser built-in, so there is no need for this module.
'')
(mkRemovedOptionModule [ "services" "polipo" ] ''
The polipo project is unmaintained and archived upstream.
'')
@ -244,6 +248,9 @@ in
"services"
"quagga"
] "the corresponding package has been removed from nixpkgs")
(mkRemovedOptionModule [ "services" "quorum" ] ''
The corresponding package was broken, abandoned upstream and thus removed from nixpkgs.
'')
(mkRemovedOptionModule [
"services"
"railcar"

141
nixos/modules/services/mail/tlsrpt.nix
View file

@ -9,6 +9,7 @@ let
inherit (lib)
mkEnableOption
mkIf
mkMerge
mkOption
mkPackageOption
types
@ -59,8 +60,6 @@ let
reportdConfigFile = format.generate "tlsrpt-reportd.cfg" {
tlsrpt_reportd = dropNullValues cfg.reportd.settings;
};
withPostfix = config.services.postfix.enable && cfg.configurePostfix;
in
{
@ -286,71 +285,83 @@ in
};
};
config = mkIf cfg.enable {
environment.etc = {
"tlsrpt/collectd.cfg".source = collectdConfigFile;
"tlsrpt/fetcher.cfg".source = fetcherConfigFile;
"tlsrpt/reportd.cfg".source = reportdConfigFile;
};
config = mkMerge [
(mkIf (cfg.enable && config.services.postfix.enable && cfg.configurePostfix) {
users.users.postfix.extraGroups = [
"tlsrpt"
];
users.users.tlsrpt = {
isSystemUser = true;
group = "tlsrpt";
};
users.groups.tlsrpt = { };
users.users.postfix.extraGroups = lib.mkIf withPostfix [
"tlsrpt"
];
systemd.services.tlsrpt-collectd = {
description = "TLSRPT datagram collector";
documentation = [ "man:tlsrpt-collectd(1)" ];
wantedBy = [ "multi-user.target" ];
restartTriggers = [ collectdConfigFile ];
serviceConfig = commonServiceSettings // {
ExecStart = toString (
[
(lib.getExe' cfg.package "tlsrpt-collectd")
]
++ cfg.collectd.extraFlags
);
IPAddressDeny = "any";
PrivateNetwork = true;
RestrictAddressFamilies = [ "AF_UNIX" ];
RuntimeDirectory = "tlsrpt";
RuntimeDirectoryMode = "0750";
UMask = "0157";
services.postfix.settings.main = {
smtp_tlsrpt_enable = true;
smtp_tlsrpt_socket_name = cfg.collectd.settings.socketname;
};
};
systemd.services.tlsrpt-reportd = {
description = "TLSRPT report generator";
documentation = [ "man:tlsrpt-reportd(1)" ];
wantedBy = [ "multi-user.target" ];
restartTriggers = [ reportdConfigFile ];
serviceConfig = commonServiceSettings // {
ExecStart = toString (
[
(lib.getExe' cfg.package "tlsrpt-reportd")
]
++ cfg.reportd.extraFlags
);
RestrictAddressFamilies = [
"AF_INET"
"AF_INET6"
"AF_NETLINK"
];
ReadWritePaths = lib.optionals withPostfix [ "/var/lib/postfix/queue/maildrop" ];
SupplementaryGroups = lib.optionals withPostfix [ "postdrop" ];
UMask = "0077";
systemd.services.tlsrpt-reportd.serviceConfig = {
ReadWritePaths = [ "/var/lib/postfix/queue/maildrop" ];
SupplementaryGroups = [ "postdrop" ];
};
};
};
})
(mkIf cfg.enable {
environment.etc = {
"tlsrpt/collectd.cfg".source = collectdConfigFile;
"tlsrpt/fetcher.cfg".source = fetcherConfigFile;
"tlsrpt/reportd.cfg".source = reportdConfigFile;
};
users.users.tlsrpt = {
isSystemUser = true;
group = "tlsrpt";
};
users.groups.tlsrpt = { };
systemd.services.tlsrpt-collectd = {
description = "TLSRPT datagram collector";
documentation = [ "man:tlsrpt-collectd(1)" ];
wantedBy = [ "multi-user.target" ];
restartTriggers = [ collectdConfigFile ];
serviceConfig = commonServiceSettings // {
ExecStart = toString (
[
(lib.getExe' cfg.package "tlsrpt-collectd")
]
++ cfg.collectd.extraFlags
);
IPAddressDeny = "any";
PrivateNetwork = true;
RestrictAddressFamilies = [ "AF_UNIX" ];
RuntimeDirectory = "tlsrpt";
RuntimeDirectoryMode = "0750";
UMask = "0157";
};
};
systemd.services.tlsrpt-reportd = {
description = "TLSRPT report generator";
documentation = [ "man:tlsrpt-reportd(1)" ];
wantedBy = [ "multi-user.target" ];
restartTriggers = [ reportdConfigFile ];
serviceConfig = commonServiceSettings // {
ExecStart = toString (
[
(lib.getExe' cfg.package "tlsrpt-reportd")
]
++ cfg.reportd.extraFlags
);
RestrictAddressFamilies = [
"AF_INET"
"AF_INET6"
"AF_NETLINK"
];
UMask = "0077";
};
};
})
];
}

144
nixos/modules/services/misc/parsoid.nix
View file

@ -1,144 +0,0 @@
{
config,
lib,
pkgs,
...
}:
let
cfg = config.services.parsoid;
parsoid = pkgs.nodePackages.parsoid;
confTree = {
worker_heartbeat_timeout = 300000;
logging = {
level = "info";
};
services = [
{
module = "lib/index.js";
entrypoint = "apiServiceWorker";
conf = {
mwApis = map (x: if lib.isAttrs x then x else { uri = x; }) cfg.wikis;
serverInterface = cfg.interface;
serverPort = cfg.port;
};
}
];
};
confFile = pkgs.writeText "config.yml" (
builtins.toJSON (lib.recursiveUpdate confTree cfg.extraConfig)
);
in
{
imports = [
(lib.mkRemovedOptionModule [
"services"
"parsoid"
"interwikis"
] "Use services.parsoid.wikis instead")
];
##### interface
options = {
services.parsoid = {
enable = lib.mkOption {
type = lib.types.bool;
default = false;
description = ''
Whether to enable Parsoid -- bidirectional
wikitext parser.
'';
};
wikis = lib.mkOption {
type = lib.types.listOf (lib.types.either lib.types.str lib.types.attrs);
example = [ "http://localhost/api.php" ];
description = ''
Used MediaWiki API endpoints.
'';
};
workers = lib.mkOption {
type = lib.types.int;
default = 2;
description = ''
Number of Parsoid workers.
'';
};
interface = lib.mkOption {
type = lib.types.str;
default = "127.0.0.1";
description = ''
Interface to listen on.
'';
};
port = lib.mkOption {
type = lib.types.port;
default = 8000;
description = ''
Port to listen on.
'';
};
extraConfig = lib.mkOption {
type = lib.types.attrs;
default = { };
description = ''
Extra configuration to add to parsoid configuration.
'';
};
};
};
##### implementation
config = lib.mkIf cfg.enable {
systemd.services.parsoid = {
description = "Bidirectional wikitext parser";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
serviceConfig = {
ExecStart = "${parsoid}/lib/node_modules/parsoid/bin/server.js -c ${confFile} -n ${toString cfg.workers}";
DynamicUser = true;
User = "parsoid";
Group = "parsoid";
CapabilityBoundingSet = "";
NoNewPrivileges = true;
ProtectSystem = "strict";
ProtectHome = true;
PrivateTmp = true;
PrivateDevices = true;
ProtectHostname = true;
ProtectKernelTunables = true;
ProtectKernelModules = true;
ProtectControlGroups = true;
RestrictAddressFamilies = [
"AF_INET"
"AF_INET6"
];
RestrictNamespaces = true;
LockPersonality = true;
#MemoryDenyWriteExecute = true;
RestrictRealtime = true;
RestrictSUIDSGID = true;
RemoveIPC = true;
};
};
};
}

250
nixos/modules/services/networking/quorum.nix
View file

@ -1,250 +0,0 @@
{
config,
options,
pkgs,
lib,
...
}:
let
inherit (lib)
mkEnableOption
mkIf
mkOption
literalExpression
types
optionalString
;
cfg = config.services.quorum;
opt = options.services.quorum;
dataDir = "/var/lib/quorum";
genesisFile = pkgs.writeText "genesis.json" (builtins.toJSON cfg.genesis);
staticNodesFile = pkgs.writeText "static-nodes.json" (builtins.toJSON cfg.staticNodes);
in
{
options = {
services.quorum = {
enable = mkEnableOption "Quorum blockchain daemon";
user = mkOption {
type = types.str;
default = "quorum";
description = "The user as which to run quorum.";
};
group = mkOption {
type = types.str;
default = cfg.user;
defaultText = literalExpression "config.${opt.user}";
description = "The group as which to run quorum.";
};
port = mkOption {
type = types.port;
default = 21000;
description = "Override the default port on which to listen for connections.";
};
nodekeyFile = mkOption {
type = types.path;
default = "${dataDir}/nodekey";
description = "Path to the nodekey.";
};
staticNodes = mkOption {
type = types.listOf types.str;
default = [ ];
example = [
"enode://dd333ec28f0a8910c92eb4d336461eea1c20803eed9cf2c056557f986e720f8e693605bba2f4e8f289b1162e5ac7c80c914c7178130711e393ca76abc1d92f57@0.0.0.0:30303?discport=0"
];
description = "List of validator nodes.";
};
privateconfig = mkOption {
type = types.str;
default = "ignore";
description = "Configuration of privacy transaction manager.";
};
syncmode = mkOption {
type = types.enum [
"fast"
"full"
"light"
];
default = "full";
description = "Blockchain sync mode.";
};
blockperiod = mkOption {
type = types.int;
default = 5;
description = "Default minimum difference between two consecutive block's timestamps in seconds.";
};
permissioned = mkOption {
type = types.bool;
default = true;
description = "Allow only a defined list of nodes to connect.";
};
rpc = {
enable = mkOption {
type = types.bool;
default = true;
description = "Enable RPC interface.";
};
address = mkOption {
type = types.str;
default = "0.0.0.0";
description = "Listening address for RPC connections.";
};
port = mkOption {
type = types.port;
default = 22004;
description = "Override the default port on which to listen for RPC connections.";
};
api = mkOption {
type = types.str;
default = "admin,db,eth,debug,miner,net,shh,txpool,personal,web3,quorum,istanbul";
description = "API's offered over the HTTP-RPC interface.";
};
};
ws = {
enable = mkOption {
type = types.bool;
default = true;
description = "Enable WS-RPC interface.";
};
address = mkOption {
type = types.str;
default = "0.0.0.0";
description = "Listening address for WS-RPC connections.";
};
port = mkOption {
type = types.port;
default = 8546;
description = "Override the default port on which to listen for WS-RPC connections.";
};
api = mkOption {
type = types.str;
default = "admin,db,eth,debug,miner,net,shh,txpool,personal,web3,quorum,istanbul";
description = "API's offered over the WS-RPC interface.";
};
origins = mkOption {
type = types.str;
default = "*";
description = "Origins from which to accept websockets requests";
};
};
genesis = mkOption {
type = types.nullOr types.attrs;
default = null;
example = literalExpression ''
{
alloc = {
a47385db68718bdcbddc2d2bb7c54018066ec111 = {
balance = "1000000000000000000000000000";
};
};
coinbase = "0x0000000000000000000000000000000000000000";
config = {
byzantiumBlock = 4;
chainId = 494702925;
eip150Block = 2;
eip155Block = 3;
eip158Block = 3;
homesteadBlock = 1;
isQuorum = true;
istanbul = {
epoch = 30000;
policy = 0;
};
};
difficulty = "0x1";
extraData = "0x0000000000000000000000000000000000000000000000000000000000000000f85ad59438f0508111273d8e482f49410ca4078afc86a961b8410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0";
gasLimit = "0x2FEFD800";
mixHash = "0x63746963616c2062797a616e74696e65201111756c7420746f6c6572616e6365";
nonce = "0x0";
parentHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
timestamp = "0x00";
}'';
description = "Blockchain genesis settings.";
};
};
};
config = mkIf cfg.enable {
environment.systemPackages = [ pkgs.quorum ];
systemd.tmpfiles.rules = [
"d '${dataDir}' 0770 '${cfg.user}' '${cfg.group}' - -"
];
systemd.services.quorum = {
description = "Quorum daemon";
after = [ "network.target" ];
wantedBy = [ "multi-user.target" ];
environment = {
PRIVATE_CONFIG = "${cfg.privateconfig}";
};
preStart = ''
if [ ! -d ${dataDir}/geth ]; then
if [ ! -d ${dataDir}/keystore ]; then
echo ERROR: You need to create a wallet before initializing your genesis file, run:
echo # su -s /bin/sh - quorum
echo $ geth --datadir ${dataDir} account new
echo and configure your genesis file accordingly.
exit 1;
fi
ln -s ${staticNodesFile} ${dataDir}/static-nodes.json
${pkgs.quorum}/bin/geth --datadir ${dataDir} init ${genesisFile}
fi
'';
serviceConfig = {
User = cfg.user;
Group = cfg.group;
ExecStart = ''
${pkgs.quorum}/bin/geth \
--nodiscover \
--verbosity 5 \
--nodekey ${cfg.nodekeyFile} \
--istanbul.blockperiod ${toString cfg.blockperiod} \
--syncmode ${cfg.syncmode} \
${optionalString (cfg.permissioned) "--permissioned"} \
--mine --miner.threads 1 \
${optionalString (cfg.rpc.enable) "--rpc --rpcaddr ${cfg.rpc.address} --rpcport ${toString cfg.rpc.port} --rpcapi ${cfg.rpc.api}"} \
${optionalString (cfg.ws.enable) "--ws --ws.addr ${cfg.ws.address} --ws.port ${toString cfg.ws.port} --ws.api ${cfg.ws.api} --ws.origins ${cfg.ws.origins}"} \
--emitcheckpoints \
--datadir ${dataDir} \
--port ${toString cfg.port}'';
Restart = "on-failure";
# Hardening measures
PrivateTmp = "true";
ProtectSystem = "full";
NoNewPrivileges = "true";
PrivateDevices = "true";
MemoryDenyWriteExecute = "true";
};
};
users.users.${cfg.user} = {
name = cfg.user;
group = cfg.group;
description = "Quorum daemon user";
home = dataDir;
isSystemUser = true;
};
users.groups.${cfg.group} = { };
};
}

8
nixos/modules/services/web-apps/nextcloud.nix
View file

@ -1235,6 +1235,8 @@ in
path = [ occ ];
restartTriggers = [ overrideConfig ];
script = ''
export OCC_BIN="${lib.getExe occ}"
${lib.optionalString (c.dbpassFile != null) ''
if [ -z "$(<"$CREDENTIALS_DIRECTORY/dbpass")" ]; then
echo "dbpassFile ${c.dbpassFile} is empty!"
@ -1275,13 +1277,13 @@ in
${occInstallCmd}
fi
${lib.getExe occ} upgrade
$OCC_BIN upgrade
${lib.getExe occ} config:system:delete trusted_domains
$OCC_BIN config:system:delete trusted_domains
${lib.optionalString (cfg.extraAppsEnable && cfg.extraApps != { }) ''
# Try to enable apps
${lib.getExe occ} app:enable ${lib.concatStringsSep " " (lib.attrNames cfg.extraApps)}
$OCC_BIN app:enable ${lib.concatStringsSep " " (lib.attrNames cfg.extraApps)}
''}
${occSetTrustedDomainsCmd}

2
nixos/modules/virtualisation/incus-virtual-machine.nix
View file

@ -25,7 +25,7 @@ in
partitionTableType = "efi";
format = "qcow2-compressed";
copyChannel = true;
copyChannel = config.system.installer.channel.enable;
};
fileSystems = {

4
nixos/modules/virtualisation/lxc-instance-common.nix
View file

@ -27,7 +27,7 @@
services.openssh.startWhenNeeded = lib.mkDefault true;
# As this is intended as a standalone image, undo some of the minimal profile stuff
documentation.enable = true;
documentation.nixos.enable = true;
documentation.enable = lib.mkDefault true;
documentation.nixos.enable = lib.mkDefault true;
services.logrotate.enable = true;
}

1
nixos/tests/agda/base.nix
View file

@ -26,7 +26,6 @@ in
testScript = ''
# agda and agda-mode are in path
machine.succeed("agda --version")
machine.succeed("agda-mode")
# Minimal script that typechecks
machine.succeed("touch TestEmpty.agda")

16
nixos/tests/all-tests.nix
View file

@ -746,13 +746,14 @@ in
immich-vectorchord-migration = runTest ./web-apps/immich-vectorchord-migration.nix;
immich-vectorchord-reindex = runTest ./web-apps/immich-vectorchord-reindex.nix;
incron = runTest ./incron.nix;
incus = recurseIntoAttrs (
handleTest ./incus {
lts = false;
inherit system pkgs;
}
);
incus-lts = recurseIntoAttrs (handleTest ./incus { inherit system pkgs; });
incus = import ./incus {
inherit runTestOn;
package = pkgs.incus;
};
incus-lts = import ./incus {
inherit runTestOn;
package = pkgs.incus-lts;
};
influxdb = runTest ./influxdb.nix;
influxdb2 = runTest ./influxdb2.nix;
initrd-luks-empty-passphrase = runTest ./initrd-luks-empty-passphrase.nix;
@ -1298,7 +1299,6 @@ in
quake3 = runTest ./quake3.nix;
quicktun = runTest ./quicktun.nix;
quickwit = runTest ./quickwit.nix;
quorum = runTest ./quorum.nix;
rabbitmq = runTest ./rabbitmq.nix;
radarr = runTest ./radarr.nix;
radicale = runTest ./radicale.nix;

133
nixos/tests/incus/default.nix
View file

@ -1,51 +1,98 @@
{
system ? builtins.currentSystem,
config ? { },
pkgs ? import ../../.. { inherit system config; },
lts ? true,
...
package,
runTestOn,
}:
let
incusTest = import ./incus-tests.nix;
incusRunTest =
config:
runTestOn [ "x86_64-linux" "aarch64-linux" ] {
imports = [
./incus-tests-module.nix
./incus-tests.nix
];
tests.incus = {
inherit package;
}
// config;
};
in
{
all = incusTest {
inherit lts pkgs system;
allTests = true;
};
container = incusTest {
inherit lts pkgs system;
instanceContainer = true;
};
lvm = incusTest {
inherit lts pkgs system;
storageLvm = true;
};
openvswitch = incusTest {
inherit lts pkgs system;
networkOvs = true;
};
ui = import ./ui.nix {
inherit lts pkgs system;
};
virtual-machine = incusTest {
inherit lts pkgs system;
instanceVm = true;
};
zfs = incusTest {
inherit lts pkgs system;
storageZfs = true;
};
appArmor = incusTest {
inherit lts pkgs system;
# this is the main test which will test as much as possible
# run this for testing incus upgrades, also available in incus package tests
all = incusRunTest {
name = "all";
appArmor = true;
allTests = true;
feature.user = true;
instances = {
c1 = {
type = "container";
};
vm1 = {
type = "virtual-machine";
};
};
network = {
ovs = true;
};
storage = {
lvm = true;
zfs = true;
};
};
# used in lxc tests to verify container functionality
container = incusRunTest {
name = "container";
instances.c1 = {
type = "container";
};
};
lvm = incusRunTest {
name = "lvm";
storage.lvm = true;
};
openvswitch = incusRunTest {
name = "openvswitch";
network.ovs = true;
};
ui = runTestOn [ "x86_64-linux" "aarch64-linux" ] {
imports = [ ./ui.nix ];
_module.args = { inherit package; };
};
virtual-machine = incusRunTest {
name = "virtual-machine";
instances = {
vm1 = {
type = "virtual-machine";
};
# disabled because never becomes available
# csm = {
# type = "virtual-machine";
# incusConfig.config = {
# "security.csm" = true;
# };
# };
};
};
zfs = incusRunTest {
name = "zfs";
storage.zfs = true;
};
}

262
nixos/tests/incus/incus-tests-module.nix Normal file
View file

@ -0,0 +1,262 @@
{
lib,
pkgs,
...
}:
let
jsonFormat = pkgs.formats.json { };
in
{
options.tests.incus = {
name = lib.mkOption {
type = lib.types.str;
description = "name appended to test";
};
package = lib.mkPackageOption pkgs "incus" { };
preseed = lib.mkOption {
description = "configuration provided to incus preseed. https://linuxcontainers.org/incus/docs/main/howto/initialize/#non-interactive-configuration";
type = lib.types.submodule {
freeformType = jsonFormat.type;
};
};
instances = lib.mkOption {
type = lib.types.attrsOf (
lib.types.submodule (
{ name, config, ... }:
{
options = {
name = lib.mkOption {
type = lib.types.str;
default = name;
};
type = lib.mkOption {
type = lib.types.enum [
"container"
"virtual-machine"
];
};
imageAlias = lib.mkOption {
type = lib.types.str;
description = "name of image when imported";
default = "nixos/${name}/${config.type}";
};
nixosConfig = lib.mkOption {
type = lib.types.attrsOf lib.types.anything;
default = { };
};
incusConfig = lib.mkOption {
type = lib.types.submodule {
freeformType = jsonFormat.type;
};
description = "incus configuration provided at launch";
default = { };
};
testScript = lib.mkOption {
type = lib.types.str;
description = "final script provided to test runner";
readOnly = true;
};
};
config =
let
releases = import ../../release.nix {
configuration = config.nixosConfig;
};
images = {
container = {
metadata =
releases.incusContainerMeta.${pkgs.stdenv.hostPlatform.system}
+ "/tarball/nixos-image-lxc-*-${pkgs.stdenv.hostPlatform.system}.tar.xz";
root =
releases.incusContainerImage.${pkgs.stdenv.hostPlatform.system}
+ "/nixos-lxc-image-${pkgs.stdenv.hostPlatform.system}.squashfs";
};
virtual-machine = {
metadata = releases.incusVirtualMachineImageMeta.${pkgs.stdenv.hostPlatform.system} + "/*/*.tar.xz";
root = releases.incusVirtualMachineImage.${pkgs.stdenv.hostPlatform.system} + "/nixos.qcow2";
};
};
root = images.${config.type}.root;
metadata = images.${config.type}.metadata;
image_id = "${config.type}/${config.name}";
in
{
incusConfig = lib.optionalAttrs (config.type == "virtual-machine") {
config."security.secureboot" = false;
};
nixosConfig = {
# Building documentation makes the test unnecessarily take a longer time:
documentation.enable = lib.mkForce false;
documentation.nixos.enable = lib.mkForce false;
# including a channel forces images to be rebuilt on any changes
system.installer.channel.enable = lib.mkForce false;
environment.etc."nix/registry.json".text = lib.mkForce "{}";
# Arbitrary sysctl setting changed from nixos default
# used for verifying `distrobuilder.generator` properly allows
# for containers to modify sysctl
boot.kernel.sysctl."net.ipv4.ip_forward" = "1";
};
testScript = # python
''
with subtest("[${image_id}] image can be imported"):
server.succeed("incus image import ${metadata} ${root} --alias ${config.imageAlias}")
with subtest("[${image_id}] can be launched and managed"):
instance_name = server.succeed("incus launch ${config.imageAlias}${
lib.optionalString (config.type == "virtual-machine") " --vm"
} --quiet < ${jsonFormat.generate "${config.name}.json" config.incusConfig}").split(":")[1].strip()
server.wait_for_instance(instance_name)
with subtest("[${image_id}] can successfully restart"):
server.succeed(f"incus restart {instance_name}")
server.wait_for_instance(instance_name)
with subtest("[${image_id}] remains running when softDaemonRestart is enabled and service is stopped"):
pid = server.succeed(f"incus info {instance_name} | grep 'PID'").split(":")[1].strip()
server.succeed(f"ps {pid}")
server.succeed("systemctl stop incus")
server.succeed(f"ps {pid}")
server.succeed("systemctl start incus")
with subtest("[${image_id}] CPU limits can be managed"):
server.set_instance_config(instance_name, "limits.cpu 1", restart=True)
server.wait_instance_exec_success(instance_name, "nproc | grep '^1$'", timeout=90)
with subtest("[${image_id}] CPU limits can be hotplug changed"):
server.set_instance_config(instance_name, "limits.cpu 2")
server.wait_instance_exec_success(instance_name, "nproc | grep '^2$'", timeout=90)
with subtest("[${image_id}] exec has a valid path"):
server.succeed(f"incus exec {instance_name} -- bash -c 'true'")
with subtest("[${image_id}] software tpm can be configured"):
# this can be hot added to containers, but stopping for vm
server.succeed(f"incus stop {instance_name}")
server.succeed(f"incus config device add {instance_name} vtpm tpm path=/dev/tpm0 pathrm=/dev/tpmrm0")
server.succeed(f"incus start {instance_name}")
server.wait_for_instance(instance_name)
server.succeed(f"incus exec {instance_name} -- test -e /dev/tpm0")
server.succeed(f"incus exec {instance_name} -- test -e /dev/tpmrm0")
''
#
# container specific
#
+
lib.optionalString (config.type == "container")
# python
''
# TODO troubleshoot VM hot memory resizing which was introduced in 6.12
with subtest("[${image_id}] memory limits can be hotplug changed"):
server.set_instance_config(instance_name, "limits.memory 512MB")
# can't use lsmem since it sees the host's memory size
server.wait_instance_exec_success(instance_name, "grep 'MemTotal:[[:space:]]*500000 kB' /proc/meminfo", timeout=1)
# verify the patched container systemd generator from `pkgs.distrobuilder.generator`
with subtest("[${image_id}] lxc-generator compatibility"):
with subtest("[${image_id}] lxc-container generator configures plain container"):
# default container is plain
server.succeed(f"incus exec {instance_name} test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
server.check_instance_sysctl(instance_name)
with subtest("[${image_id}] lxc-container generator configures nested container"):
server.set_instance_config(instance_name, "security.nesting=true", restart=True)
server.fail(f"incus exec {instance_name} test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
target = server.succeed(f"incus exec {instance_name} readlink -- -f /run/systemd/system/systemd-binfmt.service").strip()
assert target == "/dev/null", "lxc generator did not correctly mask /run/systemd/system/systemd-binfmt.service"
server.check_instance_sysctl(instance_name)
with subtest("[${image_id}] lxcfs"):
with subtest("[${image_id}] mounts lxcfs overlays"):
server.succeed(f"incus exec {instance_name} mount | grep 'lxcfs on /proc/cpuinfo type fuse.lxcfs'")
server.succeed(f"incus exec {instance_name} mount | grep 'lxcfs on /proc/meminfo type fuse.lxcfs'")
with subtest("[${image_id}] supports per-instance lxcfs"):
server.succeed(f"incus stop {instance_name}")
server.fail(f"pgrep -a lxcfs | grep 'incus/devices/{instance_name}/lxcfs'")
server.succeed("incus config set instances.lxcfs.per_instance=true")
server.succeed(f"incus start {instance_name}")
server.wait_for_instance(instance_name)
server.succeed(f"pgrep -a lxcfs | grep 'incus/devices/{instance_name}/lxcfs'")
''
#
# virtual-machine specific
#
+
lib.optionalString (config.type == "virtual-machine")
# python
''
with subtest("[${image_id}] memory limits can be managed"):
server.set_instance_config(instance_name, "limits.memory 384MB", restart=True)
lsmem = json.loads(server.instance_succeed(instance_name, "lsmem --json"))
memsize = lsmem["memory"][0]["size"]
assert memsize == "384M", f"failed to manage memory limit. {memsize} != 384M"
with subtest("[${image_id}] incus-agent is started"):
server.succeed(f"incus exec {instance_name} systemctl is-active incus-agent")
''
+
#
# finalize
#
# python
''
# this will leave the instances stopped
with subtest("[${image_id}] stop with incus-startup.service"):
pid = server.succeed(f"incus info {instance_name} | grep 'PID'").split(":")[1].strip()
server.succeed(f"ps {pid}")
server.succeed("systemctl stop incus-startup.service")
server.wait_until_fails(f"ps {pid}", timeout=120)
server.succeed("systemctl start incus-startup.service")
'';
};
}
)
);
description = "";
default = { };
};
appArmor = lib.mkEnableOption "AppArmor during tests";
feature.user = lib.mkEnableOption "Validate incus user access feature";
network.ovs = lib.mkEnableOption "Validate OVS network integration";
storage = {
lvm = lib.mkEnableOption "Validate LVM storage integration";
zfs = lib.mkEnableOption "Validate ZFS storage integration";
};
};
config = {
tests.incus = { };
};
}

626
nixos/tests/incus/incus-tests.nix
View file

@ -1,500 +1,218 @@
import ../make-test-python.nix (
{
pkgs,
lib,
{
config,
pkgs,
lib,
...
}:
lts ? true,
let
cfg = config.tests.incus;
allTests ? false,
# limit building of VMs to these systems as nested virtualization is
# required to test VMs, but support for this is poor outside x86
# will print warnings on those systems rather than failing outright
vmsEnabled = lib.elem pkgs.stdenv.system [ "x86_64-linux" ];
appArmor ? false,
featureUser ? allTests,
initLegacy ? true,
initSystemd ? true,
instanceContainer ? allTests,
instanceVm ? allTests,
networkOvs ? allTests,
storageLvm ? allTests,
storageZfs ? allTests,
...
}:
instanceScript = lib.pipe cfg.instances [
(lib.filterAttrs (
name: instance:
let
keep = instance.type != "virtual-machine" || vmsEnabled;
in
lib.warnIf (!keep) ''
Skipping virtual-machine ${name} as VMs are disabled on ${pkgs.stdenv.system}
'' keep
))
(lib.foldlAttrs (
acc: name: instance:
acc + instance.testScript
) "")
];
in
{
name = "${cfg.package.name}-${cfg.name}";
let
releases =
init:
import ../../release.nix {
configuration = {
# Building documentation makes the test unnecessarily take a longer time:
documentation.enable = lib.mkForce false;
meta = {
maintainers = lib.teams.lxc.members;
};
boot.initrd.systemd.enable = init == "systemd";
nodes.server = {
virtualisation = {
cores = 2;
memorySize = 4096;
diskSize = 20 * 1024;
emptyDiskImages = [
# vdb for zfs
2048
# vdc for lvm
2048
];
# Arbitrary sysctl modification to ensure containers can update sysctl
boot.kernel.sysctl."net.ipv4.ip_forward" = "1";
incus = {
enable = true;
package = cfg.package;
preseed = {
networks = [
{
name = "incusbr0";
type = "bridge";
config = {
"ipv4.address" = "10.0.10.1/24";
"ipv4.nat" = "true";
};
}
]
++ lib.optionals cfg.network.ovs [
{
name = "ovsbr0";
type = "bridge";
config = {
"bridge.driver" = "openvswitch";
"ipv4.address" = "10.0.20.1/24";
"ipv4.nat" = "true";
};
}
];
profiles = [
{
name = "default";
devices = {
eth0 = {
name = "eth0";
network = "incusbr0";
type = "nic";
};
root = {
path = "/";
pool = "default";
size = "35GiB";
type = "disk";
};
};
}
];
storage_pools = [
{
name = "default";
driver = "dir";
}
];
};
};
images = init: {
container = {
metadata =
(releases init).incusContainerMeta.${pkgs.stdenv.hostPlatform.system}
+ "/tarball/nixos-image-lxc-*-${pkgs.stdenv.hostPlatform.system}.tar.xz";
rootfs =
(releases init).incusContainerImage.${pkgs.stdenv.hostPlatform.system}
+ "/nixos-lxc-image-${pkgs.stdenv.hostPlatform.system}.squashfs";
};
virtual-machine = {
metadata =
(releases init).incusVirtualMachineImageMeta.${pkgs.stdenv.hostPlatform.system} + "/*/*.tar.xz";
disk = (releases init).incusVirtualMachineImage.${pkgs.stdenv.hostPlatform.system} + "/nixos.qcow2";
};
vswitch.enable = cfg.network.ovs;
};
initVariants = lib.optionals initLegacy [ "legacy" ] ++ lib.optionals initSystemd [ "systemd" ];
boot.supportedFilesystems = { inherit (cfg.storage) zfs; };
boot.zfs.forceImportRoot = false;
canTestVm = instanceVm && pkgs.stdenv.isLinux && pkgs.stdenv.isx86_64;
in
{
name = "incus" + lib.optionalString lts "-lts";
environment.systemPackages = [ pkgs.parted ];
meta = {
maintainers = lib.teams.lxc.members;
networking.hostId = "01234567";
networking.firewall.trustedInterfaces = [ "incusbr0" ];
networking.nftables.enable = true;
security.apparmor.enable = cfg.appArmor;
services.dbus.apparmor = (if cfg.appArmor then "enabled" else "disabled");
services.lvm = {
boot.thin.enable = cfg.storage.lvm;
dmeventd.enable = cfg.storage.lvm;
};
nodes.machine = {
virtualisation = {
cores = 2;
memorySize = 2048;
diskSize = 12 * 1024;
emptyDiskImages = [
# vdb for zfs
2048
# vdc for lvm
2048
];
incus = {
enable = true;
package = if lts then pkgs.incus-lts else pkgs.incus;
preseed = {
networks = [
{
name = "incusbr0";
type = "bridge";
config = {
"ipv4.address" = "10.0.10.1/24";
"ipv4.nat" = "true";
};
}
]
++ lib.optionals networkOvs [
{
name = "ovsbr0";
type = "bridge";
config = {
"bridge.driver" = "openvswitch";
"ipv4.address" = "10.0.20.1/24";
"ipv4.nat" = "true";
};
}
];
profiles = [
{
name = "default";
devices = {
eth0 = {
name = "eth0";
network = "incusbr0";
type = "nic";
};
root = {
path = "/";
pool = "default";
size = "35GiB";
type = "disk";
};
};
}
];
storage_pools = [
{
name = "default";
driver = "dir";
}
];
};
};
vswitch.enable = networkOvs;
};
boot.supportedFilesystems = lib.optionals storageZfs [ "zfs" ];
boot.zfs.forceImportRoot = false;
environment.systemPackages = [ pkgs.parted ];
networking.hostId = "01234567";
networking.firewall.trustedInterfaces = [ "incusbr0" ];
security.apparmor.enable = appArmor;
services.dbus.apparmor = (if appArmor then "enabled" else "disabled");
services.lvm = {
boot.thin.enable = storageLvm;
dmeventd.enable = storageLvm;
};
networking.nftables.enable = true;
users.users.testuser = {
isNormalUser = true;
shell = pkgs.bashInteractive;
group = "incus";
uid = 1000;
};
users.users.testuser = {
isNormalUser = true;
shell = pkgs.bashInteractive;
group = "incus";
uid = 1000;
};
};
testScript = # python
''
import json
def wait_for_instance(name: str, project: str = "default"):
machine.wait_until_succeeds(f"incus exec {name} --disable-stdin --force-interactive --project {project} -- /run/current-system/sw/bin/systemctl is-system-running")
def wait_incus_exec_success(name: str, command: str, timeout: int = 900, project: str = "default"):
def check_command(_) -> bool:
status, _ = machine.execute(f"incus exec {name} --disable-stdin --force-interactive --project {project} -- {command}")
return status == 0
with machine.nested(f"Waiting for successful exec: {command}"):
retry(check_command, timeout)
def set_config(name: str, config: str, restart: bool = False, unset: bool = False):
if restart:
machine.succeed(f"incus stop {name}")
if unset:
machine.succeed(f"incus config unset {name} {config}")
else:
machine.succeed(f"incus config set {name} {config}")
if restart:
machine.succeed(f"incus start {name}")
wait_for_instance(name)
else:
# give a moment to settle
machine.sleep(1)
def cleanup():
# avoid conflict between preseed and cleanup operations
machine.execute("systemctl kill incus-preseed.service")
instances = json.loads(machine.succeed("incus list --format json --all-projects"))
with subtest("Stopping all running instances"):
for instance in [a for a in instances if a['status'] == 'Running']:
machine.execute(f"incus stop --force {instance['name']} --project {instance['project']}")
machine.execute(f"incus delete --force {instance['name']} --project {instance['project']}")
def check_sysctl(name: str):
with subtest("systemd sysctl settings are applied"):
machine.succeed(f"incus exec {name} -- systemctl status systemd-sysctl")
sysctl = machine.succeed(f"incus exec {name} -- sysctl net.ipv4.ip_forward").strip().split(" ")[-1]
assert "1" == sysctl, f"systemd-sysctl configuration not correctly applied, {sysctl} != 1"
with subtest("Wait for startup"):
machine.wait_for_unit("incus.service")
machine.wait_for_unit("incus-preseed.service")
with subtest("Verify preseed resources created"):
machine.succeed("incus profile show default")
machine.succeed("incus network info incusbr0")
machine.succeed("incus storage show default")
''
+ lib.optionalString appArmor ''
with subtest("Verify AppArmor service is started without issue"):
# restart AppArmor service since the Incus AppArmor folders are
# created after AA service is started
machine.systemctl("restart apparmor.service")
machine.succeed("systemctl --no-pager -l status apparmor.service")
machine.wait_for_unit("apparmor.service")
''
+ lib.optionalString instanceContainer (
lib.foldl (
acc: variant:
acc
# python
+ ''
metadata = "${(images variant).container.metadata}"
rootfs = "${(images variant).container.rootfs}"
alias = "nixos/container/${variant}"
variant = "${variant}"
with subtest("container image can be imported"):
machine.succeed(f"incus image import {metadata} {rootfs} --alias {alias}")
with subtest("container can be launched and managed"):
machine.succeed(f"incus launch {alias} container-{variant}1")
wait_for_instance(f"container-{variant}1")
with subtest("container mounts lxcfs overlays"):
machine.succeed(f"incus exec container-{variant}1 mount | grep 'lxcfs on /proc/cpuinfo type fuse.lxcfs'")
machine.succeed(f"incus exec container-{variant}1 mount | grep 'lxcfs on /proc/meminfo type fuse.lxcfs'")
with subtest("container CPU limits can be managed"):
set_config(f"container-{variant}1", "limits.cpu 1", restart=True)
wait_incus_exec_success(f"container-{variant}1", "nproc | grep '^1$'", timeout=90)
with subtest("container CPU limits can be hotplug changed"):
set_config(f"container-{variant}1", "limits.cpu 2")
wait_incus_exec_success(f"container-{variant}1", "nproc | grep '^2$'", timeout=90)
with subtest("container memory limits can be managed"):
set_config(f"container-{variant}1", "limits.memory 128MB", restart=True)
wait_incus_exec_success(f"container-{variant}1", "grep 'MemTotal:[[:space:]]*125000 kB' /proc/meminfo", timeout=90)
with subtest("container memory limits can be hotplug changed"):
set_config(f"container-{variant}1", "limits.memory 256MB")
wait_incus_exec_success(f"container-{variant}1", "grep 'MemTotal:[[:space:]]*250000 kB' /proc/meminfo", timeout=90)
with subtest("container software tpm can be configured"):
machine.succeed(f"incus config device add container-{variant}1 vtpm tpm path=/dev/tpm0 pathrm=/dev/tpmrm0")
machine.succeed(f"incus exec container-{variant}1 -- test -e /dev/tpm0")
machine.succeed(f"incus exec container-{variant}1 -- test -e /dev/tpmrm0")
machine.succeed(f"incus config device remove container-{variant}1 vtpm")
machine.fail(f"incus exec container-{variant}1 -- test -e /dev/tpm0")
with subtest("container lxc-generator compatibility"):
with subtest("lxc-container generator configures plain container"):
# default container is plain
machine.succeed(f"incus exec container-{variant}1 test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
check_sysctl(f"container-{variant}1")
with subtest("lxc-container generator configures nested container"):
set_config(f"container-{variant}1", "security.nesting=true", restart=True)
machine.fail(f"incus exec container-{variant}1 test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
target = machine.succeed(f"incus exec container-{variant}1 readlink -- -f /run/systemd/system/systemd-binfmt.service").strip()
assert target == "/dev/null", "lxc generator did not correctly mask /run/systemd/system/systemd-binfmt.service"
check_sysctl(f"container-{variant}1")
with subtest("lxc-container generator configures privileged container"):
# Create a new instance for a clean state
machine.succeed(f"incus launch {alias} container-{variant}2")
wait_for_instance(f"container-{variant}2")
machine.succeed(f"incus exec container-{variant}2 test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
check_sysctl(f"container-{variant}2")
with subtest("container supports per-instance lxcfs"):
machine.succeed(f"incus stop container-{variant}1")
machine.fail(f"pgrep -a lxcfs | grep 'incus/devices/container-{variant}1/lxcfs'")
machine.succeed("incus config set instances.lxcfs.per_instance=true")
machine.succeed(f"incus start container-{variant}1")
wait_for_instance(f"container-{variant}1")
machine.succeed(f"pgrep -a lxcfs | grep 'incus/devices/container-{variant}1/lxcfs'")
with subtest("container can successfully restart"):
machine.succeed(f"incus restart container-{variant}1")
wait_for_instance(f"container-{variant}1")
with subtest("container remains running when softDaemonRestart is enabled and service is stopped"):
pid = machine.succeed(f"incus info container-{variant}1 | grep 'PID'").split(":")[1].strip()
machine.succeed(f"ps {pid}")
machine.succeed("systemctl stop incus")
machine.succeed(f"ps {pid}")
machine.succeed("systemctl start incus")
with subtest("containers stop with incus-startup.service"):
pid = machine.succeed(f"incus info container-{variant}1 | grep 'PID'").split(":")[1].strip()
machine.succeed(f"ps {pid}")
machine.succeed("systemctl stop incus-startup.service")
machine.wait_until_fails(f"ps {pid}", timeout=120)
machine.succeed("systemctl start incus-startup.service")
cleanup()
''
) "" initVariants
)
+ lib.optionalString canTestVm (
(lib.foldl (
acc: variant:
acc
# python
+ ''
metadata = "${(images variant).virtual-machine.metadata}"
disk = "${(images variant).virtual-machine.disk}"
alias = "nixos/virtual-machine/${variant}"
variant = "${variant}"
with subtest("virtual-machine image can be imported"):
machine.succeed(f"incus image import {metadata} {disk} --alias {alias}")
with subtest("virtual-machine can be created"):
machine.succeed(f"incus create {alias} vm-{variant}1 --vm --config limits.memory=512MB --config security.secureboot=false")
with subtest("virtual-machine software tpm can be configured"):
machine.succeed(f"incus config device add vm-{variant}1 vtpm tpm path=/dev/tpm0")
with subtest("virtual-machine can be launched and become available"):
machine.succeed(f"incus start vm-{variant}1")
wait_for_instance(f"vm-{variant}1")
with subtest("virtual-machine incus-agent is started"):
machine.succeed(f"incus exec vm-{variant}1 systemctl is-active incus-agent")
with subtest("virtual-machine incus-agent has a valid path"):
machine.succeed(f"incus exec vm-{variant}1 -- bash -c 'true'")
with subtest("virtual-machine CPU limits can be managed"):
set_config(f"vm-{variant}1", "limits.cpu 1", restart=True)
wait_incus_exec_success(f"vm-{variant}1", "nproc | grep '^1$'", timeout=90)
with subtest("virtual-machine CPU limits can be hotplug changed"):
set_config(f"vm-{variant}1", "limits.cpu 2")
wait_incus_exec_success(f"vm-{variant}1", "nproc | grep '^2$'", timeout=90)
with subtest("virtual-machine can successfully restart"):
machine.succeed(f"incus restart vm-{variant}1")
wait_for_instance(f"vm-{variant}1")
with subtest("virtual-machine remains running when softDaemonRestart is enabled and service is stopped"):
pid = machine.succeed(f"incus info vm-{variant}1 | grep 'PID'").split(":")[1].strip()
machine.succeed(f"ps {pid}")
machine.succeed("systemctl stop incus")
machine.succeed(f"ps {pid}")
machine.succeed("systemctl start incus")
with subtest("virtual-machines stop with incus-startup.service"):
pid = machine.succeed(f"incus info vm-{variant}1 | grep 'PID'").split(":")[1].strip()
machine.succeed(f"ps {pid}")
machine.succeed("systemctl stop incus-startup.service")
machine.wait_until_fails(f"ps {pid}", timeout=120)
machine.succeed("systemctl start incus-startup.service")
cleanup()
''
) "" initVariants)
+
# python
''
with subtest("virtual-machine can launch CSM (BIOS)"):
machine.succeed("incus init csm --vm --empty -c security.csm=true -c security.secureboot=false")
machine.succeed("incus start csm")
cleanup()
''
)
testScript =
lib.readFile ./incus_machine.py
+
lib.optionalString featureUser # python
''
with subtest("incus-user allows restricted access for users"):
machine.fail("incus project show user-1000")
machine.succeed("su - testuser bash -c 'incus list'")
# a project is created dynamically for the user
machine.succeed("incus project show user-1000")
# users shouldn't be able to list storage pools
machine.fail("su - testuser bash -c 'incus storage list'")
with subtest("incus-user allows users to launch instances"):
machine.succeed("su - testuser bash -c 'incus image import ${(images "systemd").container.metadata} ${(images "systemd").container.rootfs} --alias nixos'")
machine.succeed("su - testuser bash -c 'incus launch nixos instance2'")
wait_for_instance("instance2", "user-1000")
cleanup()
''
# python
''
server = IncusHost(machine)
''
+
lib.optionalString networkOvs # python
lib.optionalString cfg.network.ovs # python
''
with subtest("Verify openvswitch bridge"):
machine.succeed("incus network info ovsbr0")
server.succeed("incus network info ovsbr0")
with subtest("Verify openvswitch bridge"):
machine.succeed("ovs-vsctl br-exists ovsbr0")
server.succeed("ovs-vsctl br-exists ovsbr0")
''
+
lib.optionalString storageZfs # python
lib.optionalString cfg.storage.zfs # python
''
with subtest("Verify zfs pool created and usable"):
machine.succeed(
server.succeed(
"zpool status",
"parted --script /dev/vdb mklabel gpt",
"zpool create zfs_pool /dev/vdb",
)
machine.succeed("incus storage create zfs_pool zfs source=zfs_pool/incus")
machine.succeed("zfs list zfs_pool/incus")
server.succeed("incus storage create zfs_pool zfs source=zfs_pool/incus")
server.succeed("zfs list zfs_pool/incus")
machine.succeed("incus storage volume create zfs_pool test_fs --type filesystem")
machine.succeed("incus storage volume create zfs_pool test_vol --type block")
server.succeed("incus storage volume create zfs_pool test_fs --type filesystem")
server.succeed("incus storage volume create zfs_pool test_vol --type block")
machine.succeed("incus storage show zfs_pool")
machine.succeed("incus storage volume list zfs_pool")
machine.succeed("incus storage volume show zfs_pool test_fs")
machine.succeed("incus storage volume show zfs_pool test_vol")
server.succeed("incus storage show zfs_pool")
server.succeed("incus storage volume list zfs_pool")
server.succeed("incus storage volume show zfs_pool test_fs")
server.succeed("incus storage volume show zfs_pool test_vol")
machine.succeed("incus create zfs1 --empty --storage zfs_pool")
machine.succeed("incus list zfs1")
server.succeed("incus create zfs1 --empty --storage zfs_pool")
server.succeed("incus list zfs1")
''
+
lib.optionalString storageLvm # python
lib.optionalString cfg.storage.lvm # python
''
with subtest("Verify lvm pool created and usable"):
machine.succeed("incus storage create lvm_pool lvm source=/dev/vdc lvm.vg_name=incus_pool")
machine.succeed("vgs incus_pool")
server.succeed("incus storage create lvm_pool lvm source=/dev/vdc lvm.vg_name=incus_pool")
server.succeed("vgs incus_pool")
machine.succeed("incus storage volume create lvm_pool test_fs --type filesystem")
machine.succeed("incus storage volume create lvm_pool test_vol --type block")
server.succeed("incus storage volume create lvm_pool test_fs --type filesystem")
server.succeed("incus storage volume create lvm_pool test_vol --type block")
machine.succeed("incus storage show lvm_pool")
server.succeed("incus storage show lvm_pool")
machine.succeed("incus storage volume list lvm_pool")
machine.succeed("incus storage volume show lvm_pool test_fs")
machine.succeed("incus storage volume show lvm_pool test_vol")
server.succeed("incus storage volume list lvm_pool")
server.succeed("incus storage volume show lvm_pool test_fs")
server.succeed("incus storage volume show lvm_pool test_vol")
machine.succeed("incus create lvm1 --empty --storage lvm_pool")
machine.succeed("incus list lvm1")
'';
}
)
server.succeed("incus create lvm1 --empty --storage lvm_pool")
server.succeed("incus list lvm1")
''
+
lib.optionalString cfg.appArmor # python
''
with subtest("Verify AppArmor service is started without issue"):
# restart AppArmor service since the Incus AppArmor folders are
# created after AA service is started
server.systemctl("restart apparmor.service")
server.succeed("systemctl --no-pager -l status apparmor.service")
server.wait_for_unit("apparmor.service")
''
+
lib.optionalString cfg.feature.user # python
''
with subtest("incus-user allows restricted access for users"):
server.fail("incus project show user-1000")
server.succeed("su - testuser bash -c 'incus list'")
# a project is created dynamically for the user
server.succeed("incus project show user-1000")
# users shouldn't be able to list storage pools
server.fail("su - testuser bash -c 'incus storage list'")
# user can create an instance
server.succeed("su - testuser bash -c 'incus create --empty'")
''
+ instanceScript;
}

92
nixos/tests/incus/incus_machine.py Normal file
View file

@ -0,0 +1,92 @@
import json
class IncusHost(Machine):
def __init__(self, base):
with subtest("Wait for startup"):
base.wait_for_unit("incus.service")
base.wait_for_unit("incus-preseed.service")
with subtest("Verify preseed resources created"):
base.succeed("incus profile show default")
base.succeed("incus network info incusbr0")
base.succeed("incus storage show default")
self._parent = base
# delegate attribute access to the parent
def __getattr__(self, name):
return getattr(self._parent, name)
def instance_exec(self, name: str, command: str, project: str = "default"):
return super().execute(
f"incus exec {name} --disable-stdin --force-interactive --project {project} -- {command}"
)
def instance_succeed(self, name: str, command: str, project: str = "default"):
return super().succeed(
f"incus exec {name} --disable-stdin --force-interactive --project {project} -- {command}"
)
def wait_for_instance(self, name: str, project: str = "default"):
self.wait_instance_exec_success(
name,
"/run/current-system/sw/bin/systemctl is-system-running",
project=project,
)
def wait_instance_exec_success(
self, name: str, command: str, timeout: int = 900, project: str = "default"
):
def check_command(_) -> bool:
status, _ = self.instance_exec(name, command, project)
return status == 0
with super().nested(
f"Waiting for successful instance exec, instance={name}, project={project}, command={command}"
):
retry(check_command, timeout)
def set_instance_config(
self, name: str, config: str, restart: bool = False, unset: bool = False
):
if restart:
super().succeed(f"incus stop {name}")
if unset:
super().succeed(f"incus config unset {name} {config}")
else:
super().succeed(f"incus config set {name} {config}")
if restart:
super().succeed(f"incus start {name}")
self.wait_for_instance(name)
else:
# give a moment to settle
super().sleep(1)
def cleanup(self):
# avoid conflict between preseed and cleanup operations
super().execute("systemctl kill incus-preseed.service")
instances = json.loads(
super().succeed("incus list --format json --all-projects")
)
for instance in [a for a in instances if a["status"] == "Running"]:
super().execute(
f"incus stop --force {instance['name']} --project {instance['project']}"
)
super().execute(
f"incus delete --force {instance['name']} --project {instance['project']}"
)
def check_instance_sysctl(self, name: str, project: str = "default"):
self.instance_succeed(name, "systemctl status systemd-sysctl", project)
sysctl = (
self.instance_succeed(name, "sysctl net.ipv4.ip_forward", project)
.strip()
.split(" ")[-1]
)
assert "1" == sysctl, (
f"systemd-sysctl configuration not correctly applied, {sysctl} != 1"
)

146
nixos/tests/incus/ui.nix
View file

@ -1,84 +1,82 @@
import ../make-test-python.nix (
{
pkgs,
lib,
lts ? true,
...
}:
{
name = "incus-ui";
{
pkgs,
lib,
package,
...
}:
{
name = "incus-ui";
meta = {
maintainers = lib.teams.lxc.members;
};
meta = {
maintainers = lib.teams.lxc.members;
};
nodes.machine =
{ lib, ... }:
{
nodes.machine =
{ lib, ... }:
{
virtualisation.incus = {
enable = true;
package = if lts then pkgs.incus-lts else pkgs.incus;
virtualisation.incus = {
enable = true;
inherit package;
preseed.config."core.https_address" = ":8443";
ui.enable = true;
};
networking.nftables.enable = true;
environment.systemPackages =
let
seleniumScript =
pkgs.writers.writePython3Bin "selenium-script"
{
libraries = with pkgs.python3Packages; [ selenium ];
}
''
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support.ui import WebDriverWait
options = Options()
options.add_argument("--headless")
service = webdriver.FirefoxService(executable_path="${lib.getExe pkgs.geckodriver}") # noqa: E501
driver = webdriver.Firefox(options=options, service=service)
driver.implicitly_wait(10)
driver.get("https://localhost:8443/ui")
wait = WebDriverWait(driver, 60)
assert len(driver.find_elements(By.CLASS_NAME, "l-application")) > 0
assert len(driver.find_elements(By.CLASS_NAME, "l-navigation__drawer")) > 0
driver.close()
'';
in
with pkgs;
[
curl
firefox-unwrapped
geckodriver
seleniumScript
];
preseed.config."core.https_address" = ":8443";
ui.enable = true;
};
testScript = ''
machine.wait_for_unit("incus.service")
machine.wait_for_unit("incus-preseed.service")
networking.nftables.enable = true;
# Check that the INCUS_UI environment variable is populated in the systemd unit
machine.succeed("systemctl cat incus.service | grep 'INCUS_UI'")
environment.systemPackages =
let
seleniumScript =
pkgs.writers.writePython3Bin "selenium-script"
{
libraries = with pkgs.python3Packages; [ selenium ];
}
''
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support.ui import WebDriverWait
# Ensure the endpoint returns an HTML page with 'Incus UI' in the title
machine.succeed("curl -kLs https://localhost:8443/ui | grep '<title>Incus UI</title>'")
options = Options()
options.add_argument("--headless")
service = webdriver.FirefoxService(executable_path="${lib.getExe pkgs.geckodriver}") # noqa: E501
# Ensure the documentation is rendering correctly
machine.succeed("curl -kLs https://localhost:8443/documentation/ | grep '<title>Incus documentation</title>'")
driver = webdriver.Firefox(options=options, service=service)
driver.implicitly_wait(10)
driver.get("https://localhost:8443/ui")
# Ensure the application is actually rendered by the Javascript
machine.succeed("PYTHONUNBUFFERED=1 selenium-script")
'';
}
)
wait = WebDriverWait(driver, 60)
assert len(driver.find_elements(By.CLASS_NAME, "l-application")) > 0
assert len(driver.find_elements(By.CLASS_NAME, "l-navigation__drawer")) > 0
driver.close()
'';
in
with pkgs;
[
curl
firefox-unwrapped
geckodriver
seleniumScript
];
};
testScript = ''
machine.wait_for_unit("incus.service")
machine.wait_for_unit("incus-preseed.service")
# Check that the INCUS_UI environment variable is populated in the systemd unit
machine.succeed("systemctl cat incus.service | grep 'INCUS_UI'")
# Ensure the endpoint returns an HTML page with 'Incus UI' in the title
machine.succeed("curl -kLs https://localhost:8443/ui | grep '<title>Incus UI</title>'")
# Ensure the documentation is rendering correctly
machine.succeed("curl -kLs https://localhost:8443/documentation/ | grep '<title>Incus documentation</title>'")
# Ensure the application is actually rendered by the Javascript
machine.succeed("PYTHONUNBUFFERED=1 selenium-script")
'';
}

103
nixos/tests/quorum.nix
View file

@ -1,103 +0,0 @@
{ pkgs, ... }:
let
keystore = {
address = "9377bc3936de934c497e22917b81aa8774ac3bb0";
crypto = {
cipher = "aes-128-ctr";
ciphertext = "ad8341d8ef225650403fd366c955f41095e438dd966a3c84b3d406818c1e366c";
cipherparams = {
iv = "2a09f7a72fd6dff7c43150ff437e6ac2";
};
kdf = "scrypt";
kdfparams = {
dklen = 32;
n = 262144;
p = 1;
r = 8;
salt = "d1a153845bb80cd6274c87c5bac8ac09fdfac5ff131a6f41b5ed319667f12027";
};
mac = "a9621ad88fa1d042acca6fc2fcd711f7e05bfbadea3f30f379235570c8e270d3";
};
id = "89e847a3-1527-42f6-a321-77de0a14ce02";
version = 3;
};
keystore-file = pkgs.writeText "keystore-file" (builtins.toJSON keystore);
in
{
name = "quorum";
meta = with pkgs.lib.maintainers; {
maintainers = [ mmahut ];
};
nodes = {
machine =
{ ... }:
{
services.quorum = {
enable = true;
permissioned = false;
staticNodes = [
"enode://dd333ec28f0a8910c92eb4d336461eea1c20803eed9cf2c056557f986e720f8e693605bba2f4e8f289b1162e5ac7c80c914c7178130711e393ca76abc1d92f57@0.0.0.0:30303?discport=0"
];
genesis = {
alloc = {
"189d23d201b03ae1cf9113672df29a5d672aefa3" = {
balance = "0x446c3b15f9926687d2c40534fdb564000000000000";
};
"44b07d2c28b8ed8f02b45bd84ac7d9051b3349e6" = {
balance = "0x446c3b15f9926687d2c40534fdb564000000000000";
};
"4c1ccd426833b9782729a212c857f2f03b7b4c0d" = {
balance = "0x446c3b15f9926687d2c40534fdb564000000000000";
};
"7ae555d0f6faad7930434abdaac2274fd86ab516" = {
balance = "0x446c3b15f9926687d2c40534fdb564000000000000";
};
c1056df7c02b6f1a353052eaf0533cc7cb743b52 = {
balance = "0x446c3b15f9926687d2c40534fdb564000000000000";
};
};
coinbase = "0x0000000000000000000000000000000000000000";
config = {
byzantiumBlock = 1;
chainId = 10;
eip150Block = 1;
eip150Hash = "0x0000000000000000000000000000000000000000000000000000000000000000";
eip155Block = 1;
eip158Block = 1;
homesteadBlock = 1;
isQuorum = true;
istanbul = {
epoch = 30000;
policy = 0;
};
};
difficulty = "0x1";
extraData = "0x0000000000000000000000000000000000000000000000000000000000000000f8aff869944c1ccd426833b9782729a212c857f2f03b7b4c0d94189d23d201b03ae1cf9113672df29a5d672aefa39444b07d2c28b8ed8f02b45bd84ac7d9051b3349e694c1056df7c02b6f1a353052eaf0533cc7cb743b52947ae555d0f6faad7930434abdaac2274fd86ab516b8410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0";
gasLimit = "0xe0000000";
gasUsed = "0x0";
mixHash = "0x63746963616c2062797a616e74696e65206661756c7420746f6c6572616e6365";
nonce = "0x0";
number = "0x0";
parentHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
timestamp = "0x5cffc201";
};
};
};
};
testScript = ''
start_all()
machine.succeed("mkdir -p /var/lib/quorum/keystore")
machine.succeed(
'cp ${keystore-file} /var/lib/quorum/keystore/UTC--2020-03-23T11-08-34.144812212Z--${keystore.address}'
)
machine.succeed(
"echo fe2725c4e8f7617764b845e8d939a65c664e7956eb47ed7d934573f16488efc1 > /var/lib/quorum/nodekey"
)
machine.succeed("systemctl restart quorum")
machine.wait_for_unit("quorum.service")
machine.sleep(15)
machine.succeed('geth attach /var/lib/quorum/geth.ipc --exec "eth.accounts" | grep ${keystore.address}')
'';
}

6
pkgs/applications/editors/vim/plugins/non-generated/cmp-async-path/default.nix
View file

@ -7,14 +7,14 @@
}:
vimUtils.buildVimPlugin {
pname = "cmp-async-path";
version = "0-unstable-2025-04-13";
version = "0-unstable-2025-11-04";
src = fetchFromGitea {
domain = "codeberg.org";
owner = "FelipeLema";
repo = "cmp-async-path";
rev = "0ed1492f59e730c366d261a5ad822fa37e44c325";
hash = "sha256-J1Iw7yNfvWq7Jul25Eyx4qk9lSiLpZt4TRvTYi1DXtk=";
rev = "b8aade3a0626f2bc1d3cd79affcd7da9f47f7ab1";
hash = "sha256-gaK2aemMX4fzH85idIPuVZ1+ay5vCNqgxU15J4Jz5wU=";
};
checkInputs = [ vimPlugins.nvim-cmp ];

6
pkgs/applications/emulators/libretro/cores/ppsspp.nix
View file

@ -13,13 +13,13 @@
}:
mkLibretroCore {
core = "ppsspp";
version = "0-unstable-2025-10-31";
version = "0-unstable-2025-11-08";
src = fetchFromGitHub {
owner = "hrydgard";
repo = "ppsspp";
rev = "884ec9d16e39272d6f04ce6e7e202290ec31f45d";
hash = "sha256-vC2GPK5hHjOUtoxG2rw2ESiAbTOsQRx8tDABxNjRkFw=";
rev = "5646e471699de213b0fd30eecc50628322b0a8e2";
hash = "sha256-TZqqABGy2smTsIScDKb4hMAyghyN8jW6RMba1o6/nNU=";
fetchSubmodules = true;
};

69
pkgs/applications/graphics/gimp/2.0/default.nix
View file

@ -2,6 +2,7 @@
stdenv,
lib,
fetchurl,
fetchpatch,
replaceVars,
autoreconfHook,
pkg-config,
@ -88,6 +89,70 @@ stdenv.mkDerivation (finalAttrs: {
# This has already been fixed for the upcoming GIMP 3, but the fix has not been backported to 2.x yet
# (see https://gitlab.gnome.org/GNOME/gimp/-/issues/9080)
./force-enable-libheif.patch
(fetchurl {
name = "CVE-2025-2760.patch";
# https://gitlab.gnome.org/GNOME/gimp/-/commit/c17b324910204a47828d6fbb542bdcefbd66bcc1
url = "https://salsa.debian.org/gnome-team/gimp/-/raw/4cb293ec1a3b273281d5d9daf94b833c293797d7/debian/patches/CVE-2025-2760.patch";
hash = "sha256-BH5cCyg0IjfamHPchZ0HBe8EAPrWeHINQ6r7FHaz0qw=";
})
(fetchpatch {
name = "CVE-2025-2761.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/0806bc76ca74543d20e1307ccf6aebd26395c56c.patch";
hash = "sha256-I5dyD3gLbVdk5bTft3TveTWgBN7RouNpIByKbCYmGbo=";
})
(fetchpatch {
name = "CVE-2025-5473.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/c855d1df60ebaf5ef8d02807d448eb088f147a2b.patch";
hash = "sha256-QO8u5XQD3XR+sUN//LsvWpTxHe0i9m4VvdnsUGnor/0=";
})
(fetchurl {
name = "CVE-2025-6035.patch";
# https://gitlab.gnome.org/GNOME/gimp/-/commit/548bc3a46d54711d974aae9ce1bce291376c0436
url = "https://salsa.debian.org/gnome-team/gimp/-/raw/4cb293ec1a3b273281d5d9daf94b833c293797d7/debian/patches/CVE-2025-6035.patch";
hash = "sha256-cbALgUEUO8k5jaN5Y7jUR/dHJ9rHF06m9zEM/AOcFDk=";
})
(fetchpatch {
name = "CVE-2025-48797_1.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/8d309dd0385fdd298520b69148542375f56ef977.patch";
hash = "sha256-/JAUhbPko0EdHGSCnZIWVqPcXpdvRML5Fqx5w/B3P8k=";
})
(fetchpatch {
name = "CVE-2025-48797_2.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/97f8c2e468cffce70c6772e74cbff8eda4e8c180.patch";
hash = "sha256-tNG2fpZ0iRk0thrcxjZqb/zgvf4ctmXEy8iSOz5ufCo=";
})
(fetchpatch {
name = "CVE-2025-48797_3.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/d7f0829ae995ca7ca9c64851a1ed03b11702ef1c.patch";
hash = "sha256-Byvc0i8TS33ZAKONxkrS0iFdWTXZP2w8Ma+k15DGVkw=";
})
(fetchpatch {
name = "CVE-2025-48797_4.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/ffb7cad1a402377927bc2dc62dad324ae03cec92.patch";
hash = "sha256-PZvP4B3U+YalxWwmLhXyTZRacTtkG289JUWsQtZW4BE=";
})
(fetchpatch {
name = "CVE-2025-48798_1.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/ebf0b569a63f15b5dc7532f16936104af1e09f02.patch";
hash = "sha256-VyPbSyRTo+sYg2JkAH3h5exYHDMqIEHc9gYRcM/8wzg=";
})
(fetchpatch {
name = "CVE-2025-48798_2.patch";
url = "https://gitlab.gnome.org/GNOME/gimp/-/commit/e7523ed41271e48a909011b8598d496c1be642e2.patch";
hash = "sha256-ACoxobr2ySpH9VJVdJyWxQpZXOTSEs1me4Q0Rq3bDaE=";
})
(fetchurl {
name = "CVE-2025-10922.patch";
# https://gitlab.gnome.org/GNOME/gimp/-/commit/0f309f9a8d82f43fa01383bc5a5c41d28727d9e3
url = "https://salsa.debian.org/gnome-team/gimp/-/raw/4cb293ec1a3b273281d5d9daf94b833c293797d7/debian/patches/CVE-2025-10922.patch";
hash = "sha256-xkhmlOqk2QiOi4Le7v6e9PdTNxVHpSmuZJTTqKdThUo=";
})
(fetchurl {
name = "CVE-2025-10934.patch";
# https://gitlab.gnome.org/GNOME/gimp/-/commit/5c3e2122d53869599d77ef0f1bdece117b24fd7c
url = "https://salsa.debian.org/gnome-team/gimp/-/raw/4cb293ec1a3b273281d5d9daf94b833c293797d7/debian/patches/CVE-2025-10934.patch";
hash = "sha256-MmYdh74cky/dF3UTHC0xpDW6+aa8Vzh+4ADHCDtIDzo=";
})
];
# error: possibly undefined macro: AM_NLS
@ -181,7 +246,9 @@ stdenv.mkDerivation (finalAttrs: {
env = {
NIX_CFLAGS_COMPILE = toString (
[ ]
[
"-Wno-error=int-conversion" # Needed for CVE-2025-10934 patch
]
++ lib.optionals stdenv.cc.isGNU [ "-Wno-error=incompatible-pointer-types" ]
++ lib.optionals stdenv.hostPlatform.isDarwin [ "-DGDK_OSX_BIG_SUR=16" ]
);

9
pkgs/applications/misc/cubocore-packages/coreshot/default.nix
View file

@ -2,6 +2,7 @@
lib,
stdenv,
fetchFromGitLab,
fetchpatch,
qt6,
cmake,
ninja,
@ -20,6 +21,14 @@ stdenv.mkDerivation (finalAttrs: {
hash = "sha256-5KGaMCL9BCGZwK7HQz87B1qrNvx5SQyMooZw4MwMdCc=";
};
patches = [
(fetchpatch {
name = "fix-building-with-Qt-610";
url = "https://gitlab.com/cubocore/coreapps/coreshot/-/commit/a01c943bec46eea261f545957dbafafc3ea370bb.patch";
hash = "sha256-SD4bYM8nBnGPO8iS8htFZZFUdimbLmpqxgWPioLMjsM=";
})
];
nativeBuildInputs = [
cmake
ninja

4
pkgs/applications/misc/prusa-slicer/default.nix
View file

@ -62,12 +62,12 @@ let
in
stdenv.mkDerivation (finalAttrs: {
pname = "prusa-slicer";
version = "2.9.3";
version = "2.9.4";
src = fetchFromGitHub {
owner = "prusa3d";
repo = "PrusaSlicer";
hash = "sha256-B2uHrh09xKehmxnk3I4MHIjBfB/pGgFXC6R5k10JoJY=";
hash = "sha256-1ilgr9RaIoWvj0TDVc20XjjUUcNtnicR7KlE0ii3GQE=";
rev = "version_${finalAttrs.version}";
};

4
pkgs/applications/networking/cluster/terraform-providers/providers.json
View file

@ -832,11 +832,11 @@
"vendorHash": "sha256-b9+0YLuv9AVszGDQ2v+VbYameN16PCdE3jUhL9efK6M="
},
"linode_linode": {
"hash": "sha256-DMvmTryqgZyhuaDL3cslwMhMnj1x8iNsE5yyhehhANo=",
"hash": "sha256-t6vHW9t3MWsPsGUh44OXvYTfHa03qiH3lveKK0dit9Q=",
"homepage": "https://registry.terraform.io/providers/linode/linode",
"owner": "linode",
"repo": "terraform-provider-linode",
"rev": "v3.5.0",
"rev": "v3.5.1",
"spdx": "MPL-2.0",
"vendorHash": "sha256-8LbFq29JvQX3Trn81fr3YMjFwW+OTWAyK6OVAkh0I3A="
},

8
pkgs/by-name/an/anubis/package.nix
View file

@ -15,21 +15,21 @@
buildGoModule (finalAttrs: {
pname = "anubis";
version = "1.23.0";
version = "1.23.1";
src = fetchFromGitHub {
owner = "TecharoHQ";
repo = "anubis";
tag = "v${finalAttrs.version}";
hash = "sha256-uuYPtkhHMP2WafV7iFMwuh8Bm39Mf7ww6H/io54dwCM=";
hash = "sha256-nE6LXB0+q313UatT3f4Cn/hbTxc4mSMHQnUm0xzTuvE=";
};
vendorHash = "sha256-0W3nBc4vu3hnQTDB561zmx/2rOYo7D+vo8jvx10cBUc=";
vendorHash = "sha256-45SQUDvTX2xc8jJ8NXerbqRkQhBv6xyOPypJQf+tExU=";
npmDeps = fetchNpmDeps {
name = "anubis-npm-deps";
inherit (finalAttrs) src;
hash = "sha256-KEQYF+LTSw0g3+wF4e8u31ERYsNVHlOjTMdDH6Q2/hI=";
hash = "sha256-zlJD/Mv39bUHx+q+QSXpYWhELvbk7MCNWXLWcB4SP2A=";
};
nativeBuildInputs = [

2
pkgs/by-name/co/coc-sumneko-lua/update.sh
View file

@ -1,5 +1,5 @@
#!/usr/bin/env nix-shell
#!nix-shell -i bash -p bash nodejs nix-update git curl
#!nix-shell -i bash -p bash nodejs nix-update git curl jq
WORKDIR=$(mktemp -d)
PACKAGE_DIR="$(realpath "$(dirname "$0")")"

6
pkgs/by-name/co/codex/package.nix
View file

@ -14,18 +14,18 @@
}:
rustPlatform.buildRustPackage (finalAttrs: {
pname = "codex";
version = "0.55.0";
version = "0.56.0";
src = fetchFromGitHub {
owner = "openai";
repo = "codex";
tag = "rust-v${finalAttrs.version}";
hash = "sha256-gtYLMqQ3szUJMN1Jdcy2BPrJN8bxvrt0nVShcC2/JAA=";
hash = "sha256-CIKoOfqZwCCCDFXnRdU7haxfiyvrgGD3vSwXZpE9DUU=";
};
sourceRoot = "${finalAttrs.src.name}/codex-rs";
cargoHash = "sha256-1Wj6+CY9PwsOQ39dywepnaQvycg0jqq6iYYXnLgH1dw=";
cargoHash = "sha256-FN20afqRVdGl17+fbzNoXqF8BY+dPtGi1lvwB6w+ieE=";
nativeBuildInputs = [
installShellFiles

6
pkgs/by-name/co/coredns/package.nix
View file

@ -6,7 +6,7 @@
installShellFiles,
nixosTests,
externalPlugins ? [ ],
vendorHash ? "sha256-Es3xy8NVDo7Xgu32jJa4lhYWGa5hJnRyDKFYQqB3aBY=",
vendorHash ? "sha256-pU8INVCKjYfAFOeobM7N1XCMHod7Kz0N5NKwpMpA2lU=",
}:
let
@ -14,13 +14,13 @@ let
in
buildGoModule (finalAttrs: {
pname = "coredns";
version = "1.12.2";
version = "1.13.1";
src = fetchFromGitHub {
owner = "coredns";
repo = "coredns";
tag = "v${finalAttrs.version}";
hash = "sha256-P4GhWrEACR1ZhNhGAoXWvNXYlpwnm2dz6Ggqv72zYog=";
hash = "sha256-rWa4xjHRREoMtvPqW6ZP6Ym9qNTa0l8Opd15FsmxraI=";
};
inherit vendorHash;

4
pkgs/by-name/de/debian-devscripts/package.nix
View file

@ -30,14 +30,14 @@ let
in
stdenv.mkDerivation (finalAttrs: {
pname = "debian-devscripts";
version = "2.25.22";
version = "2.25.25";
src = fetchFromGitLab {
domain = "salsa.debian.org";
owner = "debian";
repo = "devscripts";
tag = "v${finalAttrs.version}";
hash = "sha256-FiqM2n33tbzHgwZGZ2CaAvNTrAUgTuwMtNbXbn6EYJ4=";
hash = "sha256-3ZPRn0SwefYoSNNy0V51+nBFTEnE+xSfe3JOz9KOw94=";
};
patches = [

0
pkgs/applications/science/electronics/fritzing/fix-stricter-types.patch → pkgs/by-name/fr/fritzing/fix-stricter-types.patch
View file

49
pkgs/applications/science/electronics/fritzing/default.nix → pkgs/by-name/fr/fritzing/package.nix
View file

@ -2,32 +2,25 @@
stdenv,
lib,
fetchFromGitHub,
wrapQtAppsHook,
qmake,
kdePackages,
pkg-config,
qtbase,
qtsvg,
qttools,
qtserialport,
qtwayland,
qt5compat,
qt6,
boost,
libngspice,
libgit2,
quazip,
clipper,
}:
let
# SHA256 of the fritzing-parts HEAD on the master branch,
# SHA256 of the fritzing-parts HEAD on the develop branch,
# which contains the latest stable parts definitions
partsSha = "4f7d39b22a6c307e6cca62c7f78eae96696e8b2c";
partsSha = "73bc0559bb8399b2f895d68f032e41d7efc720c0";
parts = fetchFromGitHub {
owner = "fritzing";
repo = "fritzing-parts";
rev = partsSha;
hash = "sha256-mAzY5CVZJF5hAvWVlDiYRxoB+9mGDG9OI/8n9aY5aFE=";
hash = "sha256-2aXvSXWjQliEChQGhcCicOVoAqeNdeq69wQVYQsd2ew=";
};
# Header-only library
@ -41,13 +34,13 @@ in
stdenv.mkDerivation {
pname = "fritzing";
version = "1.0.5";
version = "1.0.6";
src = fetchFromGitHub {
owner = "fritzing";
repo = "fritzing-app";
rev = "b9add9eaa7c426963de20c8514a69d3f15e83bdf";
hash = "sha256-OnIX+2eXT0JAs6VgSAIr1t+2DhpoUDgKVGPFjjZrKas=";
rev = "04e5bb0241e8f1de24d0fce9be070041c6d5b68e";
hash = "sha256-JlqBdzWscJoD859KMYgT/af41WNWThP65K3zh2PC2jM=";
};
patches = [
@ -56,25 +49,25 @@ stdenv.mkDerivation {
];
nativeBuildInputs = [
qmake
kdePackages.qmake
pkg-config
qttools
wrapQtAppsHook
qt6.qttools
kdePackages.wrapQtAppsHook
];
buildInputs = [
qtbase
qtsvg
qtserialport
qt5compat
qt6.qtbase
qt6.qtsvg
qt6.qtserialport
kdePackages.qt5compat
boost
libgit2
quazip
kdePackages.quazip
libngspice
clipper
]
++ lib.optionals stdenv.hostPlatform.isLinux [
qtwayland
qt6.qtwayland
];
postPatch = ''
@ -89,7 +82,7 @@ stdenv.mkDerivation {
--replace-fail 'PartsChecker::getSha(dir.absolutePath());' '"${partsSha}";'
substituteInPlace phoenix.pro \
--replace-fail "6.5.10" "${qtbase.version}"
--replace-fail "6.5.10" "${qt6.qtbase.version}"
substituteInPlace src/simulation/ngspice_simulator.cpp \
--replace-fail 'path + "/" + libName' '"${libngspice}/lib/libngspice.so"'
@ -101,13 +94,13 @@ stdenv.mkDerivation {
env = {
NIX_CFLAGS_COMPILE = lib.concatStringsSep " " (
[
"-I${lib.getDev quazip}/include/QuaZip-Qt${lib.versions.major qtbase.version}-${quazip.version}"
"-I${lib.getDev kdePackages.quazip}/include/QuaZip-Qt${lib.versions.major qt6.qtbase.version}-${kdePackages.quazip.version}"
"-I${svgpp}/include"
"-I${clipper}/include/polyclipping"
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ "-F${qt5compat}/lib" ]
++ lib.optionals stdenv.hostPlatform.isDarwin [ "-F${kdePackages.qt5compat}/lib" ]
);
NIX_LDFLAGS = "-lquazip1-qt${lib.versions.major qtbase.version}";
NIX_LDFLAGS = "-lquazip1-qt${lib.versions.major qt6.qtbase.version}";
};
qmakeFlags = [

4
pkgs/by-name/ga/gatsby-cli/package.nix
View file

@ -68,8 +68,10 @@ stdenv.mkDerivation (finalAttrs: {
passthru.updateScript = nix-update-script {
extraArgs = [
# Fixes an error with having too many versions available
"--use-github-releases"
"--version-regex"
"'gatsby-cli@(.*)'"
"gatsby@(.*)"
];
};

24
pkgs/by-name/ge/getdp/package.nix
View file

@ -1,7 +1,7 @@
{
lib,
stdenv,
fetchurl,
fetchFromGitLab,
cmake,
gfortran,
blas,
@ -14,12 +14,16 @@
let
mpiSupport = petsc.passthru.mpiSupport;
in
stdenv.mkDerivation rec {
stdenv.mkDerivation {
pname = "getdp";
version = "3.6.0";
src = fetchurl {
url = "http://getdp.info/src/getdp-${version}-source.tgz";
hash = "sha256-nzefwCV+Z9BHDofuTfhR+vhqm3cCSiUT+7cbtn601N8=";
version = "3.6.0-unstable-2025-10-25";
src = fetchFromGitLab {
domain = "gitlab.onelab.info";
owner = "getdp";
repo = "getdp";
rev = "cac7f393ac34be1618b588083d2e391efd4976f7";
hash = "sha256-yiqi9Fb3UM81iJtpU+Mg71BB73injdkWCzbJGgor4ww=";
};
nativeBuildInputs = [
@ -35,7 +39,7 @@ stdenv.mkDerivation rec {
++ lib.optional mpiSupport mpi;
cmakeFlags = lib.optional mpiSupport "-DENABLE_MPI=1";
meta = with lib; {
meta = {
description = "General Environment for the Treatment of Discrete Problems";
mainProgram = "getdp";
longDescription = ''
@ -46,8 +50,8 @@ stdenv.mkDerivation rec {
symbolic mathematical expressions of these problems.
'';
homepage = "http://getdp.info/";
license = licenses.gpl2Plus;
maintainers = [ ];
platforms = platforms.linux;
license = lib.licenses.gpl2Plus;
maintainers = with lib.maintainers; [ iedame ];
platforms = lib.platforms.linux;
};
}

6
pkgs/by-name/gi/gitbeaker-cli/package.nix
View file

@ -10,13 +10,13 @@
stdenv.mkDerivation (finalAttrs: {
pname = "gitbeaker-cli";
version = "43.7.0";
version = "43.8.0";
src = fetchFromGitHub {
owner = "jdalrymple";
repo = "gitbeaker";
tag = finalAttrs.version;
hash = "sha256-3g8VNOCyXxDg2xpLA66L57ASMhf0kWUp0a7a7FZouF8=";
hash = "sha256-EVxDUEuxCnMiqqsKFs9JpRVJ86d9hW22K4a4we8eoJA=";
};
nativeBuildInputs = [
@ -31,7 +31,7 @@ stdenv.mkDerivation (finalAttrs: {
offlineCache = yarn-berry_4.fetchYarnBerryDeps {
inherit (finalAttrs) src missingHashes;
hash = "sha256-RwQ/Xi/BKZv6+tpIIZU9U9PZJXq3baZVEv3UNKyQ18o=";
hash = "sha256-WTxUoRPooea4CqpKnnrmvoWXoglCivVet+bUh0YG7gU=";
};
buildPhase = ''

5
pkgs/by-name/gm/gmsh/package.nix
View file

@ -25,11 +25,11 @@ assert (!blas.isILP64) && (!lapack.isILP64);
stdenv.mkDerivation (finalAttrs: {
pname = "gmsh";
version = "4.14.0";
version = "4.15.0";
src = fetchurl {
url = "https://gmsh.info/src/gmsh-${finalAttrs.version}-source.tgz";
hash = "sha256-2019ogYumkNWqCCDITirmfl69jiL/rIVmaLq37C3aig=";
hash = "sha256-q7JjJxW9fQEw3tcUT9YmNjXNfeqIO432G6TaWM5qHf4=";
};
nativeBuildInputs = [
@ -113,5 +113,6 @@ stdenv.mkDerivation (finalAttrs: {
homepage = "https://gmsh.info/";
changelog = "https://gitlab.onelab.info/gmsh/gmsh/-/releases/gmsh_${lib.concatStringsSep "_" (lib.versions.splitVersion finalAttrs.version)}#changelog";
license = lib.licenses.gpl2Plus;
maintainers = with lib.maintainers; [ iedame ];
};
})

14
pkgs/by-name/go/goose-cli/package.nix
View file

@ -27,16 +27,16 @@ let
in
rustPlatform.buildRustPackage (finalAttrs: {
pname = "goose-cli";
version = "1.6.0";
version = "1.11.0";
src = fetchFromGitHub {
owner = "block";
repo = "goose";
tag = "v${finalAttrs.version}";
hash = "sha256-ZfS0U7PpGWWuqGKd7IjRaavqZSySx93F9S1d7r2wMkE=";
hash = "sha256-0pDJp/sWFn16HlWU+OYk0K9kIbNohC8NckZywinBRH8=";
};
cargoHash = "sha256-uYgYzP75QkN1VksYL3KeNMNy7wb0TgCP8HPN1QrfZoo=";
cargoHash = "sha256-bspPOgMEnSjICJWIicrD7B+APuUvlVZFarpwzzdLwPc=";
nativeBuildInputs = [
pkg-config
@ -81,9 +81,17 @@ rustPlatform.buildRustPackage (finalAttrs: {
"--skip=transport::streamable_http::tests::test_handle_outgoing_message_session_id_handling"
"--skip=transport::streamable_http::tests::test_handle_outgoing_message_session_not_found"
"--skip=transport::streamable_http::tests::test_handle_outgoing_message_successful_request"
"--skip=routes::audio::tests::test_transcribe_endpoint_requires_auth"
"--skip=routes::config_management::tests::test_get_provider_models_openai_configured"
# integration tests that need network access
"--skip=test_replayed_session::vec_uvx_mcp_server_fetch_vec_calltoolrequestparam_name_fetch_into_arguments_some_object_url_https_example_com_vec_expects"
"--skip=test_replayed_session::vec_github_mcp_server_stdio_vec_calltoolrequestparam_name_get_file_contents_into_arguments_some_object_owner_block_repo_goose_path_readme_md_sha_ab62b863c1666232a67048b6c4e10007a2a5b83c_vec_github_personal_access_token_expects"
"--skip=test_replayed_session::vec_cargo_run_quiet_p_goose_server_bin_goosed_mcp_developer_vec_calltoolrequestparam_name_text_editor_into_arguments_some_object_command_view_path_goose_crates_goose_tests_tmp_goose_txt_calltoolrequestparam_name_text_editor_into_arguments_some_object_command_str_replace_path_goose_crates_goose_tests_tmp_goose_txt_old_str_goose_new_str_goose_modified_by_test_calltoolrequestparam_name_shell_into_arguments_some_object_command_cat_goose_crates_goose_tests_tmp_goose_txt_calltoolrequestparam_name_text_editor_into_arguments_some_object_command_str_replace_path_goose_crates_goose_tests_tmp_goose_txt_old_str_goose_modified_by_test_new_str_goose_calltoolrequestparam_name_list_windows_into_arguments_some_object_vec_expects"
"--skip=test_replayed_session::vec_npx_y_modelcontextprotocol_server_everything_vec_calltoolrequestparam_name_echo_into_arguments_some_object_message_hello_world_calltoolrequestparam_name_add_into_arguments_some_object_a_1_b_2_calltoolrequestparam_name_longrunningoperation_into_arguments_some_object_duration_1_steps_5_calltoolrequestparam_name_structuredcontent_into_arguments_some_object_location_11238_vec_expects"
]
++ lib.optionals stdenv.hostPlatform.isLinux [
"--skip=context_mgmt::auto_compact::tests::test_auto_compact_respects_config"
"--skip=scheduler::tests::test_scheduled_session_has_schedule_id"
]
++ lib.optionals stdenv.hostPlatform.isDarwin [
"--skip=logging::tests::test_log_file_name_no_session"

47
pkgs/by-name/gs/gscan2pdf/package.nix
View file

@ -1,6 +1,7 @@
{
lib,
fetchurl,
fetchpatch,
perlPackages,
wrapGAppsHook3,
# libs
@ -17,18 +18,17 @@
pdftk,
# test dependencies
xvfb-run,
liberation_ttf,
file,
tesseract3,
tesseract,
}:
perlPackages.buildPerlPackage rec {
pname = "gscan2pdf";
version = "2.13.4";
version = "2.13.5";
src = fetchurl {
url = "mirror://sourceforge/gscan2pdf/gscan2pdf-${version}.tar.xz";
hash = "sha256-4HcTkVJBscBb8AxeN6orMQFVR0w4hFfkGhxQOzP3mWk=";
hash = "sha256-DUME9nI9B2+Gj+sBPj176SXfuxDc3CMXfby/Zga31fo=";
};
patches = [
@ -74,18 +74,11 @@ perlPackages.buildPerlPackage rec {
SubOverride
]);
postPatch =
let
fontSubstitute = "${liberation_ttf}/share/fonts/truetype/LiberationSans-Regular.ttf";
in
''
# Required for the program to properly load its SVG assets
substituteInPlace bin/gscan2pdf \
--replace "/usr/share" "$out/share"
# Substitute the non-free Helvetica font in the tests
sed -i 's|-pointsize|-font ${fontSubstitute} -pointsize|g' t/*.t
'';
# Required for the program to properly load its SVG assets
postPatch = ''
substituteInPlace bin/gscan2pdf \
--replace-fail "/usr/share" "$out/share"
'';
postInstall = ''
# Remove impurity
@ -123,33 +116,13 @@ perlPackages.buildPerlPackage rec {
xvfb-run
file
tesseract3 # tests are expecting tesseract 3.x precisely
tesseract
]
++ (with perlPackages; [
TestPod
]);
checkPhase = ''
# Temporarily disable a dubiously failing test:
# t/169_import_scan.t ........................... 1/1
# # Failed test 'variable-height scan imported with expected size'
# # at t/169_import_scan.t line 50.
# # got: '179'
# # expected: '296'
# # Looks like you failed 1 test of 1.
# t/169_import_scan.t ........................... Dubious, test returned 1 (wstat 256, 0x100)
rm t/169_import_scan.t
# Disable a test failing because of a warning interfering with the pinned output
# t/3722_user_defined.t ......................... 1/2
# Failed test 'user_defined caught error injected in queue'
# at t/3722_user_defined.t line 41.
# got: 'error
# WARNING: The convert command is deprecated in IMv7, use "magick" instead of "convert" or "magick convert"'
# expected: 'error'
# Looks like you failed 1 test of 2.
rm t/3722_user_defined.t
export XDG_CACHE_HOME="$(mktemp -d)"
xvfb-run -s '-screen 0 800x600x24' \
make test

4
pkgs/by-name/ha/haproxy/package.nix
View file

@ -43,11 +43,11 @@ let
in
stdenv.mkDerivation (finalAttrs: {
pname = "haproxy";
version = "3.2.7";
version = "3.2.8";
src = fetchurl {
url = "https://www.haproxy.org/download/${lib.versions.majorMinor finalAttrs.version}/src/haproxy-${finalAttrs.version}.tar.gz";
hash = "sha256-Hwrp37CzGeLVy25M35MaCHetiOAJDEbPFvrwCPv1Qng=";
hash = "sha256-RnA/uUcg+SzOKwgEmkDZF2liA3umdohcVaVr2dYl58I=";
};
buildInputs = [

1
pkgs/by-name/hi/high-tide/package.nix
View file

@ -49,6 +49,7 @@ python313Packages.buildPythonApplication rec {
gstreamer
gst-plugins-base
gst-plugins-good
gst-plugins-bad
libsecret
]);

9
pkgs/by-name/in/incus/generic.nix
View file

@ -158,7 +158,16 @@ buildGoModule (finalAttrs: {
--zsh <($out/bin/incus completion zsh)
mkdir -p $agent_loader/bin $agent_loader/etc/systemd/system $agent_loader/lib/udev/rules.d
''
+ lib.optionalString (lib.versionOlder finalAttrs.version "6.18") ''
cp internal/server/instance/drivers/agent-loader/incus-agent{,-setup} $agent_loader/bin/
''
+ lib.optionalString (lib.versionAtLeast finalAttrs.version "6.18") ''
# the agent_loader output is used by virtualisation.incus.agent
cp internal/server/instance/drivers/agent-loader/incus-agent-linux $agent_loader/bin/incus-agent
cp internal/server/instance/drivers/agent-loader/incus-agent-setup-linux $agent_loader/bin/incus-agent-setup
''
+ ''
chmod +x $agent_loader/bin/incus-agent{,-setup}
patchShebangs $agent_loader/bin/incus-agent{,-setup}
cp internal/server/instance/drivers/agent-loader/systemd/incus-agent.service $agent_loader/etc/systemd/system/

6
pkgs/by-name/in/incus/package.nix
View file

@ -1,7 +1,7 @@
import ./generic.nix {
hash = "sha256-QtsdKXgf995FzMxSHYz8LupECeRA2nriz9Bb3S0epKY=";
version = "6.17.0";
vendorHash = "sha256-5BQFoiutNuvFu+oA3ZpD8w8qtrf7l/B5b3eHwSEfzBU=";
hash = "sha256-XJp0Loaj3FFygyiIkSaMl4T0KmkNt7xtyU4nz++6yHs=";
version = "6.18.0";
vendorHash = "sha256-ySNeO06x8FzCH29EHbO3/ASVNSXTviyeULFrVoQwxcw=";
patches = [ ];
nixUpdateExtraArgs = [
"--override-filename=pkgs/by-name/in/incus/package.nix"

4
pkgs/by-name/in/inja/package.nix
View file

@ -10,13 +10,13 @@
stdenv.mkDerivation (finalAttrs: {
pname = "inja";
version = "3.4.0";
version = "3.5.0";
src = fetchFromGitHub {
owner = "pantor";
repo = "inja";
rev = "v${finalAttrs.version}";
hash = "sha256-B1EaR+qN32nLm3rdnlZvXQ/dlSd5XSc+5+gzBTPzUZU=";
hash = "sha256-P4XKz2FcMfP0HRMoEC2+RKE/ljZSpusUTDmF9Ao5txo=";
};
nativeBuildInputs = [ cmake ];

75
pkgs/by-name/jo/joplin-cli/missing-hashes.json
View file

@ -1,76 +1,98 @@
{
"@esbuild/aix-ppc64@npm:0.25.4": "c3d5aaf00899940960a27f93a63d9169efc4ff317f10bc3608291678ce71255d657129061dbfa016a0d16fd7b6bfbeb9d37558e9113432f8ff5d04b8b8e54b2f",
"@esbuild/aix-ppc64@npm:0.25.5": "098d4c3ebe965823ee43fa708457c768caea59a5fab521e1129fbf1bc47dadf8319d7170e25a91a6af779a3b91cf4ce0b01a053410fe796b2235c262f7008e30",
"@esbuild/aix-ppc64@npm:0.25.8": "451dc5fd41cf67ccc24b8d1da6f95b1082552b6908f0cb0c78fba3da39a4b6c3669ce37dc3c2c383cc18266ea35c0fcec6696fb24f8a0aaf097b94def035c129",
"@esbuild/android-arm64@npm:0.25.4": "aa5285109d86607c973ee8d20b582cb444bae31457982dbd3b004feaa4776d145d48a6692537defd8477f2bd0bdf06ff8c7e688dd07fe30b5d031c6dd434c580",
"@esbuild/android-arm64@npm:0.25.5": "0a3b0db67072835d003519a7b297f2618b8c65cf168be7421656a3eaa7240499e3f89708e5aec507007bf8637f486dd4a2aeb48183702a5a8d0ee29432c22c8d",
"@esbuild/android-arm64@npm:0.25.8": "ef542eda68837bd16cdae4ed99c312405673da95ec3fba1d2f0f102cbd983fdd7357acd1504b5a5ef517b952c9978a0c4baa65211626db6cf862e2bf9ebebe49",
"@esbuild/android-arm@npm:0.25.4": "8c5c306e03044527fb2f4eaaeda255d7f40d6a3d02aa9abd1334d67a9ea1a5ab2ab654df77eb7e17e64947c5893e1ba53fc9d3bbefa15f0692e6b56823c47abc",
"@esbuild/android-arm@npm:0.25.5": "3f85e15beb85467d5ac0bd19774fca6db353f4927a792c2281302e0f29f66931eb4ceac61216e19d9b21a5fc90c556b58bf54b4ed9d3205e81ecba16cff842d9",
"@esbuild/android-arm@npm:0.25.8": "a0a5995ed8ff2c9775e8395d3da0b7d7b9246040db680aedeb8df9ca980891fe322a6b833cf0bc554852de351aa1351b37aff0213113d4d4afd28c638edc74f1",
"@esbuild/android-x64@npm:0.25.4": "aa8665b302b65ca62e15a34e72e43d1ce7a253a354d8684cbe5ea1a04a79d1323416b46c727d6ab73a76a4ec047fb2859b054f8f80fe9ac1d286a4d00ed754e6",
"@esbuild/android-x64@npm:0.25.5": "2033f7eb50910b4b9f8064926a8d2baf62597230dc07fd931c8def2022bc8d8e15c3ed7aa892041b6605b24d31e80afeb03e59cf7b0dc2f88a6959b821defd58",
"@esbuild/android-x64@npm:0.25.8": "afb24505bf544e53c71707456a85dc21bcc26106c1863aad85733eb5d5bd2e334cb58a2fe31973b4311cc08802493c8d920f41c91f88884baf4c6700a04182ec",
"@esbuild/darwin-arm64@npm:0.25.4": "81b4d0482813ccff8c783035317d78220a4ec3eee3798e50b804a781a071f5790c7903c2f9216a25f5c167becd4c3d78fcf0a13e454b3973eb7d82b7ce1d4688",
"@esbuild/darwin-arm64@npm:0.25.5": "08d7238c6ea25cbf7de55ab2378b8bf3bf3d36de9bb3ca9fca15c41e5cec6cfcc619b2cbefd0d71722bd780ef5d1bcff5246b1676b62d131673532aa14e6ae5f",
"@esbuild/darwin-arm64@npm:0.25.8": "c5bcf68dce1ba9fa111c2da068c50ade5fd74f724bab93058542619a67554b598ef0c47593f4d5cc382f0ac53507e2bc0ac3111824df9d5776c7cd8fe2c28001",
"@esbuild/darwin-x64@npm:0.25.4": "633d97f18c299c8da3730ae04831895779b5f1271020cc924e06c6a5f0c5aac9f0653d60cca7d6ac23926797368301cd6ce2059b25f432aa2f1f378fcb34530d",
"@esbuild/darwin-x64@npm:0.25.5": "274767e53270755c1d1814eddd25a20e6ebd68cdf8432303d9e73b45a782579a4a898ffd68920f4052c4a5ba6ca85e59ba1a87e0005b94cac98e479e3f623a22",
"@esbuild/darwin-x64@npm:0.25.8": "db948746f087aace173b52d08b7085514755cbc5bab7f1e64ff7e075489fb8596c7490038bea9e54337586ba02ca3c9f56365029660e711a380bb30f1dccb41a",
"@esbuild/freebsd-arm64@npm:0.25.4": "4d52cf4e18e1f4ab2fd80c4c4a9ab9c20658c77d832d33603b5d19b3ed4565ad7186b86e30a92b78aa11694d884201d0914dba649d6277737574896a897a2af7",
"@esbuild/freebsd-arm64@npm:0.25.5": "b9ef91ca56536e988a72009c04e95f4ce18a6439151029d736c6df2af97a753f5b55f73d14da76c2c22693592a9468d57435af72bf535b2731b8fdda2aadb930",
"@esbuild/freebsd-arm64@npm:0.25.8": "faa5a23e4f2e8d1fae84ea0ae424b3b89e8c425e15427e749d0ca9f5a8ca77c6b237886914ce61495ce1f01cb5430b0e55ea61d21a2dc4930be09dffec56059f",
"@esbuild/freebsd-x64@npm:0.25.4": "af75d6724969c4d831bb09209f4ddb46532516932db98a3e4c5c5dcc7f3cd0fe0930f2875fa901b8bb9c0ecfe0a65313da6127ea9387c63859e5d58cff975e68",
"@esbuild/freebsd-x64@npm:0.25.5": "8b6f53b0c0ffc7770ab078d694b705ca0169e08e0a88849fb0a54280e55f7339abc26aee969799ba6ee725b494653fc7188dc184d2f318be78506132b5e8f955",
"@esbuild/freebsd-x64@npm:0.25.8": "e5a93cef5e2c6b191f178aa73137d2c44cee60a7a6be8806d630ec82ff1dfc72ccd30297c6b607d2ad715ef20b88068e93abb0fa8e187c8fe2547920eef9b4e7",
"@esbuild/linux-arm64@npm:0.25.4": "72b7e3b8fe3bd27206577f8eceea1e0c289dc01fa2f5b03fe22f4ea27931ca664a9b93b35f9ae424e78552caec76330383fe7dc5afeeaffa0e00645ec143a49b",
"@esbuild/linux-arm64@npm:0.25.5": "c0e1925988f0b07aa8c4712f04f3cc858b52d7180ba1600c311206eeef023dbd6f0a00cb2d50fbd81064c15e69502ab95aabb433318638a5af0d9a4bd02f7294",
"@esbuild/linux-arm64@npm:0.25.8": "deb61aafe7a2cb32d9f43b5030fb070856f45210d2ac8ac9ce527fec4016bb4a58ffea93536834cd386786cd6ec40327e057853b0348b45d7a06e6eeec71a63c",
"@esbuild/linux-arm@npm:0.25.4": "407dcf9e8fc4ebc75689b6257be576047c03285067b5b22db74dd07ae067f8dd9126936dedfeb27934e09d0d700ecb3f8d70876fe61b90d92355f35c2a5d6540",
"@esbuild/linux-arm@npm:0.25.5": "b14daff5e6b0e9d6a613e6f11a6c0c4c1a275effe762383e6b3461c6318ec371f69d8c512bda475d634154ded6e0269345fb58281ca64c406d9dd0acfdfcf042",
"@esbuild/linux-arm@npm:0.25.8": "3382c6f8e7b3bb479c5b4a01b0baa78054efdf002241eea1d606c8727b9d2168f0ee1798b5627de6b92285b85904e358c9531a1c0f07ef585845fd7d88696db4",
"@esbuild/linux-ia32@npm:0.25.4": "47b13c9952c893e749380551dfa3580eb562a0394911a9ced68b23c0cafe116614b30ffd6744dc71ec312fab8bc7115f856f078fe29f1253a1dd99d3215a1424",
"@esbuild/linux-ia32@npm:0.25.5": "f962303d6dd5062bf8cfa31801c43c4ecf2c33cf42e8e4abbcbbea2d54619ba8bd0700a342e94e13deff856e6985e50f31bf97af283b26ff36b185da40a0f7a3",
"@esbuild/linux-ia32@npm:0.25.8": "e32f2fa63c74d6723c876cec9b42c04e6aa5e6d0cd9a7447d0b4b00d7615a484da55ef95b4fcf871492019a007c40defb497ef6075ad94da46b6121828fcf83a",
"@esbuild/linux-loong64@npm:0.25.4": "75222fb808060b3f2507aee40c6ee877a1ed768c593dd8f192e1ea640bddf3b414080407ddaccac6d0cde35750a7f92c434e04af2c142075dc810c5b7a7ce5eb",
"@esbuild/linux-loong64@npm:0.25.5": "884863922180e39e9ae05c93f0d5e4e52627416237d892dca80f39bd1ce94c24920868cdeb8a8378b384332343c2b76bd7eba0ab56defaa4fa942bc361941a46",
"@esbuild/linux-loong64@npm:0.25.8": "a55894549cd7e64c2062863eaf697175a1d6f86def565555614ad335b462afbfebf403ec0f1d83bf8dff145d57c4046815b26c70e98f068a9f99317fc37d71e8",
"@esbuild/linux-mips64el@npm:0.25.4": "3f129931a6973a4fa470ddc46e3e3fa150aca64029951fe7a8d9616f41ddf8422d3744a30b0c5f36a35bff19b32b25c85bf1e5760537b329f18558e289213eea",
"@esbuild/linux-mips64el@npm:0.25.5": "90da507ace130201e4653e08187b6ec95d4acb9acf37fbd14f7c0aa60ac299cb9a8a2cc1c8541e376ac14206e10abc52e99bd2c1614dce53f6f66d00165671df",
"@esbuild/linux-mips64el@npm:0.25.8": "5c1ef406e07fbb766417be11b859baa3e905587c8bf3465f0f6ffd6cfd54b658ceffc616bfbea0340473deaebd430db6aea33468876796bcad83f05bf1910d9d",
"@esbuild/linux-ppc64@npm:0.25.4": "6f84018eda99c3f06d519abbdbdf15700707236b8643ba24150d5168062ba310ee3c972645554b05d4b768438697a9a04014bc884a1beb15bf05bbe1b29e34ca",
"@esbuild/linux-ppc64@npm:0.25.5": "1a82c32464c6e446bba510c5cafff685c113cadc3f65966465a54bed455cfc737ea3c11628785cd4ad8b169be03ef3b3c3e46b4ecd3e1a64a501d6ae3aa500d0",
"@esbuild/linux-ppc64@npm:0.25.8": "a5f386bd5b18eb3eb7f240b112595182f450382ca93a7d6cad4c57b82e13830aff22250ff02728dd5b8d65f3b9908ef291f223a6e83d78d64f497d3117a567a1",
"@esbuild/linux-riscv64@npm:0.25.4": "c5b674c2f48c5292f594141a4739f9f266ce8a1a2514eaefacc6fac761f1fa6c208981ca4c9e774c383ca33a46cad539b1fa46af6827cf89db721f33c36093c8",
"@esbuild/linux-riscv64@npm:0.25.5": "d9f49b01639ec4ceebf5455151e2632191a2bc0d96ba27ba661f4b97e314c1496a99ed5ea2d3c0bddbcf9da09bf1c06ba8f94bcab283a2f181a1c2c514848631",
"@esbuild/linux-riscv64@npm:0.25.8": "6b624062871ac3bb93af3b560a97fb489eef06cb12f4716c0c7d54fb31d4047fec570bbc9cc2bc9f98e8a4fbd07db6fa542115c02ec3bb66922e8b1988304cc1",
"@esbuild/linux-s390x@npm:0.25.4": "a54c0972230a2264714371f6545ff0d9b20d349b08e4837e7063378886f88c08ade0ed5b2c7ba744c4679deb2f60e8485ef475f92cdbadca9d34f462a2724cc1",
"@esbuild/linux-s390x@npm:0.25.5": "14ce910d0ed879bf6549c4892a020e2a652fe5cbf8897a7a967ba20801e89582e70a3567659b96049a789a6b3fa5b34b330f4002de51f87bc734a2c83d8089a8",
"@esbuild/linux-s390x@npm:0.25.8": "c13f82778a07b14fa50d52322f4b347bea6540a207e0468b060588922fae2278ae1b18a88bbd1cf3656b5d7eb8a84dcf8a237c91e7e0629fa6e56be41db46055",
"@esbuild/linux-x64@npm:0.25.4": "1ba32d40895c826e6990157a141e23d68fdf00b46d60ef3572a89781f177df75e023d38b130087b167a6e38410c3af0a6bec7b2d3b1af2a37a21c1ed70dcba45",
"@esbuild/linux-x64@npm:0.25.5": "31edf2a53f0dede747f57405d2d9e277b1ae25e40eef7a7567b8d9c11c0d23c7aa6d4f94493f5295f95dc0f75a77f8cf3a52144501a6db7bf914cff8a5370258",
"@esbuild/linux-x64@npm:0.25.8": "e6483e5c367e7c35899c98bc378e8a37f5617a741297d9b91c59c1d29b9b00f26f9c315a736b41af33f21d9d74a8c648715ce13ac520b3fa7604978a05dedd99",
"@esbuild/netbsd-arm64@npm:0.25.4": "37bc10864f14c60f995e2ef13bb53102d0ce0eab1d32dfe5f48254aafe6d791d7129cbb00c6acf9e32b561db5420c5558b84800cf6958d40d3d55a7e3f456ebb",
"@esbuild/netbsd-arm64@npm:0.25.5": "d35b97cf24a5f7e32e880b40a451c7409959acb26c9adaba1c4d5d469853982ce7e5f5e6ff33f32bde78d400c869923d2933d1620779d127e95a693422b4cc07",
"@esbuild/netbsd-arm64@npm:0.25.8": "02afba2e5fbf8e8cc4c375edfce673b38015213744f1df05a74ab9de99f5860e50dc26af97b4f0b4f804c461ab45cfa773603ce0e1b0528bd93e7a979eca7682",
"@esbuild/netbsd-x64@npm:0.25.4": "6875cc83961e613dd28f1c1d5c3b7404dc7cd4b54071596712c56574b1a24517424483c7c363c0aefa8259cf2d621e080b8270c0c242010ad04ce367aa87e897",
"@esbuild/netbsd-x64@npm:0.25.5": "7a8ecc712deda1af96de426998f39934ed5fad0cdb12b13ff31170c9dfe44f679d179c16dca7db2d686044a941a7addb9378a01f15b25efe424453ac61a0031f",
"@esbuild/netbsd-x64@npm:0.25.8": "76c43cc94f9b287a6a0d277d51f17e650d168e26008741e86035f2e054b8216d61855feddc2c0b48f989b46c58913168148a30b30fff5b87a1bc08fd78cbd0e7",
"@esbuild/openbsd-arm64@npm:0.25.4": "a7981586bbfea74746aa87113089020c73677209b71fadab43e6693c141b9415c342df01694e70aa607a1e80e9e37ccf4682dc2f095cae1ffb60c740e63e7d32",
"@esbuild/openbsd-arm64@npm:0.25.5": "9e1ccd8e6cc87b7f8c83b8fb7091b98078ac96e18d58c7a45c22c981e58be1f86d8328d48906a1869226edf1a21e62eba64e43dd2aed9046a57795ed31b8d617",
"@esbuild/openbsd-arm64@npm:0.25.8": "9c0fbf35b6cefcc46c1c545520c50c65e89d620c65c97a55d47f1440e908cbbe6535073cb78ae69c1e2ba76621f09f3ab0f4bf9d5567660b8726c198a0ebdb0f",
"@esbuild/openbsd-x64@npm:0.25.4": "7b1bf4a5032e32ed3ce33bf9373964bdf29e49b0e16179e179d7c7dd0a36dbc6ee98ba67e0ef637ed7823b3ac094e21ccde848a066deb091bacc6ea4726a2ede",
"@esbuild/openbsd-x64@npm:0.25.5": "a13696c3b5ea9971df702c3c6cf8ddd17490d4becd3c2596a33230e53523c2d8d11d43857973d06292ad6670163e42ca6203dbad5a4f708f250d2d5fc23dc4d0",
"@esbuild/openbsd-x64@npm:0.25.8": "cd45098a84bcc86d4b1a809cf6e5f9548aa69cdff3a0f63a9bb039d05fdfd0daa2e166e1e30b8fbb71ede895dfc9c371e8368e3d51e7bf0484083f9bb112945a",
"@esbuild/openharmony-arm64@npm:0.25.8": "769c3e589d62648c67cd36306aaee683429e42e7d02608a52929f245c3a42d8036156fe90d59aff7695c2e75712be89ae4d4f06f4249f15a06bdc091ff42908d",
"@esbuild/sunos-x64@npm:0.25.4": "e1807f6dbd3bdf2f1ff9dc404fe0b667dea3bb03825344728de264c4f15323e99e3f1d8125b5c39e2aae94d2c1cad344e3b8a77b5e8c8e0004f09aa12daa82d9",
"@esbuild/sunos-x64@npm:0.25.5": "87789cae50b1aacd24d3f25b903d8016f370c6bc9c2618c243283921eea00119728e824c052fb41056ab7a5c8295442b32f598343788117499fb4145f52b6795",
"@esbuild/sunos-x64@npm:0.25.8": "8b3c79794775dce54d8d2c2c87cf876e8708ba2d7ca0ccda41d96c9bf3193237909f148195a20b7fa876c8e07def6db22510948a795156beeace160e9830ab62",
"@esbuild/win32-arm64@npm:0.25.4": "0422de25c136f407bc223e1a9a65a6f528e64201a1b06b7ddcf3190045914c6d68f550a8190d18e58c4e22231acc4c7982d45bd5ceab6a739e2c539d135376fe",
"@esbuild/win32-arm64@npm:0.25.5": "4a02984bb78737aec94eac24347be38aa17e504dc7702b3de9cb59179d5df14a812ecab387ce7654e4e23e58ea7989079bdf90e515bbf774a66243387ad55c52",
"@esbuild/win32-arm64@npm:0.25.8": "80f13cf66b45a32892f9b433689897362b69042173bc1e47ff333d8dd9df746be27bee031197653ee4e034a1563f61ae34efc44c61160a104dfda6500f6b4936",
"@esbuild/win32-ia32@npm:0.25.4": "5a8738ba94c72bc07bd17952cb5ba7f7f13593687cfe57792d36fcd9809082ac95ceb54b7739da68044de01f6d5d6826a2587ea2bce48b0de1c70f8de9b5257e",
"@esbuild/win32-ia32@npm:0.25.5": "e214bba446a70d3072c124f45b948af6dba335115c2f17b2bd64f64c1ef875db815cc7f6b5a57e2b9bec0bb76d7b4ebcd3afcb857b9b7e76a7c9d1a80ba0963e",
"@esbuild/win32-ia32@npm:0.25.8": "e4f0595306b2acbf19b62305c7acf97aa18954acf04f194c3cfd7a5782fab145ec6a551eaf657c3f0d2774cf19bc1fcb7ba76fb10cac32a4c2f48825c955690e",
"@esbuild/win32-x64@npm:0.25.4": "0bc72a7dc50b20d2cb7cd38a0d85ab3ff0c6467ba7d817a74da8c671703f97c7c7f7a7375d0069c3f0a76571dc04a1072852e711131cf4d1a62a70e7a38449db",
"@esbuild/win32-x64@npm:0.25.5": "4c6381c6dd3ab7c8aa9fdcda4faf0f08c0982c497348844c764d5b0f7b3d1ccb3fc5bf341057a79ce4fdbb8dcddc115a7b9d5af3ea247b3434d3d451a88c7072",
"@esbuild/win32-x64@npm:0.25.8": "4bf57733c5c4c1409cfceaf19bf5b8ce3c9b9a29705bc8a24fc72652846afd0bd478b14a17db326ae27896574ee346ffb96b2fa043f0716d1a7f30b89f8b3855",
"@img/sharp-darwin-arm64@npm:0.34.2": "891e401a14429d293c1cdd1a9dd47b81f3fafd1b14a57f884307727662af1541dcd802a31488c394113a4ab25ebcbab1246c5ab3c90beba42f7e8afaf56f073e",
"@img/sharp-darwin-arm64@npm:0.34.3": "952e9e9c34291502e7c21258d2874539a3953a5da8df52c8e2c459f673a76179eddd48c3b7563773db7bb36b2b241d781b98a667fac4b30c1f49c1cc9fdf9b7f",
"@img/sharp-darwin-x64@npm:0.34.2": "8d5e11f3430fa61966cb600cd23e2217f1666d481bbf754bdd731e60d4a6c34c78ff0169f7ec3463252d6542b0a3bafc0686473650b0e6b8a45fddbc49a8b52a",
"@img/sharp-darwin-x64@npm:0.34.3": "57ccfecf25b6e21b3df16694a959200ee6d00ac150bf4c5e3787bedfa8f944cbc95c7130fb6d66b207a0bd987e30f302b67de35a7481909b9bc175581da1be6f",
"@img/sharp-libvips-darwin-arm64@npm:1.1.0": "f6bcbe44fa9bc0c4c87af8c655c7ecdc704b684da1169841921ff7c61692167ee3ab6a4a3a8131f206f0aa7245987be1c07a483111eadd3a684b1547ca2acf02",
"@img/sharp-libvips-darwin-arm64@npm:1.2.0": "77a6a47fe9cbc1e6d1c66fd3f617bc64a8b710ed7cb44eee64409d49456dba054495e5ef8de3442e655ad11263ed19df554e9c33c2976e3226c121d826188587",
"@img/sharp-libvips-darwin-x64@npm:1.1.0": "af6cd4ca1ccc96dcd5cb20ac45941180117baad387331a699a05e588fa843b85d327651356940d9e3e2c1fe17f0ce183043bebf882086d3cb0785bb4bc8bca05",
"@img/sharp-libvips-darwin-x64@npm:1.2.0": "334c823aa129365e7f71b3467fb3c37e7a0065d7cf192b08b2bf85d400a568da42cb236dd238ff35670f296ec5b81f08415e11c257e1c8b8df680923c3acd72a",
"@img/sharp-libvips-linux-arm64@npm:1.1.0": "1d62f454f599580d64ecf72da24a08cb9347f1319e31678594f432e71762053c60c7bca5d70be720285b0754d8ed842efb160bef02abe36f5f57d735db0c012b",
"@img/sharp-libvips-linux-arm64@npm:1.2.0": "c8e7d5641ed6d1a406d08b45536fa6a9e221024bad1b3b6e7e16942500c5ca3f5ae444ac141a61ed9b43f6f7e73ee66bf973e24a90fd94dfcf83d4617492c085",
"@img/sharp-libvips-linux-arm@npm:1.1.0": "5028a1ad8e247dc1624baaa084e981f2f152c7ee5f567ee253720b4553d06a969bd6285f1795b374532f99e63b44b4d39494cc3d5dd8f438dab67d4c018f3520",
"@img/sharp-libvips-linux-arm@npm:1.2.0": "9a854fff624303ed4bfdc7e936af47b3c6b07e486d0b366c8881306d49766b8e972c5a26fa53288b00f4b92a019b374bb66106c9d34f6fb23489cde5b861d2e3",
"@img/sharp-libvips-linux-ppc64@npm:1.1.0": "d7c39d636083be25c71966e992803d652f5260c8fa0ece49348705c739042851c83057ec1f2d1cad8419afd3132311a6a0fcade343e69c9fbe8cbd8a12a54056",
"@img/sharp-libvips-linux-ppc64@npm:1.2.0": "bd4e956d5f01efc158e992047460be6b8cddb9f89cdd02f4e377a178da1703ed12125f161ec2eeb99de9d11232333bf501bf5e70b85e0e6f94f1cddf7d5fc954",
"@img/sharp-libvips-linux-s390x@npm:1.1.0": "612a7a967192a2bb31d757305a0abac4bdd17f4e41fed4fccee673961fd3743d1f435e9869efe324fa726d39286bcb4bfc9d5b7ceaebb2700483a3d6e2be0eb5",
"@img/sharp-libvips-linux-s390x@npm:1.2.0": "6ed6d891c2ddae07fff09290b24c1ee3531264dcdb0d0d461279fa2168c196490874f84d5b5fa045a3063e76957fee0bfa765860db486779e3acb68ab743400d",
"@img/sharp-libvips-linux-x64@npm:1.1.0": "73cea31f06110740998a44cb27387d59ab5878fdb4080213a46bf312fee1e8a3b69b8d97a78611fe951fc113d7aa732d0a7d8acadf6bc77322e73b6d5228f5f2",
"@img/sharp-libvips-linux-x64@npm:1.2.0": "2a80a045237e56c5f4ec2b5c4febe9d95066beadff06bd936439f34bdd615205346dbbf996b5b4d1e43af6a128cdfd4b1a76d6fb36d9eb62f61a7248fb242728",
"@img/sharp-libvips-linuxmusl-arm64@npm:1.1.0": "21d8124bccdc98817fc69022826a18a2630fbc1a3b16bfaf1d7f7c3df95d834cd75ef79e54c2edd0be44481d26e0f98ebcadc7b5e30bd73bf9afa66224cc4f8c",
"@img/sharp-libvips-linuxmusl-arm64@npm:1.2.0": "4225b0af93ec3a600f81930bb0ac70671cb76917a033f5ac6033252a79dd04c54b1d1bf602f79877efd07d9382106d8b2058b7c9a2bfcb7beabb6861eab0879a",
"@img/sharp-libvips-linuxmusl-x64@npm:1.1.0": "6671bcdb165a7958b0478c64a5acd7eb279ebea446b91e938888a1d6e2e7c58699c55bf4a856047847e6cc56a6cdc60c9a13e2a002f081c923331585a0db2c73",
"@img/sharp-libvips-linuxmusl-x64@npm:1.2.0": "d2a47388c6d1ff90bd85fa0a93f8bf9c5855c2834736bdd78d47d12689e3bcd41c695788c6bef9a8e1c5156951a675e22dc51a0ddf35a7d56c96cae3e9f55688",
"@img/sharp-linux-arm64@npm:0.34.2": "4e314f4ea4182c6b67d03eaa8600afd78fa298f17e6f71e7d78fc3e2b91d65c3eca0474979cc9ab48eea7573d1150609326955a2b4ed168cbcfb881ca8632bb3",
"@img/sharp-linux-arm64@npm:0.34.3": "a4ec64134484037e6a1583b11e39a16afb95eff963bf9c52deb17557b0a35dbc509325368040b04939e859f3b9531d64e6405fe54d13b3633628a4f77bfd8672",
"@img/sharp-linux-arm@npm:0.34.2": "3ec11f1c8312d4313623f20a09f60e53c07770c64dac50264f9da2e60688d992abb8a55ba4c665c88204db611cecf6e16d6397e57aac92390bddc2d7ee6a9ac2",
"@img/sharp-linux-arm@npm:0.34.3": "fe4106211c93c566d3712302c081391435caaeb6ecd41e88e94e3e9780d0f27934a02a871d6280625944f625350c4f81871d92210ff6ae5511318248a4ba3ebe",
"@img/sharp-linux-ppc64@npm:0.34.3": "0671ccb3a25e53a665d50b2b52cd779b57a07f642686bbb7311c288c44b2d861cd1eacf6bd6883421c73cc5efc8fa8536280dd48fde9a6de8d287e4a99c9ab69",
"@img/sharp-linux-s390x@npm:0.34.2": "1fc3ae6eeb2af800567d26582ae97465ce5bf3aee4b4125f3b11899c8aec9b6b9e538bfc1176c257788c20e67d6f57cb1e67e9fe6c96c900d2b43127ef6a3f45",
"@img/sharp-linux-s390x@npm:0.34.3": "a5e2c3c14faa997616caf0a9296302c58b9565bb24f156dae7ad1770f5f984919fb34a0d1f59f0112205db060e8bc665842fd27621147786893619c51b81af45",
"@img/sharp-linux-x64@npm:0.34.2": "8bad1ee5e9a23520da830090e29e2c8fc62c6dcf9255e490cfb664483423126b6a5417b1beb0e5433f678bd91996ebbc925c6a5f2cf477966ca4a5ebeee3fdf5",
"@img/sharp-linux-x64@npm:0.34.3": "83a82d1a97b975b64be0ed6fd35fe87609ffcbfb7a068a7ea0e67dba7ecd71f32382b86a024bcfda8aceb4ed1628f4ee4a567c4e157e9cd3c9fafa0b225fe6c2",
"@img/sharp-linuxmusl-arm64@npm:0.34.2": "f4189234d072002934a77ea9131514fa4922c3d6acdec9768e9ca88cb088d67f1001a07fe19a920abcdbd7888b0a408128ec5561849829f8c99c4814dc04315a",
"@img/sharp-linuxmusl-arm64@npm:0.34.3": "53f9f3f673441b21ea0a8d6d95b7ba8f051d4c2d2d4c4cb0fd83bb7593a56f854b255a1b706ddd376f8003adc6431b602afbb8a1ffe0850896147b24912a9504",
"@img/sharp-linuxmusl-x64@npm:0.34.2": "884532e80b772891d9452a1e6ad070e4668cd4aceb91935b7352d96f0813f1a6a3fafa3550e63f6f93dbcfdaafe8e8dcee7d6df6e12ebe3b66ca69d947ef0572",
"@img/sharp-linuxmusl-x64@npm:0.34.3": "ebd702f0f88121b31e87db93a87839085605a02826aba5207e9ad4fed89471daf0e32276ef3e13dc289e53042baaa8244bd43c0768c0733e3a4fce02fdf30dab",
"@img/sharp-wasm32@npm:0.34.2": "ca383f6c9a8d7afc00c446b175cbc8b7827d5e02c602aeb6e889f641e3eac4b3969bbed62be8c5e595f4774b378f39d67b8f3558b1ce4ff361298e8fe3efd5ec",
"@img/sharp-wasm32@npm:0.34.3": "3a64ba7dec1883eaae60925d77b04322a81d9c2d39359fa021677252df7da3be72f469a298cf2470f7350553eb30ee84e874d7032b06fa91ce27a81e1ec5f6c7",
"@img/sharp-win32-arm64@npm:0.34.2": "b7ce72e2861be11dd9ba8a0f00da57d97d4c93e88abf5f276dee516bde07527931908913cc576acc77c1f3cc61567e557cb927afcc88c5abee5d255f70f124a3",
"@img/sharp-win32-arm64@npm:0.34.3": "9328ef81ef6df02a8f83123f59c0addea7dd12681af3068e677ac274ed238321dd5522f2e4157b1a53ee0bc27ea22733263dddf5d4b65d2c5a2533ffb724f81e",
"@img/sharp-win32-ia32@npm:0.34.2": "edf6719745e473a4cd13745cd3543c885dc076bee38b8f8b7ee42967670e6403d54d060c22288c3118c3872acdbfa27042df6b941e62d61e81294ed309828c77",
"@img/sharp-win32-ia32@npm:0.34.3": "cf08bf95ff895c831bd74c7c4567d6c4ac20100e0d1badd0a9f7100486f3f416022222e29fcbae79b379defd1f0bc13adccc16c119fd4705d00c11c35ca9988a",
"@img/sharp-win32-x64@npm:0.34.2": "bb153458a2b1b4d794e1267b53626d7ec9080fddf38df2321b8e9d71da0eeea4669df7d88365e22c51f445595e5f281d7986dd5678cf8c331ad724f0dc29d06c",
"@img/sharp-win32-x64@npm:0.34.3": "07078e460f2749ad6422135193bacdfea1f223fab9f8442b5c0cbecb6d3e92070dd0a968219ff386a03930ec4104162627ffcad5b362ec8dc0247848deb52bbc",
"@parcel/watcher-android-arm64@npm:2.5.1": "e9c94ede3bd5c5d999d117d22ac8032a17f8ebc72db3eff04ccb2b4e6718db19f24bf29a66a610e03f4ee95e2cd7b2d30c15b1845eb897b971fec75dbdd76141",
"@parcel/watcher-darwin-arm64@npm:2.5.1": "0cab55a55c128ac5742388fc8dbfeb9877018509943801ce8a52b57bb6dca24189d025d38684b1e482cb7816368a52c6434dfe45d3997e2fd2509276f48774ea",
"@parcel/watcher-darwin-x64@npm:2.5.1": "bf07b8ca9a435fb885fb0ca6565204d2f2098d7f632faf26a6478bb39f538c73b50afca17c193dc189a80a864d85e40f924ec7f21a0e7ad7d0de6f97f7154134",
@ -107,6 +129,5 @@
"lightningcss-linux-x64-gnu@npm:1.27.0": "bb1b5713ddc9d8d711b527bcce47ce3e7fd91f2058c317ad5df09cded4142a85362ee71c353dd3b332497fc32a431a22f7762ce01464ff008b2a7cf2607d3dd3",
"lightningcss-linux-x64-musl@npm:1.27.0": "ec9b11bb0d70b929335f735486f8dd8fa6fc22eb95b71545b735b480b9e2b5287a24976735c2c5f4c9c50af07fb5cfdc02b65eceb6ec10256e7c9c637dedee9a",
"lightningcss-win32-arm64-msvc@npm:1.27.0": "1814c0d0464c21e808a2909ebbee7e12c42fd81ecd480e7c4e31769c555f238c720087af4383fff14862764f52bf4250cd566c6c45c3d6633bee126ef3355bc3",
"lightningcss-win32-x64-msvc@npm:1.27.0": "be733309737e4c4ed3dff33ec9e80bbc2d269d07bfa3742dd30d9055adfdc2e22be4d484475a7ea7cb7940c17f001cdf64856e157ef9b7c1d2c9342041e9eae4",
"systeminformation@npm:5.21.15": "349877eb556ef2de51d4986f30ff3a2fad89eba356cf4d14ccad290599b2e565959952c95e64488932214572dd206c54792ceb8e24bd967409a8fee40b9882f3"
"lightningcss-win32-x64-msvc@npm:1.27.0": "be733309737e4c4ed3dff33ec9e80bbc2d269d07bfa3742dd30d9055adfdc2e22be4d484475a7ea7cb7940c17f001cdf64856e157ef9b7c1d2c9342041e9eae4"
}

6
pkgs/by-name/jo/joplin-cli/package.nix
View file

@ -15,7 +15,7 @@
stdenv.mkDerivation (finalAttrs: {
pname = "joplin-cli";
version = "3.4.12";
version = "3.5.1";
src = fetchFromGitHub {
owner = "laurent22";
@ -25,14 +25,14 @@ stdenv.mkDerivation (finalAttrs: {
# there's a file with a weird name that causes a hash mismatch on darwin
rm $out/packages/app-cli/tests/support/photo*
'';
hash = "sha256-p9MY7E0qa7LcXBpGs/DmX2A2jXQoOPYiRo/nEzkkQd0=";
hash = "sha256-NNtdY6ajMfcMWj/AIo+b2nhylBCqyOIwCepYx/ZNCBY=";
};
missingHashes = ./missing-hashes.json;
offlineCache = yarn-berry_4.fetchYarnBerryDeps {
inherit (finalAttrs) src missingHashes postPatch;
hash = "sha256-7sZX39OtNNPq5RE7+Oj58QqHhcrTY8FOdncKp3b40jQ=";
hash = "sha256-EGP/nnz4u6I0efTQu41lgmk0tuHpiavVKHRdiSYdEUs=";
};
nativeBuildInputs = [

8
pkgs/by-name/jo/joplin-cli/update.sh
View file

@ -13,14 +13,10 @@ fi
nix-update "$UPDATE_NIX_PNAME" --version "$NEW_VERSION" || true
HOME=$(mktemp -d)
export HOME
src=$(nix-build --no-link "$PWD" -A "$UPDATE_NIX_PNAME.src")
WORKDIR=$(mktemp -d)
cp --recursive --no-preserve=mode "$src/*" "$WORKDIR"
pushd "$WORKDIR"
git clone "https://github.com/laurent22/joplin" -b "v$NEW_VERSION" "$WORKDIR/src"
pushd "$WORKDIR/src"
yarn-berry-fetcher missing-hashes yarn.lock >"$PACKAGE_DIR/missing-hashes.json"
popd
rm -rf "$WORKDIR"

2
pkgs/by-name/js/json-server/package.nix
View file

@ -18,7 +18,7 @@ buildNpmPackage (finalAttrs: {
npmDepsHash = "sha256-HZmCxMKgxJ+ZiRDXh/iVmytNMbPoYzSuI0F8YmkcfZI=";
passthru.updateScript = nix-update-script { };
passthru.updateScript = nix-update-script { extraArgs = [ "--version=unstable" ]; };
meta = {
description = "Get a full fake REST API with zero coding in less than 30 seconds";

4
pkgs/by-name/ke/keycloak/package.nix
View file

@ -24,11 +24,11 @@ let
in
stdenv.mkDerivation (finalAttrs: {
pname = "keycloak";
version = "26.4.2";
version = "26.4.4";
src = fetchzip {
url = "https://github.com/keycloak/keycloak/releases/download/${finalAttrs.version}/keycloak-${finalAttrs.version}.zip";
hash = "sha256-Gq4nfr3rzd58TpAM1EYoj3R856IWcR3sz63Au3UanwQ=";
hash = "sha256-nzwkrwMHKBZWzyB5Csl6htnVAcIgtpDC6YDl3MNg+eM=";
};
nativeBuildInputs = [

6
pkgs/by-name/la/lacy/package.nix
View file

@ -6,18 +6,18 @@
}:
rustPlatform.buildRustPackage (finalAttrs: {
pname = "lacy";
version = "0.5.1";
version = "0.6.0";
src = fetchFromGitHub {
owner = "timothebot";
repo = "lacy";
tag = "v${finalAttrs.version}";
hash = "sha256-blQPIw8Ct+TGRuy+ybYr9rdlfOZdvAbhsB8sfwugS/w=";
hash = "sha256-NjLCN9RDWusfw1BwSzRQLCx4UhHyMpQZ5+igRG1rX9Q=";
};
passthru.updateScript = nix-update-script { };
cargoHash = "sha256-rNTRcQJptVi/ruCd56oHHN9n+Z3NhUNyrvXf27Sovtw=";
cargoHash = "sha256-eE/kyb09AwcYTsyXQ9Yn43QF2veCRAgGkNgykJHCsFE=";
meta = {
description = "Fast magical cd alternative for lacy terminal navigators";

3
pkgs/by-name/li/libretrack/package.nix
View file

@ -31,6 +31,9 @@ flutter329.buildFlutterApplication rec {
libappindicator
];
# https://github.com/juliansteenbakker/flutter_secure_storage/issues/965
CXXFLAGS = [ "-Wno-deprecated-literal-operator" ];
postInstall = ''
substituteInPlace snap/gui/org.proninyaroslav.libretrack.desktop \
--replace-fail 'Icon=''${SNAP}/meta/gui/libretrack.png' 'Icon=libretrack' \

4
pkgs/by-name/mo/moonfire-nvr/package.nix
View file

@ -63,7 +63,7 @@ rustPlatform.buildRustPackage {
];
postInstall = ''
mkdir -p $out/lib/ui
mkdir -p $out/lib
ln -s ${ui} $out/lib/ui
'';
@ -72,9 +72,9 @@ rustPlatform.buildRustPackage {
passthru = {
inherit ui;
tests.version = testers.testVersion {
inherit version;
package = moonfire-nvr;
command = "moonfire-nvr --version";
version = "Version: v${version}";
};
};

7
pkgs/by-name/na/natscli/package.nix
View file

@ -36,14 +36,17 @@ buildGoModule rec {
'';
doInstallCheck = true;
versionCheckProgram = "${placeholder "out"}/bin/nats";
versionCheckProgramArg = "--version";
meta = {
description = "NATS Command Line Interface";
homepage = "https://github.com/nats-io/natscli";
changelog = "https://github.com/nats-io/natscli/releases/tag/${src.tag}";
license = lib.licenses.asl20;
maintainers = with lib.maintainers; [ fab ];
maintainers = with lib.maintainers; [
bengsparks
fab
];
mainProgram = "nats";
};
}

4
pkgs/by-name/ne/nemorosa/package.nix
View file

@ -6,14 +6,14 @@
python3Packages.buildPythonApplication rec {
pname = "nemorosa";
version = "0.3.0";
version = "0.4.0";
pyproject = true;
src = fetchFromGitHub {
owner = "KyokoMiki";
repo = "nemorosa";
tag = version;
hash = "sha256-UBvtff5fU3kH/+Kw426+yyoyJ3aASBIYDPX+X5jqkA8=";
hash = "sha256-qirdikSJ5APEmPnRwGCEuc8E+J3AOd4uHO68VtmkDRA=";
};
# Upstream uses overly strict, fresh version specifiers

8
pkgs/by-name/op/opencode/hashes.json
View file

@ -1,8 +1,8 @@
{
"node_modules": {
"aarch64-linux": "sha256-nNzDvqsFLJdZYDjvuYAcohnGnqNiGiS1mI9zAeKPr/U=",
"x86_64-linux": "sha256-rrW97K4eNtW3gGxu49BdzL6p8/goHBi3IT6z0IcQY0A=",
"aarch64-darwin": "sha256-joKBnXYVtDiJeq7sdDZwseXdNIjXM6BO3RqLTvq8kTQ=",
"x86_64-darwin": "sha256-6hLqaOP6qxnkUPHsWvlD96SjXRrbqWLeExWwlRgrUdg="
"aarch64-linux": "3yXOsptDRUoyL/FBQu8esD4ipudOA9jyLenNt1WChMU=",
"x86_64-linux": "sha256-ocgmxMx+V6uBMLZTrHfYAqO4l38WQVCrQ2AbUWagaoM=",
"aarch64-darwin": "sha256-xNU+ucIy84iqmyoWKwwLBIV34TTmH/OGmIbIiNOPM/w=",
"x86_64-darwin": "sha256-9kplc7tpWgYnB+4471EBkE2xYF3RkpgKqpg26M6bUPs="
}
}

4
pkgs/by-name/op/opencode/package.nix
View file

@ -14,12 +14,12 @@
stdenvNoCC.mkDerivation (finalAttrs: {
pname = "opencode";
version = "1.0.35";
version = "1.0.45";
src = fetchFromGitHub {
owner = "sst";
repo = "opencode";
tag = "v${finalAttrs.version}";
hash = "sha256-0IFlFWMPu9ynrpu/bYJK2xOgZc+lCSQOSV2WfD0KY3w=";
hash = "sha256-59nsauILNEvQ4Q8ATHKtgTViIWMaFnUyBf7CN6qrtdk=";
};
node_modules = stdenvNoCC.mkDerivation {

12
pkgs/by-name/op/opencode/skip-npm-pack.patch
View file

@ -1,16 +1,14 @@
diff --git i/packages/opencode/script/build.ts w/packages/opencode/script/build.ts
index 4ce8bfba..5b3da591 100755
index 29706c09..584b00d4 100755
--- i/packages/opencode/script/build.ts
+++ w/packages/opencode/script/build.ts
@@ -39,17 +39,9 @@ for (const [os, arch] of targets) {
@@ -39,15 +39,9 @@ for (const [os, arch] of targets) {
const name = `${pkg.name}-${os}-${arch}`
await $`mkdir -p dist/${name}/bin`
- const opentui = `@opentui/core-${os === "windows" ? "win32" : os}-${arch.replace("-baseline", "")}`
- await $`mkdir -p ../../node_modules/${opentui}`
- await $`npm pack ${opentui}@${pkg.dependencies["@opentui/core"]}`.cwd(
- path.join(dir, "../../node_modules"),
- )
- await $`npm pack ${opentui}@${pkg.dependencies["@opentui/core"]}`.cwd(path.join(dir, "../../node_modules"))
- await $`tar -xf ../../node_modules/${opentui.replace("@opentui/", "opentui-")}-*.tgz -C ../../node_modules/${opentui} --strip-components=1`
+ // Skip npm pack - packages already installed in node_modules by Nix
@ -20,5 +18,5 @@ index 4ce8bfba..5b3da591 100755
- await $`tar -xf ../../node_modules/${watcher.replace("@parcel/", "parcel-")}-*.tgz -C ../../node_modules/${watcher} --strip-components=1`
+ // Skip npm pack - packages already installed in node_modules by Nix
const parserWorker = fs.realpathSync(
path.resolve(dir, "./node_modules/@opentui/core/parser.worker.js"),
const parserWorker = fs.realpathSync(path.resolve(dir, "./node_modules/@opentui/core/parser.worker.js"))
const workerPath = "./src/cli/cmd/tui/worker.ts"

147
pkgs/by-name/op/opentoonz/package.nix
View file

@ -1,147 +0,0 @@
{
boost,
cmake,
fetchFromGitHub,
libglut,
freetype,
glew,
libsForQt5,
libjpeg,
libmypaint,
libpng,
libusb1,
lz4,
xz,
lzo,
openblas,
opencv,
pkg-config,
lib,
stdenv,
superlu,
libtiff,
zlib,
}:
let
libtiff-ver = "4.0.3"; # The version in thirdparty/tiff-*
opentoonz-ver = "1.7.1";
src = fetchFromGitHub {
owner = "opentoonz";
repo = "opentoonz";
rev = "v${opentoonz-ver}";
hash = "sha256-5iXOvh4QTv+G0fjEHU62u7QCee+jbvKhK0+fQXbdJis=";
};
opentoonz-opencv = opencv.override {
inherit libtiff;
};
opentoonz-libtiff = stdenv.mkDerivation {
pname = "libtiff";
version = "${libtiff-ver}-opentoonz";
inherit src;
outputs = [
"bin"
"dev"
"out"
"man"
"doc"
];
nativeBuildInputs = [ pkg-config ];
propagatedBuildInputs = [
zlib
libjpeg
xz
];
postUnpack = ''
sourceRoot="$sourceRoot/thirdparty/tiff-${libtiff-ver}"
'';
# opentoonz uses internal libtiff headers
postInstall = ''
cp libtiff/{tif_config,tif_dir,tiffiop}.h $dev/include
'';
meta = libtiff.meta // {
knownVulnerabilities = [
''
Do not open untrusted files with Opentoonz:
Opentoonz uses an old custom fork of tibtiff from 2012 that is known to
be affected by at least these 50 vulnerabilities:
CVE-2012-4564 CVE-2013-4232 CVE-2013-4243 CVE-2013-4244 CVE-2014-8127
CVE-2014-8128 CVE-2014-8129 CVE-2014-8130 CVE-2014-9330 CVE-2015-1547
CVE-2015-8781 CVE-2015-8782 CVE-2015-8783 CVE-2015-8784 CVE-2015-8870
CVE-2016-3620 CVE-2016-3621 CVE-2016-3623 CVE-2016-3624 CVE-2016-3625
CVE-2016-3631 CVE-2016-3632 CVE-2016-3633 CVE-2016-3634 CVE-2016-3658
CVE-2016-3945 CVE-2016-3990 CVE-2016-3991 CVE-2016-5102 CVE-2016-5314
CVE-2016-5315 CVE-2016-5316 CVE-2016-5318 CVE-2016-5319 CVE-2016-5321
CVE-2016-5322 CVE-2016-5323 CVE-2016-6223 CVE-2016-9453 CVE-2016-9532
CVE-2017-9935 CVE-2017-9937 CVE-2018-10963 CVE-2018-5360
CVE-2019-14973 CVE-2019-17546 CVE-2020-35521 CVE-2020-35522
CVE-2020-35523 CVE-2020-35524
More info at https://github.com/opentoonz/opentoonz/issues/4193
''
];
maintainers = with lib.maintainers; [ chkno ];
};
};
in
stdenv.mkDerivation {
inherit src;
pname = "opentoonz";
version = opentoonz-ver;
nativeBuildInputs = [
cmake
pkg-config
libsForQt5.wrapQtAppsHook
];
buildInputs = [
boost
libglut
freetype
glew
libjpeg
libmypaint
libpng
opentoonz-libtiff
libusb1
lz4
xz
lzo
openblas
opentoonz-opencv
libsForQt5.qtbase
libsForQt5.qtmultimedia
libsForQt5.qtscript
libsForQt5.qtserialport
superlu
];
postUnpack = "sourceRoot=$sourceRoot/toonz";
cmakeDir = "../sources";
cmakeFlags = [
"-DCMAKE_SKIP_BUILD_RPATH=ON"
"-DTIFF_INCLUDE_DIR=${opentoonz-libtiff.dev}/include"
"-DTIFF_LIBRARY=${opentoonz-libtiff.out}/lib/libtiff.so"
(lib.cmakeBool "CMAKE_SKIP_BUILD_RPATH" true)
];
postInstall = ''
sed -i '/cp -r .*stuff/a\ chmod -R u+w $HOME/.config/OpenToonz/stuff' $out/bin/opentoonz
'';
meta = {
description = "Full-featured 2D animation creation software";
homepage = "https://opentoonz.github.io/";
license = lib.licenses.bsd3;
maintainers = with lib.maintainers; [ chkno ];
};
}

6
pkgs/by-name/po/pomsky/package.nix
View file

@ -8,16 +8,16 @@
rustPlatform.buildRustPackage rec {
pname = "pomsky";
version = "0.11";
version = "0.12.0";
src = fetchFromGitHub {
owner = "pomsky-lang";
repo = "pomsky";
rev = "v${version}";
hash = "sha256-BoA59P0jzV08hlFO7NPB9E+fdpYB9G50dNggFkexc/c=";
hash = "sha256-0rLY0WZj8p9D834SqHogV77GLHLesyPPxMGszDmkB9U=";
};
cargoHash = "sha256-/tJwJ/xF5a2NEP5A/3swq75wCk9qxgbp7ilH1PqcWJY=";
cargoHash = "sha256-zUK8v96/jHaprrfbym23X7e/ZRoDwfNyDt+GIcd7BmY=";
nativeBuildInputs = [
pkg-config

4
pkgs/by-name/pr/protoc-gen-dart/package.nix
View file

@ -11,13 +11,13 @@
buildDartApplication rec {
pname = "protoc-gen-dart";
version = "22.5.0";
version = "24.0.0";
src = fetchFromGitHub {
owner = "google";
repo = "protobuf.dart";
tag = "protoc_plugin-v${version}";
hash = "sha256-8pSCYlbZLqHnpetM4luyfGo1qnWgKx93JPjRVWCOX0w=";
hash = "sha256-DEuvwBJhSo4o5ydnutxv2PCIRgS+2dE7u3RleidhAUM=";
};
pubspecLock = lib.importJSON ./pubspec.lock.json;

8
pkgs/by-name/pr/protoc-gen-dart/pubspec.lock.json
View file

@ -14,11 +14,11 @@
"dependency": "transitive",
"description": {
"name": "analyzer",
"sha256": "a40a0cee526a7e1f387c6847bd8a5ccbf510a75952ef8a28338e989558072cb0",
"sha256": "f51c8499b35f9b26820cfe914828a6a98a94efd5cc78b37bb7d03debae3a1d08",
"url": "https://pub.dev"
},
"source": "hosted",
"version": "8.4.0"
"version": "8.4.1"
},
"args": {
"dependency": "transitive",
@ -104,11 +104,11 @@
"dependency": "transitive",
"description": {
"name": "crypto",
"sha256": "1e445881f28f22d6140f181e07737b22f1e099a5e1ff94b0af2f9e4a463f4855",
"sha256": "c8ea0233063ba03258fbcf2ca4d6dadfefe14f02fab57702265467a19f27fadf",
"url": "https://pub.dev"
},
"source": "hosted",
"version": "3.0.6"
"version": "3.0.7"
},
"dart_style": {
"dependency": "transitive",

40
pkgs/by-name/qu/quorum/package.nix
View file

@ -1,40 +0,0 @@
{
lib,
fetchFromGitHub,
buildGoModule,
nixosTests,
}:
buildGoModule rec {
pname = "quorum";
version = "24.4.1";
src = fetchFromGitHub {
owner = "Consensys";
repo = "quorum";
rev = "v${version}";
hash = "sha256-pW8I4ivcKo6dsa8rQVKU6nUZuKxaki/7cMDKwEsSzNw=";
};
vendorHash = "sha256-YK2zpQz4pAFyA+aHOn6Nx0htl5SJ2HNC+TDV1RdLQJk=";
subPackages = [
"cmd/geth"
"cmd/bootnode"
];
ldflags = [
"-s"
"-w"
];
passthru.tests = { inherit (nixosTests) quorum; };
meta = with lib; {
description = "Permissioned implementation of Ethereum supporting data privacy";
homepage = "https://consensys.net/quorum/";
license = licenses.lgpl3;
maintainers = with maintainers; [ mmahut ];
platforms = platforms.linux;
};
}

24
pkgs/by-name/ra/rabbitmq-server/package.nix
View file

@ -6,6 +6,7 @@
python3,
libxml2,
libxslt,
git,
xmlto,
docbook_xml_dtd_45,
docbook_xsl,
@ -21,6 +22,7 @@
glibcLocales,
nixosTests,
which,
p7zip,
}:
let
@ -39,14 +41,14 @@ let
);
in
stdenv.mkDerivation rec {
stdenv.mkDerivation (finalAttrs: {
pname = "rabbitmq-server";
version = "4.0.9";
version = "4.1.4";
# 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-imBxBn8RQS0jBGfT5KLLLt+fKvyybzLzPZu9DpFOos8=";
url = "https://github.com/rabbitmq/rabbitmq-server/releases/download/v${finalAttrs.version}/${finalAttrs.pname}-${finalAttrs.version}.tar.xz";
hash = "sha256-dqNdrbXSysYUMN+6gMMb9GXKER/mOGXgW6j3iOLHNks=";
};
nativeBuildInputs = [
@ -58,6 +60,7 @@ stdenv.mkDerivation rec {
rsync
python3
which
p7zip
];
buildInputs = [
@ -68,6 +71,15 @@ stdenv.mkDerivation rec {
glibcLocales
];
prePatch = ''
# erlang.mk assumes that the elixir lib directory is at the same level as the bin of the elixir binary,
# this is not for the Nixpkgs packaging, so patch this
substituteInPlace erlang.mk \
--replace-fail \
"ELIXIR_LIBS ?= $(abspath $(dir $(ELIXIR_BIN))/../lib)" \
"ELIXIR_LIBS ?= ${beamPackages.elixir}/lib/elixir/lib"
'';
outputs = [
"out"
"man"
@ -129,9 +141,9 @@ stdenv.mkDerivation rec {
meta = {
homepage = "https://www.rabbitmq.com/";
description = "Implementation of the AMQP messaging protocol";
changelog = "https://github.com/rabbitmq/rabbitmq-server/releases/tag/v${version}";
changelog = "https://github.com/rabbitmq/rabbitmq-server/releases/tag/v${finalAttrs.version}";
license = lib.licenses.mpl20;
platforms = lib.platforms.unix;
maintainers = with lib.maintainers; [ samueltardieu ];
};
}
})

4
pkgs/by-name/ra/rapidcsv/package.nix
View file

@ -6,13 +6,13 @@
}:
stdenv.mkDerivation (finalAttrs: {
pname = "rapidcsv";
version = "8.89";
version = "8.90";
src = fetchFromGitHub {
owner = "d99kris";
repo = "rapidcsv";
rev = "v${finalAttrs.version}";
hash = "sha256-Xs9dNpOU6ZcbYX9AfkWkwMb/Bc7s2GTMUTDOBaO7VDM=";
hash = "sha256-0t2iURPBJpqt1Ndznuqg0qnnz574FtDAwyWTcYM1hBA=";
};
nativeBuildInputs = [

9
pkgs/by-name/ri/rio/package.nix
View file

@ -7,8 +7,10 @@
nixosTests,
nix-update-script,
autoPatchelfHook,
installShellFiles,
cmake,
ncurses,
scdoc,
pkg-config,
gcc-unwrapped,
fontconfig,
@ -62,6 +64,8 @@ rustPlatform.buildRustPackage (finalAttrs: {
nativeBuildInputs = [
rustPlatform.bindgenHook
ncurses
scdoc
installShellFiles
]
++ lib.optionals stdenv.hostPlatform.isLinux [
cmake
@ -99,6 +103,11 @@ rustPlatform.buildRustPackage (finalAttrs: {
tic -xe rio,rio-direct -o "$terminfo/share/terminfo" misc/rio.terminfo
mkdir -p $out/nix-support
echo "$terminfo" >> $out/nix-support/propagated-user-env-packages
scdoc < extra/man/rio.1.scd > rio.1
scdoc < extra/man/rio.5.scd > rio.5
scdoc < extra/man/rio-bindings.5.scd > rio-bindings.5
installManPage rio.1 rio.5 rio-bindings.5
''
+ lib.optionalString stdenv.hostPlatform.isDarwin ''
mkdir $out/Applications/

5
pkgs/by-name/sa/sabnzbd/package.nix
View file

@ -45,6 +45,7 @@ let
pysocks
python-dateutil
pytz
rarfile
rebulk
# sabnzbd requires a specific version of sabctools
(sabctools.overridePythonAttrs (old: {
@ -72,14 +73,14 @@ let
];
in
stdenv.mkDerivation rec {
version = "4.5.3";
version = "4.5.5";
pname = "sabnzbd";
src = fetchFromGitHub {
owner = "sabnzbd";
repo = "sabnzbd";
rev = version;
hash = "sha256-RFvWk+K/5gXMSO4jPOxkl7f+tnMvz+0u4NWPTUEv4dg=";
hash = "sha256-XEWMy+Ph47neyQubehegcOxucClB1Z9t1QDLN7FrxaY=";
};
nativeBuildInputs = [ makeWrapper ];

10
pkgs/by-name/sd/SDL_image/package.nix
View file

@ -15,13 +15,13 @@
stdenv.mkDerivation (finalAttrs: {
pname = "SDL_image";
version = "1.2.12-unstable-2025-06-15";
version = "1.2.12-unstable-2025-11-06";
src = fetchFromGitHub {
owner = "libsdl-org";
repo = "SDL_image";
rev = "bb266d29e19493fa48bda9bbc56c26363099372f";
hash = "sha256-I8TqZX3249/bcZtfwrJd545E5h9d9HmRy8GGDH9S+kU=";
rev = "7c6ea40bb75262740cd07f7658bc543f13c65b3c";
hash = "sha256-V8d9En6fJArslFLIaeCdfVD5YoHPbKjOpR79Va8w8js=";
};
configureFlags = [
@ -49,10 +49,6 @@ stdenv.mkDerivation (finalAttrs: {
libwebp
];
env = lib.optionalAttrs stdenv.cc.isGNU {
NIX_CFLAGS_COMPILE = "-Wno-error=incompatible-pointer-types";
};
outputs = [
"out"
"dev"

4
pkgs/by-name/sn/snakemake/package.nix
View file

@ -10,14 +10,14 @@
python3Packages.buildPythonApplication rec {
pname = "snakemake";
version = "9.13.4";
version = "9.13.7";
pyproject = true;
src = fetchFromGitHub {
owner = "snakemake";
repo = "snakemake";
tag = "v${version}";
hash = "sha256-SNI9MS1rQ7G27HBeORQ83JOCaCNgp+6h5GeK6sXU2Lg=";
hash = "sha256-hYITdHXV5qRmxXOTHnUgkR9xVXOyqP470a8zOhlCoLo=";
};
postPatch = ''

6
pkgs/by-name/st/stackit-cli/package.nix
View file

@ -12,16 +12,16 @@
buildGoModule rec {
pname = "stackit-cli";
version = "0.46.0";
version = "0.47.0";
src = fetchFromGitHub {
owner = "stackitcloud";
repo = "stackit-cli";
rev = "v${version}";
hash = "sha256-f7Af7Zk8rRrYyGChMgAM/a2Cs7fo3ZlN78aq5teZ0oo=";
hash = "sha256-6cWFUPPRQD+uCVatj7usF0ndXvqI7hdhE1KjdYDflb4=";
};
vendorHash = "sha256-tMPj4w/9fO9NlmwZoN4F3G4Cc+8wLmAr+fTueHGBn+A=";
vendorHash = "sha256-9e643w+1oHp9w50PSHF8SOqlwoym7OjSIH4PWGEAvdQ=";
subPackages = [ "." ];

2
pkgs/by-name/sw/switch-to-configuration-ng/src/src/main.rs
View file

@ -149,7 +149,7 @@ fn parse_os_release() -> Result<HashMap<String, String>> {
fn do_pre_switch_check(command: &str, toplevel: &Path, action: &Action) -> Result<()> {
let mut cmd_split = command.split_whitespace();
let Some(argv0) = cmd_split.next() else {
bail!("missing first argument in install bootloader commands");
bail!("missing first argument in pre-switch check");
};
match std::process::Command::new(argv0)

8
pkgs/by-name/te/texlab/package.nix
View file

@ -14,16 +14,16 @@ let
in
rustPlatform.buildRustPackage rec {
pname = "texlab";
version = "5.23.1";
version = "5.24.0";
src = fetchFromGitHub {
owner = "latex-lsp";
repo = "texlab";
tag = "v${version}";
hash = "sha256-QGC2UFmbMCMr0i853M5mdXklqZFYy00fbqeLllpQ4Sg=";
hash = "sha256-gwF4cBlS43u2PfOQBxD7iq2JL9tUo8TPJqR0tWNdW9k=";
};
cargoHash = "sha256-hJDKzHrNUmN4jqp4P1Is3mYvRC5H3nnHtIW7xjDH+xo=";
cargoHash = "sha256-9sAurVJSpLNgQvJOG7kSXHIr38MHsw3BhGAaxi9xjUE=";
outputs = [ "out" ] ++ lib.optional (!isCross) "man";
@ -37,7 +37,7 @@ rustPlatform.buildRustPackage rec {
# generate the man page
postInstall = lib.optionalString (!isCross) ''
# TexLab builds man page separately in CI:
# https://github.com/latex-lsp/texlab/blob/v5.23.0/.github/workflows/publish.yml#L110-L114
# https://github.com/latex-lsp/texlab/blob/v5.24.0/.github/workflows/publish.yml#L110-L114
help2man --no-info "$out/bin/texlab" > texlab.1
installManPage texlab.1
'';

6
pkgs/by-name/up/uppy-companion/package.nix
View file

@ -8,13 +8,13 @@
stdenv.mkDerivation (finalAttrs: {
pname = "uppy-companion";
version = "6.1.1";
version = "6.2.0";
src = fetchFromGitHub {
owner = "transloadit";
repo = "uppy";
tag = "@uppy/companion@${finalAttrs.version}";
hash = "sha256-Z7u0Wrkg1/jZtOF86hUbwRVWWGHuv4ktcXx+gEcLYlQ=";
hash = "sha256-FF5I4D9obRVJqyjucemnxZiPcNHdQdo3S0z/h96Fe6c=";
};
nativeBuildInputs = [
@ -31,7 +31,7 @@ stdenv.mkDerivation (finalAttrs: {
offlineCache = yarn-berry_4.fetchYarnBerryDeps {
inherit (finalAttrs) src missingHashes;
hash = "sha256-5XLOyz1QowX08C0IBcg9Um1eY+1qwtPyqIFb83FPFz8=";
hash = "sha256-euKvBI3Y15SmBoVOEbS8GIJT/kIOhayLKGVSd8JztqI=";
};
buildPhase = ''

68
pkgs/by-name/wa/wasm-text-gen/package.nix Normal file
View file

@ -0,0 +1,68 @@
{
lib,
stdenv,
fetchFromGitHub,
fetchYarnDeps,
yarnConfigHook,
yarnBuildHook,
nodejs,
makeBinaryWrapper,
gcc,
}:
stdenv.mkDerivation (finalAttrs: {
pname = "wasm-text-gen";
version = "1.14.1";
src = fetchFromGitHub {
owner = "xtuc";
repo = "webassemblyjs";
tag = "v${finalAttrs.version}";
hash = "sha256-zkZyI/bLSCZkgSEH9kx8Qls7RZuiTVP5CwWlFaK1yI8=";
};
postPatch = ''
substituteInPlace packages/**/package.json \
--replace-warn "1.13.2" "1.14.1"
patchShebangs scripts/
'';
yarnOfflineCache = fetchYarnDeps {
inherit (finalAttrs) src;
hash = "sha256-gweiisUVp1D4BAcyuf3V81jN+ehm6z5ztftG+tc7M+A=";
};
nativeBuildInputs = [
yarnConfigHook
yarnBuildHook
nodejs
makeBinaryWrapper
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ gcc ];
preInstall = ''
yarn install --offline --prod --no-bin-links
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib/{packages,node_modules}
mkdir $out/bin
mv -t $out/lib/packages packages/**
mv -t $out/lib/node_modules node_modules/**
makeWrapper ${lib.getExe nodejs} $out/bin/wasmgen \
--add-flags "$out/lib/packages/wasm-text-gen/lib/cli.js" \
--set NODE_PATH "$out/lib/node_modules"
runHook postInstall
'';
meta = {
description = "Toolbox for WebAssembly";
homepage = "https://webassembly.js.org";
license = lib.licenses.mit;
maintainers = with lib.maintainers; [ pyrox0 ];
mainProgram = "wasmgen";
};
})

69
pkgs/by-name/wa/wast-refmt/package.nix Normal file
View file

@ -0,0 +1,69 @@
{
lib,
stdenv,
fetchFromGitHub,
fetchYarnDeps,
yarnConfigHook,
yarnBuildHook,
nodejs,
makeBinaryWrapper,
gcc,
}:
stdenv.mkDerivation (finalAttrs: {
pname = "wast-refmt";
version = "1.14.1";
src = fetchFromGitHub {
owner = "xtuc";
repo = "webassemblyjs";
tag = "v${finalAttrs.version}";
hash = "sha256-zkZyI/bLSCZkgSEH9kx8Qls7RZuiTVP5CwWlFaK1yI8=";
};
postPatch = ''
substituteInPlace packages/**/package.json \
--replace-warn "1.13.2" "1.14.1"
patchShebangs scripts/
'';
yarnOfflineCache = fetchYarnDeps {
inherit (finalAttrs) src;
hash = "sha256-gweiisUVp1D4BAcyuf3V81jN+ehm6z5ztftG+tc7M+A=";
};
nativeBuildInputs = [
yarnConfigHook
yarnBuildHook
nodejs
makeBinaryWrapper
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ gcc ];
preInstall = ''
yarn install --offline --prod --no-bin-links
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib/{packages,node_modules}
mkdir $out/bin
mv -t $out/lib/packages packages/**
mv -t $out/lib/node_modules node_modules/**
makeWrapper ${lib.getExe nodejs} $out/bin/wast-refmt \
--add-flags "$out/lib/packages/wast-refmt/lib/cli.js" \
--set NODE_PATH "$out/lib/node_modules"
runHook postInstall
'';
meta = {
description = "WAST Reformatter";
homepage = "https://webassembly.js.org";
license = lib.licenses.mit;
maintainers = with lib.maintainers; [ pyrox0 ];
mainProgram = "wast-refmt";
};
})

74
pkgs/by-name/we/webassemblyjs-cli/package.nix Normal file
View file

@ -0,0 +1,74 @@
{
lib,
stdenv,
fetchFromGitHub,
fetchYarnDeps,
yarnConfigHook,
yarnBuildHook,
nodejs,
makeBinaryWrapper,
gcc,
}:
stdenv.mkDerivation (finalAttrs: {
pname = "webassemblyjs-cli";
version = "1.14.1";
src = fetchFromGitHub {
owner = "xtuc";
repo = "webassemblyjs";
tag = "v${finalAttrs.version}";
hash = "sha256-zkZyI/bLSCZkgSEH9kx8Qls7RZuiTVP5CwWlFaK1yI8=";
};
postPatch = ''
substituteInPlace packages/**/package.json \
--replace-warn "1.13.2" "1.14.1"
patchShebangs scripts/
'';
yarnOfflineCache = fetchYarnDeps {
inherit (finalAttrs) src;
hash = "sha256-gweiisUVp1D4BAcyuf3V81jN+ehm6z5ztftG+tc7M+A=";
};
nativeBuildInputs = [
yarnConfigHook
yarnBuildHook
nodejs
makeBinaryWrapper
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ gcc ];
preInstall = ''
yarn install --offline --prod --no-bin-links
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib/{packages,node_modules}
mkdir $out/bin
mv -t $out/lib/packages packages/**
mv -t $out/lib/node_modules node_modules/**
declare -a cmds=("wasmdump" "wasmast" "wasmrun"
"wasm2wast" "wastast" "get-producer-section"
"wast-to-wasm-semantics")
for c in "''${cmds[@]}"
do
makeWrapper ${lib.getExe nodejs} $out/bin/$c \
--add-flags "$out/lib/packages/cli/lib/$c.js" \
--set NODE_PATH "$out/lib/node_modules"
done
runHook postInstall
'';
meta = {
description = "Toolbox for WebAssembly";
homepage = "https://webassembly.js.org";
license = lib.licenses.mit;
maintainers = with lib.maintainers; [ pyrox0 ];
};
})

69
pkgs/by-name/we/webassemblyjs-repl/package.nix Normal file
View file

@ -0,0 +1,69 @@
{
lib,
stdenv,
fetchFromGitHub,
fetchYarnDeps,
yarnConfigHook,
yarnBuildHook,
nodejs,
makeBinaryWrapper,
gcc,
}:
stdenv.mkDerivation (finalAttrs: {
pname = "webassemblyjs-repl";
version = "1.14.1";
src = fetchFromGitHub {
owner = "xtuc";
repo = "webassemblyjs";
tag = "v${finalAttrs.version}";
hash = "sha256-zkZyI/bLSCZkgSEH9kx8Qls7RZuiTVP5CwWlFaK1yI8=";
};
postPatch = ''
substituteInPlace packages/**/package.json \
--replace-warn "1.13.2" "1.14.1"
patchShebangs scripts/
'';
yarnOfflineCache = fetchYarnDeps {
inherit (finalAttrs) src;
hash = "sha256-gweiisUVp1D4BAcyuf3V81jN+ehm6z5ztftG+tc7M+A=";
};
nativeBuildInputs = [
yarnConfigHook
yarnBuildHook
nodejs
makeBinaryWrapper
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ gcc ];
preInstall = ''
yarn install --offline --prod --no-bin-links
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib/{packages,node_modules}
mkdir $out/bin
mv -t $out/lib/packages packages/**
mv -t $out/lib/node_modules node_modules/**
makeWrapper ${lib.getExe nodejs} $out/bin/wasm \
--add-flags "$out/lib/packages/repl/lib/bin.js" \
--set NODE_PATH "$out/lib/node_modules"
runHook postInstall
'';
meta = {
description = "WebAssembly REPL";
homepage = "https://webassembly.js.org";
license = lib.licenses.mit;
maintainers = with lib.maintainers; [ pyrox0 ];
mainProgram = "wasm";
};
})

49
pkgs/by-name/wl/wlock/package.nix
View file

@ -2,54 +2,61 @@
lib,
stdenv,
fetchFromGitea,
libxcrypt,
pkg-config,
wayland-scanner,
wayland,
wayland-protocols,
libxkbcommon,
wayland-scanner,
libxcrypt,
nix-update-script,
}:
stdenv.mkDerivation {
stdenv.mkDerivation (finalAttrs: {
pname = "wlock";
version = "0-unstable-2024-09-13";
version = "1.0";
src = fetchFromGitea {
domain = "codeberg.org";
owner = "sewn";
repo = "wlock";
rev = "be975445fa0da7252f8e13b610c518dd472652d0";
hash = "sha256-Xt7Q51RhFG+UXYukxfORIhc4Df86nxtpDhAhaSmI38A=";
tag = finalAttrs.version;
hash = "sha256-vbGrePrZN+IWwzwoNUzMHmb6k9nQbRLVZmbWIAsYneY=";
};
postPatch = ''
substituteInPlace Makefile --replace-fail 'chmod 4755' 'chmod 755'
'';
buildInputs = [
libxcrypt
wayland
wayland-protocols
libxkbcommon
];
strictDeps = true;
makeFlags = [
"PREFIX=$(out)"
("WAYLAND_SCANNER=" + lib.getExe wayland-scanner)
];
nativeBuildInputs = [
pkg-config
wayland-scanner
];
buildInputs = [
wayland
wayland-protocols
libxkbcommon
libxcrypt
];
makeFlags = [
"PREFIX=$(out)"
("WAYLAND_SCANNER=" + lib.getExe wayland-scanner)
];
passthru.updateScript = nix-update-script { };
meta = {
description = "Sessionlocker for Wayland compositors that support the ext-session-lock-v1 protocol";
license = lib.licenses.gpl3;
license = lib.licenses.gpl3Only;
homepage = "https://codeberg.org/sewn/wlock";
platforms = lib.platforms.linux;
maintainers = with lib.maintainers; [ fliegendewurst ];
maintainers = with lib.maintainers; [
fliegendewurst
yiyu
];
mainProgram = "wlock";
};
}
})

4
pkgs/by-name/xf/xfel/package.nix
View file

@ -8,13 +8,13 @@
stdenv.mkDerivation (finalAttrs: {
pname = "xfel";
version = "1.3.3";
version = "1.3.4";
src = fetchFromGitHub {
owner = "xboot";
repo = "xfel";
tag = "v${finalAttrs.version}";
hash = "sha256-5Io2qOIeGovDpbxSlmqtGMrGMxUjMu/e1304euTEtJc=";
hash = "sha256-3eWVIPfUpa8ZJjce2F6eLdLttmoBI47VQ0IheSSgGmU=";
};
postPatch = ''

6
pkgs/by-name/yo/youki/package.nix
View file

@ -13,13 +13,13 @@
rustPlatform.buildRustPackage rec {
pname = "youki";
version = "0.5.5";
version = "0.5.7";
src = fetchFromGitHub {
owner = "containers";
repo = "youki";
rev = "v${version}";
hash = "sha256-r8/H/qTPBoNubg3f4+WC8lBkQXpdEE8Dapt2sGoFcTc=";
hash = "sha256-b2R9/ADoZfRSu1Qh7hImR1Y+ZX15Uhk7JFwD8ipec6o=";
};
nativeBuildInputs = [
@ -53,7 +53,7 @@ rustPlatform.buildRustPackage rec {
"youki"
];
cargoHash = "sha256-S2Cv7k4ine9/VbY2r8BSRwqVBtuqX55RYglm9W+LXvc=";
cargoHash = "sha256-R/1wE7twjMwlSns7ZV5nr8PZ/OzghcslvU+0Ic/oamQ=";
meta = {
description = "Container runtime written in Rust";

5
pkgs/data/icons/la-capitaine-icon-theme/default.nix
View file

@ -15,8 +15,8 @@ stdenvNoCC.mkDerivation rec {
src = fetchFromGitHub {
owner = "keeferrourke";
repo = "la-capitaine-icon-theme";
rev = "v${version}";
sha256 = "0id2dddx6rl71472l47vafx968wnklmq6b980br68w82kcvqczzs";
tag = "v${version}";
hash = "sha256-+n+GN5sCcWTyAigtgyudliOTulP7ECoOCYdm01trokU=";
};
propagatedBuildInputs = [
@ -40,6 +40,7 @@ stdenvNoCC.mkDerivation rec {
mkdir -p $out/share/icons/$pname
cp -a * $out/share/icons/$pname
rm $out/share/icons/$pname/{configure,COPYING,LICENSE,*.md}
cp "$out/share/icons/$pname/places/scalable/"distributor-logo-{archlinux,debian,kubuntu}.svg "$out/share/icons/$pname/apps/scalable/"
runHook postInstall
'';

7
pkgs/development/node-packages/aliases.nix
View file

@ -57,6 +57,12 @@ mapAliases {
"@uppy/companion" = pkgs.uppy-companion; # Added 2025-11-01
"@volar/vue-language-server" = pkgs.vue-language-server; # added 2024-06-15
"@vue/language-server" = pkgs.vue-language-server; # added 2024-06-15
"@webassemblyjs/cli-1.11.1" = pkgs.webassemblyjs-cli; # Added 2025-11-06
"@webassemblyjs/repl-1.11.1" = pkgs.webassemblyjs-repl; # Added 2025-11-06
"@webassemblyjs/wasm-strip" =
"@webassemblyjs/wasm-strip has been removed because it was deprecated by upstream. Consider using wabt instead"; # Added 2025-11-06
"@webassemblyjs/wasm-text-gen-1.11.1" = pkgs.wasm-text-gen; # Added 2025-11-06
"@webassemblyjs/wast-refmt-1.11.1" = pkgs.wast-refmt; # Added 2025-11-06
"@withgraphite/graphite-cli" = pkgs.graphite-cli; # added 2024-01-25
"@zwave-js/server" = pkgs.zwave-js-server; # Added 2023-09-09
inherit (pkgs) autoprefixer; # added 2024-06-25
@ -229,6 +235,7 @@ mapAliases {
orval = throw "orval has been removed because it was broken"; # added 2025-03-23
parcel = throw "parcel has been removed because it was broken"; # added 2025-03-12
parcel-bundler = self.parcel; # added 2023-09-04
parsoid = throw "The Javascript version of Parsoid has been deprecated by upstream and no longer works with modern MediaWiki versions"; # Added 2025-11-04
inherit (pkgs) patch-package; # added 2024-06-29
pkg = pkgs.vercel-pkg; # added 2023-10-04
inherit (pkgs) pm2; # added 2024-01-22

6
pkgs/development/node-packages/main-programs.nix
View file

@ -3,15 +3,10 @@
# Packages that provide multiple executables where one is clearly the `mainProgram`.
"@antfu/ni" = "ni";
"@microsoft/rush" = "rush";
"@webassemblyjs/cli-1.11.1" = "wasm2wast";
# Packages that provide a single executable.
"@angular/cli" = "ng";
"@commitlint/cli" = "commitlint";
"@webassemblyjs/repl-1.11.1" = "wasm";
"@webassemblyjs/wasm-strip" = "wasm-strip";
"@webassemblyjs/wasm-text-gen-1.11.1" = "wasmgen";
"@webassemblyjs/wast-refmt-1.11.1" = "wast-refmt";
aws-cdk = "cdk";
cdk8s-cli = "cdk8s";
clipboard-cli = "clipboard";
@ -25,7 +20,6 @@
gulp-cli = "gulp";
jsonlint = "jsonlint";
localtunnel = "lt";
parsoid = "parse.js";
poor-mans-t-sql-formatter-cli = "sqlformat";
pulp = "pulp";
purescript-language-server = "purescript-language-server";

6
pkgs/development/node-packages/node-packages.json
View file

@ -7,11 +7,6 @@
, "@tailwindcss/forms"
, "@tailwindcss/line-clamp"
, "@tailwindcss/typography"
, {"@webassemblyjs/cli": "1.11.1"}
, {"@webassemblyjs/repl": "1.11.1"}
, "@webassemblyjs/wasm-strip"
, {"@webassemblyjs/wasm-text-gen": "1.11.1"}
, {"@webassemblyjs/wast-refmt": "1.11.1"}
, "alex"
, "audiosprite"
, "aws-cdk"
@ -62,7 +57,6 @@
, "node2nix"
, "np"
, "nrm"
, "parsoid"
, "peerflix"
, "peerflix-server"
, "poor-mans-t-sql-formatter-cli"

1350
pkgs/development/node-packages/node-packages.nix generated
View file

File diff suppressed because it is too large Load diff

9
pkgs/development/python-modules/av/default.nix
View file

@ -25,14 +25,14 @@
buildPythonPackage rec {
pname = "av";
version = "15.1.0";
version = "16.0.1";
pyproject = true;
src = fetchFromGitHub {
owner = "PyAV-Org";
repo = "PyAV";
tag = "v${version}";
hash = "sha256-VeF6Sti1Ide2LchiCuPut/bdbJUv+5eTH2q0YMcniyA=";
hash = "sha256-iFKDDOJzCynaqwHIjykfh82diGiuOjWytwU3dq1J9PA=";
};
build-system = [
@ -63,10 +63,7 @@ buildPythonPackage rec {
pytestCheckHook
];
# `__darwinAllowLocalNetworking` doesn’t work for these; not sure why.
disabledTestPaths = lib.optionals stdenv.hostPlatform.isDarwin [
"tests/test_timeout.py"
];
__darwinAllowLocalNetworking = true;
pythonImportsCheck = [
"av"

2
pkgs/development/python-modules/av/test-samples.toml
View file

@ -1,6 +1,7 @@
"fate-suite/aac/latm_stereo_to_51.ts" = { url = "http://fate.ffmpeg.org/fate-suite/aac/latm_stereo_to_51.ts", hash = "sha256-lVz0iby2IEUVdwKYamv4HVm8EUGHJS/cWY+QFBMaCBY=" }
"fate-suite/amv/MTV_high_res_320x240_sample_Penguin_Joke_MTV_from_WMV.amv" = { url = "http://fate.ffmpeg.org/fate-suite/amv/MTV_high_res_320x240_sample_Penguin_Joke_MTV_from_WMV.amv", hash = "sha256-O9YMj0+0bM4YyZNGgkZJL8E2aG+Y3lq8/c+DVht0McI=" }
"fate-suite/audio-reference/chorusnoise_2ch_44kHz_s16.wav" = { url = "http://fate.ffmpeg.org/fate-suite/audio-reference/chorusnoise_2ch_44kHz_s16.wav", hash = "sha256-KodB5hQkBFtfkI+L7hnkSonPM+IuOCNrTV3Vsy1bvhs=" }
"fate-suite/h264/extradata-reload-multi-stsd.mov" = { url = "http://fate.ffmpeg.org/fate-suite/h264/extradata-reload-multi-stsd.mov", hash = "sha256-tby9Ttwc4+rVjoaDZ+fqcqCUXSuYjQD/LiLdvhOdlOc=" }
"fate-suite/h264/interlaced_crop.mp4" = { url = "http://fate.ffmpeg.org/fate-suite/h264/interlaced_crop.mp4", hash = "sha256-SVWWaOcfOp718dvgkpgOWCYoV9Ylomv8MBYzbRqvbBE=" }
"fate-suite/hap/HAPQA_NoSnappy_127x1.mov" = { url = "http://fate.ffmpeg.org/fate-suite/hap/HAPQA_NoSnappy_127x1.mov", hash = "sha256-WMUqg9o84ki2AIIsGhY8P10KBc3qgCsmljqJXXRHbs8=" }
"fate-suite/mkv/codec_delay_opus.mkv" = { url = "http://fate.ffmpeg.org/fate-suite/mkv/codec_delay_opus.mkv", hash = "sha256-GanpfRyGKN36NLAa7pZehcM1F2VDCW3g6hhO26vFg1I=" }
@ -13,5 +14,6 @@
"fate-suite/qtrle/aletrek-rle.mov" = { url = "http://fate.ffmpeg.org/fate-suite/qtrle/aletrek-rle.mov", hash = "sha256-uXUvVkwuPbfs/rzT896ty3RZfvGoSPj3su+sjLPU09g=" }
"fate-suite/sub/MovText_capability_tester.mp4" = { url = "http://fate.ffmpeg.org/fate-suite/sub/MovText_capability_tester.mp4", hash = "sha256-Y2uhvfGrZaPebD6ZsJemzpOk+XHX6ukBceVauEit9h8=" }
"fate-suite/sub/vobsub.sub" = { url = "http://fate.ffmpeg.org/fate-suite/sub/vobsub.sub", hash = "sha256-X2rEMyTlo1xuUlqgx2uvqd2WWhfOCID9fraeGbaFPIs=" }
"fate-suite/vorbis/vorbis_chapter_extension_demo.ogg" = { url = "http://fate.ffmpeg.org/fate-suite/vorbis/vorbis_chapter_extension_demo.ogg", hash = "sha256-s0kGcghf8Td/bSPy1HOBKaG5bT5zVxFlT1NfQiKHMN8=" }
"pyav-curated/pexels/time-lapse-video-of-night-sky-857195.mp4" = { url = "https://pyav.org/datasets/pexels/time-lapse-video-of-night-sky-857195.mp4", hash = "sha256-6307VwepfoVNKeGm8WEMZtfowJZ27Hv2fwgp6J/Q0oE=" }
"pyav-curated/pexels/time-lapse-video-of-sunset-by-the-sea-854400.mp4" = { url = "https://pyav.org/datasets/pexels/time-lapse-video-of-sunset-by-the-sea-854400.mp4", hash = "sha256-2RWphhz5KWPSnJh8ARrC7aPjBa77DJO1Fv0/I4kWxYg=" }

57
pkgs/development/python-modules/gpapi/default.nix
View file

@ -1,57 +0,0 @@
{
buildPythonPackage,
cryptography,
fetchPypi,
lib,
protobuf,
pycryptodome,
requests,
protobuf_27,
setuptools,
}:
buildPythonPackage rec {
version = "0.4.4";
pname = "gpapi";
pyproject = true;
src = fetchPypi {
inherit version pname;
sha256 = "sha256-HA06ie25ny7AXI7AvZgezvowfZ3ExalY8HDkk7betyo=";
};
postPatch = ''
substituteInPlace setup.py \
--replace-fail 'PROTOC_EXEC = "protoc"' 'PROTOC_EXEC = "${lib.getExe protobuf_27}"'
'';
build-system = [ setuptools ];
buildInputs = [
protobuf_27
];
dependencies = [
cryptography
protobuf
pycryptodome
requests
];
preBuild = ''
export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION="python"
'';
# package doesn't contain unit tests
# scripts in ./test require networking
doCheck = false;
pythonImportsCheck = [ "gpapi.googleplay" ];
meta = {
homepage = "https://github.com/NoMore201/googleplay-api";
license = lib.licenses.gpl3Only;
description = "Google Play Unofficial Python API";
maintainers = [ ];
};
}

75
pkgs/development/python-modules/gplaycli/default.nix
View file

@ -1,75 +0,0 @@
{
lib,
args,
buildPythonPackage,
clint,
fetchFromGitHub,
libffi,
matlink-gpapi,
ndg-httpsclient,
protobuf,
pyasn1,
pyaxmlparser,
pytestCheckHook,
pythonOlder,
requests,
setuptools,
}:
buildPythonPackage rec {
pname = "gplaycli";
version = "3.29";
format = "setuptools";
disabled = pythonOlder "3.6";
src = fetchFromGitHub {
owner = "matlink";
repo = "gplaycli";
tag = version;
hash = "sha256-uZBrIxnDSaJDOPcD7J4SCPr9nvecDDR9h+WnIjIP7IE=";
};
propagatedBuildInputs = [
libffi
pyasn1
clint
ndg-httpsclient
protobuf
requests
args
matlink-gpapi
pyaxmlparser
setuptools
];
nativeCheckInputs = [ pytestCheckHook ];
pythonImportsCheck = [ "gplaycli" ];
preCheck = ''
export PATH="$PATH:$out/bin";
'';
disabledTests = [
"test_alter_token"
"test_another_device"
"test_connection_credentials"
"test_connection_token"
"test_download_additional_files"
"test_download_focus"
"test_download_version"
"test_download"
"test_search"
"test_update"
];
meta = with lib; {
description = "Google Play Downloader via Command line";
mainProgram = "gplaycli";
homepage = "https://github.com/matlink/gplaycli";
changelog = "https://github.com/matlink/gplaycli/releases/tag/${version}";
license = licenses.agpl3Plus;
maintainers = [ ];
};
}

13
pkgs/development/python-modules/manim/failing_tests.nix
View file

@ -89,4 +89,17 @@
# This tests checks if the manim executable is a python script. In our case it is not.
# It is a wrapper shell script instead.
"test_manim_checkhealth_subcommand"
# failing with:
# E AssertionError: assert 'Manim Commun...developers.\n' == 'Manim Community v0.19.0\n\n'
# E
# E Manim Community v0.19.0
# E
# E + Usage: manim cfg [OPTIONS] COMMAND [ARGS]...
# E +
# E + Manages Manim configuration files.
# E + ...
# E
# E ...Full output truncated (9 lines hidden), use '-vv' to show
"test_manim_cfg_subcommand"
]

40
pkgs/development/python-modules/matlink-gpapi/default.nix
View file

@ -1,40 +0,0 @@
{
buildPythonPackage,
cryptography,
fetchPypi,
lib,
protobuf,
pycryptodome,
requests,
}:
buildPythonPackage rec {
version = "0.4.4.5";
format = "setuptools";
pname = "matlink-gpapi";
src = fetchPypi {
inherit version pname;
sha256 = "0s45yb2xiq3pc1fh4bygfgly0fsjk5fkc4wckbckn3ddl7v7vz8c";
};
# package doesn't contain unit tests
# scripts in ./test require networking
doCheck = false;
pythonImportsCheck = [ "gpapi.googleplay" ];
propagatedBuildInputs = [
cryptography
protobuf
pycryptodome
requests
];
meta = with lib; {
homepage = "https://github.com/NoMore201/googleplay-api";
license = licenses.gpl3Only;
description = "Google Play Unofficial Python API";
maintainers = with maintainers; [ schnusch ];
};
}

49
pkgs/development/python-modules/mesonpep517/default.nix
View file

@ -1,49 +0,0 @@
{
lib,
buildPythonPackage,
fetchPypi,
meson,
ninja,
setuptools,
toml,
wheel,
}:
# TODO: offer meson as a Python package so we have dist-info folder.
buildPythonPackage rec {
pname = "mesonpep517";
version = "0.2";
pyproject = true;
src = fetchPypi {
inherit pname version;
hash = "sha256-Fyo7JfLqHJqbahEjVDt/0xJxOfVLqLn3xNJ4lSB7KIw=";
};
# Applies the following merge request, which doesn't apply cleanly:
# https://gitlab.com/thiblahute/mesonpep517/-/merge_requests/25
#
postPatch = ''
substituteInPlace pyproject.toml \
--replace-fail 'backend-path = "."' 'backend-path = ["."]'
'';
build-system = [
setuptools
wheel
];
dependencies = [ toml ];
propagatedNativeBuildInputs = [
meson
ninja
];
meta = {
description = "Create pep517 compliant packages from the meson build system";
homepage = "https://gitlab.com/thiblahute/mesonpep517";
license = lib.licenses.asl20;
};
}

42
pkgs/development/python-modules/pycategories/default.nix
View file

@ -1,42 +0,0 @@
{
lib,
buildPythonPackage,
callPackage,
fetchPypi,
pytestCheckHook,
pythonOlder,
}:
buildPythonPackage rec {
pname = "pycategories";
version = "1.2.0";
format = "setuptools";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
hash = "sha256-vXDstelOdlnlZOoVPwx2cykdw3xSbCRoAPwI1sU3gJk=";
};
postPatch = ''
substituteInPlace setup.py \
--replace "'pytest-runner'," ""
substituteInPlace setup.cfg \
--replace "--cov-report term --cov=categories" ""
'';
# Is private because the author states it's unmaintained
# and shouldn't be used in production code
propagatedBuildInputs = [ (callPackage ./infix.nix { }) ];
nativeCheckInputs = [ pytestCheckHook ];
meta = with lib; {
description = "Implementation of some concepts from category theory";
homepage = "https://gitlab.com/danielhones/pycategories";
changelog = "https://gitlab.com/danielhones/pycategories/-/blob/v${version}/CHANGELOG.rst";
license = licenses.mit;
maintainers = with maintainers; [ dmvianna ];
};
}

25
pkgs/development/python-modules/pycategories/infix.nix
View file

@ -1,25 +0,0 @@
{
buildPythonPackage,
lib,
fetchPypi,
}:
buildPythonPackage rec {
pname = "infix";
version = "1.2";
format = "setuptools";
src = fetchPypi {
inherit pname version;
sha256 = "a1bfdcf875bc072f41e426d0673f2e3017750743bb90cc725fffb292eb09648c";
};
# No tests
doCheck = false;
meta = {
homepage = "https://github.com/borntyping/python-infix";
description = "Decorator that allows functions to be used as infix functions";
license = lib.licenses.mit;
};
}

5
pkgs/os-specific/linux/zfs/generic.nix
View file

@ -152,6 +152,11 @@ let
]
}"
# substitute path that ZFS will pass on when calling external helper scripts (/etc/zfs/zpool.d/*, zfs_prepare_disk)
substituteInPlace ./lib/libzfs/libzfs_util.c \
--replace-fail \"PATH=/bin:/sbin:/usr/bin:/usr/sbin\" \
\"PATH=/run/wrappers/bin:/run/current-system/sw/bin:/run/current-system/sw/sbin\"
substituteInPlace ./config/zfs-build.m4 \
--replace-fail "bashcompletiondir=/etc/bash_completion.d" \
"bashcompletiondir=$out/share/bash-completion/completions"

11
pkgs/servers/web-apps/wordpress/packages/thirdparty.nix
View file

@ -21,17 +21,6 @@
meta.license = lib.licenses.agpl3Only;
};
themes = {
geist = stdenv.mkDerivation rec {
pname = "geist";
version = "2.0.3";
src = fetchzip {
inherit version;
name = pname;
url = "https://github.com/christophery/geist/archive/refs/tags/${version}.zip";
hash = "sha256-c85oRhqu5E5IJlpgqKJRQITur1W7x40obOvHZbPevzU=";
};
meta.license = lib.licenses.gpl2Only;
};
proton = stdenv.mkDerivation rec {
pname = "proton";
version = "1.0.1";

54
pkgs/tools/system/stacer/default.nix
View file

@ -1,54 +0,0 @@
{
lib,
stdenv,
fetchFromGitHub,
cmake,
qtcharts,
qttools,
wrapQtAppsHook,
}:
stdenv.mkDerivation rec {
pname = "stacer";
version = "1.1.0";
src = fetchFromGitHub {
owner = "oguzhaninan";
repo = pname;
rev = "v${version}";
sha256 = "0qndzzkbq6abapvwq202kva8j619jdn9977sbqmmfs9zkjz4mbsd";
};
postPatch = ''
substituteInPlace stacer/Managers/app_manager.cpp \
--replace 'qApp->applicationDirPath() + "/translations"' \
'QStandardPaths::locate(QStandardPaths::AppDataLocation, "translations", QStandardPaths::LocateDirectory)'
'';
buildInputs = [
qtcharts
qttools
];
nativeBuildInputs = [
cmake
wrapQtAppsHook
];
preConfigure = ''
lrelease stacer/stacer.pro
'';
postInstall = ''
install -Dm644 ../translations/*.qm -t $out/share/stacer/translations
'';
meta = with lib; {
description = "Linux System Optimizer and Monitoring";
homepage = "https://github.com/oguzhaninan/stacer";
license = licenses.gpl3Only;
maintainers = with maintainers; [ dit7ya ];
platforms = platforms.linux;
mainProgram = "stacer";
};
}

3
pkgs/top-level/aliases.nix
View file

@ -1319,6 +1319,7 @@ mapAliases {
quaternion-qt5 = throw "'quaternion-qt5' has been removed as quaternion dropped Qt5 support with v0.0.97.1"; # Added 2025-05-24
qubes-core-vchan-xen = throw "'qubes-core-vchan-xen' has been removed because it has been marked as broken since at least November 2024."; # Added 2025-10-11
quicksynergy = throw "'quicksynergy' has been removed due to lack of maintenance upstream. Consider using 'deskflow' instead."; # Added 2025-06-18
quorum = throw "'quorum' has been removed as it was broken and unmaintained upstream"; # Added 2025-11-07
qv2ray = throw "'qv2ray' has been removed as it was unmaintained"; # Added 2025-06-03
radicale3 = throw "'radicale3' has been renamed to/replaced by 'radicale'"; # Converted to throw 2025-10-27
railway-travel = throw "'railway-travel' has been renamed to/replaced by 'diebahn'"; # Converted to throw 2025-10-27
@ -1431,6 +1432,7 @@ mapAliases {
springLobby = throw "springLobby has been removed, as it had been broken since 2023"; # Added 2025-09-16
sqlbag = throw "sqlbag has been removed because it has been marked as broken since May 2024."; # Added 2025-10-11
ssm-agent = throw "'ssm-agent' has been renamed to/replaced by 'amazon-ssm-agent'"; # Converted to throw 2025-10-27
stacer = throw "'stacer' has been removed because it was abandoned upstream and relied upon vulnerable software"; # Added 2025-11-08
starpls-bin = throw "'starpls-bin' has been renamed to/replaced by 'starpls'"; # Converted to throw 2025-10-27
station = throw "station has been removed from nixpkgs, as there were no committers among its maintainers to unblock security issues"; # added 2025-06-16
steam-run-native = throw "'steam-run-native' has been renamed to/replaced by 'steam-run'"; # Converted to throw 2025-10-27
@ -1600,6 +1602,7 @@ mapAliases {
warsow = throw "'warsow' has been removed as it is unmaintained and is broken"; # Added 2025-10-09
warsow-engine = throw "'warsow-engine' has been removed as it is unmaintained and is broken"; # Added 2025-10-09
wasm-bindgen-cli = wasm-bindgen-cli_0_2_104;
wasm-strip = throw "'wasm-strip' has been removed due to upstream deprecation. Use 'wabt' instead."; # Added 2025-11-06
wavebox = throw "'wavebox' has been removed due to lack of maintenance in nixpkgs"; # Added 2025-06-24
wavm = throw "wavm has been removed, as it does not build with supported LLVM versions"; # Added 2025-08-10
wcurl = throw "'wcurl' has been removed due to being bundled with 'curl'"; # Added 2025-07-04

27
pkgs/top-level/all-packages.nix
View file

@ -3979,8 +3979,6 @@ with pkgs;
openssl = openssl.override { withZlib = true; };
};
stacer = libsForQt5.callPackage ../tools/system/stacer { };
staticjinja = with python3.pkgs; toPythonApplication staticjinja;
stoken = callPackage ../tools/security/stoken (config.stoken or { });
@ -4129,15 +4127,8 @@ with pkgs;
inherit (perlPackages) Po4a;
};
webassemblyjs-cli = nodePackages."@webassemblyjs/cli-1.11.1";
webassemblyjs-repl = nodePackages."@webassemblyjs/repl-1.11.1";
buildWasmBindgenCli = callPackage ../build-support/wasm-bindgen-cli { };
wasm-strip = nodePackages."@webassemblyjs/wasm-strip";
wasm-text-gen = nodePackages."@webassemblyjs/wasm-text-gen-1.11.1";
wast-refmt = nodePackages."@webassemblyjs/wast-refmt-1.11.1";
wasmedge = callPackage ../development/tools/wasmedge {
stdenv = clangStdenv;
};
@ -8940,14 +8931,6 @@ with pkgs;
"3000"
];
};
sbcl_2_4_10 = wrapLisp {
pkg = callPackage ../development/compilers/sbcl { version = "2.4.10"; };
faslExt = "fasl";
flags = [
"--dynamic-space-size"
"3000"
];
};
sbcl_2_5_7 = wrapLisp {
pkg = callPackage ../development/compilers/sbcl { version = "2.5.7"; };
faslExt = "fasl";
@ -9685,7 +9668,7 @@ with pkgs;
qremotecontrol-server = libsForQt5.callPackage ../servers/misc/qremotecontrol-server { };
rabbitmq-server = callPackage ../by-name/ra/rabbitmq-server/package.nix {
beamPackages = beam27Packages.extend (self: super: { elixir = elixir_1_17; });
beamPackages = beam27Packages.extend (self: super: { elixir = elixir_1_18; });
};
rethinkdb = callPackage ../servers/nosql/rethinkdb {
@ -10946,8 +10929,6 @@ with pkgs;
sqlite = sqlite.override { enableDeserialize = true; };
};
fritzing = qt6Packages.callPackage ../applications/science/electronics/fritzing { };
fvwm = fvwm2;
gaucheBootstrap = callPackage ../development/interpreters/gauche/boot.nix { };
@ -12255,11 +12236,9 @@ with pkgs;
inherit (ocaml-ng.ocamlPackages) stog;
# Stumpwm is broken on SBCL 2.4.11, see
# https://github.com/NixOS/nixpkgs/pull/360320
stumpwm = callPackage ../applications/window-managers/stumpwm {
stdenv = stdenvNoCC;
sbcl = sbcl_2_4_10.withPackages (
sbcl = sbcl.withPackages (
ps: with ps; [
alexandria
cl-ppcre
@ -12269,7 +12248,7 @@ with pkgs;
);
};
stumpwm-unwrapped = sbcl_2_4_10.pkgs.stumpwm;
stumpwm-unwrapped = sbcl.pkgs.stumpwm;
sublime3Packages = recurseIntoAttrs (
callPackage ../applications/editors/sublime/3/packages.nix { }

5
pkgs/top-level/python-aliases.nix
View file

@ -184,6 +184,8 @@ mapAliases {
GitPython = throw "'GitPython' has been renamed to/replaced by 'gitpython'"; # Converted to throw 2025-10-29
google_api_python_client = throw "'google_api_python_client' has been renamed to/replaced by 'google-api-python-client'"; # Converted to throw 2025-10-29
googleapis_common_protos = throw "'googleapis_common_protos' has been renamed to/replaced by 'googleapis-common-protos'"; # Converted to throw 2025-10-29
gpapi = throw "'gpapi' has been removed as it was broken and lacked maintenance"; # Added 2025-11-09
gplaycli = throw "'gplaycli' has been removed as it was broken and lacked maintenance"; # Added 2025-11-09
gradient_statsd = throw "'gradient_statsd' has been renamed to/replaced by 'gradient-statsd'"; # Converted to throw 2025-10-29
grappelli_safe = throw "'grappelli_safe' has been renamed to/replaced by 'grappelli-safe'"; # Converted to throw 2025-10-29
groestlcoin_hash = throw "'groestlcoin_hash' has been renamed to/replaced by 'groestlcoin-hash'"; # Converted to throw 2025-10-29
@ -249,11 +251,13 @@ mapAliases {
Mako = throw "'Mako' has been renamed to/replaced by 'mako'"; # Converted to throw 2025-10-29
Markups = throw "'Markups' has been renamed to/replaced by 'markups'"; # Converted to throw 2025-10-29
mathlibtools = throw "mathlibtools has been removed because the upstream repository was archived in 2023"; # added 2025-07-09
matlink-gpapi = throw "'matlink-gpapi' has been removed as it was broken and unmaintained"; # Added 2025-11-09
MDP = throw "'MDP' has been renamed to/replaced by 'mdp'"; # Converted to throw 2025-10-29
MechanicalSoup = throw "'MechanicalSoup' has been renamed to/replaced by 'mechanicalsoup'"; # Converted to throw 2025-10-29
memcached = throw "'memcached' has been renamed to/replaced by 'python-memcached'"; # Converted to throw 2025-10-29
memory_profiler = throw "'memory_profiler' has been renamed to/replaced by 'memory-profiler'"; # Converted to throw 2025-10-29
mesa = throw "python3Packages.mesa has been removed because it has been marked as broken since at least November 2024."; # Added 2025-10-03
mesonpep517 = throw "'mesonpep517' has been removed as it was broken and unmaintained."; # added 2025-11-08
minikerberos-bad = throw "'minikerberos-bad' has been renamed to/replaced by 'kerbad'"; # added 2025-11-06
mir_eval = throw "'mir_eval' has been renamed to/replaced by 'mir-eval'"; # Converted to throw 2025-10-29
mistune_2_0 = throw "'mistune_2_0' has been renamed to/replaced by 'mistune'"; # Converted to throw 2025-10-29
@ -307,6 +311,7 @@ mapAliases {
py-eth-sig-utils = throw "py-eth-sig-utils has been removed because it has been marked as broken since at least November 2024."; # Added 2025-10-04
py-scrypt = scrypt; # added 2025-08-07
py_stringmatching = throw "'py_stringmatching' has been renamed to/replaced by 'py-stringmatching'"; # Converted to throw 2025-10-29
pycategories = throw "'pycategories' has been removed as it was broken and unmaintained"; # added 2025-11-08
PyChromecast = throw "'PyChromecast' has been renamed to/replaced by 'pychromecast'"; # Converted to throw 2025-10-29
pydns = throw "'pydns' has been renamed to/replaced by 'py3dns'"; # Converted to throw 2025-10-29
pyechonest = throw "pyechonest was removed because it was broken and unmaintained"; # added 2025-08-26

10
pkgs/top-level/python-packages.nix
View file

@ -6292,8 +6292,6 @@ self: super: with self; {
gower = callPackage ../development/python-modules/gower { };
gpapi = callPackage ../development/python-modules/gpapi { };
gpaw = callPackage ../development/python-modules/gpaw { };
gpgme = callPackage ../development/python-modules/gpgme { inherit (pkgs) gpgme; };
@ -6304,8 +6302,6 @@ self: super: with self; {
gpiozero = callPackage ../development/python-modules/gpiozero { };
gplaycli = callPackage ../development/python-modules/gplaycli { };
gprof2dot = callPackage ../development/python-modules/gprof2dot { inherit (pkgs) graphviz; };
gps3 = callPackage ../development/python-modules/gps3 { };
@ -9156,8 +9152,6 @@ self: super: with self; {
mathutils = callPackage ../development/python-modules/mathutils { };
matlink-gpapi = callPackage ../development/python-modules/matlink-gpapi { };
matplotlib = callPackage ../development/python-modules/matplotlib {
stdenv = if stdenv.hostPlatform.isDarwin then pkgs.clangStdenv else pkgs.stdenv;
};
@ -9354,8 +9348,6 @@ self: super: with self; {
meson-python = callPackage ../development/python-modules/meson-python { inherit (pkgs) ninja; };
mesonpep517 = callPackage ../development/python-modules/mesonpep517 { };
messagebird = callPackage ../development/python-modules/messagebird { };
metaflow = callPackage ../development/python-modules/metaflow { };
@ -12831,8 +12823,6 @@ self: super: with self; {
pycatch22 = callPackage ../development/python-modules/pycatch22 { };
pycategories = callPackage ../development/python-modules/pycategories { };
pycayennelpp = callPackage ../development/python-modules/pycayennelpp { };
pycddl = callPackage ../development/python-modules/pycddl { };