quixos/flake.nix

{
  description = "Dev shell with Node.js 24 and Yarn (Berry)";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    control-cli = {
      url = "path:./quixos-instance/control-cli";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };
    app-server = {
      url = "path:./services/app-server";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };
    nix-cache = {
      url = "path:./services/nix-cache";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };
  };

  outputs = { self, nixpkgs, flake-utils, control-cli, app-server, nix-cache }:
    (flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
        qx-control = control-cli.packages.${system}.default;
        orchestratorProject = (pkgs.callPackage ./quixos-instance/orchestrator/yarn-project.nix { }) {
          src = ./quixos-instance/orchestrator;
          overrideAttrs = old: {
            buildPhase = ''
              runHook preBuild
              yarn build
              runHook postBuild
            '';
          };
        };
        quixos-orchestrator = pkgs.writeShellApplication {
          name = "quixos-orchestrator";
          runtimeInputs = [
            pkgs.git
            pkgs.nix
            pkgs.nodejs_24
            orchestratorProject.passthru.yarn
          ];
          text = ''
            cd ${orchestratorProject}/libexec/${orchestratorProject.name}
            exec ${orchestratorProject.passthru.yarn}/bin/yarn node --enable-source-maps dist/server.js "$@"
          '';
        };
        projectVisualizerProject = (pkgs.callPackage ./quixos-instance/project-visualizer/yarn-project.nix { }) {
          src = ./quixos-instance/project-visualizer;
          overrideAttrs = old: {
            buildPhase = ''
              runHook preBuild
              yarn build
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              cp --reflink=auto --recursive dist "$out"
              runHook postInstall
            '';
          };
        };
        project-visualizer-static = projectVisualizerProject;
        quixos-proxy-heartbeat-script = pkgs.stdenvNoCC.mkDerivation {
          pname = "quixos-proxy-heartbeat-script";
          version = "0.1.0";
          src = ./quixos-instance/proxy-heartbeat;
          nativeBuildInputs = [ pkgs.esbuild ];
          buildPhase = ''
            runHook preBuild
            esbuild src/main.ts \
              --bundle \
              --platform=node \
              --target=node24 \
              --format=esm \
              --outfile=proxy-heartbeat.mjs
            runHook postBuild
          '';
          installPhase = ''
            runHook preInstall
            install -Dm755 proxy-heartbeat.mjs "$out/libexec/quixos-proxy-heartbeat/proxy-heartbeat.mjs"
            runHook postInstall
          '';
        };
        quixos-proxy-heartbeat = pkgs.writeShellApplication {
          name = "quixos-proxy-heartbeat";
          runtimeInputs = [ pkgs.nodejs_24 ];
          text = ''
            exec ${pkgs.nodejs_24}/bin/node ${quixos-proxy-heartbeat-script}/libexec/quixos-proxy-heartbeat/proxy-heartbeat.mjs "$@"
          '';
        };
        quixos-deploy-script = pkgs.stdenvNoCC.mkDerivation {
          pname = "quixos-deploy-script";
          version = "0.1.0";
          src = ./tofu/runtime;
          npmDeps = pkgs.importNpmLock { npmRoot = ./tofu/runtime; };
          npmConfigHook = pkgs.importNpmLock.npmConfigHook;
          nativeBuildInputs = [
            pkgs.esbuild
            pkgs.importNpmLock.npmConfigHook
            pkgs.nodejs_24
          ];
          buildPhase = ''
            runHook preBuild
            esbuild deploy.ts \
              --bundle \
              --platform=node \
              --target=node24 \
              --format=esm \
              --outfile=deploy.mjs
            runHook postBuild
          '';
          installPhase = ''
            runHook preInstall
            install -Dm755 deploy.mjs "$out/libexec/quixos-deploy/deploy.mjs"
            runHook postInstall
          '';
        };
        quixos-deploy = pkgs.writeShellApplication {
          name = "quixos-deploy";
          runtimeInputs = [
            pkgs.awscli2
            pkgs.bash
            pkgs.git
            pkgs.nodejs_24
            pkgs.opentofu
          ];
          text = ''
            repo_root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
            export QUIXOS_REPO_ROOT="$repo_root"
            export QUIXOS_RUNTIME_DIR="$repo_root/tofu/runtime"
            exec ${pkgs.nodejs_24}/bin/node ${quixos-deploy-script}/libexec/quixos-deploy/deploy.mjs "$@"
          '';
        };
      in {
        packages.qx-control = qx-control;
        packages.quixos-orchestrator = quixos-orchestrator;
        packages.project-visualizer-static = project-visualizer-static;
        packages.quixos-proxy-heartbeat = quixos-proxy-heartbeat;
        packages.quixos-deploy = quixos-deploy;
        packages.quixos-app-server = app-server.packages.${system}.default;
        packages.quixos-nix-cache = nix-cache.packages.${system}.default;
        packages.default = quixos-orchestrator;

        apps.qx-control = control-cli.apps.${system}.default // {
          meta.description = "Quixos control-plane CLI";
        };
        apps.quixos-orchestrator = {
          type = "app";
          program = "${quixos-orchestrator}/bin/quixos-orchestrator";
          meta.description = "Quixos orchestrator";
        };
        apps.quixos-deploy = {
          type = "app";
          program = "${quixos-deploy}/bin/quixos-deploy";
          meta.description = "Deploy Quixos runtime infrastructure";
        };
        apps.quixos-app-server = app-server.apps.${system}.default // {
          meta.description = "Quixos central app server";
        };
        apps.quixos-nix-cache = nix-cache.apps.${system}.default // {
          meta.description = "Quixos internal Nix binary cache client";
        };

        devShells.default = pkgs.mkShell {
          packages = [
            pkgs.nodejs_24
            pkgs.opentofu
            pkgs.awscli2
            pkgs.yarn-berry_4
            qx-control
          ];
          shellHook = ''
            quixos_control_env_file="$PWD/.quixos-control.env"
            if [ -f "$quixos_control_env_file" ]; then
              set -a
              . "$quixos_control_env_file"
              set +a
            else
              echo "Quixos control env not found at $quixos_control_env_file; copy .quixos-control.env.example and fill it in if you need the control plane."
            fi

            if [ -n "$PS1" ]; then
              export PS1="[nix] $PS1"
            fi
          '';
        };
      })) // {
        nixosModules.quixosHost = import ./quixos-instance/nix/nixos/quixos-host.nix { inherit self; };
        nixosModules.quixosAppServer = app-server.nixosModules.default;
        nixosModules.quixosNixCache = nix-cache.nixosModules.default;
      };
}