Upload flake-iter to S3

.github/workflows/build-and-release.yml

@@ -0,0 +1,77 @@
+on:
+  workflow_call:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  build-artifacts:
+    runs-on: ${{ matrix.systems.runner }}
+    permissions:
+      id-token: write
+      contents: read
+    strategy:
+      matrix:
+        systems:
+          - nix-system: aarch64-darwin
+            runner: macos-latest-xlarge
+            artifact: flake-iter-ARM64-macOS
+          - nix-system: aarch64-linux
+            runner: namespace-profile-default-arm64
+            artifact: flake-iter-ARM64-Linux
+          - nix-system: x86_64-linux
+            runner: ubuntu-24.04
+            artifact: flake-iter-X64-Linux
+    steps:
+      - name: git checkout
+        uses: actions/checkout@v6
+
+      - name: Install Determinate Nix
+        uses: DeterminateSystems/determinate-nix-action@main
+
+      - name: Set up FlakeHub Cache
+        uses: DeterminateSystems/flakehub-cache-action@main
+
+      - name: Build package for ${{ matrix.systems.nix-system }}
+        run: |
+          nix build -L
+
+      - name: Prepare ${{ matrix.systems.nix-system }} artifact
+        run: |
+          mkdir -p artifacts
+          cp result/bin/flake-iter artifacts/${{ matrix.systems.artifact }}
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: flake-iter-${{ matrix.systems.nix-system }}
+          path: artifacts/${{ matrix.systems.artifact }}
+          if-no-files-found: error
+          overwrite: true
+          retention-days: 1
+
+  upload-artifacts-to-s3:
+    needs: build-artifacts
+    # Upload only on PR merge
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-24.04
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Download artifacts directory
+        uses: actions/download-artifact@v7
+        with:
+          pattern: flake-iter-*
+          path: ./artifacts
+          merge-multiple: true
+
+      - name: Upload to S3
+        uses: DeterminateSystems/push-artifact-ids@main
+        with:
+          s3_upload_role: ${{ secrets.AWS_S3_UPLOAD_ROLE }}
+          bucket: ${{ secrets.AWS_S3_UPLOAD_BUCKET }}
+          directory: ./artifacts
+          ids_project_name: flake-iter
+          ids_binary_prefix: flake-iter

.github/workflows/nix.yml

@@ -18,7 +18,7 @@ jobs:
       - uses: DeterminateSystems/flakehub-cache-action@main
 
       - name: Nix formatting
-        run: git ls-files '*.nix' | nix develop --command xargs nixpkgs-fmt --check
+        run: git ls-files '*.nix' | nix develop --command xargs nixfmt --check
 
-      - name: Nix Flake Check
+      - name: Nix flake check
         run: nix flake check --print-build-logs --all-systems

flake.nix

@@ -11,25 +11,29 @@
     crane = {
       url = "https://flakehub.com/f/ipetkov/crane/0.20";
     };
-    flake-schemas.url = "https://flakehub.com/f/DeterminateSystems/flake-schemas/*";
+    flake-schemas.url = "https://flakehub.com/f/DeterminateSystems/flake-schemas/0.1";
   };
 
   outputs =
-    inputs:
+    { self, ... }@inputs:
     let
+      inherit (inputs.nixpkgs) lib;
+
       supportedSystems = [
         "x86_64-linux"
         "aarch64-darwin"
         "aarch64-linux"
       ];
+
       forEachSupportedSystem =
         f:
-        inputs.nixpkgs.lib.genAttrs supportedSystems (
+        lib.genAttrs supportedSystems (
           system:
           f {
+            inherit system;
             pkgs = import inputs.nixpkgs {
               inherit system;
-              overlays = [ inputs.self.overlays.default ];
+              overlays = [ self.overlays.default ];
             };
           }
         );
@@ -50,18 +54,18 @@
               stable.rustfmt
               stable.rust-src
             ]
-            ++ inputs.nixpkgs.lib.optionals (system == "x86_64-linux") [
+            ++ lib.optionals (system == "x86_64-linux") [
               targets.x86_64-unknown-linux-musl.stable.rust-std
             ]
-            ++ inputs.nixpkgs.lib.optionals (system == "aarch64-linux") [
+            ++ lib.optionals (system == "aarch64-linux") [
               targets.aarch64-unknown-linux-musl.stable.rust-std
             ]
           );
         craneLib = (inputs.crane.mkLib final).overrideToolchain rustToolchain;
       };
 
       devShells = forEachSupportedSystem (
-        { pkgs }:
+        { pkgs, system }:
         rec {
           default = pkgs.mkShell {
             packages = with pkgs; [
@@ -70,9 +74,9 @@
               cargo-watch
               bacon
               rust-analyzer
-              nixpkgs-fmt
               cargo-machete
               iconv
+              self.formatter.${system}
             ];
 
             env = {
@@ -87,14 +91,16 @@
         }
       );
 
+      formatter = forEachSupportedSystem ({ pkgs, ... }: pkgs.nixfmt);
+
       # These outputs are solely for local testing
       packages = forEachSupportedSystem (
-        { pkgs }:
+        { pkgs, ... }:
         rec {
           default = pkgs.craneLib.buildPackage {
             pname = meta.name;
             inherit (meta) version;
-            src = inputs.self;
+            src = self;
             doCheck = true;
             buildInputs = with pkgs; [ iconv ];
           };

src/cli.rs

@@ -14,6 +14,7 @@ enum FlakeIterCommand {
 
 /// A tool for working with flake outputs.
 #[derive(Parser)]
+#[command(version)]
 pub struct Cli {
     /// Whether to display all Nix build output.
     #[arg(