Benjamin Yang

Got it packaged with pygbag onto my server, can use web to access

Since there is not much time left, i speedran making some new levels and the project will probably have to be shipped unfinished, i will try to package with pygame wasm now.

started working on new levels

setup the project

Realized I needed to add the ability to set memory allocation (should be last devlog before ship) and also needed the daily sticker

Ready to ship, attached a video showing the functions of the app so far

Finished writing the Dockerfile and setup for deployment with docker-compose. The app will now create servers in a defined location instead of allowing the user to set the path, due to the virtual environment. Also fixed a bug where startup failure on the subprocess would still push it to the running list, and it would be stuck running without any way to stop off.

Finished the implementation of Java detection on Unix and Windows platforms, and began dockerizing the app for deployment.

Implemented the ability to change the Java binary that will be used to run the server, and auto-detection of Java binaries in defined install paths.

Added types to most locations and began implementing the ability to change the install of Java that will be used for running the server (required for versions of Minecraft that require versions of Java other than the default version)

Added support for fabric mods downloads from modrinth, and fixed a condition where if the mod/plugin download failed, its record would still be updated.

Added basic fabric server support (downloading and updating, mods not supported yet). The video has a server crash in it because i had another server running

Add function for adding/removing servers, there is a limitation that the directory must be manually inputed as text, as client-side cannot get directories from select dialog (security reasons)

Tidied up the server.properties modification view, using the json mappings to decide label, input box type, and hover text (extended description)

Fixed an issue where extensions would end up with ids such as msgappname or similar. As my code generated the id based on extension name, if an extension had this as their name in the manifest (i18n locales handling) then its name would show up normally in the browser, but the script could not handle it, resulting in such an extension id. This was fixed by having the script scan for the i18n message in the _locales directory of the extracted crx, and use that instead.

Created the name/description mappings for the keys in server.properties, which can later be integrated into the ui to make it less confusing

Added the install script and extension packaging to the actions workflow.

Made a python install script that can later be converted with pyinstaller for easy installation process on all os. Currently it downloads the native messaging executable from github and registers the native manifest, and the user only has to run this and install the extension.

Spent way too long setting up gh actions to build the python script into an executable file. It simplifies the installation process as there is no longer a need for setting up venv etc

Fixed an issue where installing multiple extensions in quick succession resulted in an error of address already in use, by making the temp server shut down as soon as it finished serving a file. Also fixed some issues on the extension end...

Added a ui to modify the server.properties file which contains the server settings. As it is in java properties file format, it first needs to be parsed into json. Later I will create mappings for labels instead of the property ids shown now.

Implemented the ansi escape sequences usually in the terminal using ansi_up to convert them to html, and began the reading/writing function of the server.properties to modify server settings

Fixed an issue where with larger files, the connection to the temporary server would be reset and the file could not be downloaded. This was because due to Firefox security, an extension can only be programmatically installed in the same event frame as a user action (button press etc) so now when the extension has been converted, it shows another button to install it, bypassing this.

Running server instances from inside the app now works, including status, log, start/stop, etc. Uses node.js child_process to spawn the server, and stores the instance, which can be retrieved by the app.

Created an installation script for installing the native messaging manifest, setup python venv, etc. Eventually it will be easier once i package the script into a single executable without need for external python

Added more plugin sources (Bukkit, PaperMC Hangar). Bukkit downloads don't support versioning as I could not find an api, only a 'download latest' link per plugin. I also did some bug fixes and small improvements in the UI.

Implemented the communication between the browser extension and a python script that allows the extension to send extension info to the script, after which it will be downloaded, converted to xpi, then hosted on a temporary http server which the extension opens for user to confirm installation. Also implemented changing of Chrome service_worker to Firefox scripts in the manifest.

Created the start of a Firefox extension, which adds the add to firefox button to the webpage. Currently working on an implementation to communicate with the script using extensions native messaging for the script to handle conversion. (bypass webextensions restrictions)

Fixed issues with path resolution on the windows build, which now works, and the project is ready to be shipped. (no i will not activate windows)

Got the app packaged with electron as a wrapper to make running the app easier, and spent a lot of time struggling with Github actions and cross-compiling (which did not work) to get the app built with electron-builder.

Fully implemented the cloud mqtt (including Bambu cloud authentication) and added support for local camera/ftp connections in cloud mode (there is no way to get these connections over the cloud even though Bambu Handy can do it, as the apis are undocumented). Here is an in-progress firmware update tested using the cloud mqtt

Added support for the Bambu cloud MQTT server, which removes the restriction of operating the printer in LAN only mode, although with reduced functionality (haven't gotten camera or files browsing to work yet)

Finished the entire software management view - updating plugins, updating the server software, adding and removing plugins. Currently the app only supports paper for server software through the papermc api, but spigot support is planned. Plugins support spigot, direct urls, and github releases, and bukkit support is planned

Implemented timelapse file downloading from FTP, implemented the settings view to change printer settings, and tried (and failed) to make MQTT subscriptions faster, as the printer's implementation does not send status updates on a published command, but only at a defined interval (2s). Some of the settings in the video that look like they are not working have just not updated due to the slow status updates.

Implemented version checking when downloading plugins and integrated download functions into ui.

Implemented downloading jarfiles of plugins from SpigotMC, GitHub Releases, and direct urls.

Made the ui and started working on plugin file downloading.

Implemented skip objects functionality. The implementation downloads the 3mf print file from the printer through FTP, then extracts it and obtains the top_X.png, which is the top view image of the print for selecting objects, plate_X.json which contains bounding box data for the pick image, and slice_info.config which contains object ids sent to the printer for skipping.

Implemented the Bambu HMS system, implemented some more MQTT commands, started implementation of settings view

Set up the base of the project, implemented the player, some enemies, and a test level

Implemented the camera stream. For some reason Bambu Lab streams the video as a series of JPEGs on a TCP server, which made implementation much more difficult. The implementation connects to the TCP server, sends an authentication header, then receives the frames.

Sending new prints to the printer over MQTT now works. All the settings available on the printer's touchscreen are also available through the new view.

Implemented most MQTT functions used by the printer, and now it is now able to retrieve the print image over FTP.

The MQTT is working, but it can't yet retrieve some data, like print image or filaments info. Also the ui is ugly and I haven't made the icons yet.

The initial version of the app can take a local crx or download it from a url, and zip it into xpi format with required parameters for use in Firefox.

Publishing commands and making subscriptions over MQTT now works. I made a pool of persistent connections so it doesn't have to reconnect every time.

Finished the filament chooser, file browser, and control UIs.

Made the printer list editable, some ui changes

Changed the hardcoded values in most views to states so they are variable, and added popups to modify those values.

Changed to a sidebar navigation, added actual stuff to some more views

Got ftp working to scan the printer for printable files

Made a basic files view with fake data

need to post something...started working on the backend (messing around in mqttx)

Created the controller view as a clone of the A1 UI.

Needed a way to control my Bambu A1 from my phone in LAN only mode. Home Assistant is overkill (I don't have anything else to use it for) and most of the available solutions don't support Android.