Remove references to deleted webapp

This repository doesn’t contain the webapp. Remove dangling references
to it.

9 files changed, 0 insertions, 1753 deletions

diff --git a/Annex/MakeRepo.hs b/Annex/MakeRepo.hs
deleted file mode 100644
index 189e98c7d..000000000
--- a/Annex/MakeRepo.hs
+++ /dev/null
@@ -1,90 +0,0 @@
-{- making local repositories (used by webapp mostly)
- -
- - Copyright 2012-2014 Joey Hess <id@joeyh.name>
- -
- - Licensed under the GNU GPL version 3 or higher.
- -}
-
-module Annex.MakeRepo where
-
-import Assistant.WebApp.Common
-import Annex.Init
-import qualified Git.Construct
-import qualified Git.Config
-import qualified Git.Command
-import qualified Git.Branch
-import qualified Annex
-import Annex.UUID
-import Annex.Direct
-import Annex.Action
-import Types.StandardGroups
-import Logs.PreferredContent
-import qualified Annex.Branch
-import Utility.Process.Transcript
-
-{- Makes a new git repository. Or, if a git repository already
- - exists, returns False. -}
-makeRepo :: FilePath -> Bool -> IO Bool
-makeRepo path bare = ifM (probeRepoExists path)
-	( return False
-	, do
-		(transcript, ok) <-
-			processTranscript "git" (toCommand params) Nothing
-		unless ok $
-			error $ "git init failed!\nOutput:\n" ++ transcript
-		return True
-	)
-  where
-	baseparams = [Param "init", Param "--quiet"]
-	params
-		| bare = baseparams ++ [Param "--bare", File path]
-		| otherwise = baseparams ++ [File path]
-
-{- Runs an action in the git repository in the specified directory. -}
-inDir :: FilePath -> Annex a -> IO a
-inDir dir a = do
-	state <- Annex.new =<< Git.Config.read =<< Git.Construct.fromPath dir
-	Annex.eval state $ a `finally` stopCoProcesses
-
-{- Creates a new repository, and returns its UUID. -}
-initRepo :: Bool -> Bool -> FilePath -> Maybe String -> Maybe StandardGroup -> IO UUID
-initRepo True primary_assistant_repo dir desc mgroup = inDir dir $ do
-	initRepo' desc mgroup
-	{- Initialize the master branch, so things that expect
-	 - to have it will work, before any files are added. -}
-	unlessM (Git.Config.isBare <$> gitRepo) $
-		void $ inRepo $ Git.Branch.commitCommand Git.Branch.AutomaticCommit
-			[ Param "--quiet"
-			, Param "--allow-empty"
-			, Param "-m"
-			, Param "created repository"
-			]
-	{- Repositories directly managed by the assistant use direct mode.
-	 - 
-	 - Automatic gc is disabled, as it can be slow. Insted, gc is done
-	 - once a day.
-	 -}
-	when primary_assistant_repo $ do
-		setDirect True
-		inRepo $ Git.Command.run
-			[Param "config", Param "gc.auto", Param "0"]
-	getUUID
-{- Repo already exists, could be a non-git-annex repo though so
- - still initialize it. -}
-initRepo False _ dir desc mgroup = inDir dir $ do
-	initRepo' desc mgroup
-	getUUID
-
-initRepo' :: Maybe String -> Maybe StandardGroup -> Annex ()
-initRepo' desc mgroup = unlessM isInitialized $ do
-	initialize (AutoInit False) desc Nothing
-	u <- getUUID
-	maybe noop (defaultStandardGroup u) mgroup
-	{- Ensure branch gets committed right away so it is
-	 - available for merging immediately. -}
-	Annex.Branch.commit "update"
-
-{- Checks if a git repo exists at a location. -}
-probeRepoExists :: FilePath -> IO Bool
-probeRepoExists dir = isJust <$>
-	catchDefaultIO Nothing (Git.Construct.checkForRepo dir)
diff --git a/Assistant/Threads/PairListener.hs b/Assistant/Threads/PairListener.hs
deleted file mode 100644
index 09eaf1fe8..000000000
--- a/Assistant/Threads/PairListener.hs
+++ /dev/null
@@ -1,154 +0,0 @@
-{- git-annex assistant thread to listen for incoming pairing traffic
- -
- - Copyright 2012 Joey Hess <id@joeyh.name>
- -
- - Licensed under the GNU GPL version 3 or higher.
- -}
-
-module Assistant.Threads.PairListener where
-
-import Assistant.Common
-import Assistant.Pairing
-import Assistant.Pairing.Network
-import Assistant.Pairing.MakeRemote
-import Assistant.WebApp (UrlRenderer)
-import Assistant.WebApp.Types
-import Assistant.Alert
-import Assistant.DaemonStatus
-import Utility.ThreadScheduler
-import Git
-
-import Network.Multicast
-import Network.Socket
-import qualified Data.ByteString as B
-import qualified Data.ByteString.UTF8 as BU8
-import qualified Network.Socket.ByteString as B
-import qualified Data.Text as T
-
-pairListenerThread :: UrlRenderer -> NamedThread
-pairListenerThread urlrenderer = namedThread "PairListener" $ do
-	listener <- asIO1 $ go [] []
-	liftIO $ withSocketsDo $
-		runEvery (Seconds 60) $ void $ tryIO $ 
-			listener =<< getsock
-  where
-	{- Note this can crash if there's no network interface,
-	 - or only one like lo that doesn't support multicast. -}
-	getsock = multicastReceiver (multicastAddress IPv4AddrClass) pairingPort
-		
-	go reqs cache sock = liftIO (getmsg sock B.empty) >>= \msg -> case readish (BU8.toString msg) of
-		Nothing -> go reqs cache sock
-		Just m -> do
-			debug ["received", show msg]
-			(pip, verified) <- verificationCheck m
-				=<< (pairingInProgress <$> getDaemonStatus)
-			let wrongstage = maybe False (\p -> pairMsgStage m <= inProgressPairStage p) pip
-			let fromus = maybe False (\p -> remoteSshPubKey (pairMsgData m) == remoteSshPubKey (inProgressPairData p)) pip
-			case (wrongstage, fromus, checkSane (pairMsgData m), pairMsgStage m) of
-				(_, True, _, _) -> do
-					debug ["ignoring message that looped back"]
-					go reqs cache sock
-				(_, _, False, _) -> do
-					liftAnnex $ warning $
-						"illegal control characters in pairing message; ignoring (" ++ show (pairMsgData m) ++ ")"
-					go reqs cache sock
-				-- PairReq starts a pairing process, so a
-				-- new one is always heeded, even if
-				-- some other pairing is in process.
-				(_, _, _, PairReq) -> if m `elem` reqs
-					then go reqs (invalidateCache m cache) sock
-					else do
-						pairReqReceived verified urlrenderer m
-						go (m:take 10 reqs) (invalidateCache m cache) sock
-				(True, _, _, _) -> do
-					debug
-						["ignoring out of order message"
-						, show (pairMsgStage m)
-						, "expected"
-						, show (succ . inProgressPairStage <$> pip)
-						]
-					go reqs cache sock
-				(_, _, _, PairAck) -> do
-					cache' <- pairAckReceived verified pip m cache
-					go reqs cache' sock
-				(_,_ , _, PairDone) -> do
-					pairDoneReceived verified pip m
-					go reqs cache sock
-
-	{- As well as verifying the message using the shared secret,
-	 - check its UUID against the UUID we have stored. If
-	 - they're the same, someone is sending bogus messages,
-	 - which could be an attempt to brute force the shared secret. -}
-	verificationCheck _ Nothing = return (Nothing, False)
-	verificationCheck m (Just pip)
-		| not verified && sameuuid = do
-			liftAnnex $ warning
-				"detected possible pairing brute force attempt; disabled pairing"
-			stopSending pip
-			return (Nothing, False)
-		| otherwise = return (Just pip, verified && sameuuid)
-	  where
-		verified = verifiedPairMsg m pip
-		sameuuid = pairUUID (inProgressPairData pip) == pairUUID (pairMsgData m)
-
-	{- PairReqs invalidate the cache of recently finished pairings.
-	 - This is so that, if a new pairing is started with the
-	 - same secret used before, a bogus PairDone is not sent. -}
-	invalidateCache msg = filter (not . verifiedPairMsg msg)
-
-	getmsg sock c = do
-		(msg, _) <- B.recvFrom sock chunksz
-		if B.length msg < chunksz
-			then return $ c <> msg
-			else getmsg sock $ c <> msg
-	  where
-		chunksz = 1024
-
-{- Show an alert when a PairReq is seen. -}
-pairReqReceived :: Bool -> UrlRenderer -> PairMsg -> Assistant ()
-pairReqReceived True _ _ = noop -- ignore our own PairReq
-pairReqReceived False urlrenderer msg = do
-	button <- mkAlertButton True (T.pack "Respond") urlrenderer (FinishLocalPairR msg)
-	void $ addAlert $ pairRequestReceivedAlert repo button
-  where
-	repo = pairRepo msg
-
-{- When a verified PairAck is seen, a host is ready to pair with us, and has
- - already configured our ssh key. Stop sending PairReqs, finish the pairing,
- - and send a single PairDone. -}
-pairAckReceived :: Bool -> Maybe PairingInProgress -> PairMsg -> [PairingInProgress] -> Assistant [PairingInProgress]
-pairAckReceived True (Just pip) msg cache = do
-	stopSending pip
-	repodir <- repoPath <$> liftAnnex gitRepo
-	liftIO $ setupAuthorizedKeys msg repodir
-	finishedLocalPairing msg (inProgressSshKeyPair pip)
-	startSending pip PairDone $ multicastPairMsg
-		(Just 1) (inProgressSecret pip) (inProgressPairData pip)
-	return $ pip : take 10 cache
-{- A stale PairAck might also be seen, after we've finished pairing.
- - Perhaps our PairDone was not received. To handle this, we keep
- - a cache of recently finished pairings, and re-send PairDone in
- - response to stale PairAcks for them. -}
-pairAckReceived _ _ msg cache = do
-	let pips = filter (verifiedPairMsg msg) cache
-	unless (null pips) $
-		forM_ pips $ \pip ->
-			startSending pip PairDone $ multicastPairMsg
-				(Just 1) (inProgressSecret pip) (inProgressPairData pip)
-	return cache
-
-{- If we get a verified PairDone, the host has accepted our PairAck, and
- - has paired with us. Stop sending PairAcks, and finish pairing with them.
- -
- - TODO: Should third-party hosts remove their pair request alert when they
- - see a PairDone?
- - Complication: The user could have already clicked on the alert and be
- - entering the secret. Would be better to start a fresh pair request in this
- - situation.
- -}
-pairDoneReceived :: Bool -> Maybe PairingInProgress -> PairMsg -> Assistant ()
-pairDoneReceived False _ _ = noop -- not verified
-pairDoneReceived True Nothing _ = noop -- not in progress
-pairDoneReceived True (Just pip) msg = do
-	stopSending pip
-	finishedLocalPairing msg (inProgressSshKeyPair pip)
diff --git a/Assistant/Threads/WebApp.hs b/Assistant/Threads/WebApp.hs
deleted file mode 100644
index dfb631bc6..000000000
--- a/Assistant/Threads/WebApp.hs
+++ /dev/null
@@ -1,137 +0,0 @@
-{- git-annex assistant webapp thread
- -
- - Copyright 2012-2014 Joey Hess <id@joeyh.name>
- -
- - Licensed under the GNU GPL version 3 or higher.
- -}
-
-{-# LANGUAGE TemplateHaskell, MultiParamTypeClasses #-}
-{-# LANGUAGE ViewPatterns, OverloadedStrings #-}
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Assistant.Threads.WebApp where
-
-import Assistant.Common
-import Assistant.WebApp
-import Assistant.WebApp.Types
-import Assistant.WebApp.DashBoard
-import Assistant.WebApp.SideBar
-import Assistant.WebApp.Notifications
-import Assistant.WebApp.RepoList
-import Assistant.WebApp.Configurators
-import Assistant.WebApp.Configurators.Local
-import Assistant.WebApp.Configurators.Ssh
-import Assistant.WebApp.Configurators.Pairing
-import Assistant.WebApp.Configurators.AWS
-import Assistant.WebApp.Configurators.IA
-import Assistant.WebApp.Configurators.WebDAV
-import Assistant.WebApp.Configurators.Preferences
-import Assistant.WebApp.Configurators.Unused
-import Assistant.WebApp.Configurators.Edit
-import Assistant.WebApp.Configurators.Delete
-import Assistant.WebApp.Configurators.Fsck
-import Assistant.WebApp.Configurators.Upgrade
-import Assistant.WebApp.Documentation
-import Assistant.WebApp.Control
-import Assistant.WebApp.OtherRepos
-import Assistant.WebApp.Repair
-import Assistant.WebApp.Pairing
-import Assistant.Types.ThreadedMonad
-import Utility.WebApp
-import Utility.AuthToken
-import Utility.Tmp
-import Utility.FileMode
-import Git
-import qualified Annex
-
-import Yesod
-import Network.Socket (SockAddr, HostName)
-import Data.Text (pack, unpack)
-import qualified Network.Wai.Handler.WarpTLS as TLS
-import Network.Wai.Middleware.RequestLogger
-
-mkYesodDispatch "WebApp" $(parseRoutesFile "Assistant/WebApp/routes")
-
-type Url = String
-
-webAppThread
-	:: AssistantData
-	-> UrlRenderer
-	-> Bool
-	-> Maybe String
-	-> Maybe (IO Url)
-	-> Maybe HostName
-	-> Maybe (Url -> FilePath -> IO ())
-	-> NamedThread
-webAppThread assistantdata urlrenderer noannex cannotrun postfirstrun listenhost onstartup = thread $ liftIO $ do
-	listenhost' <- if isJust listenhost
-		then pure listenhost
-		else getAnnex $ annexListen <$> Annex.getGitConfig
-	tlssettings <- getAnnex getTlsSettings
-#ifdef __ANDROID__
-	when (isJust listenhost') $
-		-- See Utility.WebApp
-		giveup "Sorry, --listen is not currently supported on Android"
-#endif
-	webapp <- WebApp
-		<$> pure assistantdata
-		<*> genAuthToken 128
-		<*> getreldir
-		<*> pure staticRoutes
-		<*> pure postfirstrun
-		<*> pure cannotrun
-		<*> pure noannex
-		<*> pure listenhost'
-		<*> newWormholePairingState
-	setUrlRenderer urlrenderer $ yesodRender webapp (pack "")
-	app <- toWaiAppPlain webapp
-	app' <- ifM debugEnabled
-		( return $ logStdout app
-		, return app
-		)
-	runWebApp tlssettings listenhost' app' $ \addr -> if noannex
-		then withTmpFile "webapp.html" $ \tmpfile h -> do
-			hClose h
-			go tlssettings addr webapp tmpfile Nothing
-		else do
-			htmlshim <- getAnnex' $ fromRepo gitAnnexHtmlShim
-			urlfile <- getAnnex' $ fromRepo gitAnnexUrlFile
-			go tlssettings addr webapp htmlshim (Just urlfile)
-  where
-	-- The webapp thread does not wait for the startupSanityCheckThread
-	-- to finish, so that the user interface remains responsive while
-	-- that's going on.
-	thread = namedThreadUnchecked "WebApp"
-	getreldir
-		| noannex = return Nothing
-		| otherwise = Just <$>
-			(relHome =<< absPath
-				=<< getAnnex' (fromRepo repoPath))
-	go tlssettings addr webapp htmlshim urlfile = do
-		let url = myUrl tlssettings webapp addr
-		maybe noop (`writeFileProtected` url) urlfile
-		writeHtmlShim "Starting webapp..." url htmlshim
-		maybe noop (\a -> a url htmlshim) onstartup
-
-	getAnnex a
-		| noannex = pure Nothing
-		| otherwise = getAnnex' a
-	getAnnex' = runThreadState (threadState assistantdata)
-
-myUrl :: Maybe TLS.TLSSettings -> WebApp -> SockAddr -> Url
-myUrl tlssettings webapp addr = unpack $ yesodRender webapp urlbase DashboardR []
-  where
-	urlbase = pack $ proto ++ "://" ++ show addr
-	proto
-		| isJust tlssettings = "https"
-		| otherwise = "http"
-
-getTlsSettings :: Annex (Maybe TLS.TLSSettings)
-getTlsSettings = do
-	cert <- fromRepo gitAnnexWebCertificate
-	privkey <- fromRepo gitAnnexWebPrivKey
-	ifM (liftIO $ allM doesFileExist [cert, privkey])
-		( return $ Just $ TLS.tlsSettings cert privkey
-		, return Nothing
-		)
diff --git a/BuildFlags.hs b/BuildFlags.hs
index e750506e6..312ec62a9 100644
--- a/BuildFlags.hs
+++ b/BuildFlags.hs
@@ -23,8 +23,6 @@ buildFlags = filter (not . null)
 #endif
 #ifdef WITH_WEBAPP
 	, "Webapp"
-#else
-#warning Building without the webapp. You probably need to install Yesod..
 #endif
 #ifdef WITH_PAIRING
 	, "Pairing"
diff --git a/COPYRIGHT b/COPYRIGHT
index 1bb6ebbab..d3007b4ec 100644
--- a/COPYRIGHT
+++ b/COPYRIGHT
@@ -6,11 +6,6 @@ Copyright: © 2010-2018 Joey Hess <id@joeyh.name>
            © 2022 Benjamin Barenblat <bbarenblat@gmail.com>
 License: GPL-3+
 
-Files: Assistant/WebApp.hs Assistant/WebApp/* templates/* static/*
-Copyright: © 2012-2017 Joey Hess <id@joeyh.name>
-           © 2014 Sören Brunk
-License: AGPL-3+
-
 Files: Remote/Ddar.hs
 Copyright: © 2011 Joey Hess <id@joeyh.name>
            © 2014 Robie Basak <robie@justgohome.co.uk>
@@ -150,666 +145,3 @@ License: BSD-2-clause
  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  SUCH DAMAGE.
-
-License: AGPL-3+
-                      GNU AFFERO GENERAL PUBLIC LICENSE
-                         Version 3, 19 November 2007
- .
-   Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
-   Everyone is permitted to copy and distribute verbatim copies
-   of this license document, but changing it is not allowed.
- .
-                              Preamble
- .
-    The GNU Affero General Public License is a free, copyleft license for
-  software and other kinds of works, specifically designed to ensure
-  cooperation with the community in the case of network server software.
- .
-    The licenses for most software and other practical works are designed
-  to take away your freedom to share and change the works.  By contrast,
-  our General Public Licenses are intended to guarantee your freedom to
-  share and change all versions of a program--to make sure it remains free
-  software for all its users.
- .
-    When we speak of free software, we are referring to freedom, not
-  price.  Our General Public Licenses are designed to make sure that you
-  have the freedom to distribute copies of free software (and charge for
-  them if you wish), that you receive source code or can get it if you
-  want it, that you can change the software or use pieces of it in new
-  free programs, and that you know you can do these things.
- .
-    Developers that use our General Public Licenses protect your rights
-  with two steps: (1) assert copyright on the software, and (2) offer
-  you this License which gives you legal permission to copy, distribute
-  and/or modify the software.
- .
-    A secondary benefit of defending all users' freedom is that
-  improvements made in alternate versions of the program, if they
-  receive widespread use, become available for other developers to
-  incorporate.  Many developers of free software are heartened and
-  encouraged by the resulting cooperation.  However, in the case of
-  software used on network servers, this result may fail to come about.
-  The GNU General Public License permits making a modified version and
-  letting the public access it on a server without ever releasing its
-  source code to the public.
- .
-    The GNU Affero General Public License is designed specifically to
-  ensure that, in such cases, the modified source code becomes available
-  to the community.  It requires the operator of a network server to
-  provide the source code of the modified version running there to the
-  users of that server.  Therefore, public use of a modified version, on
-  a publicly accessible server, gives the public access to the source
-  code of the modified version.
- .
-    An older license, called the Affero General Public License and
-  published by Affero, was designed to accomplish similar goals.  This is
-  a different license, not a version of the Affero GPL, but Affero has
-  released a new version of the Affero GPL which permits relicensing under
-  this license.
- .
-    The precise terms and conditions for copying, distribution and
-  modification follow.
- .
-                         TERMS AND CONDITIONS
- .
-    0. Definitions.
- .
-    "This License" refers to version 3 of the GNU Affero General Public License.
- .
-    "Copyright" also means copyright-like laws that apply to other kinds of
-  works, such as semiconductor masks.
- .
-    "The Program" refers to any copyrightable work licensed under this
-  License.  Each licensee is addressed as "you".  "Licensees" and
-  "recipients" may be individuals or organizations.
- .
-    To "modify" a work means to copy from or adapt all or part of the work
-  in a fashion requiring copyright permission, other than the making of an
-  exact copy.  The resulting work is called a "modified version" of the
-  earlier work or a work "based on" the earlier work.
- .
-    A "covered work" means either the unmodified Program or a work based
-  on the Program.
- .
-    To "propagate" a work means to do anything with it that, without
-  permission, would make you directly or secondarily liable for
-  infringement under applicable copyright law, except executing it on a
-  computer or modifying a private copy.  Propagation includes copying,
-  distribution (with or without modification), making available to the
-  public, and in some countries other activities as well.
- .
-    To "convey" a work means any kind of propagation that enables other
-  parties to make or receive copies.  Mere interaction with a user through
-  a computer network, with no transfer of a copy, is not conveying.
- .
-    An interactive user interface displays "Appropriate Legal Notices"
-  to the extent that it includes a convenient and prominently visible
-  feature that (1) displays an appropriate copyright notice, and (2)
-  tells the user that there is no warranty for the work (except to the
-  extent that warranties are provided), that licensees may convey the
-  work under this License, and how to view a copy of this License.  If
-  the interface presents a list of user commands or options, such as a
-  menu, a prominent item in the list meets this criterion.
- .
-    1. Source Code.
- .
-    The "source code" for a work means the preferred form of the work
-  for making modifications to it.  "Object code" means any non-source
-  form of a work.
- .
-    A "Standard Interface" means an interface that either is an official
-  standard defined by a recognized standards body, or, in the case of
-  interfaces specified for a particular programming language, one that
-  is widely used among developers working in that language.
- .
-    The "System Libraries" of an executable work include anything, other
-  than the work as a whole, that (a) is included in the normal form of
-  packaging a Major Component, but which is not part of that Major
-  Component, and (b) serves only to enable use of the work with that
-  Major Component, or to implement a Standard Interface for which an
-  implementation is available to the public in source code form.  A
-  "Major Component", in this context, means a major essential component
-  (kernel, window system, and so on) of the specific operating system
-  (if any) on which the executable work runs, or a compiler used to
-  produce the work, or an object code interpreter used to run it.
- .
-    The "Corresponding Source" for a work in object code form means all
-  the source code needed to generate, install, and (for an executable
-  work) run the object code and to modify the work, including scripts to
-  control those activities.  However, it does not include the work's
-  System Libraries, or general-purpose tools or generally available free
-  programs which are used unmodified in performing those activities but
-  which are not part of the work.  For example, Corresponding Source
-  includes interface definition files associated with source files for
-  the work, and the source code for shared libraries and dynamically
-  linked subprograms that the work is specifically designed to require,
-  such as by intimate data communication or control flow between those
-  subprograms and other parts of the work.
- .
-    The Corresponding Source need not include anything that users
-  can regenerate automatically from other parts of the Corresponding
-  Source.
- .
-    The Corresponding Source for a work in source code form is that
-  same work.
- .
-    2. Basic Permissions.
- .
-    All rights granted under this License are granted for the term of
-  copyright on the Program, and are irrevocable provided the stated
-  conditions are met.  This License explicitly affirms your unlimited
-  permission to run the unmodified Program.  The output from running a
-  covered work is covered by this License only if the output, given its
-  content, constitutes a covered work.  This License acknowledges your
-  rights of fair use or other equivalent, as provided by copyright law.
- .
-    You may make, run and propagate covered works that you do not
-  convey, without conditions so long as your license otherwise remains
-  in force.  You may convey covered works to others for the sole purpose
-  of having them make modifications exclusively for you, or provide you
-  with facilities for running those works, provided that you comply with
-  the terms of this License in conveying all material for which you do
-  not control copyright.  Those thus making or running the covered works
-  for you must do so exclusively on your behalf, under your direction
-  and control, on terms that prohibit them from making any copies of
-  your copyrighted material outside their relationship with you.
- .
-    Conveying under any other circumstances is permitted solely under
-  the conditions stated below.  Sublicensing is not allowed; section 10
-  makes it unnecessary.
- .
-    3. Protecting Users' Legal Rights From Anti-Circumvention Law.
- .
-    No covered work shall be deemed part of an effective technological
-  measure under any applicable law fulfilling obligations under article
-  11 of the WIPO copyright treaty adopted on 20 December 1996, or
-  similar laws prohibiting or restricting circumvention of such
-  measures.
- .
-    When you convey a covered work, you waive any legal power to forbid
-  circumvention of technological measures to the extent such circumvention
-  is effected by exercising rights under this License with respect to
-  the covered work, and you disclaim any intention to limit operation or
-  modification of the work as a means of enforcing, against the work's
-  users, your or third parties' legal rights to forbid circumvention of
-  technological measures.
- .
-    4. Conveying Verbatim Copies.
- .
-    You may convey verbatim copies of the Program's source code as you
-  receive it, in any medium, provided that you conspicuously and
-  appropriately publish on each copy an appropriate copyright notice;
-  keep intact all notices stating that this License and any
-  non-permissive terms added in accord with section 7 apply to the code;
-  keep intact all notices of the absence of any warranty; and give all
-  recipients a copy of this License along with the Program.
- .
-    You may charge any price or no price for each copy that you convey,
-  and you may offer support or warranty protection for a fee.
- .
-    5. Conveying Modified Source Versions.
- .
-    You may convey a work based on the Program, or the modifications to
-  produce it from the Program, in the form of source code under the
-  terms of section 4, provided that you also meet all of these conditions:
- .
-      a) The work must carry prominent notices stating that you modified
-      it, and giving a relevant date.
- .
-      b) The work must carry prominent notices stating that it is
-      released under this License and any conditions added under section
-      7.  This requirement modifies the requirement in section 4 to
-      "keep intact all notices".
- .
-      c) You must license the entire work, as a whole, under this
-      License to anyone who comes into possession of a copy.  This
-      License will therefore apply, along with any applicable section 7
-      additional terms, to the whole of the work, and all its parts,
-      regardless of how they are packaged.  This License gives no
-      permission to license the work in any other way, but it does not
-      invalidate such permission if you have separately received it.
- .
-      d) If the work has interactive user interfaces, each must display
-      Appropriate Legal Notices; however, if the Program has interactive
-      interfaces that do not display Appropriate Legal Notices, your
-      work need not make them do so.
- .
-    A compilation of a covered work with other separate and independent
-  works, which are not by their nature extensions of the covered work,
-  and which are not combined with it such as to form a larger program,
-  in or on a volume of a storage or distribution medium, is called an
-  "aggregate" if the compilation and its resulting copyright are not
-  used to limit the access or legal rights of the compilation's users
-  beyond what the individual works permit.  Inclusion of a covered work
-  in an aggregate does not cause this License to apply to the other
-  parts of the aggregate.
- .
-    6. Conveying Non-Source Forms.
- .
-    You may convey a covered work in object code form under the terms
-  of sections 4 and 5, provided that you also convey the
-  machine-readable Corresponding Source under the terms of this License,
-  in one of these ways:
- .
-      a) Convey the object code in, or embodied in, a physical product
-      (including a physical distribution medium), accompanied by the
-      Corresponding Source fixed on a durable physical medium
-      customarily used for software interchange.
- .
-      b) Convey the object code in, or embodied in, a physical product
-      (including a physical distribution medium), accompanied by a
-      written offer, valid for at least three years and valid for as
-      long as you offer spare parts or customer support for that product
-      model, to give anyone who possesses the object code either (1) a
-      copy of the Corresponding Source for all the software in the
-      product that is covered by this License, on a durable physical
-      medium customarily used for software interchange, for a price no
-      more than your reasonable cost of physically performing this
-      conveying of source, or (2) access to copy the
-      Corresponding Source from a network server at no charge.
- .
-      c) Convey individual copies of the object code with a copy of the
-      written offer to provide the Corresponding Source.  This
-      alternative is allowed only occasionally and noncommercially, and
-      only if you received the object code with such an offer, in accord
-      with subsection 6b.
- .
-      d) Convey the object code by offering access from a designated
-      place (gratis or for a charge), and offer equivalent access to the
-      Corresponding Source in the same way through the same place at no
-      further charge.  You need not require recipients to copy the
-      Corresponding Source along with the object code.  If the place to
-      copy the object code is a network server, the Corresponding Source
-      may be on a different server (operated by you or a third party)
-      that supports equivalent copying facilities, provided you maintain
-      clear directions next to the object code saying where to find the
-      Corresponding Source.  Regardless of what server hosts the
-      Corresponding Source, you remain obligated to ensure that it is
-      available for as long as needed to satisfy these requirements.
- .
-      e) Convey the object code using peer-to-peer transmission, provided
-      you inform other peers where the object code and Corresponding
-      Source of the work are being offered to the general public at no
-      charge under subsection 6d.
- .
-    A separable portion of the object code, whose source code is excluded
-  from the Corresponding Source as a System Library, need not be
-  included in conveying the object code work.
- .
-    A "User Product" is either (1) a "consumer product", which means any
-  tangible personal property which is normally used for personal, family,
-  or household purposes, or (2) anything designed or sold for incorporation
-  into a dwelling.  In determining whether a product is a consumer product,
-  doubtful cases shall be resolved in favor of coverage.  For a particular
-  product received by a particular user, "normally used" refers to a
-  typical or common use of that class of product, regardless of the status
-  of the particular user or of the way in which the particular user
-  actually uses, or expects or is expected to use, the product.  A product
-  is a consumer product regardless of whether the product has substantial
-  commercial, industrial or non-consumer uses, unless such uses represent
-  the only significant mode of use of the product.
- .
-    "Installation Information" for a User Product means any methods,
-  procedures, authorization keys, or other information required to install
-  and execute modified versions of a covered work in that User Product from
-  a modified version of its Corresponding Source.  The information must
-  suffice to ensure that the continued functioning of the modified object
-  code is in no case prevented or interfered with solely because
-  modification has been made.
- .
-    If you convey an object code work under this section in, or with, or
-  specifically for use in, a User Product, and the conveying occurs as
-  part of a transaction in which the right of possession and use of the
-  User Product is transferred to the recipient in perpetuity or for a
-  fixed term (regardless of how the transaction is characterized), the
-  Corresponding Source conveyed under this section must be accompanied
-  by the Installation Information.  But this requirement does not apply
-  if neither you nor any third party retains the ability to install
-  modified object code on the User Product (for example, the work has
-  been installed in ROM).
- .
-    The requirement to provide Installation Information does not include a
-  requirement to continue to provide support service, warranty, or updates
-  for a work that has been modified or installed by the recipient, or for
-  the User Product in which it has been modified or installed.  Access to a
-  network may be denied when the modification itself materially and
-  adversely affects the operation of the network or violates the rules and
-  protocols for communication across the network.
- .
-    Corresponding Source conveyed, and Installation Information provided,
-  in accord with this section must be in a format that is publicly
-  documented (and with an implementation available to the public in
-  source code form), and must require no special password or key for
-  unpacking, reading or copying.
- .
-    7. Additional Terms.
- .
-    "Additional permissions" are terms that supplement the terms of this
-  License by making exceptions from one or more of its conditions.
-  Additional permissions that are applicable to the entire Program shall
-  be treated as though they were included in this License, to the extent
-  that they are valid under applicable law.  If additional permissions
-  apply only to part of the Program, that part may be used separately
-  under those permissions, but the entire Program remains governed by
-  this License without regard to the additional permissions.
- .
-    When you convey a copy of a covered work, you may at your option
-  remove any additional permissions from that copy, or from any part of
-  it.  (Additional permissions may be written to require their own
-  removal in certain cases when you modify the work.)  You may place
-  additional permissions on material, added by you to a covered work,
-  for which you have or can give appropriate copyright permission.
- .
-    Notwithstanding any other provision of this License, for material you
-  add to a covered work, you may (if authorized by the copyright holders of
-  that material) supplement the terms of this License with terms:
- .
-      a) Disclaiming warranty or limiting liability differently from the
-      terms of sections 15 and 16 of this License; or
- .
-      b) Requiring preservation of specified reasonable legal notices or
-      author attributions in that material or in the Appropriate Legal
-      Notices displayed by works containing it; or
- .
-      c) Prohibiting misrepresentation of the origin of that material, or
-      requiring that modified versions of such material be marked in
-      reasonable ways as different from the original version; or
- .
-      d) Limiting the use for publicity purposes of names of licensors or
-      authors of the material; or
- .
-      e) Declining to grant rights under trademark law for use of some
-      trade names, trademarks, or service marks; or
- .
-      f) Requiring indemnification of licensors and authors of that
-      material by anyone who conveys the material (or modified versions of
-      it) with contractual assumptions of liability to the recipient, for
-      any liability that these contractual assumptions directly impose on
-      those licensors and authors.
- .
-    All other non-permissive additional terms are considered "further
-  restrictions" within the meaning of section 10.  If the Program as you
-  received it, or any part of it, contains a notice stating that it is
-  governed by this License along with a term that is a further
-  restriction, you may remove that term.  If a license document contains
-  a further restriction but permits relicensing or conveying under this
-  License, you may add to a covered work material governed by the terms
-  of that license document, provided that the further restriction does
-  not survive such relicensing or conveying.
- .
-    If you add terms to a covered work in accord with this section, you
-  must place, in the relevant source files, a statement of the
-  additional terms that apply to those files, or a notice indicating
-  where to find the applicable terms.
- .
-    Additional terms, permissive or non-permissive, may be stated in the
-  form of a separately written license, or stated as exceptions;
-  the above requirements apply either way.
- .
-    8. Termination.
- .
-    You may not propagate or modify a covered work except as expressly
-  provided under this License.  Any attempt otherwise to propagate or
-  modify it is void, and will automatically terminate your rights under
-  this License (including any patent licenses granted under the third
-  paragraph of section 11).
- .
-    However, if you cease all violation of this License, then your
-  license from a particular copyright holder is reinstated (a)
-  provisionally, unless and until the copyright holder explicitly and
-  finally terminates your license, and (b) permanently, if the copyright
-  holder fails to notify you of the violation by some reasonable means
-  prior to 60 days after the cessation.
- .
-    Moreover, your license from a particular copyright holder is
-  reinstated permanently if the copyright holder notifies you of the
-  violation by some reasonable means, this is the first time you have
-  received notice of violation of this License (for any work) from that
-  copyright holder, and you cure the violation prior to 30 days after
-  your receipt of the notice.
- .
-    Termination of your rights under this section does not terminate the
-  licenses of parties who have received copies or rights from you under
-  this License.  If your rights have been terminated and not permanently
-  reinstated, you do not qualify to receive new licenses for the same
-  material under section 10.
- .
-    9. Acceptance Not Required for Having Copies.
- .
-    You are not required to accept this License in order to receive or
-  run a copy of the Program.  Ancillary propagation of a covered work
-  occurring solely as a consequence of using peer-to-peer transmission
-  to receive a copy likewise does not require acceptance.  However,
-  nothing other than this License grants you permission to propagate or
-  modify any covered work.  These actions infringe copyright if you do
-  not accept this License.  Therefore, by modifying or propagating a
-  covered work, you indicate your acceptance of this License to do so.
- .
-    10. Automatic Licensing of Downstream Recipients.
- .
-    Each time you convey a covered work, the recipient automatically
-  receives a license from the original licensors, to run, modify and
-  propagate that work, subject to this License.  You are not responsible
-  for enforcing compliance by third parties with this License.
- .
-    An "entity transaction" is a transaction transferring control of an
-  organization, or substantially all assets of one, or subdividing an
-  organization, or merging organizations.  If propagation of a covered
-  work results from an entity transaction, each party to that
-  transaction who receives a copy of the work also receives whatever
-  licenses to the work the party's predecessor in interest had or could
-  give under the previous paragraph, plus a right to possession of the
-  Corresponding Source of the work from the predecessor in interest, if
-  the predecessor has it or can get it with reasonable efforts.
- .
-    You may not impose any further restrictions on the exercise of the
-  rights granted or affirmed under this License.  For example, you may
-  not impose a license fee, royalty, or other charge for exercise of
-  rights granted under this License, and you may not initiate litigation
-  (including a cross-claim or counterclaim in a lawsuit) alleging that
-  any patent claim is infringed by making, using, selling, offering for
-  sale, or importing the Program or any portion of it.
- .
-    11. Patents.
- .
-    A "contributor" is a copyright holder who authorizes use under this
-  License of the Program or a work on which the Program is based.  The
-  work thus licensed is called the contributor's "contributor version".
- .
-    A contributor's "essential patent claims" are all patent claims
-  owned or controlled by the contributor, whether already acquired or
-  hereafter acquired, that would be infringed by some manner, permitted
-  by this License, of making, using, or selling its contributor version,
-  but do not include claims that would be infringed only as a
-  consequence of further modification of the contributor version.  For
-  purposes of this definition, "control" includes the right to grant
-  patent sublicenses in a manner consistent with the requirements of
-  this License.
- .
-    Each contributor grants you a non-exclusive, worldwide, royalty-free
-  patent license under the contributor's essential patent claims, to
-  make, use, sell, offer for sale, import and otherwise run, modify and
-  propagate the contents of its contributor version.
- .
-    In the following three paragraphs, a "patent license" is any express
-  agreement or commitment, however denominated, not to enforce a patent
-  (such as an express permission to practice a patent or covenant not to
-  sue for patent infringement).  To "grant" such a patent license to a
-  party means to make such an agreement or commitment not to enforce a
-  patent against the party.
- .
-    If you convey a covered work, knowingly relying on a patent license,
-  and the Corresponding Source of the work is not available for anyone
-  to copy, free of charge and under the terms of this License, through a
-  publicly available network server or other readily accessible means,
-  then you must either (1) cause the Corresponding Source to be so
-  available, or (2) arrange to deprive yourself of the benefit of the
-  patent license for this particular work, or (3) arrange, in a manner
-  consistent with the requirements of this License, to extend the patent
-  license to downstream recipients.  "Knowingly relying" means you have
-  actual knowledge that, but for the patent license, your conveying the
-  covered work in a country, or your recipient's use of the covered work
-  in a country, would infringe one or more identifiable patents in that
-  country that you have reason to believe are valid.
- .
-    If, pursuant to or in connection with a single transaction or
-  arrangement, you convey, or propagate by procuring conveyance of, a
-  covered work, and grant a patent license to some of the parties
-  receiving the covered work authorizing them to use, propagate, modify
-  or convey a specific copy of the covered work, then the patent license
-  you grant is automatically extended to all recipients of the covered
-  work and works based on it.
- .
-    A patent license is "discriminatory" if it does not include within
-  the scope of its coverage, prohibits the exercise of, or is
-  conditioned on the non-exercise of one or more of the rights that are
-  specifically granted under this License.  You may not convey a covered
-  work if you are a party to an arrangement with a third party that is
-  in the business of distributing software, under which you make payment
-  to the third party based on the extent of your activity of conveying
-  the work, and under which the third party grants, to any of the
-  parties who would receive the covered work from you, a discriminatory
-  patent license (a) in connection with copies of the covered work
-  conveyed by you (or copies made from those copies), or (b) primarily
-  for and in connection with specific products or compilations that
-  contain the covered work, unless you entered into that arrangement,
-  or that patent license was granted, prior to 28 March 2007.
- .
-    Nothing in this License shall be construed as excluding or limiting
-  any implied license or other defenses to infringement that may
-  otherwise be available to you under applicable patent law.
- .
-    12. No Surrender of Others' Freedom.
- .
-    If conditions are imposed on you (whether by court order, agreement or
-  otherwise) that contradict the conditions of this License, they do not
-  excuse you from the conditions of this License.  If you cannot convey a
-  covered work so as to satisfy simultaneously your obligations under this
-  License and any other pertinent obligations, then as a consequence you may
-  not convey it at all.  For example, if you agree to terms that obligate you
-  to collect a royalty for further conveying from those to whom you convey
-  the Program, the only way you could satisfy both those terms and this
-  License would be to refrain entirely from conveying the Program.
- .
-    13. Remote Network Interaction; Use with the GNU General Public License.
- .
-    Notwithstanding any other provision of this License, if you modify the
-  Program, your modified version must prominently offer all users
-  interacting with it remotely through a computer network (if your version
-  supports such interaction) an opportunity to receive the Corresponding
-  Source of your version by providing access to the Corresponding Source
-  from a network server at no charge, through some standard or customary
-  means of facilitating copying of software.  This Corresponding Source
-  shall include the Corresponding Source for any work covered by version 3
-  of the GNU General Public License that is incorporated pursuant to the
-  following paragraph.
- .
-    Notwithstanding any other provision of this License, you have
-  permission to link or combine any covered work with a work licensed
-  under version 3 of the GNU General Public License into a single
-  combined work, and to convey the resulting work.  The terms of this
-  License will continue to apply to the part which is the covered work,
-  but the work with which it is combined will remain governed by version
-  3 of the GNU General Public License.
- .
-    14. Revised Versions of this License.
- .
-    The Free Software Foundation may publish revised and/or new versions of
-  the GNU Affero General Public License from time to time.  Such new versions
-  will be similar in spirit to the present version, but may differ in detail to
-  address new problems or concerns.
- .
-    Each version is given a distinguishing version number.  If the
-  Program specifies that a certain numbered version of the GNU Affero General
-  Public License "or any later version" applies to it, you have the
-  option of following the terms and conditions either of that numbered
-  version or of any later version published by the Free Software
-  Foundation.  If the Program does not specify a version number of the
-  GNU Affero General Public License, you may choose any version ever published
-  by the Free Software Foundation.
- .
-    If the Program specifies that a proxy can decide which future
-  versions of the GNU Affero General Public License can be used, that proxy's
-  public statement of acceptance of a version permanently authorizes you
-  to choose that version for the Program.
- .
-    Later license versions may give you additional or different
-  permissions.  However, no additional obligations are imposed on any
-  author or copyright holder as a result of your choosing to follow a
-  later version.
- .
-    15. Disclaimer of Warranty.
- .
-    THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-  APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-  HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-  OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-  PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-  IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-  ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
- .
-    16. Limitation of Liability.
- .
-    IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-  WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-  THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-  GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-  USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-  DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-  PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-  EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-  SUCH DAMAGES.
- .
-    17. Interpretation of Sections 15 and 16.
- .
-    If the disclaimer of warranty and limitation of liability provided
-  above cannot be given local legal effect according to their terms,
-  reviewing courts shall apply local law that most closely approximates
-  an absolute waiver of all civil liability in connection with the
-  Program, unless a warranty or assumption of liability accompanies a
-  copy of the Program in return for a fee.
- .
-                       END OF TERMS AND CONDITIONS
- .
-              How to Apply These Terms to Your New Programs
- .
-    If you develop a new program, and you want it to be of the greatest
-  possible use to the public, the best way to achieve this is to make it
-  free software which everyone can redistribute and change under these terms.
- .
-    To do so, attach the following notices to the program.  It is safest
-  to attach them to the start of each source file to most effectively
-  state the exclusion of warranty; and each file should have at least
-  the "copyright" line and a pointer to where the full notice is found.
- .
-      <one line to give the program's name and a brief idea of what it does.>
-      Copyright (C) <year>  <name of author>
- .
-      This program is free software: you can redistribute it and/or modify
-      it under the terms of the GNU Affero General Public License as published by
-      the Free Software Foundation, either version 3 of the License, or
-      (at your option) any later version.
- .
-      This program is distributed in the hope that it will be useful,
-      but WITHOUT ANY WARRANTY; without even the implied warranty of
-      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-      GNU Affero General Public License for more details.
- .
-      You should have received a copy of the GNU Affero General Public License
-      along with this program.  If not, see <http://www.gnu.org/licenses/>.
- .
-  Also add information on how to contact you by electronic and paper mail.
- .
-    If your software can interact with users remotely through a computer
-  network, you should also make sure that it provides a way for users to
-  get its source.  For example, if your program is a web application, its
-  interface could display a "Source" link that leads users to an archive
-  of the code.  There are many ways you could offer source, and different
-  solutions will be better for different programs; see section 13 for the
-  specific requirements.
- .
-    You should also get your employer (if you work as a programmer) or school,
-  if any, to sign a "copyright disclaimer" for the program, if necessary.
-  For more information on this, and how to apply and follow the GNU AGPL, see
-  <http://www.gnu.org/licenses/>.
diff --git a/Command/WebApp.hs b/Command/WebApp.hs
deleted file mode 100644
index d9c001b22..000000000
--- a/Command/WebApp.hs
+++ /dev/null
@@ -1,264 +0,0 @@
-{- git-annex webapp launcher
- -
- - Copyright 2012 Joey Hess <id@joeyh.name>
- -
- - Licensed under the GNU GPL version 3 or higher.
- -}
-
-{-# LANGUAGE CPP #-}
-
-module Command.WebApp where
-
-import Command
-import Assistant
-import Assistant.Common
-import Assistant.NamedThread
-import Assistant.Threads.WebApp
-import Assistant.WebApp
-import Assistant.Install
-import Annex.Environment
-import Utility.WebApp
-import Utility.Daemon (checkDaemon)
-#ifdef __ANDROID__
-import Utility.Env
-#endif
-import Utility.UserInfo
-import Annex.Init
-import qualified Git
-import qualified Git.Config
-import qualified Git.CurrentRepo
-import qualified Annex
-import Config.Files
-import Upgrade
-import Annex.Version
-
-import Control.Concurrent
-import Control.Concurrent.STM
-
-cmd :: Command
-cmd = noCommit $ dontCheck repoExists $ notBareRepo $
-	noRepo (startNoRepo <$$> optParser) $
-		command "webapp" SectionCommon "launch webapp"
-			paramNothing (seek <$$> optParser)
-
-data WebAppOptions = WebAppOptions
-	{ listenAddress :: Maybe String
-	}
-
-optParser :: CmdParamsDesc -> Parser WebAppOptions
-optParser _ = WebAppOptions
-	<$> optional (strOption
-		( long "listen" <> metavar paramAddress
-		<> help "accept connections to this address"
-		))
-
-seek :: WebAppOptions -> CommandSeek
-seek = commandAction . start
-
-start :: WebAppOptions -> CommandStart
-start = start' True
-
-start' :: Bool -> WebAppOptions -> CommandStart
-start' allowauto o = do
-	liftIO ensureInstalled
-	ifM (isInitialized <&&> notHome)
-		( maybe notinitialized (go <=< needsUpgrade) =<< getVersion
-		, if allowauto
-			then liftIO $ startNoRepo o
-			else notinitialized
-		)
-	stop
-  where
-	go cannotrun = do
-		browser <- fromRepo webBrowser
-		f <- liftIO . absPath =<< fromRepo gitAnnexHtmlShim
-		listenAddress' <- if isJust (listenAddress o)
-			then pure (listenAddress o)
-			else annexListen <$> Annex.getGitConfig
-		ifM (checkpid <&&> checkshim f)
-			( if isJust (listenAddress o)
-				then giveup "The assistant is already running, so --listen cannot be used."
-				else do
-					url <- liftIO . readFile
-						=<< fromRepo gitAnnexUrlFile
-					liftIO $ if isJust listenAddress'
-						then putStrLn url
-						else liftIO $ openBrowser browser f url Nothing Nothing
-			, do
-				startDaemon True True Nothing cannotrun listenAddress' $ Just $ 
-					\origout origerr url htmlshim ->
-						if isJust listenAddress'
-							then maybe noop (`hPutStrLn` url) origout
-							else openBrowser browser htmlshim url origout origerr
-			)
-	checkpid = do
-		pidfile <- fromRepo gitAnnexPidFile
-		liftIO $ isJust <$> checkDaemon pidfile
-	checkshim f = liftIO $ doesFileExist f
-	notinitialized = do
-		g <- Annex.gitRepo
-		liftIO $ cannotStartIn (Git.repoLocation g) "repository has not been initialized by git-annex"
-		liftIO $ firstRun o
-
-{- If HOME is a git repo, even if it's initialized for git-annex,
- - the user almost certianly does not want to run the assistant there. -}
-notHome :: Annex Bool
-notHome = do
-	g <- Annex.gitRepo
-	d <- liftIO $ absPath (Git.repoLocation g)
-	h <- liftIO $ absPath =<< myHomeDir
-	return (d /= h)
-
-{- When run without a repo, start the first available listed repository in
- - the autostart file. If none, it's our first time being run! -}
-startNoRepo :: WebAppOptions -> IO ()
-startNoRepo o = go =<< liftIO (filterM doesDirectoryExist =<< readAutoStartFile)
-  where
-	go [] = firstRun o
-	go (d:ds) = do
-		v <- tryNonAsync $ do
-			setCurrentDirectory d
-			Annex.new =<< Git.CurrentRepo.get
-		case v of
-			Left e -> do
-				cannotStartIn d (show e)
-				go ds
-			Right state -> void $ Annex.eval state $ do
-				whenM (fromRepo Git.repoIsLocalBare) $
-					giveup $ d ++ " is a bare git repository, cannot run the webapp in it"
-				callCommandAction $
-					start' False o
-
-cannotStartIn :: FilePath -> String -> IO ()
-cannotStartIn d reason = warningIO $ "unable to start webapp in repository " ++ d ++ ": " ++ reason
-
-{- Run the webapp without a repository, which prompts the user, makes one,
- - changes to it, starts the regular assistant, and redirects the
- - browser to its url.
- -
- - This is a very tricky dance -- The first webapp calls the signaler,
- - which signals the main thread when it's ok to continue by writing to a
- - MVar. The main thread starts the second webapp, and uses its callback
- - to write its url back to the MVar, from where the signaler retrieves it,
- - returning it to the first webapp, which does the redirect.
- -
- - Note that it's important that mainthread never terminates! Much
- - of this complication is due to needing to keep the mainthread running.
- -}
-firstRun :: WebAppOptions -> IO ()
-firstRun o = do
-	checkEnvironmentIO
-	{- Without a repository, we cannot have an Annex monad, so cannot
-	 - get a ThreadState. This is only safe because the
-	 - webapp checks its noAnnex field before accessing the
-	 - threadstate. -}
-	let st = error "annex state not available"
-	{- Get a DaemonStatus without running in the Annex monad. -}
-	dstatus <- atomically . newTVar =<< newDaemonStatus
-	d <- newAssistantData st dstatus
-	urlrenderer <- newUrlRenderer
-	v <- newEmptyMVar
-	let callback a = Just $ a v
-	runAssistant d $ do
-		startNamedThread urlrenderer $
-			webAppThread d urlrenderer True Nothing
-				(callback signaler)
-				(listenAddress o)
-				(callback mainthread)
-		waitNamedThreads
-  where
-	signaler v = do
-		putMVar v ""
-		takeMVar v
-	mainthread v url htmlshim
-		| isJust (listenAddress o)= do
-			putStrLn url
-			hFlush stdout
-			go
-		| otherwise = do
-			browser <- maybe Nothing webBrowser
-				<$> catchDefaultIO Nothing Git.Config.global
-			openBrowser browser htmlshim url Nothing Nothing
-			go
-	  where
-		go = do
-			_wait <- takeMVar v
-			state <- Annex.new =<< Git.CurrentRepo.get
-			Annex.eval state $
-				startDaemon True True Nothing Nothing (listenAddress o) $ Just $
-					sendurlback v
-	sendurlback v _origout _origerr url _htmlshim = do
-		recordUrl url
-		putMVar v url
-
-recordUrl :: String -> IO ()
-#ifdef __ANDROID__
-{- The Android app has a menu item that opens the url recorded
- - in this file. -}
-recordUrl url = writeFile "/sdcard/git-annex.home/.git-annex-url" url
-#else
-recordUrl _ = noop
-#endif
-
-openBrowser :: Maybe FilePath -> FilePath -> String -> Maybe Handle -> Maybe Handle -> IO ()
-openBrowser mcmd htmlshim realurl outh errh = do
-	htmlshim' <- absPath htmlshim
-	openBrowser' mcmd htmlshim' realurl outh errh
-
-openBrowser' :: Maybe FilePath -> FilePath -> String -> Maybe Handle -> Maybe Handle -> IO ()
-#ifndef __ANDROID__
-openBrowser' mcmd htmlshim _realurl outh errh = runbrowser
-#else
-openBrowser' mcmd htmlshim realurl outh errh = do
-	recordUrl url
-	{- Android's `am` command does not work reliably across the
-	 - wide range of Android devices. Intead, FIFO should be set to 
-	 - the filename of a fifo that we can write the URL to. -}
-	v <- getEnv "FIFO"
-	case v of
-		Nothing -> runbrowser
-		Just f -> void $ forkIO $ do
-			fd <- openFd f WriteOnly Nothing defaultFileFlags
-			void $ fdWrite fd url
-			closeFd fd
-#endif
-  where
-	p = case mcmd of
-		Just c -> proc c [htmlshim]
-		Nothing -> 
-#ifndef mingw32_HOST_OS
-			browserProc url
-#else
-			{- Windows hack to avoid using the full path,
-			 - which might contain spaces that cause problems
-			 - for browserProc. -}
-			(browserProc (takeFileName htmlshim))
-				{ cwd = Just (takeDirectory htmlshim) } 
-#endif
-#ifdef __ANDROID__
-	{- Android does not support file:// urls, but neither is
-	 - the security of the url in the process table important
-	 - there, so just use the real url. -}
-	url = realurl
-#else
-	url = fileUrl htmlshim
-#endif
-	runbrowser = do
-		hPutStrLn (fromMaybe stdout outh) $ "Launching web browser on " ++ url
-		hFlush stdout
-		environ <- cleanEnvironment
-		(_, _, _, pid) <- createProcess p
-			{ env = environ
-			, std_out = maybe Inherit UseHandle outh
-			, std_err = maybe Inherit UseHandle errh
-			}
-		exitcode <- waitForProcess pid
-		unless (exitcode == ExitSuccess) $
-			hPutStrLn (fromMaybe stderr errh) "failed to start web browser"
-
-{- web.browser is a generic git config setting for a web browser program -}
-webBrowser :: Git.Repo -> Maybe FilePath
-webBrowser = Git.Config.getMaybe "web.browser"
-
-fileUrl :: FilePath -> String
-fileUrl file = "file://" ++ file
diff --git a/Utility/WebApp.hs b/Utility/WebApp.hs
deleted file mode 100644
index 6fc154329..000000000
--- a/Utility/WebApp.hs
+++ /dev/null
@@ -1,221 +0,0 @@
-{- Yesod webapp
- -
- - Copyright 2012-2014 Joey Hess <id@joeyh.name>
- -
- - License: BSD-2-clause
- -}
-
-{-# LANGUAGE OverloadedStrings, CPP, RankNTypes #-}
-
-module Utility.WebApp where
-
-import Common
-import Utility.Tmp
-import Utility.FileMode
-import Utility.AuthToken
-
-import qualified Yesod
-import qualified Network.Wai as Wai
-import Network.Wai.Handler.Warp
-import Network.Wai.Handler.WarpTLS
-import Network.HTTP.Types
-import qualified Data.CaseInsensitive as CI
-import Network.Socket
-import "crypto-api" Crypto.Random
-import qualified Web.ClientSession as CS
-import qualified Data.ByteString as B
-import qualified Data.Text as T
-import qualified Data.Text.Encoding as TE
-import Blaze.ByteString.Builder.Char.Utf8 (fromText)
-import Blaze.ByteString.Builder (Builder)
-import Control.Arrow ((***))
-import Control.Concurrent
-#ifdef __ANDROID__
-import Data.Endian
-#endif
-
-localhost :: HostName
-localhost = "localhost"
-
-{- Builds a command to use to start or open a web browser showing an url. -}
-browserProc :: String -> CreateProcess
-#ifdef darwin_HOST_OS
-browserProc url = proc "open" [url]
-#else
-#ifdef __ANDROID__
--- Warning: The `am` command does not work very reliably on Android.
-browserProc url = proc "am"
-	["start", "-a", "android.intent.action.VIEW", "-d", url]
-#else
-#ifdef mingw32_HOST_OS
--- Warning: On Windows, no quoting or escaping of the url seems possible,
--- so spaces in it will cause problems. One approach is to make the url
--- be a relative filename, and adjust the returned CreateProcess to change
--- to the directory it's in.
-browserProc url = proc "cmd" ["/c start " ++ url]
-#else
-browserProc url = proc "xdg-open" [url]
-#endif
-#endif
-#endif
-
-{- Binds to a socket on localhost, or possibly a different specified
- - hostname or address, and runs a webapp on it.
- -
- - An IO action can also be run, to do something with the address,
- - such as start a web browser to view the webapp.
- -}
-runWebApp :: Maybe TLSSettings -> Maybe HostName -> Wai.Application -> (SockAddr -> IO ()) -> IO ()
-runWebApp tlssettings h app observer = withSocketsDo $ do
-	sock <- getSocket h
-	void $ forkIO $ go webAppSettings sock app	
-	sockaddr <- fixSockAddr <$> getSocketName sock
-	observer sockaddr
-  where
-	go = (maybe runSettingsSocket (\ts -> runTLSSocket ts) tlssettings)
-
-fixSockAddr :: SockAddr -> SockAddr
-#ifdef __ANDROID__
-{- On Android, the port is currently incorrectly returned in network
- - byte order, which is wrong on little endian systems. -}
-fixSockAddr (SockAddrInet (PortNum port) addr) = SockAddrInet (PortNum $ swapEndian port) addr
-#endif
-fixSockAddr addr = addr
-
--- disable buggy sloworis attack prevention code
-webAppSettings :: Settings
-webAppSettings = setTimeout halfhour defaultSettings
-  where
-	halfhour = 30 * 60
-
-{- Binds to a local socket, or if specified, to a socket on the specified
- - hostname or address. Selects any free port, unless the hostname ends with
- - ":port"
- -
- - Prefers to bind to the ipv4 address rather than the ipv6 address
- - of localhost, if it's available.
- -}
-getSocket :: Maybe HostName -> IO Socket
-getSocket h = do
-#if defined(__ANDROID__) || defined (mingw32_HOST_OS)
-	-- getAddrInfo currently segfaults on Android.
-	-- The HostName is ignored by this code.
-	when (isJust h) $
-		error "getSocket with HostName not supported on this OS"
-	addr <- inet_addr "127.0.0.1"
-	sock <- socket AF_INET Stream defaultProtocol
-	preparesocket sock
-	bind sock (SockAddrInet aNY_PORT addr)
-	use sock
-  where
-#else
-	addrs <- getAddrInfo (Just hints) (Just hostname) Nothing
-	case (partition (\a -> addrFamily a == AF_INET) addrs) of
-		(v4addr:_, _) -> go v4addr
-		(_, v6addr:_) -> go v6addr
-		_ -> error "unable to bind to a local socket"
-  where
-	hostname = fromMaybe localhost h
-	hints = defaultHints { addrSocketType = Stream }
-	{- Repeated attempts because bind sometimes fails for an
-	 - unknown reason on OSX. -} 
-	go addr = go' 100 addr
-	go' :: Int -> AddrInfo -> IO Socket
-	go' 0 _ = error "unable to bind to local socket"
-	go' n addr = do
-		r <- tryIO $ bracketOnError (open addr) close (useaddr addr)
-		either (const $ go' (pred n) addr) return r
-	open addr = socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
-	useaddr addr sock = do
-		preparesocket sock
-		bind sock (addrAddress addr)
-		use sock
-#endif
-	preparesocket sock = setSocketOption sock ReuseAddr 1
-	use sock = do
-		listen sock maxListenQueue
-		return sock
-
-lookupRequestField :: CI.CI B.ByteString -> Wai.Request -> B.ByteString
-lookupRequestField k req = fromMaybe "" . lookup k $ Wai.requestHeaders req
-
-{- Rather than storing a session key on disk, use a random key
- - that will only be valid for this run of the webapp. -}
-webAppSessionBackend :: Yesod.Yesod y => y -> IO (Maybe Yesod.SessionBackend)
-webAppSessionBackend _ = do
-	g <- newGenIO :: IO SystemRandom
-	case genBytes 96 g of
-		Left e -> error $ "failed to generate random key: " ++ show e
-		Right (s, _) -> case CS.initKey s of
-			Left e -> error $ "failed to initialize key: " ++ show e
-			Right key -> use key
-  where
-	timeout = 120 * 60 -- 120 minutes
-	use key =
-		Just . Yesod.clientSessionBackend key . fst
-			<$> Yesod.clientSessionDateCacher timeout
-
-{- A Yesod isAuthorized method, which checks the auth cgi parameter
- - against a token extracted from the Yesod application.
- -
- - Note that the usual Yesod error page is bypassed on error, to avoid
- - possibly leaking the auth token in urls on that page!
- -
- - If the predicate does not match the route, the auth parameter is not
- - needed.
- -}
-checkAuthToken :: Yesod.MonadHandler m => Yesod.RenderRoute site => (Yesod.HandlerSite m -> AuthToken) -> Yesod.Route site -> ([T.Text] -> Bool) -> m Yesod.AuthResult
-checkAuthToken extractAuthToken r predicate
-	| not (predicate (fst (Yesod.renderRoute r))) = return Yesod.Authorized
-	| otherwise = do
-		webapp <- Yesod.getYesod
-		req <- Yesod.getRequest
-		let params = Yesod.reqGetParams req
-		if (toAuthToken =<< lookup "auth" params) == Just (extractAuthToken webapp)
-			then return Yesod.Authorized
-			else Yesod.sendResponseStatus unauthorized401 ()
-
-{- A Yesod joinPath method, which adds an auth cgi parameter to every
- - url matching a predicate, containing a token extracted from the
- - Yesod application.
- - 
- - A typical predicate would exclude files under /static.
- -}
-insertAuthToken :: forall y. (y -> AuthToken)
-	-> ([T.Text] -> Bool)
-	-> y
-	-> T.Text
-	-> [T.Text]
-	-> [(T.Text, T.Text)]
-	-> Builder
-insertAuthToken extractAuthToken predicate webapp root pathbits params =
-	fromText root `mappend` encodePath pathbits' encodedparams
-  where
-	pathbits' = if null pathbits then [T.empty] else pathbits
-	encodedparams = map (TE.encodeUtf8 *** go) params'
-	go "" = Nothing
-	go x = Just $ TE.encodeUtf8 x
-	authparam = (T.pack "auth", fromAuthToken (extractAuthToken webapp))
-	params'
-		| predicate pathbits = authparam:params
-		| otherwise = params
-
-{- Creates a html shim file that's used to redirect into the webapp,
- - to avoid exposing the secret token when launching the web browser. -}
-writeHtmlShim :: String -> String -> FilePath -> IO ()
-writeHtmlShim title url file = viaTmp writeFileProtected file $ genHtmlShim title url
-
-{- TODO: generate this static file using Yesod. -}
-genHtmlShim :: String -> String -> String
-genHtmlShim title url = unlines
-	[ "<html>"
-	, "<head>"
-	, "<title>"++ title ++ "</title>"
-	, "<meta http-equiv=\"refresh\" content=\"1; URL="++url++"\">"
-	, "<body>"
-	, "<p>"
-	, "<a href=\"" ++ url ++ "\">" ++ title ++ "</a>"
-	, "</p>"
-	, "</body>"
-	, "</html>"
-	]
diff --git a/Utility/Yesod.hs b/Utility/Yesod.hs
deleted file mode 100644
index 0223f9fc4..000000000
--- a/Utility/Yesod.hs
+++ /dev/null
@@ -1,56 +0,0 @@
-{- Yesod stuff, that's typically found in the scaffolded site.
- -
- - Also a bit of a compatability layer to make it easier to support yesod
- - 1.1-1.4 in the same code base.
- -
- - Copyright 2012-2014 Joey Hess <id@joeyh.name>
- -
- - Licensed under the GNU GPL version 3 or higher.
- -}
-
-{-# LANGUAGE CPP, RankNTypes, FlexibleContexts #-}
-
-module Utility.Yesod 
-	( module Y
-	, liftH
-#ifndef __NO_TH__
-	, widgetFile
-	, hamletTemplate
-#endif
-#if ! MIN_VERSION_yesod_core(1,2,20)
-	, withUrlRenderer
-#endif
-	) where
-
-import Yesod as Y
-import Yesod.Form.Bootstrap3 as Y hiding (bfs)
-#ifndef __NO_TH__
-import Yesod.Default.Util
-import Language.Haskell.TH.Syntax (Q, Exp)
-import Data.Default (def)
-import Text.Hamlet hiding (Html)
-#endif
-#if ! MIN_VERSION_yesod(1,4,0)
-import Data.Text (Text)
-#endif
-
-#ifndef __NO_TH__
-widgetFile :: String -> Q Exp
-widgetFile = widgetFileNoReload $ def
-	{ wfsHamletSettings = defaultHamletSettings
-		{ hamletNewlines = AlwaysNewlines
-		}
-	}
-
-hamletTemplate :: FilePath -> FilePath
-hamletTemplate f = globFile "hamlet" f
-#endif
-
-{- Lift Handler to Widget -}
-liftH :: Monad m => HandlerT site m a -> WidgetT site m a
-liftH = handlerToWidget
-
-#if ! MIN_VERSION_yesod_core(1,2,20)
-withUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output
-withUrlRenderer = giveUrlRenderer
-#endif
diff --git a/git-annex.cabal b/git-annex.cabal
index 5b87cb04b..d94b1469f 100644
--- a/git-annex.cabal
+++ b/git-annex.cabal
@@ -143,113 +143,6 @@ Extra-Source-Files:
   doc/logo.svg
   doc/logo_16x16.png
   Build/mdwn2man
-  Assistant/WebApp/routes
-  static/activityicon.gif
-  static/css/bootstrap.css
-  static/css/bootstrap-theme.css
-  static/js/jquery.ui.core.js
-  static/js/longpolling.js
-  static/js/jquery.full.js
-  static/js/jquery.ui.sortable.js
-  static/js/jquery.ui.mouse.js
-  static/js/jquery.ui.widget.js
-  static/js/bootstrap.js
-  static/syncicon.gif
-  static/favicon.ico
-  static/fonts/glyphicons-halflings-regular.woff
-  static/fonts/glyphicons-halflings-regular.eot
-  static/fonts/glyphicons-halflings-regular.svg
-  static/fonts/glyphicons-halflings-regular.ttf
-  templates/sidebar/main.hamlet
-  templates/sidebar/alert.hamlet
-  templates/bootstrap.hamlet
-  templates/error.cassius
-  templates/README
-  templates/error.hamlet
-  templates/documentation/license.hamlet
-  templates/documentation/repogroup.hamlet
-  templates/documentation/about.hamlet
-  templates/dashboard/main.hamlet
-  templates/dashboard/transfers.cassius
-  templates/dashboard/transfers.hamlet
-  templates/dashboard/metarefresh.hamlet
-  templates/page.cassius
-  templates/page.hamlet
-  templates/control/repairrepository.hamlet
-  templates/control/repairrepository/done.hamlet
-  templates/control/notrunning.julius
-  templates/control/notrunning.hamlet
-  templates/control/repositoryswitcher.hamlet
-  templates/control/shutdown.hamlet
-  templates/control/log.hamlet
-  templates/page.julius
-  templates/repolist.julius
-  templates/configurators/adddrive/combine.hamlet
-  templates/configurators/adddrive/setupmodal.hamlet
-  templates/configurators/adddrive/encrypt.hamlet
-  templates/configurators/newrepository.hamlet
-  templates/configurators/needglaciercli.hamlet
-  templates/configurators/adds3.hamlet
-  templates/configurators/genkeymodal.hamlet
-  templates/configurators/main.hamlet
-  templates/configurators/needconnection.hamlet
-  templates/configurators/newrepository/form.hamlet
-  templates/configurators/newrepository/first.hamlet
-  templates/configurators/newrepository/combine.hamlet
-  templates/configurators/enablewebdav.hamlet
-  templates/configurators/pairing/local/inprogress.hamlet
-  templates/configurators/pairing/local/prompt.hamlet
-  templates/configurators/pairing/wormhole/prompt.hamlet
-  templates/configurators/pairing/wormhole/start.hamlet
-  templates/configurators/pairing/disabled.hamlet
-  templates/configurators/addglacier.hamlet
-  templates/configurators/fsck.cassius
-  templates/configurators/edit/nonannexremote.hamlet
-  templates/configurators/edit/webrepository.hamlet
-  templates/configurators/edit/repository.hamlet
-  templates/configurators/unused.hamlet
-  templates/configurators/addbox.com.hamlet
-  templates/configurators/ssh/testmodal.hamlet
-  templates/configurators/ssh/expiredpassword.hamlet
-  templates/configurators/ssh/error.hamlet
-  templates/configurators/ssh/combine.hamlet
-  templates/configurators/ssh/enable.hamlet
-  templates/configurators/ssh/add.hamlet
-  templates/configurators/ssh/setupmodal.hamlet
-  templates/configurators/ssh/confirm.hamlet
-  templates/configurators/upgrade/android.hamlet
-  templates/configurators/enableia.hamlet
-  templates/configurators/fsck.hamlet
-  templates/configurators/addrepository/archive.hamlet
-  templates/configurators/addrepository/cloud.hamlet
-  templates/configurators/addrepository/connection.hamlet
-  templates/configurators/addrepository/ssh.hamlet
-  templates/configurators/addrepository/misc.hamlet
-  templates/configurators/addrepository/wormholepairing.hamlet
-  templates/configurators/rsync.net/add.hamlet
-  templates/configurators/rsync.net/encrypt.hamlet
-  templates/configurators/gitlab.com/add.hamlet
-  templates/configurators/needgcrypt.hamlet
-  templates/configurators/needtor.hamlet
-  templates/configurators/needmagicwormhole.hamlet
-  templates/configurators/enabledirectory.hamlet
-  templates/configurators/fsck/status.hamlet
-  templates/configurators/fsck/form.hamlet
-  templates/configurators/fsck/preferencesform.hamlet
-  templates/configurators/fsck/formcontent.hamlet
-  templates/configurators/delete/finished.hamlet
-  templates/configurators/delete/start.hamlet
-  templates/configurators/delete/currentrepository.hamlet
-  templates/configurators/unused/form.hamlet
-  templates/configurators/adddrive.hamlet
-  templates/configurators/preferences.hamlet
-  templates/configurators/addia.hamlet
-  templates/configurators/enableaws.hamlet
-  templates/configurators/addrepository.hamlet
-  templates/actionbutton.hamlet
-  templates/repolist.hamlet
-  templates/controlmenu.hamlet
-  templates/notifications/longpolling.julius
 
 Flag S3
   Description: Enable S3 support
@@ -457,60 +350,6 @@ Executable git-annex
   if flag(AndroidSplice)
     CPP-Options: -DANDROID_SPLICES
 
-  if flag(Webapp)
-    Build-Depends:
-     yesod (>= 1.2.6), 
-     yesod-static (>= 1.2.4),
-     yesod-form (>= 1.3.15),
-     yesod-core (>= 1.2.19),
-     path-pieces (>= 0.1.4),
-     warp (>= 3.0.0.5),
-     warp-tls (>= 1.4),
-     wai,
-     wai-extra,
-     blaze-builder,
-     clientsession,
-     template-haskell,
-     shakespeare (>= 2.0.0)
-    CPP-Options: -DWITH_WEBAPP
-    Other-Modules:
-      Command.WebApp
-      Assistant.Threads.WebApp
-      Assistant.Threads.PairListener
-      Assistant.WebApp
-      Assistant.WebApp.Common
-      Assistant.WebApp.Configurators
-      Assistant.WebApp.Configurators.AWS
-      Assistant.WebApp.Configurators.Delete
-      Assistant.WebApp.Configurators.Edit
-      Assistant.WebApp.Configurators.Fsck
-      Assistant.WebApp.Configurators.IA
-      Assistant.WebApp.Configurators.Local
-      Assistant.WebApp.Configurators.Pairing
-      Assistant.WebApp.Configurators.Preferences
-      Assistant.WebApp.Configurators.Ssh
-      Assistant.WebApp.Configurators.Unused
-      Assistant.WebApp.Configurators.Upgrade
-      Assistant.WebApp.Configurators.WebDAV
-      Assistant.WebApp.Control
-      Assistant.WebApp.DashBoard
-      Assistant.WebApp.Documentation
-      Assistant.WebApp.Form
-      Assistant.WebApp.Gpg
-      Assistant.WebApp.MakeRemote
-      Assistant.WebApp.Notifications
-      Assistant.WebApp.OtherRepos
-      Assistant.WebApp.Page
-      Assistant.WebApp.Pairing
-      Assistant.WebApp.Repair
-      Assistant.WebApp.RepoId
-      Assistant.WebApp.RepoList
-      Assistant.WebApp.SideBar
-      Assistant.WebApp.Types
-      Annex.MakeRepo
-      Utility.Yesod
-      Utility.WebApp
-
   if flag(Pairing)
     Build-Depends: network-multicast, network-info
     CPP-Options: -DWITH_PAIRING