added working build for microcoms pkgs, based on work by @overby.me, added skeleton of modules too, began work on nuschtOS search docs generation

flake.lock

···
         "type": "github"
       }
     },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "ixx": {
+      "inputs": {
+        "flake-utils": [
+          "search",
+          "flake-utils"
+        ],
+        "nixpkgs": [
+          "search",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1754860581,
+        "narHash": "sha256-EM0IE63OHxXCOpDHXaTyHIOk2cNvMCGPqLt/IdtVxgk=",
+        "owner": "NuschtOS",
+        "repo": "ixx",
+        "rev": "babfe85a876162c4acc9ab6fb4483df88fa1f281",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NuschtOS",
+        "ref": "v0.1.1",
+        "repo": "ixx",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
         "lastModified": 1758262103,
···
         "type": "github"
       }
     },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1758035966,
+        "narHash": "sha256-qqIJ3yxPiB0ZQTT9//nFGQYn8X/PBoJbofA7hRKZnmE=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "8d4ddb19d03c65a36ad8d189d001dc32ffb0306b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "crane": "crane",
+        "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs",
-        "rust-overlay": "rust-overlay"
+        "rust-overlay": "rust-overlay",
+        "search": "search"
       }
     },
     "rust-overlay": {
···
       "original": {
         "owner": "oxalica",
         "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "search": {
+      "inputs": {
+        "flake-utils": "flake-utils_2",
+        "ixx": "ixx",
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1758272005,
+        "narHash": "sha256-1u3xTH+3kaHhztPmWtLAD8LF5pTYLR2CpsPFWTFnVtQ=",
+        "owner": "NuschtOS",
+        "repo": "search",
+        "rev": "aa975a3757f28ce862812466c5848787b868e116",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NuschtOS",
+        "repo": "search",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
         "type": "github"
       }
     }

flake.nix

···
 {
-  description = "My personal NUR repository";
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-  inputs.rust-overlay.url = "github:oxalica/rust-overlay";
-  inputs.crane.url = "github:ipetkov/crane";
+  description = "ATproto NUR repository";
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    crane.url = "github:ipetkov/crane";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    search.url = "github:NuschtOS/search"; 
+  };
 
-  outputs = { self, nixpkgs, rust-overlay, crane }@inputs:
-    let
-      forAllSystems = nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed;
-    in
-    {
-      legacyPackages = forAllSystems (system:
-        let
-          overlays = [ (import rust-overlay) ];
-          pkgs = import nixpkgs { inherit system overlays; };
-          rustToolchain = pkgs.rust-bin.stable.latest.default.override {
-            extensions = [ "rust-src" ];
-          };
-          craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain;
-        in
-        import ./default.nix {
+  outputs = { self, nixpkgs, flake-utils, crane, rust-overlay, search }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        overlays = [ (import rust-overlay) ];
+        pkgs = import nixpkgs {
+          inherit system overlays;
+        };
+        rustVersion = pkgs.rust-bin.stable.latest.default;
+        craneLib = (crane.mkLib pkgs).overrideToolchain rustVersion;
+
+        nurPackages = import ./default.nix {
           inherit pkgs craneLib;
-        });
-      packages = forAllSystems (system: nixpkgs.lib.filterAttrs (_: v: nixpkgs.lib.isDerivation v) self.legacyPackages.${system});
-    };
+        };
+      in
+      {
+        packages = nurPackages // {
+          default = nurPackages.microcosm.default;
+          search = search.packages.${system}.default; 
+        };
+        legacyPackages = nurPackages;
+        nixosModules = {
+          microcosm = import ./modules/microcosm;
+          search = search.nixosModules.default; 
+        };
+        devShells.default = pkgs.mkShell {
+          # todo? 
+        };
+      }
+    );
 }

modules/default.nix

···
-{
-  # Add your NixOS modules here
-  #
-  # my-module = ./my-module;
-}
+{}

