initial proton code

.woodpecker/release.yaml

@@ -0,0 +1,13 @@
+when:
+  - event: tag
+    ref: refs/tags/v*
+steps:
+  - name: Parse git metadata
+    image: build-runner
+    commands:
+      - git tag -n $CI_COMMIT_TAG --format "%(contents)" > ./.tag_message.txt
+  - name: Release
+    image: woodpeckerci/plugin-release
+    settings:
+      api_key:
+        from_secret: WOODPECKER_CI_TOKEN

cmake/Qt.cmake

@@ -1,68 +0,0 @@
-find_package(Qt5 REQUIRED COMPONENTS Core Widgets)
-include_directories(${Qt5_INCLUDES} ${Qt5_DIR})
-
-file(READ "${CMAKE_SOURCE_DIR}/res/moc.txt" moclist)
-string(REGEX REPLACE "\n" ";" moclist ${moclist}) # split into array by line
-
-# note: i am aware of the existence of qt5_wrap_cpp and friends, but those functions
-#       aren't aware of my code generator so i have to do it myself
-#       also, qt5_wrap_ui just dumps headers in the root of the build dir. ew.
-
-if(NOT QT_UIC_EXECUTABLE)
-    string(REPLACE moc uic QT_UIC_EXECUTABLE "${QT_MOC_EXECUTABLE}")
-endif()
-  
-set(mocsources)
-set(qtcogged FALSE)
-if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/src/qtgenerated")
-        file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/src/qtgenerated")
-endif()
-foreach(mocfile ${moclist})
-    if(EXISTS ${CMAKE_SOURCE_DIR}/${mocfile})
-        string(REGEX REPLACE ".h\$" ".cpp" implfile_rel "${mocfile}")
-        string(REGEX REPLACE "include/" "src/qtgenerated/moc_" implfile_rel "${implfile_rel}")
-        set(implfile_abs "${CMAKE_CURRENT_BINARY_DIR}/${implfile_rel}")
-        add_custom_command(OUTPUT "${implfile_abs}" PRE_BUILD
-                COMMAND ${QT_MOC_EXECUTABLE} -o "${implfile_abs}" "${CMAKE_SOURCE_DIR}/${mocfile}"
-                DEPENDS "${CMAKE_SOURCE_DIR}/${mocfile}"
-                COMMENT "Qt MOC: ${BoldCyan}${mocfile}${ColourReset}")
-    elseif(EXISTS ${CMAKE_SOURCE_DIR}/${mocfile}.cog)
-        set(qtcogged TRUE)
-        string(REGEX REPLACE ".h\$" ".cpp" implfile_rel "${mocfile}")
-        string(REGEX REPLACE "include/" "src/qtgenerated/moc_" implfile_rel "${implfile_rel}")
-        set(implfile_abs "${CMAKE_CURRENT_BINARY_DIR}/${implfile_rel}")
-        add_custom_command(OUTPUT "${implfile_abs}" PRE_BUILD
-                COMMAND ${QT_MOC_EXECUTABLE} -o "${implfile_abs}" "${CMAKE_CURRENT_BINARY_DIR}/${mocfile}"
-                DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${mocfile}"
-                COMMENT "Qt MOC: ${BoldCyan}${mocfile}${ColourReset}")
-    endif()
-
-    set(mocsources ${mocsources} "${implfile_abs}")
-endforeach()
-
-file(GLOB_RECURSE uilist RELATIVE "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/res/ui/*.ui")
-set(uicsources)
-foreach(uifile ${uilist})
-    string(REGEX REPLACE "res/ui/" "" uiname ${uifile})
-    string(REGEX REPLACE ".ui\$" "" uiname ${uiname})
-    string(REGEX REPLACE "/" "_" uiname ${uiname})
-    # res/ui/dlg/license.ui should result in ${uiname} being "dlg_license" at this point
-    
-    set(headerfile "${CMAKE_CURRENT_BINARY_DIR}/include/ui_${uiname}.h")
-
-    add_custom_command(OUTPUT "${headerfile}" PRE_BUILD
-            # TODO: not hardcode this path
-            COMMAND ${QT_UIC_EXECUTABLE} -o "${headerfile}" "${CMAKE_SOURCE_DIR}/${uifile}"
-            DEPENDS "${CMAKE_SOURCE_DIR}/${uifile}"
-            COMMENT "Qt UIC: ${BoldCyan}${uifile}${ColourReset}")
-
-    set(uicsources ${uicsources} "${headerfile}")
-endforeach()
-
-add_library(qtgenerated STATIC ${mocsources} ${uicsources})
-target_link_libraries(qtgenerated Qt5::Core Qt5::Widgets)
-if (qtcogged)
-    add_dependencies(qtgenerated cog)
-endif()
-
-message(STATUS "Found Qt: ${Qt5_VERSION}")

