Merge branch acc into master

CONTRIBUTING.md

@@ -0,0 +1,37 @@
+# Contributors guide
+
+If you're interested in contributing to XPipe, you can easily do so! Just submit a pull request with your changes.
+
+In terms of development environment setup, be sure to read the [development page](https://github.com/xpipe-io/xpipe/blob/master/DEVELOPMENT.md) first.
+Especially when starting out, it might be a good idea to start with easy tasks first. Here's a selection of suitable common tasks that are very easy to implement:
+
+### Implementing support for a new editor
+
+All code for handling external editors can be found [here](https://github.com/xpipe-io/xpipe/blob/master/app/src/main/java/io/xpipe/app/prefs/ExternalEditorType.java). There you will find plenty of working examples that you can use as a base for your own implementation.
+
+### Implementing support for a new terminal
+
+All code for handling external terminals can be found [here](https://github.com/xpipe-io/xpipe/blob/master/app/src/main/java/io/xpipe/app/prefs/ExternalTerminalType.java). There you will find plenty of working examples that you can use as a base for your own implementation.
+
+### Adding more file icons for specific types
+
+You can register file types [here](https://github.com/xpipe-io/xpipe/blob/master/app/src/main/resources/io/xpipe/app/resources/file_list.txt) and add the respective icons [here](https://github.com/xpipe-io/xpipe/tree/master/app/src/main/resources/io/xpipe/app/resources/browser_icons).
+
+The existing file list and icons are taken from the [vscode-icons](https://github.com/vscode-icons/vscode-icons) project. Due to limitations in the file definition list compatibility, some file types might not be listed by their proper extension and are therefore not being applied correctly even though the images and definitions exist already.
+
+### Adding more context menu actions in the file browser
+
+In case you want to implement your own actions for certain file types in the file browser, you can easily do so. You can find most existing actions [here](https://github.com/xpipe-io/xpipe/tree/master/ext/base/src/main/java/io/xpipe/ext/base/browser) to get some inspiration.
+Once you created your custom classes, you have to register them in your module info, just like [here](https://github.com/xpipe-io/xpipe/blob/master/ext/base/src/main/java/module-info.java).
+
+### Implementing custom actions for the connection hub
+
+All actions that you can perform for certain connections in the connection overview tab are implemented using an [Action API](https://github.com/xpipe-io/xpipe/blob/master/app/src/main/java/io/xpipe/app/ext/ActionProvider.java). You can find a sample implementation [here](https://github.com/xpipe-io/xpipe/blob/master/ext/base/src/main/java/io/xpipe/ext/base/action/SampleAction.java) and many common action implementations [here](https://github.com/xpipe-io/xpipe/tree/master/ext/base/src/main/java/io/xpipe/ext/base/action).
+
+### Familiarising yourself with the shell and command API
+
+The [sample action](https://github.com/xpipe-io/xpipe/blob/master/ext/base/src/main/java/io/xpipe/ext/base/action/SampleAction.java) shows the basics of working with shells and executing commands in them. For more references, just look for the usages of the [API classes](https://github.com/xpipe-io/xpipe/tree/master/core/src/main/java/io/xpipe/core/process).
+
+### Implementing something else
+
+if you want to work on something that was not listed here, you can still do so of course. You can reach out on the [Discord server](https://discord.gg/8y89vS8cRb) to discuss any development plans and get you started.

DEVELOPMENT.md

@@ -5,14 +5,14 @@ There are no real formal contribution guidelines right now, they will maybe come
 
 ## Repository Structure
 
-- [core](core) - Shared core classes of the XPipe Java API, XPipe extensions, and the XPipe daemon implementation
+- [core](core) - Shared core classes of the XPipe Java API, XPipe extensions, and the XPipe daemon implementation.
+  This mainly concerns API classes not a lot of implementation.
 - [beacon](beacon) - The XPipe beacon component is responsible for handling all communications between the XPipe
-  daemon
-  and the client applications, for example the various programming language APIs and the CLI
+  daemon and the client applications, for example APIs and the CLI
 - [app](app) - Contains the XPipe daemon implementation, the XPipe desktop application, and an
   API to create all different kinds of extensions for the XPipe platform
 - [dist](dist) - Tools to create a distributable package of XPipe
-- [ext](ext) - Available XPipe extensions. Essentially every feature is implemented as an extension
+- [ext](ext) - Available XPipe extensions. Essentially every concrete feature implementation is implemented as an extension
 
 ## Modularity
 
@@ -21,8 +21,11 @@ All components are modularized, including all their dependencies.
 In case a dependency is (sadly) not modularized yet, module information is manually added using [moditect](https://github.com/moditect/moditect-gradle-plugin).
 Further, note that as this is a pretty complicated Java project that fully utilizes modularity,
 many IDEs still have problems building this project properly.
+
 For example, you can't build this project in eclipse or vscode as it will complain about missing modules.
 The tested and recommended IDE is IntelliJ.
+When setting up the project in IntelliJ, make sure that the correct JDK (Java 20)
+is selected both for the project and for gradle itself.
 
 ## Setup
 
@@ -44,8 +47,8 @@ You can use the gradle wrapper to build and run the project:
 - `gradlew <project>:test` will run the tests of the specified project.
 
 You are also able to properly debug the built production application through two different methods:
-- The `app/scripts/xpiped_debug` script will launch the application in debug mode and with a console attached to it
-- The `app/scripts/xpiped_debug_attach` script attaches a debugger with the help of [AttachMe](https://plugins.jetbrains.com/plugin/13263-attachme).
+- The `dist/build/dist/base/app/scripts/xpiped_debug` script will launch the application in debug mode and with a console attached to it
+- The `dist/build/dist/base/app/scripts/xpiped_debug_attach` script attaches a debugger with the help of [AttachMe](https://plugins.jetbrains.com/plugin/13263-attachme).
   Just make sure that the attachme process is running within IntelliJ, and the debugger should launch automatically once you start up the application.
 
 Note that when any unit test is run using a debugger, the XPipe daemon process that is started will also attempt

FAQ.md

@@ -5,18 +5,16 @@
 Compared to other existing tools, the fundamental approach of how to
 connect and how to communicate with remote systems differs.
 Other tools utilize the established protocol-based approach, i.e. connect and communicate with a
-server via a certain protocol like SSH, SFTP, and many more using an integrated library for that purpose.
-XPipe utilizes a shell-based approach that works on top of command-line programs.
-It interacts with your installed command-line programs via their stdout, stderr,
+server via a certain protocol like SSH, SFTP, and many more using a bundled library for that purpose.
+XPipe instead utilizes a shell-based approach that works on top of command-line programs.
+It exclusively interacts with your installed command-line programs via their stdout, stderr,
 and stdin to handle local and remote shell connections.
 This approach makes it much more flexible as it doesn't have to deal with any file system APIs, remote file handling protocols, or libraries at all as that part is delegated to your existing programs.
 
-
 Let's use the example of SSH.
 Protocol-based programs come with an included SSH library that allows them to interact with a remote system via SSH.
-This requires an SSH server implementation to be running on the remote system.
 XPipe does not ship with any sort of SSH library or similar.
-Instead, XPipe creates a new process using your local `ssh` executable, which is usually the OpenSSH client.
+Instead, XPipe starts a new process using your local `ssh` executable, which is usually the OpenSSH client.
 I.e. it launches the process `ssh user@host` in the background and communicates
 with the opened remote shell through the stdout, stderr, stdin of the process.
 From there, it detects what kind of server and environment,
@@ -25,8 +23,7 @@ and adjusts how it talks to the remote system from there.
 It effectively delegates everything protocol and connection related to your external programs.
 
 As a result of this approach, you can do stuff with XPipe that you can't do with other tools.
-One example would be connecting and accessing files on a
-docker container as there's no real protocol to formally connect here by default.
+One example would be connecting and accessing files on a docker container as there's no real protocol to formally connect here by default.
 XPipe can simply execute `docker exec -i <name> sh` to open a shell into the container
 and handle the file management through this opened shell by sending commands like `ls`, `touch`, and more.
 
@@ -39,40 +36,33 @@ you can read the [introduction article](https://foojay.io/today/presenting-xpipe
 
 ## Does it run on my system?
 
-The desktop application should run on any reasonably up-to-date
-Windows/Linux/macOS system that has been released in the last ten years.
-
-## What else do I need to use this?
-
-As mentioned previously, XPipe itself does not ship with any sort of libraries for connection handling
-and instead delegates this to your existing command-line tools.
-For this approach to work however, you need to have the required tools installed.
+The desktop application should run on any reasonably up-to-date Windows/Linux/macOS system that has been released in the last ten years.
 
-For example, if you want to connect to a remote system via SSH with XPipe,
-you need to have an `ssh` client installed and added to your PATH.
-The exact vendor and version of this `ssh` command-line
-tool doesn't matter as long as the standard options are supported.
-
-If a required program is attempted to be used but can not be found, XPipe will notify you.
+In case you are running this on a very slow system, there is also a performance mode available in the settings menu to reduce the visual fidelity and make the application more responsive.
 
 ## Is this secure / Can I entrust my sensitive information to this?
 
-Due to its nature, XPipe has to handle a lot of sensitive information like passwords, keys, and more.
-As security plays a very important role here, there exists a dedicated [security page](/SECURITY.md)
-that should contain all relevant information for you to make your decision.
+Due to its nature, XPipe has to handle a lot of sensitive information like passwords, keys, and more. As security plays a very important role here, there exists a dedicated [security details page](/SECURITY.md) that should contain all relevant information for you to make your decision.
+
+In short, all is transferred in an encrypted manner to other programs. You can choose whether you want to store sensitive information within XPipe or source it from other sources such as password managers. If you store that sensitive data in XPipe, it is also stored encrypted on your local machine. You can also set a custom master password to improve the encryption security of your data further.
 
 ## How does XPipe handle privacy?
 
-XPipe does not collect any sort of data like usage or tracking data.
-The only case in which some sort of data is collected is when you choose to
-use the built-in error reporter to submit a report.
+XPipe does not collect any personal data.
+The only case in which some sort of data is collected is when the built-in error reporter is used to submit a report.
 This report data is limited to general system and error information, no sensitive information is submitted.
 For those people who like to read legalese, there's the [privacy policy](/PRIVACY.md).
 
-## How does XPipe handle updates?
+## Do I have to pay to use this effectively?
+
+I recently decided to develop XPipe full time and hope to finance this by providing plans for professional and commercial users.
+The commercialization model is designed to be very generous for personal users. If you don't use XPipe for commercial purposes, you can use it basically without any limitations for free. If you intend to use it for commercial purposes or want to support the development, you can check out the [available tiers](https://buy.xpipe.io/checkout/buy/dbcd37b8-be94-40a5-8c1c-af61979e6537).
 
-Especially in its early development stage, it can be pretty important to frequently distribute new releases.
-How exactly the update process is handled depends on your distribution:
+## Which release type should I choose?
+
+You are able to essentially get the same feature set regardless which way you choose. There are a few small exceptions, such as desktop environment integrations for your operating system that are only available with installers, however these features are not crucial to XPipe.
+
+Especially in its early development stage, it can be pretty important to frequently distribute new releases. How exactly the update process is handled depends on your distribution:
 
 - Installers (msi/deb/rpm/pkg): They come with the ability to automatically check for
   updates, download them, and install them if you provide your confirmation.
@@ -83,17 +73,47 @@ How exactly the update process is handled depends on your distribution:
 
 Note that you can choose to disable this update check functionality entirely in the settings menu.
 
+## Does it matter which type of release I choose initially?
+
+Not really, they all share the same configuration data locations. You can switch between different release types, e.g. from the portable version to an installer without any issues if you just want to try it out without installing.
+
+There also exists a separate PTB (Public Test Build) release that is meant for testing out new features early on. You can find them at https://github.com/xpipe-io/xpipe-ptb if you're interested. The regular releases and PTB releases are designed to not interfere with each other and can therefore be installed and used side by side.
+
+## How can I save/export my configuration data?
+
+If you want to export or share the whole connection list, you can find all the data at ~/.xpipe/storage. You can also change that directory in the settings menu.
+
+A simple solution is to change the storage directory to be in a cloud directory like OneDrive or Dropbox so it automatically synchronizes the data across all systems.
+
+The professional version also comes with a feature to synchronize your storage with a remote git repository that you can host yourself wherever you like. This comes with the advantage of a commit history for individual connections and the ability to share this repository data with other team members using the access management of your git platform.
+
+## Can I contribute to this project?
+
+Yes, check out the [development page](/DEVELOPMENT.md) for details on how to set up a development environment and the [contributing page](/CONTRIBUTING.md) on how to get started.
+
 ## Why are there no GitHub actions workflows in this repository?
 
-There are several test workflows run in a private environment as they use private test connections
-such as remote server connections and database connections.
-Other private workflows are responsible for packaging, signing, and distributing the releases.
-So you can assume that the code is tested and the release is automated!
+There are several test workflows run in a private environment as they use private test connections such as remote server connections and database connections. Other private workflows are responsible for packaging, signing, and distributing the releases and are also kept private due to them handling a lot of passwords and API keys. So you can assume that the code is tested and the release is automated!
 
 ## What is the best way to reach out to the developers and other users?
 
-You can always open a GitHub issue in this repository in case you encounter a problem.
-There are also several other ways to reach out, so you can choose whatever you like best:
+You can always open a GitHub issue in this repository in case you encounter a problem. There are also several other ways to reach out, so you can choose whatever you like best:
 
 - [XPipe Discord Server](https://discord.gg/8y89vS8cRb)
 - [XPipe Slack Server](https://join.slack.com/t/XPipe/shared_invite/zt-1awjq0t5j-5i4UjNJfNe1VN4b_auu6Cg)
+
+## What is XPipe not?
+
+XPipe is not:
+
+- a backup tool: It is not designed to copy large masses of files across systems reliably.
+- a system management tool: While it allows you to access any remote system, it does not come with a fancy management dashboard and overview for your server infrastructure.
+- a terminal emulator: XPipe is designed around integrating with your own favorite terminal and will allow you to launch any preconfigured shell connection in it. It does not come with any integrated terminal functionality itself.
+- a separate protocol handling implementation: XPipe does not come with its own libraries to handle protocols, so it is not able to connect via SSH without a locally installed SSH client like OpenSSH
+- an RDP/VNC client: It does not support these protocols (yet)
+
+## What will definitely not be implemented?
+
+While the general development direction is still very open, there are a few things that definitely won't be implemented:
+
+- A mobile version, an app store version, and a flatpak version: The concept of integrating with your local CLI tools is incompatible with most sandboxes.