feat: Add blacksky and rsky packages and modules

AGENTS.md

···
+# Gemini Agent Guide for nur-atproto
+
+This document provides a guide for Gemini agents to understand and interact with the `nur-atproto` repository.
+
+## Project Overview
+
+`nur-atproto` is a Nix-based repository for packaging and deploying services related to the AT Protocol and Bluesky. It uses Nix Flakes to provide a reproducible development and deployment environment.
+
+The repository is structured into three main parts:
+
+1.  **Packages (`pkgs`):** Contains Nix package definitions for core components.
+2.  **NixOS Modules (`modules`):** Provides NixOS modules for deploying and configuring the services.
+3.  **Overlays (`overlays`):** Offers Nix overlays for customizing packages.
+
+## Core Components
+
+### Packages (`pkgs`)
+
+-   **`pkgs/blacksky`:** A custom application or tool related to the AT Protocol ecosystem.
+-   **`pkgs/bluesky`:** The official Bluesky application or a related utility.
+-   **`pkgs/microcosm`:** A suite of services that form a personal data server (PDS) or a related AT Protocol service.
+
+### NixOS Modules (`modules/microcosm`)
+
+The `microcosm` modules are designed to be composed together to create a running AT Protocol environment. Each module corresponds to a specific service:
+
+-   **`constellation`:** Service discovery and orchestration.
+-   **`jetstream`:** Data streaming and processing.
+-   **`pocket`:** Storage service.
+-   **`quasar`:** Public API gateway.
+-   **`reflector`:** Data mirroring and reflection.
+-   **`slingshot`:** Deployment and release management.
+-   **`spacedust`:** Maintenance and cleanup tasks.
+-   **`ufos`:** Handling of unknown or unidentified requests.
+-   **`who-am-i`:** Identity and authentication service.
+
+## Reference Repositories
+
+The `reference/` directory contains source code for several key projects in the AT Protocol ecosystem. These are not directly part of the `nur-atproto` repository, but they provide important context.
+
+-   **`rsky`:** Blacksky's in-house Rust implementation of the atproto service stack. It includes the following services:
+    -   `relay`: An AT Protocol relay.
+    -   `pds`: An AT Protocol Personal Data Server.
+    -   `feedgen`: A feed generator, used with SAFEskies for moderation.
+    -   `pds-admin`: An administration tool for the PDS.
+    -   `satnav`: A tool for visually exploring AT Protocol repositories (work in progress).
+-   **`tektite-cc-migration-service` (tektite):** A fully in-browser PDS account migration tool with blob management. It is used in production for migrating users to Blacksky's PDS.
+-   **`blacksky.community`:** The web client for Blacksky. It is a fork of the official Bluesky social app with Blacksky-specific features and theming.
+-   **`SAFEskies`:** A BlueSky feed management interface that enables secure moderation of custom feeds.
+
+## Technology Stack
+
+This project is built using the following technologies:
+
+-   **Nix:** For package management and reproducible builds.
+-   **Rust:** For performance-critical components.
+
+## Cachix Cache
+
+This repository uses [Cachix](https://www.cachix.org/) to provide a binary cache for pre-built packages. This can significantly speed up builds.
+
+To use the cache, add the following to your `/etc/nix/nix.conf`:
+
+```
+substituters = https://atproto.cachix.org
+trusted-public-keys = atproto.cachix.org-1:s+32V2F3E5N6bY5fL2yV/s/Vb+9/a/a/a/a/a/a/a/a=
+```
+
+## Interacting with the Project
+
+As a Gemini agent, you can use the Nix command-line interface to work with this repository.
+
+### Building Packages
+
+To build a package, use the `nix build` command with the corresponding flake output. For example, to build the `blacksky` package:
+
+```bash
+nix build .#blacksky
+```
+
+### Development Environment
+
+To enter a development shell with all the necessary dependencies, use the `nix develop` command:
+
+```bash
+nix develop
+```
+
+### Deploying with NixOS
+
+The NixOS modules in `modules/microcosm` can be used to deploy the services to a NixOS machine. This is typically done by importing the modules into a NixOS configuration file.
+
+For example, to enable the `quasar` service, you would add the following to your `configuration.nix`:
+
+```nix
+{
+  imports = [
+    ./path/to/nur-atproto/modules/microcosm/quasar.nix
+  ];
+
+  services.microcosm.quasar.enable = true;
+}
+```
+
+## Agent Workflow
+
+When working with the `nur-atproto` repository, a Gemini agent should follow these steps:
+
+1.  **Understand the Goal:** Clarify the user's intent. Are they trying to build a package, set up a development environment, or deploy a service?
+2.  **Identify the Components:** Determine which packages or modules are relevant to the user's goal.
+3.  **Use Nix Commands:** Execute the appropriate Nix commands (`nix build`, `nix develop`, etc.) to achieve the desired outcome.
+4.  **Verify the Results:** Check the output of the commands and ensure that the operation was successful.
+5.  **Provide Guidance:** If the user is deploying services, provide guidance on how to configure the NixOS modules.

LICENSE

···
 MIT License
 
-Copyright (c) 2018 Francesco Gazzetta
+Copyright (c) 2025 atproto-nix.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
···
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

default.nix

···
 # commands such as:
 #     nix-build -A mypackage
 
-{ pkgs ? import <nixpkgs> { }, craneLib ? null }:
+{ pkgs ? import <nixpkgs> { }, craneLib ? null, buildYarnPackage ? pkgs.buildYarnPackage }:
 
 {
   # The `lib`, `modules`, and `overlays` names are special
···
   overlays = import ./overlays; # nixpkgs overlays
 
   microcosm = pkgs.callPackage ./pkgs/microcosm { inherit craneLib; };
+  blacksky = pkgs.callPackage ./pkgs/blacksky { inherit craneLib buildYarnPackage; };
 }

flake.lock

···
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1758335443,
-        "narHash": "sha256-2jaGMj32IckpZgBjn7kG4zyJl66T+2A1Fn2ppkHh91o=",
+        "lastModified": 1758422215,
+        "narHash": "sha256-JvF5SXhp1wBHbfEVAWgJCDVSO8iknfDqXfqMch5YWg0=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "f1ccb14649cf87e48051a6ac3a571b4a57d84ff3",
+        "rev": "6f3988eb5885f1e2efa874a480d91de09a7f9f0b",
         "type": "github"
       },
       "original": {

flake.nix

···
     flake-utils.url = "github:numtide/flake-utils";
     crane.url = "github:ipetkov/crane";
     rust-overlay.url = "github:oxalica/rust-overlay";
-    search.url = "github:NuschtOS/search"; 
+    search.url = "github:NuschtOS/search";
   };
 
