3 files changed, 375 insertions, 15 deletions

diff --git a/platform/linuxbsd/export/export.cpp b/platform/linuxbsd/export/export.cpp
index e6925a2011..2c5a945b6c 100644
--- a/platform/linuxbsd/export/export.cpp
+++ b/platform/linuxbsd/export/export.cpp
@@ -36,7 +36,6 @@
 void register_linuxbsd_exporter() {
 	Ref<EditorExportPlatformLinuxBSD> platform;
 	platform.instantiate();
-	platform->set_logo(ImageTexture::create_from_image(memnew(Image(_linuxbsd_logo))));
 	platform->set_name("Linux/X11");
 	platform->set_os_name("Linux");
 	platform->set_chmod_flags(0755);
diff --git a/platform/linuxbsd/export/export_plugin.cpp b/platform/linuxbsd/export/export_plugin.cpp
index f6e59bf465..c900cad007 100644
--- a/platform/linuxbsd/export/export_plugin.cpp
+++ b/platform/linuxbsd/export/export_plugin.cpp
@@ -32,6 +32,15 @@
 
 #include "core/config/project_settings.h"
 #include "editor/editor_node.h"
+#include "editor/editor_paths.h"
+#include "editor/editor_scale.h"
+#include "platform/linuxbsd/logo_svg.gen.h"
+#include "platform/linuxbsd/run_icon_svg.gen.h"
+
+#include "modules/modules_enabled.gen.h" // For svg.
+#ifdef MODULE_SVG_ENABLED
+#include "modules/svg/image_loader_svg.h"
+#endif
 
 Error EditorExportPlatformLinuxBSD::_export_debug_script(const Ref<EditorExportPreset> &p_preset, const String &p_app_name, const String &p_pkg_name, const String &p_path) {
 	Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::WRITE);
@@ -49,26 +58,47 @@ Error EditorExportPlatformLinuxBSD::_export_debug_script(const Ref<EditorExportP
 }
 
 Error EditorExportPlatformLinuxBSD::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
-	Error err = EditorExportPlatformPC::export_project(p_preset, p_debug, p_path, p_flags);
-
-	if (err != OK) {
-		return err;
-	}
+	bool export_as_zip = p_path.ends_with("zip");
 
-	String app_name;
+	String pkg_name;
 	if (String(GLOBAL_GET("application/config/name")) != "") {
-		app_name = String(GLOBAL_GET("application/config/name"));
+		pkg_name = String(GLOBAL_GET("application/config/name"));
 	} else {
-		app_name = "Unnamed";
+		pkg_name = "Unnamed";
+	}
+
+	pkg_name = OS::get_singleton()->get_safe_dir_name(pkg_name);
+
+	// Setup temp folder.
+	String path = p_path;
+	String tmp_dir_path = EditorPaths::get_singleton()->get_cache_dir().path_join(pkg_name);
+
+	Ref<DirAccess> tmp_app_dir = DirAccess::create_for_path(tmp_dir_path);
+	if (export_as_zip) {
+		if (tmp_app_dir.is_null()) {
+			return ERR_CANT_CREATE;
+		}
+		if (DirAccess::exists(tmp_dir_path)) {
+			if (tmp_app_dir->change_dir(tmp_dir_path) == OK) {
+				tmp_app_dir->erase_contents_recursive();
+			}
+		}
+		tmp_app_dir->make_dir_recursive(tmp_dir_path);
+		path = tmp_dir_path.path_join(p_path.get_file().get_basename());
+	}
+
+	// Export project.
+	Error err = EditorExportPlatformPC::export_project(p_preset, p_debug, path, p_flags);
+	if (err != OK) {
+		return err;
 	}
-	app_name = OS::get_singleton()->get_safe_dir_name(app_name);
 
 	// Save console script.
 	if (err == OK) {
 		int con_scr = p_preset->get("debug/export_console_script");
 		if ((con_scr == 1 && p_debug) || (con_scr == 2)) {
-			String scr_path = p_path.get_basename() + ".sh";
-			err = _export_debug_script(p_preset, app_name, p_path.get_file(), scr_path);
+			String scr_path = path.get_basename() + ".sh";
+			err = _export_debug_script(p_preset, pkg_name, path.get_file(), scr_path);
 			FileAccess::set_unix_permissions(scr_path, 0755);
 			if (err != OK) {
 				add_message(EXPORT_MESSAGE_ERROR, TTR("Debug Script Export"), TTR("Could not create console script."));
@@ -76,6 +106,27 @@ Error EditorExportPlatformLinuxBSD::export_project(const Ref<EditorExportPreset>
 		}
 	}
 
+	// ZIP project.
+	if (export_as_zip) {
+		if (FileAccess::exists(p_path)) {
+			OS::get_singleton()->move_to_trash(p_path);
+		}
+
+		Ref<FileAccess> io_fa_dst;
+		zlib_filefunc_def io_dst = zipio_create_io(&io_fa_dst);
+		zipFile zip = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, nullptr, &io_dst);
+
+		zip_folder_recursive(zip, tmp_dir_path, "", pkg_name);
+
+		zipClose(zip, nullptr);
+
+		if (tmp_app_dir->change_dir(tmp_dir_path) == OK) {
+			tmp_app_dir->erase_contents_recursive();
+			tmp_app_dir->change_dir("..");
+			tmp_app_dir->remove(pkg_name);
+		}
+	}
+
 	return err;
 }
 
@@ -86,12 +137,51 @@ String EditorExportPlatformLinuxBSD::get_template_file_name(const String &p_targ
 List<String> EditorExportPlatformLinuxBSD::get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const {
 	List<String> list;
 	list.push_back(p_preset->get("binary_format/architecture"));
+	list.push_back("zip");
+
 	return list;
 }
 
 void EditorExportPlatformLinuxBSD::get_export_options(List<ExportOption> *r_options) {
 	EditorExportPlatformPC::get_export_options(r_options);
+
 	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "binary_format/architecture", PROPERTY_HINT_ENUM, "x86_64,x86_32,arm64,arm32,rv64,ppc64,ppc32"), "x86_64"));
