fix: work with remotes by not writing our own expressions

app/Main.hs

···
 module Main (main) where
 
+import Data.Attoparsec.Text (IResult (..), parse)
+import Data.Map.Strict qualified as Map
 import Data.Text (strip)
+import Nix.Derivation (parseDerivation)
+import Nix.Derivation qualified as DRV
 import Options.Applicative
 import Options.Applicative qualified as OA
 import System.Environment (withArgs)
+import System.FilePath ((</>))
 import System.IO (hPutStrLn)
 import System.Posix (executeFile)
 import System.Process (readProcess)
···
 nixCommonArgs :: BuildOptions -> [Text]
 nixCommonArgs BuildOptions {..} =
   concat
-    [ concatMap (\i -> ["-I", i]) buildIncludePaths,
+    [ concatMap (\(n, v) -> ["--arg", n, v]) buildArgs,
+      concatMap (\(n, v) -> ["--argstr", n, v]) buildArgStrs,
+      concatMap (\i -> ["-I", i]) buildIncludePaths,
       concatMap (\(n, v) -> ["--option", n, v]) buildOptions,
       replicate buildVerbose "--verbose",
       replicate buildQuiet "--quiet",
···
 nixBuildArgs opts@(BuildOptions {..}) =
   nixCommonArgs opts
     ++ concat
-      [ concatMap (\(n, v) -> ["--arg", n, v]) buildArgs,
-        concatMap (\(n, v) -> ["--argstr", n, v]) buildArgStrs,
-        ["--repair" | buildRepair],
+      [ ["--repair" | buildRepair],
         ["--no-build-output" | buildNoBuildOutput],
         maybe [] (\j -> ["-j", j]) buildMaxJobs,
         maybe [] (\c -> ["--cores", show c]) buildCores,
···
     (_, Just p) -> Just p
     (Nothing, Nothing) -> Nothing
 
-getExeExprFromFile :: Text -> Maybe Text -> [(Text, Text)] -> [(Text, Text)] -> Text
-getExeExprFromFile file attr args argstrs =
-  unlines
-    [ "let",
-      "  lib = import <nixpkgs/lib>;",
-      "  drv = import (" <> file <> ");",
-      "  drvResolved = if builtins.isFunction drv then drv " <> argsBlock <> " else drv;",
-      "in lib.getExe drvResolved" <> attrSub
-    ]
-  where
-    attrSub = maybe "" ("." <>) attr
-    argNix = unwords . fmap (\(n, v) -> n <> " = " <> v <> ";") $ args
-    argstrNix = unwords . fmap (\(n, v) -> n <> " = " <> "\"" <> v <> "\"" <> ";") $ argstrs
-    argsBlock = "{" <> (unwords [argNix, argstrNix]) <> " }"
+readProcessText :: FilePath -> [Text] -> Text -> IO Text
+readProcessText cmd args input = toText <$> readProcess cmd (map toString args) (toString input)
 
-getExeExprFromExpr :: Text -> Maybe Text -> Text
-getExeExprFromExpr expr attr =
-  unlines
-    [ "let",
-      "  lib = import <nixpkgs/lib>;",
-      "  drv = (" <> expr <> ");",
-      "in lib.getExe drv" <> attrSub
-    ]
+getAttrOf :: Text -> BuildOptions -> Text -> IO Text
+getAttrOf output opts exprOrFile = do
+  strip
+    <$> readProcessText
+      "nix-instantiate"
+      (args ++ nixCommonArgs opts)
+      ""
   where
-    attrSub = maybe "" ("." <>) attr
+    attr = (maybe "" (<> ".") (getAttr opts)) <> output
+    args =
+      [exprOrFile, "--eval", "--raw", "-A", attr]
+        ++ ["-E" | buildExpr opts /= Nothing]
+        ++ if buildReadonlyMode opts then ["--readonly-mode"] else ["--read-write-mode"]
 
-readProcessText :: FilePath -> [Text] -> Text -> IO Text
-readProcessText cmd args input = toText <$> readProcess cmd (map toString args) (toString input)
+mainProgram :: BuildOptions -> Text -> IO Text
+mainProgram = getAttrOf "meta.mainProgram"
 
-executeFileText :: Text -> Bool -> [Text] -> Maybe [(String, String)] -> IO a
-executeFileText binPath search args env =
-  executeFile (toString binPath) search (map toString args) env
+binOutputOrOut :: BuildOptions -> Text -> IO FilePath
+binOutputOrOut opts exprOrFile = do
+  drvPath <- toString . strip <$> readProcessText "nix-instantiate" (args ++ nixCommonArgs opts) ""
+  drvText <- (decodeUtf8 <$> readFileBS drvPath) :: IO Text
+  let outputs = case parse parseDerivation drvText of
+        Fail _ _ err -> error $ "Failed to parse derivation: " <> toText err
+        Partial _ -> error "Failed to parse derivation: incomplete input"
+        Done _ drv -> DRV.outputs drv
+  let outputPath = case (flip find ["bin", "out"] $ \out -> Map.member out outputs) of
+        Just out -> DRV.path (outputs Map.! out)
+        Nothing -> error "Derivation has no 'out' or 'bin' output"
+  pure $ outputPath
+  where
+    args =
+      [exprOrFile, "--no-gc-warning"]
+        ++ maybe [] (("-A" :) . one) (getAttr opts)
+        ++ ["-E" | buildExpr opts /= Nothing]
+        ++ if buildReadonlyMode opts then ["--readonly-mode"] else ["--read-write-mode"]
 
 main :: IO ()
 main = do
···
 
     case buildExpr opts of
       Just exprText -> do
+        binPath <- toString <$> mainProgram opts exprText
+        outPath <- binOutputOrOut opts exprText
         let attr = buildAttrs opts
-        let expr = getExeExprFromExpr exprText attr
-        binPath <-
-          readProcessText
-            "nix-instantiate"
-            ( ["--eval", "--raw", "-E", expr]
-                ++ nixCommonArgs opts
-                ++ if (buildReadonlyMode opts) then ["--readonly-mode"] else ["--read-write-mode"]
-            )
-            ""
         let attrArgs = maybe [] (("-A" :) . one) attr
         void $
           readProcessText
             "nix-build"
             (["--no-out-link", "-E", exprText] ++ attrArgs ++ nixBuildArgs opts)
             ""
-        executeFileText (strip binPath) False passthrough Nothing
+        executeFile (outPath </> "bin" </> binPath) False (map toString passthrough) Nothing
       Nothing -> do
         let file = getFile opts
+        binPath <- toString <$> mainProgram opts file
+        outPath <- binOutputOrOut opts file
         let attr = getAttr opts
-        let expr = getExeExprFromFile file attr (buildArgs opts) (buildArgStrs opts)
-        binPath <-
-          readProcessText
-            "nix-instantiate"
-            ( ["--eval", "--raw", "-E", expr]
-                ++ nixCommonArgs opts
-                ++ if (buildReadonlyMode opts) then ["--readonly-mode"] else ["--read-write-mode"]
-            )
-            ""
         let attrArgs = maybe [] (("-A" :) . one) attr
         void $
           readProcessText
             "nix-build"
             (["--no-out-link", file] ++ attrArgs ++ nixBuildArgs opts)
             ""
-        executeFileText (strip binPath) False passthrough Nothing
+        executeFile (outPath </> "bin" </> binPath) False (map toString passthrough) Nothing

package.yaml

···
           - (Relude as Prelude)
           - ""
       - hercules-ci-optparse-applicative ^>= 0.19.0.0
+      - nix-derivation ^>= 1.1.3
+      - attoparsec ^>= 0.14.4
       - process
       - unix
+      - filepath
     language: GHC2024
     default-extensions:
       - ApplicativeDo