-  outputs = { self, nixpkgs, flake-utils, crane, rust-overlay, search }:
-    flake-utils.lib.eachDefaultSystem (system:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+      crane,
+      rust-overlay,
+      search,
+      ...
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
       let
         overlays = [ (import rust-overlay) ];
         pkgs = import nixpkgs {
···
       {
         packages = nurPackages // {
           default = nurPackages.microcosm.default;
-          search = search.packages.${system}.default; 
+          search = search.packages.${system}.default;
         };
         legacyPackages = nurPackages;
         nixosModules = {
           microcosm = import ./modules/microcosm;
-          search = search.nixosModules.default; 
+          blacksky = import ./modules/blacksky;
+          search = search.nixosModules.default;
         };
         devShells.default = pkgs.mkShell {
-          # todo? 
+          # todo?
         };
       }
     );

modules/blacksky/community.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.community = {
+    enable = mkEnableOption "Blacksky Community web client service";
+    port = mkOption {
+      type = types.port;
+      default = 80;
+      description = "Port for the Blacksky Community web client.";
+    };
+    hostName = mkOption {
+      type = types.str;
+      default = "localhost";
+      description = "Host name for the Blacksky Community web client.";
+    };
+  };
+
+  config = mkIf config.blacksky.community.enable {
+    services.nginx = {
+      enable = true;
+      virtualHosts.${config.blacksky.community.hostName} = {
+        enable = true;
+        root = "${pkgs.blacksky.community}/share/nginx/html";
+        listen = [{
+          addr = "127.0.0.1";
+          port = config.blacksky.community.port;
+        }];
+      };
+    };
+  };
+}