cmake/Sphinx.cmake

@@ -1,37 +0,0 @@
-find_program(DVIPNG dvipng)
-find_program(DVISVGM dvisvgm)
-find_program(SPHINX_BUILD sphinx-build)
-
-if(NOT DOCS_TOO)
-    set(DOCS_TOO 0)
-endif()
-
-if(NOT DVIPNG OR NOT DVISVGM OR NOT SPHINX_BUILD)
-        message(WARNING "${BoldYellow}Cannot build library documentation.${ColourReset}")
-
-    # report what's missing
-    if(NOT DVIPNG)
-        message(WARNING "    dvipng not installed.")
-    endif()
-    if(NOT DVISVGM)
-        message(WARNING "    dvisvgm not installed.")
-    endif()
-    if(NOT SPHINX_BUILD)
-        message(WARNING "    Sphinx not installed.")
-    endif()
-
-    if (DOCS_TOO EQUAL 1)
-        message(FATAL_ERROR "${BoldRed}This is a problem, since you specified DOCS_TOO.${ColourReset}")
-    endif()
-else()
-    if(DOCS_TOO EQUAL 1)
-        set(MAYBE_ALL ALL)
-    else()
-            message(STATUS "${Green}Not building docs automatically. Build them with: ${BoldGreen}${CMAKE_MAKE_PROGRAM} sphinx${ColourReset}
-   An alternative strategy would be to run CMake again with ${BoldYellow}-DDOCS_TOO=1${ColourReset}")
-        set(MAYBE_ALL "")
-    endif()
-    
-    add_custom_target(sphinx ${MAYBE_ALL}
-        COMMAND ${SPHINX_BUILD} -b html "${CMAKE_SOURCE_DIR}/doc/sphinx" "${CMAKE_CURRENT_BINARY_DIR}/doc")
-endif()

doc/cellar.1.ronn

@@ -34,4 +34,4 @@ TODO: Generate this.
 
 ## COPYRIGHT
 
-Copyright © 2017-2019 Nicholas O'Connor. Provided under the terms of the MIT license: https://opensource.org/licenses/MIT
+Copyright © 2017-2025 Nicole O'Connor. Provided under the terms of the MIT license: https://opensource.org/licenses/MIT

include/ansicol.hpp

@@ -1,5 +1,5 @@
 /* This file contains string definitions for ANSI color sequences
- * it was written by Nicole O'Connor and is available  to all 
+ * it was written by Nicole O'Connor and is available to all 
  * under the MIT license.
  *
  * Usage:

include/bottles.hpp

@@ -18,12 +18,28 @@ namespace cellar {
             bottle_error,
             bottle_anonymous,
             bottle_labelled,
-            bottle_symlink
+            bottle_symlink,
+            bottle_steam
         };
+
+        enum bottle_manager {
+            manager_error,
+            manager_cellar,
+            manager_steam
+        };
+
+        extern std::string bottle_home;
+
+        /**
+         * Bottles are the internal name for WINE prefixes. In addition to standard WINE contents,
+         * bottles contain a configuration file managed by cellar, which labels the bottle as well
+         * as providing configuration settings.
+         */
         class Bottle {
             public:
                 // public members
                 bottle_type type;
+                bottle_manager manager;
                 json config;
                 string path;
                 string canonical_path;

include/internal/bottles.hpp.cog

@@ -21,6 +21,8 @@ namespace cellar {
                 cog.outl("extern void {0} (int, vector<string>);".format(item[1]))
       ]]]*/
     //[[[end]]]