+
+	String run_script = "#!/usr/bin/env bash\n"
+						"export DISPLAY=:0\n"
+						"unzip -o -q \"{temp_dir}/{archive_name}\" -d \"{temp_dir}\"\n"
+						"\"{temp_dir}/{exe_name}\" {cmd_args}";
+
+	String cleanup_script = "#!/usr/bin/env bash\n"
+							"kill $(pgrep -x -f \"{temp_dir}/{exe_name} {cmd_args}\")\n"
+							"rm -rf \"{temp_dir}\"";
+
+	r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "ssh_remote_deploy/enabled"), false));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/host"), "user@host_ip"));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/port"), "22"));
+
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/extra_args_ssh", PROPERTY_HINT_MULTILINE_TEXT), ""));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/extra_args_scp", PROPERTY_HINT_MULTILINE_TEXT), ""));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/run_script", PROPERTY_HINT_MULTILINE_TEXT), run_script));
+	r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/cleanup_script", PROPERTY_HINT_MULTILINE_TEXT), cleanup_script));
+}
+
+bool EditorExportPlatformLinuxBSD::is_elf(const String &p_path) const {
+	Ref<FileAccess> fb = FileAccess::open(p_path, FileAccess::READ);
+	ERR_FAIL_COND_V_MSG(fb.is_null(), false, vformat("Can't open file: \"%s\".", p_path));
+	uint32_t magic = fb->get_32();
+	return (magic == 0x464c457f);
+}
+
+bool EditorExportPlatformLinuxBSD::is_shebang(const String &p_path) const {
+	Ref<FileAccess> fb = FileAccess::open(p_path, FileAccess::READ);
+	ERR_FAIL_COND_V_MSG(fb.is_null(), false, vformat("Can't open file: \"%s\".", p_path));
+	uint16_t magic = fb->get_16();
+	return (magic == 0x2123);
+}
+
+bool EditorExportPlatformLinuxBSD::is_executable(const String &p_path) const {
+	return is_elf(p_path) || is_shebang(p_path);
 }
 
 Error EditorExportPlatformLinuxBSD::fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size) {
@@ -200,3 +290,235 @@ Error EditorExportPlatformLinuxBSD::fixup_embedded_pck(const String &p_path, int
 	}
 	return OK;
 }
