Merge branch '1.11.2-backport' into 1.11.2

Mumfrey
2 parents 434901f7 21dc1eac
Showing 28 changed files with 1433 additions and 440 deletions
build.gradle
src/client/java/com/mumfrey/liteloader/client/gui/GuiPanelLiteLoaderLog.java
src/client/java/com/mumfrey/liteloader/modconfig/AbstractConfigPanel.java
src/main/java/com/mumfrey/liteloader/api/EnumeratorModule.java
src/main/java/com/mumfrey/liteloader/core/EnabledModsList.java
src/main/java/com/mumfrey/liteloader/core/LiteLoaderBootstrap.java
src/main/java/com/mumfrey/liteloader/core/LiteLoaderEnumerator.java
src/main/java/com/mumfrey/liteloader/core/LiteLoaderMods.java
src/main/java/com/mumfrey/liteloader/core/api/EnumeratorModuleClassPath.java
src/main/java/com/mumfrey/liteloader/core/api/EnumeratorModuleFiles.java
src/main/java/com/mumfrey/liteloader/core/api/EnumeratorModuleFolder.java
src/main/java/com/mumfrey/liteloader/core/api/EnumeratorModuleRepository.java
src/main/java/com/mumfrey/liteloader/core/api/LiteLoaderCoreAPI.java
src/main/java/com/mumfrey/liteloader/core/api/repository/Artefact.java
src/main/java/com/mumfrey/liteloader/core/api/repository/JsonResolver.java
src/main/java/com/mumfrey/liteloader/core/api/repository/Repository.java
src/main/java/com/mumfrey/liteloader/interfaces/LoadableFile.java
src/main/java/com/mumfrey/liteloader/interfaces/MixinContainer.java
src/main/java/com/mumfrey/liteloader/launch/GameEnvironment.java
src/main/java/com/mumfrey/liteloader/launch/LiteLoaderTweaker.java
@@ -72,7 +72,7 @@ repositories {
 }
  
 dependencies {
-    compile('org.spongepowered:mixin:0.7.1-SNAPSHOT') {
+    compile('org.spongepowered:mixin:0.7.3-SNAPSHOT') {
         exclude module: 'asm-commons'
         exclude module: 'asm-tree'
         exclude module: 'launchwrapper'
@@ -290,6 +290,9 @@ class GuiPanelLiteLoaderLog extends GuiPanel implements ScrollPanelContent
         if (logLine.startsWith("tweakClass '")) return 0x5555FF;
         if (logLine.startsWith("baking listener list")) return 0x00AAAA;
         if (logLine.startsWith("generating new event handler")) return 0xFFFF55;
+        if (logLine.startsWith("resolving mods")) return 0xFFAA00;
+        if (logLine.startsWith("resolved artefact")) return 0x00AA00;
+        if (logLine.startsWith("evicting")) return 0xFFAA00;
  
         return 0xCCCCCC;
     }
@@ -105,7 +105,7 @@ public abstract class AbstractConfigPanel implements ConfigPanel
     /**
      * Base for config option handle structs
      */
-    static abstract class ConfigOption
+    abstract static class ConfigOption
     {
         void onTick()
         {
@@ -303,7 +303,7 @@ public abstract class AbstractConfigPanel implements ConfigPanel
         @Override
         public ConfigTextField setRegex(String regex, boolean force)
         {
-            this.textField.setRegex(Pattern.compile(regex), force);;
+            this.textField.setRegex(Pattern.compile(regex), force);
             return this;
         }
  
@@ -343,7 +343,8 @@ public abstract class AbstractConfigPanel implements ConfigPanel
                 }
             else
             {
-                this.setValidator((text) -> {
+                this.setValidator((text) ->
+                {
                     this.validate(text);
                 return true;
                 });
@@ -36,10 +36,7 @@ public interface EnumeratorModule
     public abstract void writeSettings(LoaderEnvironment environment, LoaderProperties properties);
  
     /**
-     * Find loadable mods in this enumerator's domain, the enumerator module
-     * should call back against the enumerator itself to register containers it
-     * discovers using the registerModContainer() and registerTweakContainer()
-     * callbacks.
+     * Find loadable mods in this enumerator's domain.
      * 
      * <p>This method is called during loader PREINIT phase so <b>do not use any
      * game classes here</b>!</p>
@@ -48,6 +45,20 @@ public interface EnumeratorModule
      * @param profile
      */
     public abstract void enumerate(ModularEnumerator enumerator, String profile);
+    
+    /**
+     * Register loadable mods discovered in this enumerator's domain during the
+     * call to {@link #enumerate}, the enumerator module should call back
+     * against the enumerator itself to register containers it discovers using
+     * the registerModContainer() and registerTweakContainer() callbacks.
+     * 
+     * <p>This method is called during loader PREINIT phase so <b>do not use any
+     * game classes here</b>!</p>
+     * 
+     * @param enumerator
+     * @param profile
+     */
+    public abstract void register(ModularEnumerator enumerator, String profile);
  
     /**
      * The enumerator module should inject (as required) any discovered
@@ -8,7 +8,6 @@ package com.mumfrey.liteloader.core;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
-import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -186,12 +185,9 @@ public final class EnabledModsList
     {
         if (file.exists())
         {
-            FileReader reader = null;
-
-            try
+            try (FileReader reader = new FileReader(file))
             {
-                reader = new FileReader(file);
-                EnabledModsList instance = gson.fromJson(reader, EnabledModsList.class);
+                EnabledModsList instance = EnabledModsList.gson.fromJson(reader, EnabledModsList.class);
                 instance.setEnabledModsFile(file);
                 return instance;
             }
@@ -199,20 +195,6 @@ public final class EnabledModsList
             {
                 ex.printStackTrace();
             }
-            finally
-            {
-                try
-                {
-                    if (reader != null)
-                    {
-                        reader.close();
-                    }
-                }
-                catch (IOException ex)
-                {
-                    ex.printStackTrace();
-                }
-            }
         }
  
         EnabledModsList instance = new EnabledModsList();
@@ -229,31 +211,14 @@ public final class EnabledModsList
     {
         if (!this.allowSave) return;
  
-        FileWriter writer = null;
-
-        try
+        try (FileWriter writer = new FileWriter(file))
         {
-            writer = new FileWriter(file);
-            gson.toJson(this, writer);
+            EnabledModsList.gson.toJson(this, writer);
         }
         catch (Exception ex)
         {
             ex.printStackTrace();
         }
-        finally
-        {
-            try
-            {
-                if (writer != null)
-                {
-                    writer.close();
-                }
-            }
-            catch (IOException ex)
-            {
-                ex.printStackTrace();
-            }
-        }
     }
  
     /**
@@ -29,6 +29,7 @@ import com.mumfrey.liteloader.api.manager.APIProvider;
 import com.mumfrey.liteloader.api.manager.APIRegistry;
 import com.mumfrey.liteloader.common.LoadingProgress;
 import com.mumfrey.liteloader.core.api.LiteLoaderCoreAPI;
+import com.mumfrey.liteloader.core.api.repository.Repository;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
 import com.mumfrey.liteloader.launch.ClassTransformerManager;
 import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
@@ -102,6 +103,16 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
      * Folder containing version-specific configuration
      */
     private final File versionConfigFolder;
+    
+    /**
+     * Mods repo file
+     */
+    private final String repositoryFile;
+    
+    /**
+     * Mod repository defined in JSON
+     */
+    private final Repository repository;
  
     /**
      * File to write log entries to
@@ -138,6 +149,8 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
  
     private LaunchClassLoader classLoader; 
  
+    private final StartupEnvironment env;
+
     private final ITweaker tweaker;
  
     private final APIRegistry apiRegistry;
@@ -157,7 +170,7 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
      * List of mods passed into the command line
      */
     private EnabledModsList enabledModsList;
-
+    
     /**
      * @param env
      * @param tweaker
@@ -165,6 +178,7 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
     public LiteLoaderBootstrap(StartupEnvironment env, ITweaker tweaker)
     {
         this.environmentType     = EnvironmentType.values()[env.getEnvironmentTypeId()];
+        this.env                 = env;
         this.tweaker             = tweaker;
  
         this.apiRegistry         = new APIRegistry(this.getEnvironment(), this.getProperties());
@@ -173,6 +187,7 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
         this.assetsDirectory     = env.getAssetsDirectory();
         this.profile             = env.getProfile();
         this.modsFolder          = env.getModsFolder();
+        this.repositoryFile      = env.getModsRepoFile();
  
         this.versionedModsFolder = new File(this.modsFolder,       LiteLoaderVersion.CURRENT.getMinecraftVersion());
         this.configBaseFolder    = new File(this.gameDirectory,    "liteconfig");
@@ -183,17 +198,27 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
         this.commonConfigFolder  = new File(this.configBaseFolder, "common");
         this.versionConfigFolder = this.inflectVersionedConfigPath(LiteLoaderVersion.CURRENT);
  
-        if (!this.modsFolder.exists()) this.modsFolder.mkdirs();
-        if (!this.versionedModsFolder.exists()) this.versionedModsFolder.mkdirs();
-        if (!this.configBaseFolder.exists()) this.configBaseFolder.mkdirs();
-        if (!this.commonConfigFolder.exists()) this.commonConfigFolder.mkdirs();
-        if (!this.versionConfigFolder.exists()) this.versionConfigFolder.mkdirs();
+        this.repository = new Repository(this.gameDirectory, this.versionedModsFolder);
+
+        this.mkdir(this.modsFolder);
+        this.mkdir(this.versionedModsFolder);
+        this.mkdir(this.configBaseFolder);
+        this.mkdir(this.commonConfigFolder);
+        this.mkdir(this.versionConfigFolder);
  
         this.initAPIs(env.getAPIsToLoad());
         this.apiProvider = this.apiRegistry.getProvider();
         this.apiAdapter = this.apiRegistry.getAdapter();
     }
  
+    private void mkdir(File dir)
+    {
+        if (!dir.isDirectory())
+        {
+            dir.mkdirs();
+        }
+    }
+
     /**
      * @param version
      */
@@ -249,6 +274,12 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
     {
         return this.enabledModsList;
     }
+    
+    @Override
+    public Repository getModRepository()
+    {
+        return this.repository;
+    }
  
     @Override
     public LoaderEnumerator getEnumerator()
@@ -301,15 +332,20 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
      *      #preInit(net.minecraft.launchwrapper.LaunchClassLoader, boolean)
      */
     @Override
-    public void preInit(LaunchClassLoader classLoader, boolean loadTweaks, List<String> modsToLoad)
+    public void preInit(LaunchClassLoader classLoader, boolean loadTweaks)
     {
+        List<String> modsToLoad = this.env.getModFilterList();
+
         this.classLoader = classLoader;
         this.loadTweaks = loadTweaks;
  
         LiteLoaderLogger.info(Verbosity.REDUCED, "LiteLoader begin PREINIT...");
  
         // Set up the bootstrap
-        if (!this.prepare()) return;
+        if (!this.prepare())
+        {
+            return;
+        }
  
         LiteLoaderLogger.info(Verbosity.REDUCED, "LiteLoader %s starting up...", LiteLoaderVersion.CURRENT.getLoaderVersion());
  
@@ -323,7 +359,7 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
  
         this.enabledModsList = EnabledModsList.createFrom(this.enabledModsFile);
         this.enabledModsList.processModsList(this.profile, modsToLoad);
-
+        
         this.enumerator = this.spawnEnumerator(classLoader);
         this.enumerator.onPreInit();
  
@@ -599,6 +635,16 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
     {
         return this.versionConfigFolder;
     }
+    
+    /**
+     * Get the path to a JSON file describing a mod repository layout, can be
+     * null if not defined
+     */
+    @Override
+    public String getModsRepoFile()
+    {
+        return this.repositoryFile;
+    }
  
     /**
      * Get a boolean propery from the properties file and also write the new
@@ -122,7 +122,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
     private final FastIterableDeque<EnumerationObserver> observers = new HandlerList<EnumerationObserver>(EnumerationObserver.class);
  
     protected EnumeratorState state = EnumeratorState.INIT;
-
+    
     /**
      * @param environment
      * @param properties
@@ -144,7 +144,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
         // Initialise the shared mod list if we haven't already
         this.getSharedModList();
     }
-
+    
     /**
      * @param environment
      */
@@ -397,11 +397,13 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
     {
         this.gotoState(EnumeratorState.DISCOVER);
  
+        String profile = this.environment.getProfile();
+        
         for (EnumeratorModule module : this.modules)
         {
             try
             {
-                module.enumerate(this, this.environment.getProfile());
+                module.enumerate(this, profile);
             }
             catch (Throwable th)
             {
@@ -409,6 +411,18 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
             }
         }
  
+        for (EnumeratorModule module : this.modules)
+        {
+            try
+            {
+                module.register(this, profile);
+            }
+            catch (Throwable th)
+            {
+                LiteLoaderLogger.warning(th, "Enumerator Module %s encountered an error whilst enumerating", module.getClass().getName());
+            }
+        }
+        
         this.checkDependencies();
     }
  
@@ -651,7 +665,15 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
                 if (config.endsWith(".json"))
                 {
                     LiteLoaderLogger.info(Verbosity.REDUCED, "Registering mixin config %s for %s", config, container.getName());
-                    Mixins.addConfiguration(config);
+                    try
+                    {
+                        Mixins.addConfiguration(config);
+                    }
+                    catch (Throwable th)
+                    {
+                        LiteLoaderLogger.severe(th, "Error registering mixin config %s for %s", config, container);
+                        container.registerMixinError(th);
+                    }
                 }
                 else if (config.contains(".json@"))
                 {
@@ -24,6 +24,7 @@ import com.mumfrey.liteloader.interfaces.FastIterableDeque;
 import com.mumfrey.liteloader.interfaces.Loadable;
 import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
+import com.mumfrey.liteloader.interfaces.MixinContainer;
 import com.mumfrey.liteloader.interfaces.TweakContainer;
 import com.mumfrey.liteloader.launch.ClassTransformerManager;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
@@ -444,6 +445,12 @@ public class LiteLoaderMods
                 String identifier = mod.getIdentifier();
                 if (identifier == null || this.environment.getEnabledModsList().isEnabled(this.environment.getProfile(), identifier))
                 {
+                    if (!this.validateMixins(mod, container))
+                    {
+                        this.onModLoadFailed(container, identifier, "mixins for the specified mod encountered a startup error", null);
+                        continue;
+                    }
+                    
                     if (!this.enumerator.checkDependencies(container))
                     {
                         this.onModLoadFailed(container, identifier, "the mod was missing a required dependency", null);
@@ -474,6 +481,23 @@ public class LiteLoaderMods
             this.observers.all().onPostModLoaded(mod);
         }
     }
+    
+    private boolean validateMixins(ModInfo<?> mod, LoadableMod<?> container)
+    {
+        if (container instanceof MixinContainer)
+        {
+            @SuppressWarnings("unchecked")
+            Collection<Throwable> errors = ((MixinContainer<File>)container).getMixinErrors();
+            for (Throwable error : errors)
+            {
+                this.registerModStartupError(mod, error, true);
+            }
+            
+            return errors.size() == 0;
+        }
+        
+        return true;
+    }
  
     /**
      * @param identifier
@@ -697,26 +721,28 @@ public class LiteLoaderMods
  
         for (Mod mod : this.loadedMods)
         {
-            if (mod.hasClassTransformers())
+            if (!mod.hasClassTransformers())
             {
-                List<String> modTransformers = ((TweakContainer<?>)mod.getContainer()).getClassTransformerClassNames();
-                for (String modTransformer : modTransformers)
+                continue;
+            }
+            
+            List<String> modTransformers = ((TweakContainer<?>)mod.getContainer()).getClassTransformerClassNames();
+            for (String modTransformer : modTransformers)
+            {
+                if (!injectedTransformers.contains(modTransformer))
                 {
-                    if (!injectedTransformers.contains(modTransformer))
+                    List<Throwable> throwables = transformerManager.getTransformerStartupErrors(modTransformer);
+                    if (throwables != null)
                     {
-                        List<Throwable> throwables = transformerManager.getTransformerStartupErrors(modTransformer);
-                        if (throwables != null)
+                        for (Throwable th : throwables)
                         {
-                            for (Throwable th : throwables)
-                            {
-                                this.registerModStartupError(mod, th, true);
-                            }
-                        }
-                        else
-                        {
-                            this.registerModStartupError(mod, new RuntimeException("Missing class transformer " + modTransformer), true);
+                            this.registerModStartupError(mod, th, true);
                         }
                     }
+                    else
+                    {
+                        this.registerModStartupError(mod, new RuntimeException("Missing class transformer " + modTransformer), true);
+                    }
                 }
             }
         }
@@ -765,7 +791,11 @@ public class LiteLoaderMods
     private void registerModStartupError(ModInfo<?> mod, Throwable th, boolean critical)
     {
         this.startupErrorCount++;
-        if (critical) this.criticalErrorCount++;
+        if (critical)
+        {
+            this.criticalErrorCount++;
+        }
+        
         mod.registerStartupError(th);
  
         if (!this.loadedMods.contains(mod) && !this.disabledMods.contains(mod))
@@ -82,37 +82,43 @@ public class EnumeratorModuleClassPath implements EnumeratorModule
     @Override
     public void enumerate(ModularEnumerator enumerator, String profile)
     {
-        if (this.loadTweaks)
+    }
+    
+    @Override
+    public void register(ModularEnumerator enumerator, String profile)
+    {
+        if (!this.loadTweaks)
         {
-            LiteLoaderLogger.info("Discovering tweaks on class path...");
-
-            for (String classPathPart : this.classPathEntries)
+            return;
+        }
+        
+        LiteLoaderLogger.info("Discovering tweaks on class path...");
+        for (String classPathPart : this.classPathEntries)
+        {
+            try
             {
-                try
+                File packagePath = new File(classPathPart);
+                if (packagePath.exists())
                 {
-                    File packagePath = new File(classPathPart);
-                    if (packagePath.exists())
+                    LoadableModClassPath classPathMod = new LoadableModClassPath(packagePath);
+                    if (enumerator.registerModContainer(classPathMod))
                     {
-                        LoadableModClassPath classPathMod = new LoadableModClassPath(packagePath);
-                        if (enumerator.registerModContainer(classPathMod))
+                        this.loadableMods.add(classPathMod);
+                        if (classPathMod.requiresPreInitInjection())
                         {
-                            this.loadableMods.add(classPathMod);
-                            if (classPathMod.requiresPreInitInjection())
-                            {
-                                enumerator.registerTweakContainer(classPathMod);
-                            }
-                        }
-                        else
-                        {
-                            LiteLoaderLogger.info(Verbosity.REDUCED, "Mod %s is disabled or missing a required dependency, not injecting tranformers",
-                                    classPathMod.getIdentifier());
+                            enumerator.registerTweakContainer(classPathMod);
                         }
                     }
+                    else
+                    {
+                        LiteLoaderLogger.info(Verbosity.REDUCED, "Mod %s is disabled or missing a required dependency, not injecting tranformers",
+                                classPathMod.getIdentifier());
+                    }
                 }
-                catch (Throwable th)
-                {
-                    LiteLoaderLogger.warning(th, "Error encountered whilst inspecting %s", classPathPart);
-                }
+            }
+            catch (Throwable th)
+            {
+                LiteLoaderLogger.warning(th, "Error encountered whilst inspecting %s", classPathPart);
             }
         }
     }
+/*
+ * This file is part of LiteLoader.
+ * Copyright (C) 2012-16 Adam Mummery-Smith
+ * All Rights Reserved.
+ */
+package com.mumfrey.liteloader.core.api;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.net.MalformedURLException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import com.google.common.base.Charsets;
+import com.mumfrey.liteloader.api.EnumeratorModule;
+import com.mumfrey.liteloader.common.LoadingProgress;
+import com.mumfrey.liteloader.core.LiteLoaderVersion;
+import com.mumfrey.liteloader.core.api.EnumeratorModuleFiles.ContainerEnvironment.Candidate;
+import com.mumfrey.liteloader.interfaces.LoadableFile;
+import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.interfaces.ModularEnumerator;
+import com.mumfrey.liteloader.interfaces.TweakContainer;
+import com.mumfrey.liteloader.launch.LoaderEnvironment;
+import com.mumfrey.liteloader.launch.LoaderProperties;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
+
+import net.minecraft.launchwrapper.LaunchClassLoader;
+
+public abstract class EnumeratorModuleFiles implements FilenameFilter, EnumeratorModule
+{
+    public static class ContainerEnvironment implements Iterable<ContainerEnvironment.Candidate>
+    {
+        static class Candidate
+        {
+            private final Set<LoadableMod<File>> availableFiles = new TreeSet<LoadableMod<File>>();
+            
+            private boolean isRegistered;
+
+            public void add(LoadableMod<File> modFile)
+            {
+                if (!this.isRegistered)
+                {
+                    this.availableFiles.add(modFile);
+                }
+            }
+            
+            public LoadableMod<File> getNewestVersion()
+            {
+                return this.availableFiles.iterator().next();
+            }
+            
+            public boolean isRegistered()
+            {
+                return this.isRegistered;
+            }
+            
+            public void register()
+            {
+                this.isRegistered = true;
+            }
+        }
+        
+        /**
+         * Ordered sets used to sort mods by version/revision  
+         */
+        private final Map<String, Candidate> orderedCandidates = new LinkedHashMap<String, Candidate>();
+
+        public void addCandidate(LoadableMod<File> modFile)
+        {
+            if (!this.orderedCandidates.containsKey(modFile.getModName()))
+            {
+                this.orderedCandidates.put(modFile.getModName(), new Candidate());
+            }
+
+            LiteLoaderLogger.info("Considering valid mod file: %s", modFile);
+            this.orderedCandidates.get(modFile.getModName()).add(modFile);
+        }
+        
+        @Override
+        public Iterator<Candidate> iterator()
+        {
+            return this.orderedCandidates.values().iterator();
+        }
+    }
+    
+    /**
+     * Ordered sets used to sort mods by version/revision  
+     */
+    private final ContainerEnvironment containers;
+
+    /**
+     * Mods to add once init is completed
+     */
+    private final List<LoadableMod<File>> loadableMods = new ArrayList<LoadableMod<File>>();
+
+    protected final LiteLoaderCoreAPI api;
+
+    public EnumeratorModuleFiles(LiteLoaderCoreAPI api, ContainerEnvironment containers)
+    {
+        this.api = api;
+        this.containers = containers;
+    }
+
+    protected abstract boolean readJarFiles();
+
+    protected abstract boolean loadTweakJars();
+
+    protected abstract boolean loadTweaks();
+
+    protected abstract boolean forceInjection();
+
+    protected abstract File[] getFiles();
+
+    @Override
+    public void init(LoaderEnvironment environment, LoaderProperties properties)
+    {
+    }
+
+    /**
+     * Write settings
+     */
+    @Override
+    public void writeSettings(LoaderEnvironment environment, LoaderProperties properties)
+    {
+    }
+
+    /* (non-Javadoc)
+     * @see com.mumfrey.liteloader.core.Enumerator#getLoadableMods()
+     */
+    public List<LoadableMod<File>> getLoadableMods()
+    {
+        return this.loadableMods;
+    }
+
+    /**
+     * For FilenameFilter interface
+     * 
+     * @see java.io.FilenameFilter#accept(java.io.File, java.lang.String)
+     */
+    @Override
+    public boolean accept(File dir, String fileName)
+    {
+        fileName = fileName.toLowerCase();
+
+        if (fileName.endsWith(".litemod.zip"))
+        {
+            LiteLoaderLogger.warning("Found %s with unsupported extension .litemod.zip."
+                    + " Please change file extension to .litemod to allow this file to be loaded!", fileName);
+            return true;
+        }
+
+        return fileName.endsWith(".litemod") || fileName.endsWith(".jar");
+    }
+
+    /**
+     * Search the folder for (potentially) valid files
+     */
+    protected void findValidFiles(ModularEnumerator enumerator)
+    {
+        for (File file : this.getFiles())
+        {
+            LoadableFile candidateFile = new LoadableFile(file);
+            candidateFile.setForceInjection(this.forceInjection());
+            try
+            {
+                this.inspectFile(enumerator, candidateFile);
+            }
+            catch (Exception ex)
+            {
+                LiteLoaderLogger.warning(ex, "An error occurred whilst inspecting %s", candidateFile);
+            }
+        }
+    }
+
+    /**
+     * Check whether a particular file is valid, and add it to the candiates
+     * list if it appears to be acceptable.
+     * 
+     * @param enumerator
+     * @param candidateFile
+     */
+    protected void inspectFile(ModularEnumerator enumerator, LoadableFile candidateFile)
+    {
+        if (this.isValidFile(enumerator, candidateFile))
+        {
+            String metaData = candidateFile.getFileContents(LoadableMod.METADATA_FILENAME, Charsets.UTF_8);
+            if (metaData != null)
+            {
+                LoadableMod<File> modFile = this.getModFile(candidateFile, metaData);
+                this.addModFile(enumerator, modFile);
+                return;
+            }
+            else if (this.isValidTweakContainer(candidateFile))
+            {
+                TweakContainer<File> container = this.getTweakFile(candidateFile);
+                this.addTweakFile(enumerator, container);
+                return;
+            }
+            else
+            {
+                LiteLoaderLogger.info("Ignoring %s", candidateFile);
+//                enumerator.registerBadContainer(candidateFile, "No metadata");
+            }
+        }
+//        else
+//        {
+//            enumerator.registerBadContainer(candidateFile, "Not a valid file");
+//        }
+    }
+
+    /**
+     * Check whether the specified file is a valid mod container
+     * 
+     * @param enumerator
+     * @param candidateFile
+     */
+    protected boolean isValidFile(ModularEnumerator enumerator, LoadableFile candidateFile)
+    {
+        String filename = candidateFile.getName().toLowerCase();
+        if (filename.endsWith(".litemod.zip"))
+        {
+            enumerator.registerBadContainer(candidateFile, "Invalid file extension .litemod.zip");
+            return false;
+        }
+        else if (filename.endsWith(".litemod"))
+        {
+            return true;
+        }
+        else if (filename.endsWith(".jar"))
+        {
+            Set<String> modSystems = candidateFile.getModSystems();
+            boolean hasLiteLoader = modSystems.contains("LiteLoader");
+            if (modSystems.size() > 0)
+            {
+                LiteLoaderLogger.info("%s supports mod systems %s", candidateFile, modSystems);
+                if (!hasLiteLoader) return false;
+            }
+
+            return this.loadTweakJars() || this.readJarFiles() || hasLiteLoader;
+        }
+
+        return false;
+    }
+
+    /**
+     * Called only if the file is not a valid mod container (has no mod
+     * metadata) to check whether it could instead be a potential tweak
+     * container.
+     * 
+     * @param candidateFile
+     */
+    protected boolean isValidTweakContainer(LoadableFile candidateFile)
+    {
+        return this.loadTweakJars() && this.loadTweaks() && candidateFile.getName().toLowerCase().endsWith(".jar");
+    }
+
+    /**
+     * Get the {@link FilenameFilter} to use to filter candidate files
+     */
+    protected FilenameFilter getFilenameFilter()
+    {
+        return this;
+    }
+
+    /**
+     * @param modFile
+     */
+    protected boolean isFileSupported(LoadableMod<File> modFile)
+    {
+        return LiteLoaderVersion.CURRENT.isVersionSupported(modFile.getTargetVersion());
+    }
+
+    /**
+     * @param candidateFile
+     * @param metaData
+     */
+    protected LoadableMod<File> getModFile(LoadableFile candidateFile, String metaData)
+    {
+        return new LoadableModFile(candidateFile, metaData);
+    }
+
+    /**
+     * @param candidateFile
+     */
+    protected TweakContainer<File> getTweakFile(LoadableFile candidateFile)
+    {
+        return candidateFile;
+    }
+
+    /**
+     * @param enumerator 
+     * @param modFile
+     */
+    protected void addModFile(ModularEnumerator enumerator, LoadableMod<File> modFile)
+    {
+        if (modFile.hasValidMetaData())
+        {
+            // Only add the mod if the version matches, we add candidates to the versionOrderingSets in
+            // order to determine the most recent version available.
+            if (this.isFileSupported(modFile))
+            {
+                this.containers.addCandidate(modFile);
+            }
+            else
+            {
+                LiteLoaderLogger.info(Verbosity.REDUCED, "Not adding invalid or version-mismatched mod file: %s", modFile);
+                enumerator.registerBadContainer(modFile, "Version not supported");
+            }
+        }
+    }
+
+    /**
+     * @param enumerator
+     * @param container
+     */
+    protected void addTweakFile(ModularEnumerator enumerator, TweakContainer<File> container)
+    {
+        enumerator.registerTweakContainer(container);
+    }
+
+    /**
+     * @param enumerator 
+     */
+    protected void sortAndRegisterFiles(ModularEnumerator enumerator)
+    {
+        // Copy the first entry in every version set into the modfiles list
+        for (Candidate candidate : this.containers)
+        {
+            if (candidate.isRegistered())
+            {
+                continue;
+            }
+            
+            LoadableMod<File> newestVersion = candidate.getNewestVersion();
+            this.registerFile(enumerator, newestVersion);
+            candidate.register();
+        }
+    }
+
+    /**
+     * @param enumerator
+     * @param modFile
+     */
+    @SuppressWarnings("unchecked")
+    protected void registerFile(ModularEnumerator enumerator, LoadableMod<File> modFile)
+    {
+        if (enumerator.registerModContainer(modFile))
+        {
+            LiteLoaderLogger.info(Verbosity.REDUCED, "Adding newest valid mod file '%s' at revision %.4f", modFile, modFile.getRevision());
+            this.loadableMods.add(modFile);
+        }
+        else
+        {
+            LiteLoaderLogger.info(Verbosity.REDUCED, "Not adding valid mod file '%s', the specified mod is disabled or missing a required dependency",
+                    modFile);
+        }
+
+        if (this.loadTweaks())
+        {
+            try
+            {
+                if (modFile instanceof TweakContainer)
+                {
+                    this.addTweakFile(enumerator, (TweakContainer<File>)modFile);
+                }
+            }
+            catch (Throwable th)
+            {
+                LiteLoaderLogger.warning("Error adding tweaks from '%s'", modFile);
+            }
+        }
+    }
+
+    @Override
+    public void injectIntoClassLoader(ModularEnumerator enumerator, LaunchClassLoader classLoader)
+    {
+        LiteLoaderLogger.info("Injecting external mods into class path...");
+
+        for (LoadableMod<?> loadableMod : this.loadableMods)
+        {
+            try
+            {
+                if (loadableMod.injectIntoClassPath(classLoader, false))
+                {
+                    LiteLoaderLogger.info("Successfully injected mod file '%s' into classpath", loadableMod);
+                }
+            }
+            catch (MalformedURLException ex)
+            {
+                LiteLoaderLogger.warning("Error injecting '%s' into classPath. The mod will not be loaded", loadableMod);
+            }
+        }
+    }
+
+    @Override
+    public void registerMods(ModularEnumerator enumerator, LaunchClassLoader classLoader)
+    {
+        LiteLoaderLogger.info(Verbosity.REDUCED, "Discovering mods in valid mod files...");
+        LoadingProgress.incTotalLiteLoaderProgress(this.loadableMods.size());
+
+        for (LoadableMod<?> modFile : this.loadableMods)
+        {
+            LoadingProgress.incLiteLoaderProgress("Searching for mods in " + modFile.getModName() + "...");
+            LiteLoaderLogger.info("Searching %s...", modFile);
+            try
+            {
+                enumerator.registerModsFrom(modFile, true);
+            }
+            catch (Exception ex)
+            {
+                LiteLoaderLogger.warning("Error encountered whilst searching in %s...", modFile);
+            }
+        }
+    }
+}
@@ -6,50 +6,19 @@
 package com.mumfrey.liteloader.core.api;
  
 import java.io.File;
-import java.io.FilenameFilter;
-import java.net.MalformedURLException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeSet;
  
-import com.google.common.base.Charsets;
-import com.mumfrey.liteloader.api.EnumeratorModule;
-import com.mumfrey.liteloader.common.LoadingProgress;
-import com.mumfrey.liteloader.core.LiteLoaderVersion;
-import com.mumfrey.liteloader.interfaces.LoadableFile;
-import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.ModularEnumerator;
-import com.mumfrey.liteloader.interfaces.TweakContainer;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
-import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
-
-import net.minecraft.launchwrapper.LaunchClassLoader;
  
 /**
  * Enumerator module which searches for mods and tweaks in a folder
  * 
  * @author Adam Mummery-Smith
  */
-public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
+public class EnumeratorModuleFolder extends EnumeratorModuleFiles
 {
-    /**
-     * Ordered sets used to sort mods by version/revision  
-     */
-    protected final Map<String, TreeSet<LoadableMod<File>>> versionOrderingSets = new HashMap<String, TreeSet<LoadableMod<File>>>();
-
-    /**
-     * Mods to add once init is completed
-     */
-    protected final List<LoadableMod<File>> loadableMods = new ArrayList<LoadableMod<File>>();
-
-    protected LiteLoaderCoreAPI coreAPI;
-
     protected File directory;
  
     protected boolean readJarFiles;
@@ -62,13 +31,13 @@ public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
      */
     protected final boolean loadTweakJars;
  
-    public EnumeratorModuleFolder(LiteLoaderCoreAPI coreAPI, File directory, boolean loadTweakJars)
+    public EnumeratorModuleFolder(LiteLoaderCoreAPI api, ContainerEnvironment containers, File directory, boolean loadTweakJars)
     {
-        this.coreAPI         = coreAPI;
-        this.directory       = directory;
-        this.loadTweakJars   = loadTweakJars;
+        super(api, containers);
+        this.directory = directory;
+        this.loadTweakJars = loadTweakJars;
     }
-
+    
     @Override
     public void init(LoaderEnvironment environment, LoaderProperties properties)
     {
@@ -76,7 +45,7 @@ public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
         this.readJarFiles = properties.getAndStoreBooleanProperty(LoaderProperties.OPTION_SEARCH_JARFILES, true);
         this.forceInjection = properties.getAndStoreBooleanProperty(LoaderProperties.OPTION_FORCE_INJECTION, false);
  
-        this.coreAPI.writeDiscoverySettings();
+        this.api.writeDiscoverySettings();
     }
  
     /**
@@ -88,6 +57,36 @@ public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
         properties.setBooleanProperty(LoaderProperties.OPTION_SEARCH_JARFILES, this.readJarFiles);
         properties.setBooleanProperty(LoaderProperties.OPTION_FORCE_INJECTION, this.forceInjection);
     }
+    
+    @Override
+    protected boolean forceInjection()
+    {
+        return this.forceInjection;
+    }
+    
+    @Override
+    protected boolean loadTweakJars()
+    {
+        return this.loadTweakJars;
+    }
+    
+    @Override
+    protected boolean loadTweaks()
+    {
+        return this.loadTweaks;
+    }
+    
+    @Override
+    protected boolean readJarFiles()
+    {
+        return this.readJarFiles;
+    }
+
+    @Override
+    protected File[] getFiles()
+    {
+        return this.directory.listFiles(this.getFilenameFilter());
+    }
  
     /* (non-Javadoc)
      * @see java.lang.Object#toString()
@@ -107,34 +106,6 @@ public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
     }
  
     /* (non-Javadoc)
-     * @see com.mumfrey.liteloader.core.Enumerator#getLoadableMods()
-     */
-    public List<LoadableMod<File>> getLoadableMods()
-    {
-        return this.loadableMods;
-    }
-
-    /**
-     * For FilenameFilter interface
-     * 
-     * @see java.io.FilenameFilter#accept(java.io.File, java.lang.String)
-     */
-    @Override
-    public boolean accept(File dir, String fileName)
-    {
-        fileName = fileName.toLowerCase();
-
-        if (fileName.endsWith(".litemod.zip"))
-        {
-            LiteLoaderLogger.warning("Found %s with unsupported extension .litemod.zip."
-                    + " Please change file extension to .litemod to allow this file to be loaded!", fileName);
-            return true;
-        }
-
-        return fileName.endsWith(".litemod") || fileName.endsWith(".jar");
-    }
-
-    /* (non-Javadoc)
      * @see com.mumfrey.liteloader.core.Enumerator
      *      #enumerate(com.mumfrey.liteloader.core.EnabledModsList,
      *      java.lang.String)
@@ -145,272 +116,22 @@ public class EnumeratorModuleFolder implements FilenameFilter, EnumeratorModule
         if (this.directory.exists() && this.directory.isDirectory())
         {
             LiteLoaderLogger.info("Discovering valid mod files in folder %s", this.directory.getPath());
-
             this.findValidFiles(enumerator);
-            this.sortAndRegisterFiles(enumerator);
-        }
-    }
-
-    /**
-     * Search the folder for (potentially) valid files
-     */
-    private void findValidFiles(ModularEnumerator enumerator)
-    {
-        for (File file : this.directory.listFiles(this.getFilenameFilter()))
-        {
-            LoadableFile candidateFile = new LoadableFile(file);
-            candidateFile.setForceInjection(this.forceInjection);
-            try
-            {
-                this.inspectFile(enumerator, candidateFile);
-            }
-            catch (Exception ex)
-            {
-                LiteLoaderLogger.warning(ex, "An error occurred whilst inspecting %s", candidateFile);
-            }
         }
     }
-
-    /**
-     * Check whether a particular file is valid, and add it to the candiates
-     * list if it appears to be acceptable.
-     * 
-     * @param enumerator
-     * @param candidateFile
-     */
-    protected void inspectFile(ModularEnumerator enumerator, LoadableFile candidateFile)
-    {
-        if (this.isValidFile(enumerator, candidateFile))
-        {
-            String metaData = candidateFile.getFileContents(LoadableMod.METADATA_FILENAME, Charsets.UTF_8);
-            if (metaData != null)
-            {
-                LoadableMod<File> modFile = this.getModFile(candidateFile, metaData);
-                this.addModFile(enumerator, modFile);
-                return;
-            }
-            else if (this.isValidTweakContainer(candidateFile))
-            {
-                TweakContainer<File> container = this.getTweakFile(candidateFile);
-                this.addTweakFile(enumerator, container);
-                return;
-            }
-            else
-            {
-                LiteLoaderLogger.info("Ignoring %s", candidateFile);
-//                enumerator.registerBadContainer(candidateFile, "No metadata");
-            }
-        }
-//        else
-//        {
-//            enumerator.registerBadContainer(candidateFile, "Not a valid file");
-//        }
-    }
-
-    /**
-     * Check whether the specified file is a valid mod container
-     * 
-     * @param enumerator
-     * @param candidateFile
-     */
-    protected boolean isValidFile(ModularEnumerator enumerator, LoadableFile candidateFile)
-    {
-        String filename = candidateFile.getName().toLowerCase();
-        if (filename.endsWith(".litemod.zip"))
-        {
-            enumerator.registerBadContainer(candidateFile, "Invalid file extension .litemod.zip");
-            return false;
-        }
-        else if (filename.endsWith(".litemod"))
-        {
-            return true;
-        }
-        else if (filename.endsWith(".jar"))
-        {
-            Set<String> modSystems = candidateFile.getModSystems();
-            boolean hasLiteLoader = modSystems.contains("LiteLoader");
-            if (modSystems.size() > 0)
-            {
-                LiteLoaderLogger.info("%s supports mod systems %s", candidateFile, modSystems);
-                if (!hasLiteLoader) return false;
-            }
-
-            return this.loadTweakJars || this.readJarFiles || hasLiteLoader;
-        }
-
-        return false;
-    }
-
-    /**
-     * Called only if the file is not a valid mod container (has no mod
-     * metadata) to check whether it could instead be a potential tweak
-     * container.
-     * 
-     * @param candidateFile
-     */
-    protected boolean isValidTweakContainer(LoadableFile candidateFile)
-    {
-        return this.loadTweakJars && this.loadTweaks && candidateFile.getName().toLowerCase().endsWith(".jar");
-    }
-
-    /**
-     * Get the {@link FilenameFilter} to use to filter candidate files
-     */
-    protected FilenameFilter getFilenameFilter()
-    {
-        return this;
-    }
-
-    /**
-     * @param modFile
-     */
-    protected boolean isFileSupported(LoadableMod<File> modFile)
-    {
-        return LiteLoaderVersion.CURRENT.isVersionSupported(modFile.getTargetVersion());
-    }
-
-    /**
-     * @param candidateFile
-     * @param metaData
-     */
-    protected LoadableMod<File> getModFile(LoadableFile candidateFile, String metaData)
-    {
-        return new LoadableModFile(candidateFile, metaData);
-    }
-
-    /**
-     * @param candidateFile
-     */
-    protected TweakContainer<File> getTweakFile(LoadableFile candidateFile)
-    {
-        return candidateFile;
-    }
-
-    /**
-     * @param enumerator 
-     * @param modFile
-     */
-    protected void addModFile(ModularEnumerator enumerator, LoadableMod<File> modFile)
-    {
-        if (modFile.hasValidMetaData())
-        {
-            // Only add the mod if the version matches, we add candidates to the versionOrderingSets in
-            // order to determine the most recent version available.
-            if (this.isFileSupported(modFile))
-            {
-                if (!this.versionOrderingSets.containsKey(modFile.getName()))
-                {
-                    this.versionOrderingSets.put(modFile.getModName(), new TreeSet<LoadableMod<File>>());
-                }
-
-                LiteLoaderLogger.info("Considering valid mod file: %s", modFile);
-                this.versionOrderingSets.get(modFile.getModName()).add(modFile);
-            }
-            else
-            {
-                LiteLoaderLogger.info(Verbosity.REDUCED, "Not adding invalid or version-mismatched mod file: %s", modFile);
-                enumerator.registerBadContainer(modFile, "Version not supported");
-            }
-        }
-    }
-
-    /**
-     * @param enumerator
-     * @param container
-     */
-    protected void addTweakFile(ModularEnumerator enumerator, TweakContainer<File> container)
-    {
-        enumerator.registerTweakContainer(container);
-    }
-
-    /**
-     * @param enumerator 
-     */
-    protected void sortAndRegisterFiles(ModularEnumerator enumerator)
-    {
-        // Copy the first entry in every version set into the modfiles list
-        for (Entry<String, TreeSet<LoadableMod<File>>> modFileEntry : this.versionOrderingSets.entrySet())
-        {
-            LoadableMod<File> newestVersion = modFileEntry.getValue().iterator().next();
-            this.registerFile(enumerator, newestVersion);
-        }
-
-        this.versionOrderingSets.clear();
-    }
-
-    /**
-     * @param enumerator
-     * @param modFile
+    
+    /* (non-Javadoc)
+     * @see com.mumfrey.liteloader.api.EnumeratorModule#register(
+     *      com.mumfrey.liteloader.interfaces.ModularEnumerator,
+     *      java.lang.String)
      */
-    @SuppressWarnings("unchecked")
-    protected void registerFile(ModularEnumerator enumerator, LoadableMod<File> modFile)
-    {
-        if (enumerator.registerModContainer(modFile))
-        {
-            LiteLoaderLogger.info(Verbosity.REDUCED, "Adding newest valid mod file '%s' at revision %.4f", modFile, modFile.getRevision());
-            this.loadableMods.add(modFile);
-        }
-        else
-        {
-            LiteLoaderLogger.info(Verbosity.REDUCED, "Not adding valid mod file '%s', the specified mod is disabled or missing a required dependency",
-                    modFile);
-        }
-
-        if (this.loadTweaks)
-        {
-            try
-            {
-                if (modFile instanceof TweakContainer)
-                {
-                    this.addTweakFile(enumerator, (TweakContainer<File>)modFile);
-                }
-            }
-            catch (Throwable th)
-            {
-                LiteLoaderLogger.warning("Error adding tweaks from '%s'", modFile);
-            }
-        }
-    }
-
     @Override
-    public void injectIntoClassLoader(ModularEnumerator enumerator, LaunchClassLoader classLoader)
+    public void register(ModularEnumerator enumerator, String profile)
     {
-        LiteLoaderLogger.info("Injecting external mods into class path...");
-
-        for (LoadableMod<?> loadableMod : this.loadableMods)
-        {
-            try
-            {
-                if (loadableMod.injectIntoClassPath(classLoader, false))
-                {
-                    LiteLoaderLogger.info("Successfully injected mod file '%s' into classpath", loadableMod);
-                }
-            }
-            catch (MalformedURLException ex)
-            {
-                LiteLoaderLogger.warning("Error injecting '%s' into classPath. The mod will not be loaded", loadableMod);
-            }
-        }
-    }
-
-    @Override
-    public void registerMods(ModularEnumerator enumerator, LaunchClassLoader classLoader)
-    {
-        LiteLoaderLogger.info(Verbosity.REDUCED, "Discovering mods in valid mod files...");
-        LoadingProgress.incTotalLiteLoaderProgress(this.loadableMods.size());
-
-        for (LoadableMod<?> modFile : this.loadableMods)
+        if (this.directory.exists() && this.directory.isDirectory())
         {
-            LoadingProgress.incLiteLoaderProgress("Searching for mods in " + modFile.getModName() + "...");
-            LiteLoaderLogger.info("Searching %s...", modFile);
-            try
-            {
-                enumerator.registerModsFrom(modFile, true);
-            }
-            catch (Exception ex)
-            {
-                LiteLoaderLogger.warning("Error encountered whilst searching in %s...", modFile);
-            }
+            LiteLoaderLogger.info("Registering discovered mod files in folder %s", this.directory.getPath());
+            this.sortAndRegisterFiles(enumerator);
         }
     }
 }
+/*
+ * This file is part of LiteLoader.
+ * Copyright (C) 2012-16 Adam Mummery-Smith
+ * All Rights Reserved.
+ */
+package com.mumfrey.liteloader.core.api;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.mumfrey.liteloader.core.api.repository.Repository;
+import com.mumfrey.liteloader.interfaces.ModularEnumerator;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+
+/**
+ * Enumerator module which searches for mods and tweaks in a folder
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class EnumeratorModuleRepository extends EnumeratorModuleFiles
+{
+    private final File modList;
+    
+    private final Repository repo;
+    
+    private File[] files = new File[0];
+
+    public EnumeratorModuleRepository(LiteLoaderCoreAPI api, ContainerEnvironment containers, Repository repo, File modList)
+    {
+        super(api, containers);
+        this.repo = repo;
+        this.modList = modList;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString()
+    {
+        return this.modList.getAbsolutePath();
+    }
+
+    public File getModList()
+    {
+        return this.modList;
+    }
+
+    @Override
+    protected boolean readJarFiles()
+    {
+        return true;
+    }
+
+    @Override
+    protected boolean loadTweakJars()
+    {
+        return true;
+    }
+
+    @Override
+    protected boolean loadTweaks()
+    {
+        return true;
+    }
+
+    @Override
+    protected boolean forceInjection()
+    {
+        return false;
+    }
+
+    @Override
+    protected File[] getFiles()
+    {
+        return this.files;
+    }
+
+    /* (non-Javadoc)
+     * @see com.mumfrey.liteloader.core.Enumerator
+     *      #enumerate(com.mumfrey.liteloader.core.EnabledModsList,
+     *      java.lang.String)
+     */
+    @Override
+    public void enumerate(ModularEnumerator enumerator, String profile)
+    {
+        if (this.modList.isFile())
+        {
+            LiteLoaderLogger.info("Discovering mod files defined in repository %s", this.modList.getPath());
+            this.resolve();
+            
+            this.findValidFiles(enumerator);
+        }
+    }
+    
+    @Override
+    public void register(ModularEnumerator enumerator, String profile)
+    {
+        if (this.modList.isFile())
+        {
+            LiteLoaderLogger.info("Discovering mod files defined in repository %s", this.modList.getPath());
+            this.resolve();
+            
+            this.findValidFiles(enumerator);
+            this.sortAndRegisterFiles(enumerator);
+        }
+    }
+
+    private void resolve()
+    {
+        this.repo.resolve(this.modList);
+        
+        List<File> files = new ArrayList<File>();
+        files.addAll(this.repo.getFiles());
+        this.files = files.toArray(this.files);
+    }
+}
@@ -14,6 +14,7 @@ import com.mumfrey.liteloader.api.EnumeratorModule;
 import com.mumfrey.liteloader.api.LiteAPI;
 import com.mumfrey.liteloader.api.MixinConfigProvider;
 import com.mumfrey.liteloader.core.LiteLoaderVersion;
+import com.mumfrey.liteloader.core.api.EnumeratorModuleFiles.ContainerEnvironment;
 import com.mumfrey.liteloader.interfaces.ObjectFactory;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
@@ -133,17 +134,26 @@ public abstract class LiteLoaderCoreAPI implements LiteAPI, MixinConfigProvider
         {
             enumeratorModules.add(new EnumeratorModuleClassPath());
         }
+        
+        ContainerEnvironment containers = new ContainerEnvironment();
  
         if (this.searchModsFolder)
         {
             File modsFolder = this.environment.getModsFolder();
-            enumeratorModules.add(new EnumeratorModuleFolder(this, modsFolder, false));
+            enumeratorModules.add(new EnumeratorModuleFolder(this, containers, modsFolder, false));
  
             File versionedModsFolder = this.environment.getVersionedModsFolder();
-            enumeratorModules.add(new EnumeratorModuleFolder(this, versionedModsFolder, true));
+            enumeratorModules.add(new EnumeratorModuleFolder(this, containers, versionedModsFolder, true));
+        }
+        
+        String modsRepoFile = this.environment.getModsRepoFile();
+        if (modsRepoFile != null)
+        {
+            File modList = new File(modsRepoFile);
+            enumeratorModules.add(new EnumeratorModuleRepository(this, containers, this.environment.getModRepository(), modList));
         }
  
-        return Collections.unmodifiableList(enumeratorModules);
+        return Collections.<EnumeratorModule>unmodifiableList(enumeratorModules);
     }
  
     /**
+/*
+ * This file is part of LiteLoader.
+ * Copyright (C) 2012-16 Adam Mummery-Smith
+ * All Rights Reserved.
+ */
+package com.mumfrey.liteloader.core.api.repository;
+
+import java.io.File;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Specifier for a mod in the ivy repo shorthand notation
+ */
+public final class Artefact
+{
+    /**
+     * Regex for matching valid specifiers
+     */
+    private static final Pattern PATTERN = Pattern.compile("^([^:]+):([^:]+):([^:@]+?)(:([^:@]+?))?(@(zip|jar|litemod))?$"); 
+    
+    /**
+     * Artefact group id
+     */
+    private final String group;
+    
+    /**
+     * Artefact name
+     */
+    private final String name;
+    
+    /**
+     * Artefact version
+     */
+    private final String version;
+    
+    /**
+     * Artefact classifier (can be null)
+     */
+    private final String classifier;
+    
+    /**
+     * Artefact type (can be null)
+     */
+    private final String type;
+    
+    /**
+     * Resolved file 
+     */
+    private File file;
+
+    public Artefact(String specifier)
+    {
+        if (specifier == null)
+        {
+            throw new IllegalArgumentException("Invalid artefact specifier: null");
+        }
+        
+        Matcher matcher = Artefact.PATTERN.matcher(specifier);
+        if (!matcher.matches())
+        {
+            throw new IllegalArgumentException("Invalid artefact specifier: " + specifier);
+        }
+        
+        this.group = matcher.group(1);
+        this.name = matcher.group(2);
+        this.version = matcher.group(3);
+        this.classifier = matcher.group(5);
+        this.type = matcher.group(7);
+    }
+    
+    /**
+     * Get the artefact id consisting of the group and name
+     * 
+     * @return
+     */
+    public String getArtefactId()
+    {
+        return String.format("%s:%s", this.getGroup(), this.getName());
+    }
+
+    /**
+     * Get the path portion of this artefact's resolved location
+     * 
+     * @return artefact path
+     */
+    public String getPath()
+    {
+        return String.format("%s/%s/%s", this.getGroup().replace('.', '/'), this.getName(), this.getVersion());
+    }
+    
+    /**
+     * Get the file name portion of this artefact's resolved location
+     * 
+     * @return arefact file name
+     */
+    public String getFileName()
+    {
+        return String.format("%s-%s%s.%s", this.getName(), this.getVersion(), this.getClassifier("-"), this.getType());
+    }
+    
+    /**
+     * Get the artefact group
+     */
+    public String getGroup()
+    {
+        return this.group;
+    }
+    
+    /**
+     * Get the artefact name
+     */
+    public String getName()
+    {
+        return this.name;
+    }
+    
+    /**
+     * Get the artefact version
+     */
+    public String getVersion()
+    {
+        return this.version;
+    }
+
+    /**
+     * Get the artefact classifier, returns an empty string if no classifier is
+     * set
+     */
+    public String getClassifier()
+    {
+        return this.getClassifier("");
+    }
+
+    private String getClassifier(String prefix)
+    {
+        return this.classifier != null ? prefix + this.classifier : "";
+    }
+
+    /**
+     * Get the artefact type, defaults to "jar" if no type was specified
+     */
+    public String getType()
+    {
+        return this.type != null ? this.type : "jar";
+    }
+    
+    /**
+     * Resolve this artefact beneath the specified repository root
+     * 
+     * @param repositoryRoot repository root
+     * @return resolved file
+     */
+    void resolve(File repositoryRoot)
+    {
+        this.file = new File(new File(repositoryRoot, this.getPath()), this.getFileName());
+    }
+    
+    /**
+     * Get whether the resolved artefact actually exists
+     */
+    public boolean exists()
+    {
+        return this.file != null && this.file.isFile();
+    }
+    
+    /**
+     * After resolution, return the resolved file location
+     * 
+     * @return resolved location
+     */
+    public File getFile()
+    {
+        return this.file;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString()
+    {
+        String type = this.type != null && !"jar".equals(this.type) ? "@" + this.type : "";
+        return String.format("%s:%s:%s%s%s", this.getGroup(), this.getName(), this.getVersion(), this.getClassifier(":"), type);
+    }
+}
 \ No newline at end of file
+/*
+ * This file is part of LiteLoader.
+ * Copyright (C) 2012-16 Adam Mummery-Smith
+ * All Rights Reserved.
+ */
+package com.mumfrey.liteloader.core.api.repository;
+
+import java.io.File;
+import java.io.FileReader;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.google.common.base.Strings;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.annotations.SerializedName;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
+
+/**
+ * Modlist JSON resolver
+ */
+public final class JsonResolver
+{
+    /**
+     * Gson object for deserialisation
+     */
+    private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+    
+    /**
+     * Root resolver, used as parent for resolvers with no parent
+     */
+    private static final JsonResolver rootResolver = new JsonResolver().setRoot();
+
+    @SerializedName("repositoryRoot")
+    private String repositoryRoot;
+    
+    @SerializedName("modRef")
+    private List<String> modRefs;
+    
+    @SerializedName("parentList")
+    private String parentList;
+    
+    /**
+     * True when resolving, used to prevent accidental re-entrance if a config
+     * is defined as its own parent!
+     */
+    private transient boolean resolving = false;
+    
+    /**
+     * JSON file in the file system
+     */
+    private transient File file;
+    
+    /**
+     * Resolved repository root
+     */
+    private transient File root;
+    
+    /**
+     * Resolved parent
+     */
+    private transient JsonResolver parent;
+    
+    /**
+     * Resolved artefacts
+     */
+    private final transient Map<String, Artefact> artefacts = new TreeMap<String, Artefact>(); 
+    
+    private JsonResolver()
+    {
+    }
+    
+    /**
+     * Configure this resolver as the root resolver
+     */
+    private JsonResolver setRoot()
+    {
+        this.parent = this;
+        return this;
+    }
+
+    /**
+     * Set the source file, called by the deserialisation routine
+     * 
+     * @param file JSON file
+     * @return fluent
+     */
+    JsonResolver setFile(File file)
+    {
+        this.file = file;
+        return this;
+    }
+    
+    boolean isResolved()
+    {
+        return this.parent != null;
+    }
+    
+    boolean isResolving()
+    {
+        return this.resolving;
+    }
+    
+    /**
+     * Get resolved artefacts from this resolver
+     */
+    public Map<String, Artefact> getArtefacts()
+    {
+        return Collections.<String, Artefact>unmodifiableMap(this.artefacts);
+    }
+    
+    /**
+     * Resolve this modlist, resolves parents recursively as required
+     * 
+     * @param repository owning repository
+     * @return fluent
+     */
+    JsonResolver resolve(Repository repository)
+    {
+        if (!this.isResolved() && !this.isResolving())
+        {
+            LiteLoaderLogger.info(Verbosity.REDUCED, "Resolving mods in repository %s", this);
+            this.doResolve(repository);
+        }
+    
+        return this;
+    }
+
+    private void doResolve(Repository repository)
+    {
+        this.resolving = true;
+        this.root = this.resolveRoot(repository);
+
+        JsonResolver parent = this.resolveParent(repository);
+        if (parent.isResolving())
+        {
+            throw new IllegalStateException("Unexpected circular dependency in mod lists: " + this + " <-> " + parent);
+        }
+        
+        this.artefacts.clear();
+        this.artefacts.putAll(parent.artefacts);
+
+        this.resolveArtefacts(repository);
+        this.resolving = false;
+        this.parent = parent;
+    }
+
+    private File resolveRoot(Repository repository)
+    {
+        if (this.repositoryRoot == null)
+        {
+            if (this.file != null)
+            {
+                return this.file.getParentFile();
+            }
+            
+            return repository.getDefaultRepositoryRoot();
+        }
+        
+        // Absolute path
+        if (Repository.isAbsolutePath(this.repositoryRoot))
+        {
+            return new File(this.repositoryRoot);
+        }
+        
+        // Relative path, relative to 
+        return new File(repository.getRoot(), this.repositoryRoot);
+    }
+
+    private JsonResolver resolveParent(Repository repository)
+    {
+        if (this.parentList == null)
+        {
+            return JsonResolver.rootResolver;
+        }
+        
+        if (Repository.isAbsolutePath(this.parentList))
+        {
+            File path = new File(this.parentList);
+            return repository.getResolver(path).resolve(repository);
+        }
+        
+        File path = new File(repository.getRoot(), this.parentList);
+        return repository.getResolver(path).resolve(repository);
+    }
+    
+    private void resolveArtefacts(Repository repository)
+    {
+        if (this.modRefs == null)
+        {
+            return;
+        }
+        
+        for (String ref : this.modRefs)
+        {
+            if (Strings.isNullOrEmpty(ref))
+            {
+                continue;
+            }
+            
+            try
+            {
+                Artefact artefact = new Artefact(ref);
+                artefact.resolve(this.root);
+                
+                LiteLoaderLogger.info(Verbosity.VERBOSE, "Resolved artefact '%s' at %s", artefact.getArtefactId(), artefact.getFile());
+
+                String artefactId = artefact.getArtefactId();
+                Artefact existing = this.artefacts.get(artefactId);
+                if (existing != null)
+                {
+                    LiteLoaderLogger.info(Verbosity.VERBOSE, "Evicting artefact '%s' -> '%s'", existing, artefact.getVersion());
+                }
+                
+                this.artefacts.put(artefactId, artefact);
+            }
+            catch (IllegalArgumentException ex)
+            {
+                ex.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Deserialise a resolver from a JSON source using Gson
+     * 
+     * @param file file to read
+     * @return deserialised resolver or new resolver if could not be read
+     */
+    static JsonResolver createFrom(File file)
+    {
+        if (file.isFile())
+        {
+            try (FileReader reader = new FileReader(file))
+            {
+                return JsonResolver.gson.fromJson(reader, JsonResolver.class).setFile(file);
+            }
+            catch (Exception ex)
+            {
+                ex.printStackTrace();
+            }
+        }
+
+        return new JsonResolver().setFile(file);
+    }
+
+    @Override
+    public String toString()
+    {
+        return this.file.getPath();
+    }
+}
+/*
+ * This file is part of LiteLoader.
+ * Copyright (C) 2012-16 Adam Mummery-Smith
+ * All Rights Reserved.
+ */
+package com.mumfrey.liteloader.core.api.repository;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
+
+/**
+ * A mod container repository defined by JSON modlists
+ */
+public class Repository
+{
+    /**
+     * Default root which relative paths are relative to, usually the game
+     * directory
+     */
+    private final File root;
+    
+    /**
+     * Fallback repository root in case things go wrong. Usually the versionsed
+     * mods directory
+     */
+    private final File defaultRepositoryRoot;
+    
+    /**
+     * Resolvers in this repository
+     */
+    private final Map<String, JsonResolver> resolvers = new TreeMap<String, JsonResolver>();
+    
+    /**
+     * Global list of resolved artefacts
+     */
+    private final List<Artefact> artefacts = new ArrayList<Artefact>();
+
+    public Repository(File root, File defaultRepositoryRoot)
+    {
+        this.root = root;
+        this.defaultRepositoryRoot = defaultRepositoryRoot;
+    }
+
+    /**
+     * Get the repository root, usually the game dir
+     */
+    public File getRoot()
+    {
+        return this.root;
+    }
+    
+    /**
+     * Get the default repository location, usually the versioned mods dir
+     */
+    public File getDefaultRepositoryRoot()
+    {
+        return this.defaultRepositoryRoot;
+    }
+
+    Map<String, JsonResolver> getResolvers()
+    {
+        return this.resolvers;
+    }
+    
+    JsonResolver getResolver(File path)
+    {
+        String location = path.getAbsolutePath();
+        JsonResolver resolver = this.resolvers.get(location);
+        if (resolver == null)
+        {
+            resolver = JsonResolver.createFrom(path);
+            this.resolvers.put(location, resolver);
+        }
+        return resolver;
+    }
+    
+    /**
+     * Resolve the specified modlist
+     * 
+     * @param path modlist path
+     */
+    public void resolve(File path)
+    {
+        JsonResolver resolver = this.getResolver(path);
+        resolver.resolve(this);
+        this.artefacts.addAll(resolver.getArtefacts().values());
+    }
+    
+    /**
+     * Get resolved artefacts from this repository
+     */
+    public Collection<Artefact> getArtefacts()
+    {
+        return Collections.<Artefact>unmodifiableList(this.artefacts);
+    }
+    
+    /**
+     * Get all resolved files in this repository
+     */
+    public Collection<File> getFiles()
+    {
+        Builder<File> files = ImmutableList.<File>builder();
+        for (Artefact artefact : this.artefacts)
+        {
+            if (artefact.exists())
+            {
+                files.add(artefact.getFile());
+            }
+            else
+            {
+                LiteLoaderLogger.info(Verbosity.REDUCED, "Rejecting non-existent artefact %s at %s", artefact.getArtefactId(), artefact.getFile());
+            }
+        }
+        return files.build();
+    }
+
+    static boolean isAbsolutePath(String path)
+    {
+        return path.matches("^([a-zA-Z]:[/\\\\]|/).+$");
+    }
+}
@@ -10,6 +10,8 @@ import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -97,6 +99,11 @@ public class LoadableFile extends File implements TweakContainer&lt;File&gt;
      * Mixin config resource names
      */
     protected Set<String> mixinConfigs = new HashSet<String>();
+    
+    /**
+     * Mixin errors 
+     */
+    protected List<Throwable> mixinErrors = new ArrayList<Throwable>();
  
     /**
      * Create a new tweak container wrapping the specified file
@@ -344,6 +351,18 @@ public class LoadableFile extends File implements TweakContainer&lt;File&gt;
     {
         return this.mixinConfigs;
     }
+    
+    @Override
+    public void registerMixinError(Throwable th)
+    {
+        this.mixinErrors.add(th);
+    }
+    
+    @Override
+    public Collection<Throwable> getMixinErrors()
+    {
+        return this.mixinErrors;
+    }
  
     @Override
     public boolean hasEventTransformers()
@@ -5,6 +5,7 @@
  */
 package com.mumfrey.liteloader.interfaces;
  
+import java.util.Collection;
 import java.util.Set;
  
 public interface MixinContainer<L> extends Loadable<L>, Injectable
@@ -19,5 +20,17 @@ public interface MixinContainer&lt;L&gt; extends Loadable&lt;L&gt;, Injectable
      * Get this mod's list of mixin configs
      */
     public abstract Set<String> getMixinConfigs();
+    
+    /**
+     * Register a mixin error with the container
+     * 
+     * @param th caught throwable
+     */
+    public abstract void registerMixinError(Throwable th);
+    
+    /**
+     * @return mixin errors
+     */
+    public abstract Collection<Throwable> getMixinErrors();
  
 }
@@ -30,4 +30,10 @@ public interface GameEnvironment
      * config for legacy mods.
      */
     public abstract File getModsFolder();
+
+    /**
+     * Get the path to a JSON file describing a mod repository layout, can be
+     * null if not defined
+     */
+    public abstract String getModsRepoFile();
 }
@@ -41,7 +41,8 @@ public class LiteLoaderTweaker implements ITweaker
     // TODO Version - 1.11.2
     public static final String VERSION = "1.11.2";
  
-    protected static final String bootstrapClassName = "com.mumfrey.liteloader.core.LiteLoaderBootstrap";
+    protected static final String BOOTSTRAP_CLASS = "com.mumfrey.liteloader.core.LiteLoaderBootstrap";
+    private static final String CLIENT_API = "com.mumfrey.liteloader.client.api.LiteLoaderCoreAPIClient";
  
     /**
      * Loader startup state
@@ -323,7 +324,7 @@ public class LiteLoaderTweaker implements ITweaker
         {
             this.initEnvironment(args, gameDirectory, assetsDirectory, profile);
  
-            this.bootstrap = this.spawnBootstrap(LiteLoaderTweaker.bootstrapClassName, Launch.classLoader);
+            this.bootstrap = this.spawnBootstrap(LiteLoaderTweaker.BOOTSTRAP_CLASS, Launch.classLoader);
  
             this.transformerManager = new ClassTransformerManager(this.bootstrap.getRequiredTransformers());
  
@@ -347,7 +348,7 @@ public class LiteLoaderTweaker implements ITweaker
         {
             MixinBootstrap.init();
  
-            this.bootstrap.preInit(Launch.classLoader, true, this.env.getModFilterList());
+            this.bootstrap.preInit(Launch.classLoader, true);
  
             this.injectDiscoveredTweakClasses();
             StartupState.PREINIT.completed();
@@ -567,7 +568,7 @@ public class LiteLoaderTweaker implements ITweaker
             @Override
             public void registerCoreAPIs(List<String> apisToLoad)
             {
-                apisToLoad.add(0, "com.mumfrey.liteloader.client.api.LiteLoaderCoreAPIClient");
+                apisToLoad.add(0, LiteLoaderTweaker.CLIENT_API);
             }
  
             @Override
@@ -13,9 +13,11 @@ import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
  
 public class LiteLoaderTweakerServer extends LiteLoaderTweaker
 {
+    private static final String SERVER_API = "com.mumfrey.liteloader.server.api.LiteLoaderCoreAPIServer";
+
     public LiteLoaderTweakerServer()
     {
-        LiteLoaderLogger.verbosity = Verbosity.REDUCED;
+        LiteLoaderLogger.setVerbosity(Verbosity.REDUCED);
     }
  
     @Override
@@ -26,7 +28,7 @@ public class LiteLoaderTweakerServer extends LiteLoaderTweaker
             @Override
             public void registerCoreAPIs(List<String> apisToLoad)
             {
-                apisToLoad.add(0, "com.mumfrey.liteloader.server.api.LiteLoaderCoreAPIServer");
+                apisToLoad.add(0, LiteLoaderTweakerServer.SERVER_API);
             }
  
             @Override
@@ -41,7 +43,6 @@ public class LiteLoaderTweakerServer extends LiteLoaderTweaker
     public String getLaunchTarget()
     {
         super.getLaunchTarget();
-
         return "net.minecraft.server.MinecraftServer";
     }
 }
@@ -24,9 +24,8 @@ public interface LoaderBootstrap
      * 
      * @param classLoader
      * @param loadTweaks
-     * @param modsToLoad
      */
-    public abstract void preInit(LaunchClassLoader classLoader, boolean loadTweaks, List<String> modsToLoad);
+    public abstract void preInit(LaunchClassLoader classLoader, boolean loadTweaks);
  
     /**
      * 
@@ -11,6 +11,7 @@ import com.mumfrey.liteloader.api.manager.APIAdapter;
 import com.mumfrey.liteloader.api.manager.APIProvider;
 import com.mumfrey.liteloader.core.EnabledModsList;
 import com.mumfrey.liteloader.core.LiteLoaderVersion;
+import com.mumfrey.liteloader.core.api.repository.Repository;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
  
 /**
@@ -49,6 +50,12 @@ public interface LoaderEnvironment extends GameEnvironment
      * about which mods are enabled/disabled.
      */
     public abstract EnabledModsList getEnabledModsList();
+    
+    /**
+     * The mod repository defined by command-line option which specifies a JSON
+     * file defining a mod repository
+     */
+    public abstract Repository getModRepository();
  
     /**
      * The enumerator manages mod container and class discovery
@@ -31,6 +31,7 @@ public abstract class StartupEnvironment implements GameEnvironment
  
     private ArgumentAcceptingOptionSpec<String> modsDirOption;
     private ArgumentAcceptingOptionSpec<String> modsOption;
+    private ArgumentAcceptingOptionSpec<String> modsRepoOption;
     private ArgumentAcceptingOptionSpec<String> apisOption;
     private NonOptionArgumentSpec<String> unparsedOptions;
     private OptionSet parsedOptions;
@@ -84,6 +85,8 @@ public abstract class StartupEnvironment implements GameEnvironment
  
         this.modsOption = optionParser.accepts("mods", "Comma-separated list of mods to load")
                 .withRequiredArg().ofType(String.class).withValuesSeparatedBy(',');
+        this.modsRepoOption = optionParser.accepts("modRepo", "Path to a JSON file which defines a mod repository")
+                .withRequiredArg().ofType(String.class);
         this.apisOption = optionParser.accepts("api", "Additional API classes to load")
                 .withRequiredArg().ofType(String.class);
         this.modsDirOption = optionParser.accepts("modsDir", "Path to 'mods' folder to use instead of default")
@@ -239,4 +242,13 @@ public abstract class StartupEnvironment implements GameEnvironment
     {
         return this.getOptionalDirectory(this.gameDirectory, this.modsDirOption, "mods");
     }
+    
+    /**
+     * Get the mods repo json path
+     */
+    @Override
+    public String getModsRepoFile()
+    {
+        return (this.parsedOptions.has(this.modsRepoOption)) ? this.modsRepoOption.value(this.parsedOptions) : null;
+    }
 }
@@ -47,7 +47,7 @@ public final class PermissionsManagerClient implements PermissionsManager, Plugi
      * Permissions permissible which is a proxy for permissions that are common
      * to all mods.
      */
-    private final static Permissible allMods = new PermissibleAllMods();
+    private static final Permissible allMods = new PermissibleAllMods();
  
     /**
      * List of registered client mods supporting permissions
@@ -69,7 +69,9 @@ public class IsolatedClassWriter extends ClassWriter
         do
         {
             c = c.getSuperclass();
-        } while (!c.isAssignableFrom(d));
+        }
+        while (!c.isAssignableFrom(d));
+        
         return c.getName().replace('.', '/');
     }
 }
@@ -98,7 +98,8 @@ public class ComponentRegistry
                 components.add(component);
             }
  
-        } while (component != null && components.size() < 32);
+        }
+        while (component != null && components.size() < 32);
  
         return components;
     }
@@ -150,7 +151,8 @@ public class ComponentRegistry
                 controllers.add(controller);
             }
  
-        } while (controller != null && controllers.size() < 32);
+        }
+        while (controller != null && controllers.size() < 32);
  
         return controllers;
     }
@@ -65,7 +65,7 @@ public class LiteLoaderLogger extends AbstractAppender
         }
     }
  
-    public static Verbosity verbosity = LiteLoaderLogger.DEBUG ? Verbosity.VERBOSE : Verbosity.NORMAL;
+    private static Verbosity verbosity = LiteLoaderLogger.DEBUG ? Verbosity.VERBOSE : Verbosity.NORMAL;
  
     static
     {
@@ -77,6 +77,11 @@ public class LiteLoaderLogger extends AbstractAppender
         super("Internal Log Appender", null, null);
         this.start();
     }
+    
+    public static void setVerbosity(Verbosity verbosity)
+    {
+        LiteLoaderLogger.verbosity = verbosity;
+    }
  
     @Override
     public void append(LogEvent event)