+        
+        extern void setup_bottle_home();
     }
     namespace commands {
         extern map<string, cellar::commands::CommandFunction> bottles_commands();

include/internal/steam.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "commands.hpp"
+
+namespace cellar {
+    namespace steam {
+        extern std::vector<std::string> find_steam_libraries();
+        extern std::map<std::string, std::string> find_steam_protons();
+    }
+}

include/internal/steam.hpp.cog

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "commands.hpp"
-
-namespace cellar {
-    namespace steam {
-        extern std::vector<std::string> find_steam_libraries();
-        extern void test_command(int argc, std::vector<std::string> argv);
-        /*[[[cog
-            import cog
-         
-            with open("src/steam/commands.txt") as commandsfile:
-                for line in commandsfile:
-                    item = line.strip().split(" ")
-                    cog.outl("extern void {0} (int, vector<string>);".format(item[1]))
-        ]]]*/
-        //[[[end]]]
-    }
-    namespace commands {
-        extern std::map<std::string,cellar::commands::CommandFunction> steam_commands();
-    }
-}

src/bottles/active.cpp

@@ -17,6 +17,7 @@ void cellar::bottles::print_active_bottle(int argc, vector<string> argv) {
     string bottlepath = active_bottle.canonical_path;
     stringstream outstr;
     bool cellar_managed = true;
+    bool external_managed = false;
     if (active_bottle.type == bottle_symlink) {
         outstr << "symlink to ";
         string homedir = getenv("HOME");
@@ -24,6 +25,8 @@ void cellar::bottles::print_active_bottle(int argc, vector<string> argv) {
         if (active_bottle.canonical_path.substr(0, bottlerack.length()) == bottlerack) {
             bottlepath.replace(0, bottlerack.length() + 1, ""); // should convert "/home/someone/.wine.example" to ".wine.example"
             active_bottle = bottlemap[bottlepath];
+            active_bottle.set_config("manager", "cellar");
+            active_bottle.save_config();
         } else {
             outstr << active_bottle.canonical_path;
             cellar_managed = false;

src/bottles/bottles.cpp

@@ -1,4 +1,5 @@
 #include <cstdlib>
+#include <filesystem>
 #include <fstream>
 #include <map>
 #include <string>
@@ -24,32 +25,75 @@ using namespace cellar::bottles;
 using CommandFunction = cellar::commands::CommandFunction;
 using json = nlohmann::json;
 
+/**
+ * @brief Construct an empty bottle object.
+ * This empty bottle object can then be used to help create new ones.
+ */
 Bottle::Bottle() {
     // define a null bottle
     // strings handle themselves
     config = json({});
     type = bottle_anonymous;
+    manager = manager_error;
 }
 
+std::string cellar::bottles::bottle_home;
+
+/**
+ * @brief Sets up bottle home.
+ * Called once from early mainloop. 
+ * @todo Have this not be an effectively hardcoded path. Respect xdg paths.
+ */
+void cellar::bottles::setup_bottle_home() {
+    stringstream sstr_bottle_home;
+    sstr_bottle_home << std::getenv("HOME");
+    sstr_bottle_home << "/.local/share/cellar/bottles";
+    bottle_home = sstr_bottle_home.str();
+}
+
+/**
+ * @brief Construct a bottle object from at a given path.
+ * 
+ * @param patharg The path to load a bottle from.
+ */
 Bottle::Bottle(string patharg) {
     output::statement("loading bottle from " + patharg, true);
     config = json({});
     path = patharg;
     
-    boost::filesystem::file_status path_status = boost::filesystem::symlink_status(path);
+    //boost::filesystem::file_status path_status = boost::filesystem::symlink_status(path);
-    bool symlink = boost::filesystem::is_symlink(path_status);
+    //bool symlink = boost::filesystem::is_symlink(path_status);
+    auto path_status = std::filesystem::path(path);
+    auto path_canon = std::filesystem::canonical(path_status);
+    canonical_path = path_canon.string();
 
-    if (symlink) {
+    if (std::filesystem::is_symlink(path_canon)) {
-        boost::filesystem::path realpath = boost::filesystem::canonical(path);
-        canonical_path = realpath.string();
         type = bottle_symlink;
     } else {
-        canonical_path = path;
 		try {
-            if (load_config()) {
+            load_config();
-                type = bottle_labelled;
+            auto cur_manager = get_config("manager");
-            } else {
+            if (cur_manager == "cellar") {
-                type = bottle_anonymous;
+                manager = manager_cellar;
+
+                if (get_config("name") != "") {
+                    type = bottle_labelled;
+                } else {
+                    type = bottle_anonymous;
+                }
+            } else if (path_canon.parent_path() == bottle_home) {
+                manager = manager_cellar;
+                set_config("manager", "cellar"); // migrate from older cellar (or correct for something weird happening)
+                save_config();
+
+                if (get_config("name") != "") {
+                    type = bottle_labelled;
+                } else {
+                    type = bottle_anonymous;
+                }
+            } else if (cur_manager == "steam") {
+                type = bottle_steam;
+                manager = manager_steam;
             }
     	}
 		catch (const exception &exc) {
@@ -58,6 +102,14 @@ Bottle::Bottle(string patharg) {
     }
 }
 
+/**
+ * @brief Lists all bottles cellar manages or is otherwise aware of.
+ * This includes bottles managed by other tools like Steam or Lutris,
+ * assuming support for those tools is compiled into cellar. (Steam
+ * support is present; Lutris support is planned for the future.)
+ * 
+ * @return map<string, Bottle> All bottles. Bottles managed by other tools have prefixed keys, e.g. Steam bottles use "steam:"
+ */
 map<string, Bottle> cellar::bottles::get_bottles() {
 	map<string, Bottle> result;
 
@@ -80,6 +132,19 @@ map<string, Bottle> cellar::bottles::get_bottles() {
 	return result;
 }
 
+/**
+ * @brief Takes an input that refers to a bottle and returns a path to that bottle.
+ * This input can be any of the following:
+ *  * A bottle name as managed by cellar
+ *  * A prefixed bottle name, in the format `<tool>:<identifier>`. (e.g. `steam:78000`)
+ *  * An absolute or relative path, in which case it is returned with no modification.
+ *  * A path relative to (and starting with ~). cellar will throw a warning in verbose mode,
+ *    since usually the shell expands this for us, but will do a naive replacement on its own
+ *    and try to prevent confused users.
+ * 
+ * @param bottlechoice Input, usually referring to a specific bottle known to cellar.
+ * @return string Path to referenced bottle.
+ */
 string cellar::bottles::resolve_bottle(string bottlechoice) {
     string result;
     if (bottlechoice.substr(0,1) == "/" || bottlechoice.substr(0,1) == ".") { // absolute or relative path
@@ -101,12 +166,15 @@ string cellar::bottles::resolve_bottle(string bottlechoice) {
 #endif
     } else {
         string homepath = getenv("HOME");
-        string fullbottlepath = homepath + "/.local/share/cellar/bottles" + bottlechoice;
+        string fullbottlepath = homepath + "/.local/share/cellar/bottles/" + bottlechoice;
         result = fullbottlepath;
     }
     return result;
 }
 
+/**
+ * @brief Prints bottles. Used as a command in CLI.
+ */
 void cellar::bottles::print_bottles(int argc, vector<string> argv) {
     map<string, Bottle> bottles = get_bottles();
 
@@ -130,6 +198,9 @@ void cellar::bottles::print_bottles(int argc, vector<string> argv) {
             case bottle_labelled:
                 outstr << bottle.config["name"];
                 break;
+            case bottle_steam:
+                outstr << "Steam managed bottle for " << bottle.config["name"];
+                break;
             default:
                 outstr << "broken or unsupported wine bottle";
         }

src/core/cellar.cpp.cog

@@ -10,6 +10,7 @@
 #include "nlohmann/json.hpp"
 
 #include "bottles.hpp"
+#include "internal/bottles.hpp"
 #include "cellar.hpp"
 #include "commands.hpp"
 #include "output.hpp"
@@ -45,6 +46,7 @@ int main(int argc, char* argv[]) {
         cout << "\n(try \"cellar help\" if you're confused)" << endl;
         return 0;
     }
+    cellar::bottles::setup_bottle_home();
     try {
         const string desc = "bottle management tool for WINE connoisseurs";
         const string versionstr = version::short_version();
@@ -70,7 +72,7 @@ int main(int argc, char* argv[]) {
         dryrun = dryrunarg.getValue();
         verbose = dryrun || verbosearg.getValue();
 
-        // BULLSHIT: trying to use str.format on this string causes bizarre compiler errors
+        // TODO: i'm sure stdlib has come a long way in formatting strings since this ancient hack was put in
         /*[[[cog
              import cog
 
@@ -103,7 +105,7 @@ int main(int argc, char* argv[]) {
             if (bottlechoice.substr(0,1) == "/" || bottlechoice.substr(0,1) == ".") { // absolute or relative path
                 bottles::active_bottle = bottles::Bottle(bottlechoice);
             } else if (bottlechoice.substr(0,1) == "~") { // "absolute" path in home directory, not expanded by the shell for some reason (i've seen some shit)
-                // this is a naive replacement and will fail if the user tries something like ~nick/.wine
+                // this is a naive replacement and will fail if the user tries something like ~nicole/.wine
                 // i'm figuring at that point if you're doing that, you'll also recognize if your shell
                 // isn't actually expanding your path...
                 bottlechoice.replace(0,1,getenv("HOME"));

src/core/paths.cpp

@@ -1,4 +1,5 @@
 #include <exception>
+#include <filesystem>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -7,6 +8,7 @@
 #include <boost/algorithm/string.hpp>
 #include "tclap/CmdLine.h"
 
+#include "bottles.hpp"
 #include "output.hpp"
 #include "paths.hpp"
 #include "version.hpp"
@@ -22,10 +24,6 @@ string cellar::paths::translate(std::string in_path, bool lazy) {
 
     windows_input = regex_match(in_path.substr(0, 3), drive_letter_rgx);
 
-    if (!lazy) {
-        output::warning("non-lazy path translation is not implemented yet");
-    }
-
     if (windows_input) {
         if (lazy) {
             if (boost::algorithm::to_lower_copy(in_path.substr(0,1)) != "z") {
@@ -44,14 +42,51 @@ string cellar::paths::translate(std::string in_path, bool lazy) {
             return paths::resolve_drive_letter(in_path);
         }
     } else {
-        // lazy
+        string out_path;
-        string out_path = "Z:";
+        string str_absolutepath = filesystem::canonical(in_path);
-        out_path.append(in_path);
 
-        size_t slashpos = out_path.find("/");
+        if (lazy) {
-        while (slashpos != std::string::npos) {
+            out_path = "Z:";
-            out_path.replace(slashpos, 1, "\\");
+            out_path.append(str_absolutepath);
-            slashpos = out_path.find("/");
+
+            size_t slashpos = out_path.find("/");
+            while (slashpos != std::string::npos) {
+                out_path.replace(slashpos, 1, "\\");
+                slashpos = out_path.find("/");
+            }
+        } else {
+            map<string, string> dct_drives;
+            for (auto hnd_curitem : filesystem::directory_iterator(filesystem::path(bottles::active_bottle.canonical_path) / "dosdevices"))  {
+                auto pth_curitem = hnd_curitem.path();
+                dct_drives.insert_or_assign(pth_curitem.filename().string(), filesystem::canonical(pth_curitem));
+            }
+
+            for (auto hnd_curdrive : dct_drives) {
+                size_t sz_drivelen = hnd_curdrive.second.length();
+                size_t sz_findpos = in_path.rfind(hnd_curdrive.second, 0);
+                if (sz_findpos == 0) {
+                    out_path.append(hnd_curdrive.first);
+                    out_path.append(in_path.substr(sz_drivelen));
+
+                    size_t slashpos = out_path.find("/");
+                    while (slashpos != std::string::npos) {
+                        out_path.replace(slashpos, 1, "\\");
+                        slashpos = out_path.find("/");
+                    }
+
+                    break;
+                }
+            }
+
+            // if we're here, it's not on a drive letter. use Z:
+            out_path = "Z:";
+            out_path.append(str_absolutepath);
+
+            size_t slashpos = out_path.find("/");
+            while (slashpos != std::string::npos) {
+                out_path.replace(slashpos, 1, "\\");
+                slashpos = out_path.find("/");
+            }
         }
 
         return out_path;

src/modules.txt

@@ -2,4 +2,3 @@ core
 config
 bottles
 launch
-steam

src/paths/drive_letters.cpp

@@ -1,4 +1,5 @@
 #include <exception>
+#include <filesystem>
 #include <regex>
 #include <string>
 #include <unistd.h>
@@ -12,6 +13,7 @@
 using namespace std;
 
 string cellar::paths::resolve_drive_letter(string in_path) {
+    filesystem::path lastwd = filesystem::current_path();
     bool windows_input;
     static regex drive_letter_rgx(R"([a-zA-Z]:\\)");
 
@@ -25,6 +27,7 @@ string cellar::paths::resolve_drive_letter(string in_path) {
         string link_path = "";
         link_path.append(bottles::active_bottle.canonical_path);
         link_path.append("/dosdevices/");
+        filesystem::current_path(filesystem::path(link_path));
         link_path.append(drive_letter);
         
         char stringbuffer[512];
@@ -32,7 +35,9 @@ string cellar::paths::resolve_drive_letter(string in_path) {
 
         if (bufflen != -1) {
             stringbuffer[bufflen] = '\0';
-            out_path.append(stringbuffer);
+            string str_absolutepath = filesystem::canonical(stringbuffer);
+            out_path.append(str_absolutepath);
+            out_path.append("/");
         } else {
             throw runtime_error("readlink isn't having it");
         }
@@ -47,5 +52,6 @@ string cellar::paths::resolve_drive_letter(string in_path) {
         out_path.append(rest_of_path);
     }
 
+    filesystem::current_path(lastwd);
     return out_path;
 }

src/steam/bottles.cpp

@@ -11,6 +11,11 @@
 
 using namespace tyti; //vdf
 
+/**
+ * @brief Returns all app bottles managed by Steam.
+ * 
+ * @return std::map<std::string, cellar::bottles::Bottle> Steam managed bottles. Keys are "steam:<appid>".
+ */
 std::map<std::string, cellar::bottles::Bottle> cellar::steam::get_app_bottles() {
     std::map<std::string, cellar::bottles::Bottle> result;
 
@@ -39,7 +44,9 @@ std::map<std::string, cellar::bottles::Bottle> cellar::steam::get_app_bottles()
                 }
 
                 auto curbottle = cellar::bottles::Bottle((pth_appid / "pfx").string());
+                curbottle.type = cellar::bottles::bottle_steam;
                 curbottle.set_config("name", str_gamename);
+                curbottle.set_config("manager", "steam");
                 curbottle.save_config();
                 result[std::string("steam:" + pth_appid.filename().string())] = curbottle;
             }

src/steam/commands.txt

@@ -1 +0,0 @@
-steamtest test_command Test Steam related thing.

src/steam/paths.cpp

@@ -1,9 +1,12 @@
 #include <cstdlib>
+#include <filesystem>
 #include <fstream>
+#include <regex>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "nlohmann/json.hpp"
 #include "vdf_parser.hpp"
 
 #include "bottles.hpp"
@@ -12,17 +15,23 @@
 
 using namespace tyti;
 
+/**
+ * @brief Reads Steam library settings and returns a list of Steam library paths.
+ * Returns an empty vector if it can't read ~/.steam/root/config/libraryfolders.vdf.
+ * 
+ * @return std::vector<std::string> Steam library paths.
+ */
 std::vector<std::string> cellar::steam::find_steam_libraries() {
     std::stringstream sstr_steam_library_config;
     sstr_steam_library_config << std::getenv("HOME");
     sstr_steam_library_config << "/.steam/root/config/libraryfolders.vdf";
     std::string str_steam_library_config = sstr_steam_library_config.str();
+    std::vector<std::string> result = {};
 
     std::ifstream fd_steam_library_config(str_steam_library_config);
+    if (fd_steam_library_config.fail()) { return result; } // return empty if something went wrong (should cover most problems)
     auto hnd_steam_library_config = vdf::read(fd_steam_library_config);
 
-    std::vector<std::string> result;
-
     for (auto hnd_library_def : hnd_steam_library_config.childs) {
         std::string str_index = hnd_library_def.first;
         auto hnd_library = hnd_library_def.second;
@@ -31,3 +40,18 @@ std::vector<std::string> cellar::steam::find_steam_libraries() {
 
     return result;
 }
+
+/**
+ * @brief Gets available versions of Proton from Steam.
+ * 
+ * @return std::vector<std::string> Proton versions.
+ */
+std::map<std::string, std::string> cellar::steam::find_steam_protons() {
+    std::map<std::string, std::string> result;
+
+    for (std::string str_library_path : find_steam_libraries()) {
+        std::filesystem::path pth_library(str_library_path);
+
+        for ()
+    }
+}

src/steam/test_command.cpp

@@ -1,49 +0,0 @@
-#include <cstdlib>
-#include <filesystem>
-#include <format>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "vdf_parser.hpp"
-
-#include "bottles.hpp"
-#include "output.hpp"
-#include "steam.hpp"
-#include "internal/steam.hpp"
-
-using namespace tyti; // vdf
-
-void cellar::steam::test_command(int argc, std::vector<std::string> argv) {
-    for (std::string str_path_library : cellar::steam::find_steam_libraries()) {
-        output::statement(str_path_library);
-        
-        std::filesystem::path pth_library(str_path_library);
-        std::filesystem::path pth_steam_cellar = pth_library / "steamapps/compatdata";
-        for (auto const& itm_appid : std::filesystem::directory_iterator(pth_steam_cellar)) {
-            auto pth_appid = itm_appid.path();
-            if (std::filesystem::is_directory(pth_appid / "pfx") && ! std::filesystem::is_empty(pth_appid / "pfx")) {
-                //                            \/ string-to-unsigned-long
-                std::string str_appid = pth_appid.filename().string(); // should become, e.g. 1124300
-                auto pth_appmanifest = pth_library / ("steamapps/appmanifest_" + str_appid + ".acf");
-                if (! std::filesystem::exists(pth_appmanifest) ) { continue; }
-                std::string str_gamename = "";
-
-                std::ifstream fd_appmanifest(pth_appmanifest);
-                auto hnd_appmanifest = vdf::read(fd_appmanifest);
-                for (auto hnd_appmanifest_def : hnd_appmanifest.attribs) {
-                    std::string str_index = hnd_appmanifest_def.first;
-                    std::string str_value = hnd_appmanifest_def.second;
-
-                    if (str_index == "name") {
-                        str_gamename = str_value;
-                        break;
-                    }
-                }
-
-                output::warning("Steam App #" + str_appid + " (" + str_gamename + ")");
-            }
-        }
-    }
-}