modules/microcosm/constellation.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-constellation;
+  microcosmPkgs = pkgs.microcosm; # Access the packages we built
+in
+{
+  options.services.microcosm-constellation = {
+    enable = mkEnableOption "Microcosm Constellation service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.constellation;
+      description = "The Microcosm Constellation package to use.";
+    };
+    port = mkOption {
+      type = types.port;
+      default = 8080; # Example default port
+      description = "The port on which the Constellation service listens.";
+    };
+    # Add other service-specific options here (e.g., databaseUrl, logLevel)
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-constellation = {
+      description = "Microcosm Constellation Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/constellation --port ${toString cfg.port}"; # Example command
+        Restart = "always";
+        User = "microcosm-constellation"; # Create a dedicated user
+        Group = "microcosm-constellation";
+        # Add other systemd options as needed (e.g., working directory, environment variables)
+      };
+      # Create user and group
+      users.users.microcosm-constellation = {
+        isSystem = true;
+        group = "microcosm-constellation";
+      };
+      users.groups.microcosm-constellation = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/default.nix

···
+{ pkgs, ... }:
+
+{
+  imports = [
+    ./constellation.nix
+    ./spacedust.nix
+    ./slingshot.nix
+    ./ufos.nix
+    ./jetstream.nix
+    ./who-am-i.nix
+    ./quasar.nix
+    ./pocket.nix
+    ./reflector.nix
+  ];
+}

modules/microcosm/jetstream.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-jetstream;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-jetstream = {
+    enable = mkEnableOption "Microcosm Jetstream service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.jetstream;
+      description = "The Microcosm Jetstream package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-jetstream = {
+      description = "Microcosm Jetstream Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/jetstream"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-jetstream";
+        Group = "microcosm-jetstream";
+      };
+      users.users.microcosm-jetstream = {
+        isSystem = true;
+        group = "microcosm-jetstream";
+      };
+      users.groups.microcosm-jetstream = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/pocket.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-pocket;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-pocket = {
+    enable = mkEnableOption "Microcosm Pocket service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.pocket;
+      description = "The Microcosm Pocket package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-pocket = {
+      description = "Microcosm Pocket Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/pocket"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-pocket";
+        Group = "microcosm-pocket";
+      };
+      users.users.microcosm-pocket = {
+        isSystem = true;
+        group = "microcosm-pocket";
+      };
+      users.groups.microcosm-pocket = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/quasar.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-quasar;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-quasar = {
+    enable = mkEnableOption "Microcosm Quasar service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.quasar;
+      description = "The Microcosm Quasar package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-quasar = {
+      description = "Microcosm Quasar Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/quasar"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-quasar";
+        Group = "microcosm-quasar";
+      };
+      users.users.microcosm-quasar = {
+        isSystem = true;
+        group = "microcosm-quasar";
+      };
+      users.groups.microcosm-quasar = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/reflector.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-reflector;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-reflector = {
+    enable = mkEnableOption "Microcosm Reflector service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.reflector;
+      description = "The Microcosm Reflector package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-reflector = {
+      description = "Microcosm Reflector Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/reflector"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-reflector";
+        Group = "microcosm-reflector";
+      };
+      users.users.microcosm-reflector = {
+        isSystem = true;
+        group = "microcosm-reflector";
+      };
+      users.groups.microcosm-reflector = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/slingshot.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-slingshot;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-slingshot = {
+    enable = mkEnableOption "Microcosm Slingshot service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.slingshot;
+      description = "The Microcosm Slingshot package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-slingshot = {
+      description = "Microcosm Slingshot Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/slingshot"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-slingshot";
+        Group = "microcosm-slingshot";
+      };
+      users.users.microcosm-slingshot = {
+        isSystem = true;
+        group = "microcosm-slingshot";
+      };
+      users.groups.microcosm-slingshot = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/spacedust.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-spacedust;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-spacedust = {
+    enable = mkEnableOption "Microcosm Spacedust service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.spacedust;
+      description = "The Microcosm Spacedust package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-spacedust = {
+      description = "Microcosm Spacedust Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/spacedust"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-spacedust";
+        Group = "microcosm-spacedust";
+      };
+      users.users.microcosm-spacedust = {
+        isSystem = true;
+        group = "microcosm-spacedust";
+      };
+      users.groups.microcosm-spacedust = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/ufos.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-ufos;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-ufos = {
+    enable = mkEnableOption "Microcosm UFOs service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs.ufos;
+      description = "The Microcosm UFOs package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-ufos = {
+      description = "Microcosm UFOs Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/ufos"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-ufos";
+        Group = "microcosm-ufos";
+      };
+      users.users.microcosm-ufos = {
+        isSystem = true;
+        group = "microcosm-ufos";
+      };
+      users.groups.microcosm-ufos = {
+        isSystem = true;
+      };
+    };
+  };
+}