+
+Ref<Texture2D> EditorExportPlatformLinuxBSD::get_run_icon() const {
+	return run_icon;
+}
+
+bool EditorExportPlatformLinuxBSD::poll_export() {
+	Ref<EditorExportPreset> preset;
+
+	for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
+		Ref<EditorExportPreset> ep = EditorExport::get_singleton()->get_export_preset(i);
+		if (ep->is_runnable() && ep->get_platform() == this) {
+			preset = ep;
+			break;
+		}
+	}
+
+	int prev = menu_options;
+	menu_options = (preset.is_valid() && preset->get("ssh_remote_deploy/enabled").operator bool());
+	if (ssh_pid != 0 || !cleanup_commands.is_empty()) {
+		if (menu_options == 0) {
+			cleanup();
+		} else {
+			menu_options += 1;
+		}
+	}
+	return menu_options != prev;
+}
+
+Ref<ImageTexture> EditorExportPlatformLinuxBSD::get_option_icon(int p_index) const {
+	return p_index == 1 ? stop_icon : EditorExportPlatform::get_option_icon(p_index);
+}
+
+int EditorExportPlatformLinuxBSD::get_options_count() const {
+	return menu_options;
+}
+
+String EditorExportPlatformLinuxBSD::get_option_label(int p_index) const {
+	return (p_index) ? TTR("Stop and uninstall") : TTR("Run on remote Linux/BSD system");
+}
+
+String EditorExportPlatformLinuxBSD::get_option_tooltip(int p_index) const {
+	return (p_index) ? TTR("Stop and uninstall running project from the remote system") : TTR("Run exported project on remote Linux/BSD system");
+}
+
+void EditorExportPlatformLinuxBSD::cleanup() {
+	if (ssh_pid != 0 && OS::get_singleton()->is_process_running(ssh_pid)) {
+		print_line("Terminating connection...");
+		OS::get_singleton()->kill(ssh_pid);
+		OS::get_singleton()->delay_usec(1000);
+	}
+
+	if (!cleanup_commands.is_empty()) {
+		print_line("Stopping and deleting previous version...");
+		for (const SSHCleanupCommand &cmd : cleanup_commands) {
+			if (cmd.wait) {
+				ssh_run_on_remote(cmd.host, cmd.port, cmd.ssh_args, cmd.cmd_args);
+			} else {
+				ssh_run_on_remote_no_wait(cmd.host, cmd.port, cmd.ssh_args, cmd.cmd_args);
+			}
+		}
+	}
+	ssh_pid = 0;
+	cleanup_commands.clear();
+}
+
+Error EditorExportPlatformLinuxBSD::run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) {
+	cleanup();
+	if (p_device) { // Stop command, cleanup only.
+		return OK;
+	}
+
+	EditorProgress ep("run", TTR("Running..."), 5);
+
+	const String dest = EditorPaths::get_singleton()->get_cache_dir().path_join("linuxbsd");
+	Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+	if (!da->dir_exists(dest)) {
+		Error err = da->make_dir_recursive(dest);
+		if (err != OK) {
+			EditorNode::get_singleton()->show_warning(TTR("Could not create temp directory:") + "\n" + dest);
+			return err;
+		}
+	}
+
+	String host = p_preset->get("ssh_remote_deploy/host").operator String();
+	String port = p_preset->get("ssh_remote_deploy/port").operator String();
+	if (port.is_empty()) {
+		port = "22";
+	}
+	Vector<String> extra_args_ssh = p_preset->get("ssh_remote_deploy/extra_args_ssh").operator String().split(" ");
+	Vector<String> extra_args_scp = p_preset->get("ssh_remote_deploy/extra_args_scp").operator String().split(" ");
+
+	const String basepath = dest.path_join("tmp_linuxbsd_export");
+
+#define CLEANUP_AND_RETURN(m_err)                      \
+	{                                                  \
+		if (da->file_exists(basepath + ".zip")) {      \
+			da->remove(basepath + ".zip");             \
+		}                                              \
+		if (da->file_exists(basepath + "_start.sh")) { \
+			da->remove(basepath + "_start.sh");        \
+		}                                              \
+		if (da->file_exists(basepath + "_clean.sh")) { \
+			da->remove(basepath + "_clean.sh");        \
+		}                                              \
+		return m_err;                                  \
+	}                                                  \
+	((void)0)
+
+	if (ep.step(TTR("Exporting project..."), 1)) {
+		return ERR_SKIP;
+	}
+	Error err = export_project(p_preset, true, basepath + ".zip", p_debug_flags);
+	if (err != OK) {
+		DirAccess::remove_file_or_error(basepath + ".zip");
+		return err;
+	}
+
+	String cmd_args;
+	{
+		Vector<String> cmd_args_list;
+		gen_debug_flags(cmd_args_list, p_debug_flags);
+		for (int i = 0; i < cmd_args_list.size(); i++) {
+			if (i != 0) {
+				cmd_args += " ";
+			}
+			cmd_args += cmd_args_list[i];
+		}
+	}
+
+	const bool use_remote = (p_debug_flags & DEBUG_FLAG_REMOTE_DEBUG) || (p_debug_flags & DEBUG_FLAG_DUMB_CLIENT);
+	int dbg_port = EditorSettings::get_singleton()->get("network/debug/remote_port");
+
+	print_line("Creating temporary directory...");
+	ep.step(TTR("Creating temporary directory..."), 2);
+	String temp_dir;
+	err = ssh_run_on_remote(host, port, extra_args_ssh, "mktemp -d", &temp_dir);
+	if (err != OK || temp_dir.is_empty()) {
+		CLEANUP_AND_RETURN(err);
+	}
+
+	print_line("Uploading archive...");
+	ep.step(TTR("Uploading archive..."), 3);
+	err = ssh_push_to_remote(host, port, extra_args_scp, basepath + ".zip", temp_dir);
+	if (err != OK) {
+		CLEANUP_AND_RETURN(err);
+	}
+
+	{
+		String run_script = p_preset->get("ssh_remote_deploy/run_script");
+		run_script = run_script.replace("{temp_dir}", temp_dir);
+		run_script = run_script.replace("{archive_name}", basepath.get_file() + ".zip");
+		run_script = run_script.replace("{exe_name}", basepath.get_file());
+		run_script = run_script.replace("{cmd_args}", cmd_args);
+
+		Ref<FileAccess> f = FileAccess::open(basepath + "_start.sh", FileAccess::WRITE);
+		if (f.is_null()) {
+			CLEANUP_AND_RETURN(err);
+		}
+
+		f->store_string(run_script);
+	}
+
+	{
+		String clean_script = p_preset->get("ssh_remote_deploy/cleanup_script");
+		clean_script = clean_script.replace("{temp_dir}", temp_dir);
+		clean_script = clean_script.replace("{archive_name}", basepath.get_file() + ".zip");
+		clean_script = clean_script.replace("{exe_name}", basepath.get_file());
+		clean_script = clean_script.replace("{cmd_args}", cmd_args);
+
+		Ref<FileAccess> f = FileAccess::open(basepath + "_clean.sh", FileAccess::WRITE);
+		if (f.is_null()) {
+			CLEANUP_AND_RETURN(err);
+		}
+
+		f->store_string(clean_script);
+	}
+
+	print_line("Uploading scripts...");
+	ep.step(TTR("Uploading scripts..."), 4);
+	err = ssh_push_to_remote(host, port, extra_args_scp, basepath + "_start.sh", temp_dir);
+	if (err != OK) {
+		CLEANUP_AND_RETURN(err);
+	}
+	err = ssh_run_on_remote(host, port, extra_args_ssh, vformat("chmod +x \"%s/%s\"", temp_dir, basepath.get_file() + "_start.sh"));
+	if (err != OK || temp_dir.is_empty()) {
+		CLEANUP_AND_RETURN(err);
+	}
+	err = ssh_push_to_remote(host, port, extra_args_scp, basepath + "_clean.sh", temp_dir);
+	if (err != OK) {
+		CLEANUP_AND_RETURN(err);
+	}
+	err = ssh_run_on_remote(host, port, extra_args_ssh, vformat("chmod +x \"%s/%s\"", temp_dir, basepath.get_file() + "_clean.sh"));
+	if (err != OK || temp_dir.is_empty()) {
+		CLEANUP_AND_RETURN(err);
+	}
+
+	print_line("Starting project...");
+	ep.step(TTR("Starting project..."), 5);
+	err = ssh_run_on_remote_no_wait(host, port, extra_args_ssh, vformat("\"%s/%s\"", temp_dir, basepath.get_file() + "_start.sh"), &ssh_pid, (use_remote) ? dbg_port : -1);
+	if (err != OK) {
+		CLEANUP_AND_RETURN(err);
+	}
+
+	cleanup_commands.clear();
+	cleanup_commands.push_back(SSHCleanupCommand(host, port, extra_args_ssh, vformat("\"%s/%s\"", temp_dir, basepath.get_file() + "_clean.sh")));
+
+	print_line("Project started.");
+
+	CLEANUP_AND_RETURN(OK);
+#undef CLEANUP_AND_RETURN
+}
+
+EditorExportPlatformLinuxBSD::EditorExportPlatformLinuxBSD() {
+#ifdef MODULE_SVG_ENABLED
+	Ref<Image> img = memnew(Image);
+	const bool upsample = !Math::is_equal_approx(Math::round(EDSCALE), EDSCALE);
+
+	ImageLoaderSVG img_loader;
+	img_loader.create_image_from_string(img, _linuxbsd_logo_svg, EDSCALE, upsample, false);
+	set_logo(ImageTexture::create_from_image(img));
+
+	img_loader.create_image_from_string(img, _linuxbsd_run_icon_svg, EDSCALE, upsample, false);
+	run_icon = ImageTexture::create_from_image(img);
+#endif
+
+	Ref<Theme> theme = EditorNode::get_singleton()->get_editor_theme();
+	if (theme.is_valid()) {
+		stop_icon = theme->get_icon(SNAME("Stop"), SNAME("EditorIcons"));
+	} else {
+		stop_icon.instantiate();
+	}
+}
diff --git a/platform/linuxbsd/export/export_plugin.h b/platform/linuxbsd/export/export_plugin.h
index 71cf18ff3e..4f860c3fd0 100644
--- a/platform/linuxbsd/export/export_plugin.h
+++ b/platform/linuxbsd/export/export_plugin.h
@@ -34,19 +34,58 @@
 #include "core/io/file_access.h"
 #include "editor/editor_settings.h"
 #include "editor/export/editor_export_platform_pc.h"