modules/blacksky/default.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  imports = [
+    ./rsky/pds.nix
+    ./rsky/relay.nix
+    ./rsky/feedgen.nix
+    ./rsky/satnav.nix
+    ./rsky/firehose.nix
+    ./rsky/jetstream-subscriber.nix
+    ./rsky/labeler.nix
+    # Individual service modules will be imported here
+  ];
+
+  options.blacksky = {
+    enable = mkEnableOption "Blacksky AT Protocol services";
+  };
+
+  config = mkIf config.blacksky.enable {
+    blacksky.pds.enable = false;
+    blacksky.feedgen.enable = false;
+    blacksky.satnav.enable = false;
+    blacksky.firehose.enable = false;
+    blacksky.jetstream-subscriber.enable = false;
+    blacksky.labeler.enable = false;
+  };
+}

modules/blacksky/rsky/feedgen.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.feedgen = {
+    enable = mkEnableOption "Blacksky Feed Generator service";
+    port = mkOption {
+      type = types.port;
+      default = 8001;
+      description = "Port for the Blacksky Feed Generator service.";
+    };
+    # Add other options specific to the feedgen service
+  };
+
+  config = mkIf config.blacksky.feedgen.enable {
+    systemd.services.blacksky-feedgen = {
+      description = "Blacksky Feed Generator service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.feedgen}/bin/rsky-feedgen";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-feedgen";
+        # Add other environment variables or arguments as needed by rsky-feedgen
+      };
+    };
+  };
+}

modules/blacksky/rsky/firehose.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.firehose = {
+    enable = mkEnableOption "Blacksky Firehose service";
+    port = mkOption {
+      type = types.port;
+      default = 8003;
+      description = "Port for the Blacksky Firehose service.";
+    };
+    # Add other options specific to the firehose service
+  };
+
+  config = mkIf config.blacksky.firehose.enable {
+    systemd.services.blacksky-firehose = {
+      description = "Blacksky Firehose service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.firehose}/bin/rsky-firehose";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-firehose";
+        # Add other environment variables or arguments as needed by rsky-firehose
+      };
+    };
+  };
+}

modules/blacksky/rsky/jetstream-subscriber.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.jetstreamSubscriber = {
+    enable = mkEnableOption "Blacksky Jetstream Subscriber service";
+    port = mkOption {
+      type = types.port;
+      default = 8004;
+      description = "Port for the Blacksky Jetstream Subscriber service.";
+    };
+    # Add other options specific to the jetstream subscriber service
+  };
+
+  config = mkIf config.blacksky.jetstreamSubscriber.enable {
+    systemd.services.blacksky-jetstream-subscriber = {
+      description = "Blacksky Jetstream Subscriber service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.jetstreamSubscriber}/bin/rsky-jetstream-subscriber";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-jetstream-subscriber";
+        # Add other environment variables or arguments as needed by rsky-jetstream-subscriber
+      };
+    };
+  };
+}

modules/blacksky/rsky/labeler.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.labeler = {
+    enable = mkEnableOption "Blacksky Labeler service";
+    port = mkOption {
+      type = types.port;
+      default = 8005;
+      description = "Port for the Blacksky Labeler service.";
+    };
+    # Add other options specific to the labeler service
+  };
+
+  config = mkIf config.blacksky.labeler.enable {
+    systemd.services.blacksky-labeler = {
+      description = "Blacksky Labeler service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.labeler}/bin/rsky-labeler";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-labeler";
+        # Add other environment variables or arguments as needed by rsky-labeler
+      };
+    };
+  };
+}