modules/microcosm/who-am-i.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.microcosm-who-am-i;
+  microcosmPkgs = pkgs.microcosm;
+in
+{
+  options.services.microcosm-who-am-i = {
+    enable = mkEnableOption "Microcosm Who-Am-I service";
+    package = mkOption {
+      type = types.package;
+      default = microcosmPkgs."who-am-i";
+      description = "The Microcosm Who-Am-I package to use.";
+    };
+    # Add other service-specific options here
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.microcosm-who-am-i = {
+      description = "Microcosm Who-Am-I Service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/who-am-i"; # This command likely needs adjustment
+        Restart = "always";
+        User = "microcosm-who-am-i";
+        Group = "microcosm-who-am-i";
+      };
+      users.users.microcosm-who-am-i = {
+        isSystem = true;
+        group = "microcosm-who-am-i";
+      };
+      users.groups.microcosm-who-am-i = {
+        isSystem = true;
+      };
+    };
+  };
+}

pkgs/microcosm/default.nix

···
     sha256 = "sha256-swdAcsjRWnj9abmnrce5LzeKRK+LHm8RubCEIuk+53c=";
   };
 
-  commonArgs = {
+  commonEnv = {
+    LIBCLANG_PATH = pkgs.lib.makeLibraryPath [ pkgs.llvmPackages.libclang.lib ];
+    OPENSSL_NO_VENDOR = "1";
+    OPENSSL_LIB_DIR = "${pkgs.lib.getLib pkgs.openssl}/lib";
+    OPENSSL_INCLUDE_DIR = "${pkgs.lib.getDev pkgs.openssl}/include";
+    BINDGEN_EXTRA_CLANG_ARGS = pkgs.lib.concatStringsSep " " [
+        "-I${pkgs.llvmPackages.libclang.lib}/lib/clang/${pkgs.lib.versions.major pkgs.llvmPackages.libclang.version}/include"
+        "-I${pkgs.glibc.dev}"
+    ];
+    ZSTD_SYS_USE_PKG_CONFIG = "1";
+    CC = "${pkgs.llvmPackages.clang}/bin/clang";
+    CXX = "${pkgs.llvmPackages.clang}/bin/clang++";
+    PKG_CONFIG_PATH = "${pkgs.zstd.dev}/lib/pkgconfig:${pkgs.lz4.dev}/lib/pkgconfig";
+  };
+
+  nativeInputs = with pkgs; [
+    pkg-config
+    perl
+  ];
+
+  buildInputs = with pkgs; [
+    zstd
+    lz4
+    rocksdb
+    openssl
+  ];
+
+  cargoArtifacts = craneLib.buildDepsOnly {
     inherit src;
     pname = "microcosm-rs-deps";
-    version = "0.1";
-    buildInputs = with pkgs; [
-      openssl
-      zlib
-    ];
-    nativeBuildInputs = with pkgs; [
-      pkg-config
-    ];
+    nativeBuildInputs = nativeInputs;
+    buildInputs = buildInputs;
+    env = commonEnv;
   };
 
-  cargoArtifacts = craneLib.buildDepsOnly commonArgs;
+  members = [
+    "links"
+    "constellation"
+    "jetstream"
+    "ufos"
+    "ufos/fuzz"
+    "spacedust"
+    "who-am-i"
+    "slingshot"
+    "quasar"
+    "pocket"
+    "reflector"
+  ];
 
-  buildPackage = pname: craneLib.buildPackage (commonArgs // {
-    inherit pname;
-    cargoArtifacts = cargoArtifacts;
-  });
+  buildPackage = member:
+    let
+      packageName = if member == "ufos/fuzz" then "ufos-fuzz" else member;
+    in
+    craneLib.buildPackage {
+      inherit src cargoArtifacts;
+      pname = packageName;
+      version = "0.1.0";
+      cargoExtraArgs = "--package ${packageName}";
+      nativeBuildInputs = nativeInputs;
+      buildInputs = buildInputs ++ (pkgs.lib.optional (member == "pocket") pkgs.sqlite);
+      env = commonEnv;
+    };
+
+  packages = pkgs.lib.genAttrs members (member: buildPackage member);
 
 in
-{
-  constellation = buildPackage "constellation";
-  jetstream = buildPackage "jetstream";
-  links = buildPackage "links";
-  pocket = buildPackage "pocket";
-  quasar = buildPackage "quasar";
-  reflector = buildPackage "reflector";
-  slingshot = buildPackage "slingshot";
-  spacedust = buildPackage "spacedust";
-  ufos = buildPackage "ufos";
-  "who-am-i" = buildPackage "who-am-i";
-}
+packages // {
+  default = pkgs.linkFarm "microcosm-rs" (pkgs.lib.mapAttrsToList (name: value:
+    let
+      linkName = if name == "ufos/fuzz" then "ufos-fuzz" else name;
+    in
+    { name = linkName; path = value; }
+  ) packages);
+}