-#include "platform/linuxbsd/logo.gen.h"
 #include "scene/resources/texture.h"
 
 class EditorExportPlatformLinuxBSD : public EditorExportPlatformPC {
+	HashMap<String, String> extensions;
+
+	struct SSHCleanupCommand {
+		String host;
+		String port;
+		Vector<String> ssh_args;
+		String cmd_args;
+		bool wait = false;
+
+		SSHCleanupCommand(){};
+		SSHCleanupCommand(const String &p_host, const String &p_port, const Vector<String> &p_ssh_arg, const String &p_cmd_args, bool p_wait = false) {
+			host = p_host;
+			port = p_port;
+			ssh_args = p_ssh_arg;
+			cmd_args = p_cmd_args;
+			wait = p_wait;
+		};
+	};
+
+	Ref<ImageTexture> run_icon;
+	Ref<ImageTexture> stop_icon;
+
+	Vector<SSHCleanupCommand> cleanup_commands;
+	OS::ProcessID ssh_pid = 0;
+	int menu_options = 0;
+
+	bool is_elf(const String &p_path) const;
+	bool is_shebang(const String &p_path) const;
+
 	Error _export_debug_script(const Ref<EditorExportPreset> &p_preset, const String &p_app_name, const String &p_pkg_name, const String &p_path);
 
 public:
-	void set_extension(const String &p_extension, const String &p_feature_key = "default");
-	virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const override;
 	virtual void get_export_options(List<ExportOption> *r_options) override;
+	virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const override;
 	virtual Error export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0) override;
 	virtual String get_template_file_name(const String &p_target, const String &p_arch) const override;
 	virtual Error fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size) override;
+	virtual bool is_executable(const String &p_path) const override;
+
+	virtual Ref<Texture2D> get_run_icon() const override;
+	virtual bool poll_export() override;
+	virtual Ref<ImageTexture> get_option_icon(int p_index) const override;
+	virtual int get_options_count() const override;
+	virtual String get_option_label(int p_index) const override;
+	virtual String get_option_tooltip(int p_index) const override;
+	virtual Error run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) override;
+	virtual void cleanup() override;
+
+	EditorExportPlatformLinuxBSD();
 };
 
 #endif // LINUXBSD_EXPORT_PLUGIN_H