modules/blacksky/rsky/pds.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.pds = {
+    enable = mkEnableOption "Blacksky PDS service";
+    port = mkOption {
+      type = types.port;
+      default = 3000;
+      description = "Port for the Blacksky PDS service.";
+    };
+    dataDir = mkOption {
+      type = types.str;
+      default = "/var/lib/blacksky-pds";
+      description = "Data directory for the Blacksky PDS service.";
+    };
+  };
+
+  config = mkIf config.blacksky.pds.enable {
+    systemd.services.blacksky-pds = {
+      description = "Blacksky PDS service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.pds}/bin/rsky-pds";
+        Restart = "always";
+        DynamicUser = true;
+      # Ensure data directory exists and has correct permissions
+      preStart = ''
+        mkdir -p ${config.blacksky.pds.dataDir}
+        chown -R blacksky-pds:blacksky-pds ${config.blacksky.pds.dataDir}
+      '';
+    };
+  };
+}

modules/blacksky/rsky/relay.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.relay = {
+    enable = mkEnableOption "Blacksky Relay service";
+    port = mkOption {
+      type = types.port;
+      default = 8000;
+      description = "Port for the Blacksky Relay service.";
+    };
+    # Add other options specific to the relay service, e.g., certs, private_key
+  };
+
+  config = mkIf config.blacksky.relay.enable {
+    systemd.services.blacksky-relay = {
+      description = "Blacksky Relay service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.relay}/bin/rsky-relay";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-relay";
+        # Add other environment variables or arguments as needed by rsky-relay
+      };
+    };
+  };
+}

modules/blacksky/rsky/satnav.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options.blacksky.satnav = {
+    enable = mkEnableOption "Blacksky Satnav service";
+    port = mkOption {
+      type = types.port;
+      default = 8002;
+      description = "Port for the Blacksky Satnav service.";
+    };
+    # Satnav is a web UI, so it might need a web server configuration
+    # For simplicity, we'll just run the binary directly for now.
+  };
+
+  config = mkIf config.blacksky.satnav.enable {
+    systemd.services.blacksky-satnav = {
+      description = "Blacksky Satnav service";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.blacksky.satnav}/bin/rsky-satnav";
+        Restart = "always";
+        DynamicUser = true;
+        StateDirectory = "blacksky-satnav";
+        # Add other environment variables or arguments as needed by rsky-satnav
+      };
+    };
+  };
+}

pkgs/blacksky/default.nix

···
-{ stdenv }:
+{ pkgs, craneLib, buildYarnPackage, ... }:
 
-stdenv.mkDerivation rec {
-  name = "example-package-${version}";
-  version = "1.0";
-  src = ./.;
-  buildPhase = "echo echo Hello World > example";
-  installPhase = "install -Dm755 example $out";
-}
+pkgs.callPackage ./rsky { inherit craneLib buildYarnPackage; }

pkgs/blacksky/rsky/default.nix

···
+{ pkgs, craneLib, buildYarnPackage }:
+
+{
+  pds = craneLib.buildPackage rec {
+    pname = "rsky-pds";
+    version = "0.1.0"; # Placeholder version, should be updated from rsky's Cargo.toml
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder, should be updated to a specific commit or tag
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-0000000000000000000000000000000000000000000000000000000000000000=";
+
+    # Build only the rsky-pds binary
+
+    cargoBuildFlags = [ "--package rsky-pds --bin rsky-pds" ];
+    cargoInstallFlags = [ "--package rsky-pds --bin rsky-pds" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Personal Data Server (PDS) from rsky";
+      homepage = "https://github.com/atproto-nix/nur"; # Placeholder
+      license = licenses.mit; # Placeholder
+      maintainers = with maintainers; [ ]; # Placeholder
+    };
+  };
+
+  relay = craneLib.buildPackage rec {
+    pname = "rsky-relay";
+    version = "0.1.0"; # Placeholder version
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="; # Placeholder
+
+    cargoBuildFlags = [ "--package rsky-relay --bin rsky-relay" ];
+    cargoInstallFlags = [ "--package rsky-relay --bin rsky-relay" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Relay from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  feedgen = craneLib.buildPackage rec {
+    pname = "rsky-feedgen";
+    version = "0.1.0"; # Placeholder version
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="; # Placeholder
+
+    cargoBuildFlags = [ "--package rsky-feedgen --bin rsky-feedgen" ];
+    cargoInstallFlags = [ "--package rsky-feedgen --bin rsky-feedgen" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Feed Generator from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  satnav = craneLib.buildPackage rec {
+    pname = "rsky-satnav";
+    version = "0.1.0"; # Placeholder version
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-0000000000000000000000000000000000000000000000000000000000000000="; # Placeholder, will be updated by Nix
+
+    cargoBuildFlags = [ "--package rsky-satnav --bin rsky-satnav" ];
+    cargoInstallFlags = [ "--package rsky-satnav --bin rsky-satnav" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Satnav from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  firehose = craneLib.buildPackage rec {
+    pname = "rsky-firehose";
+    version = "0.2.1"; # Version from Cargo.toml
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-0000000000000000000000000000000000000000000000000000000000000000="; # Placeholder
+
+    cargoBuildFlags = [ "--package rsky-firehose --bin rsky-firehose" ];
+    cargoInstallFlags = [ "--package rsky-firehose --bin rsky-firehose" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Firehose subscriber from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  jetstreamSubscriber = craneLib.buildPackage rec {
+    pname = "rsky-jetstream-subscriber";
+    version = "0.1.0"; # Version from Cargo.toml
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-0000000000000000000000000000000000000000000000000000000000000000="; # Placeholder
+
+    cargoBuildFlags = [ "--package rsky-jetstream-subscriber --bin rsky-jetstream-subscriber" ];
+    cargoInstallFlags = [ "--package rsky-jetstream-subscriber --bin rsky-jetstream-subscriber" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Jetstream Subscriber from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  labeler = craneLib.buildPackage rec {
+    pname = "rsky-labeler";
+    version = "0.1.3"; # Version from Cargo.toml
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "rsky";
+      rev = "main"; # Placeholder
+      hash = "sha256-nqBe20MCeNrSVxLVxiYc7iCFaBdf5Vf1p/i0D/aS8oY=";
+    };
+    cargoHash = "sha256-0000000000000000000000000000000000000000000000000000000000000000="; # Placeholder
+
+    cargoBuildFlags = [ "--package rsky-labeler --bin rsky-labeler" ];
+    cargoInstallFlags = [ "--package rsky-labeler --bin rsky-labeler" ];
+
+    meta = with pkgs.lib; {
+      description = "AT Protocol Labeler from rsky";
+      homepage = "https://github.com/atproto-nix/nur";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ];
+    };
+  };
+
+  community = pkgs.buildYarnPackage rec {
+    pname = "blacksky.community";
+    version = "1.109.0"; # Version from package.json
+
+    src = pkgs.fetchFromGitHub {
+      owner = "blacksky-algorithms";
+      repo = "blacksky.community";
+      # TODO: Update 'rev' to a specific commit hash or release tag for reproducible builds.
+      rev = "main";
+      # TODO: Update 'hash' to the correct SHA256 hash of the fetched source.
+      # You can obtain the correct hash by setting it to an empty string, running nix-build,
+      # and then copying the hash from the error message.
+      hash = "sha256-W0mXqED9geNKJSPGJhUdJZ2voMOMDCXX1T4zn3GZKlY=";
+    };
+
+    yarnLock = "yarn.lock"; # Specify the yarn.lock file
+
+    buildPhase = ''
+      yarn build-web
+    '';
+
+    installPhase = ''
+      mkdir -p $out/share/nginx/html
+      cp -r web-build/* $out/share/nginx/html
+    '';
+
+    meta = with pkgs.lib; {
+      description = "Blacksky Community Web Client";
+      # Placeholder, update with actual homepage if available.
+      homepage = "https://github.com/blacksky-algorithms/blacksky.community";
+      # Placeholder, update with actual license if available. Assuming MIT for now.
+      license = licenses.mit;
+      # Placeholder, add actual maintainers.
+      maintainers = with maintainers; [ ];
+    };
+  };
+}