Merge pull request #290 from Faless/fix/disable_zlib_detection

ssh2: Disable zlib detection

.gitattributes

@@ -1,14 +1,2 @@
 # Normalize EOL for all files that Git considers text files.
 * text=auto eol=lf
-
-# Ignore some files when exporting to a ZIP.
-/.github/           			export-ignore
-/godot-cpp/           			export-ignore
-/godot-git-plugin/           	export-ignore
-/thirdparty/           			export-ignore
-/.gitattributes     			export-ignore
-/.gitignore         			export-ignore
-/.gitmodules         			export-ignore
-/api.ci.json         			export-ignore
-/build_openssl_universal_oxs.sh	export-ignore
-/SConstruct						export-ignore

.github/workflows/build.yml

@@ -2,59 +2,93 @@ name: C/C++ CI
 
 on: [push, pull_request]
 
+env:
+  # Only used for the cache key. Increment version to force clean build.
+  GODOT_BASE_BRANCH: master
+  SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
+
 jobs:
   linux-x64:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v2
-      - name: build-linux-release-x64
-        run: |
-          git submodule update --init --recursive
-          pip3 install --user scons
-          scons platform=linux target=release bits=64 godot_cpp=yes generate_bindings=yes use_custom_api_file=yes custom_api_file=api.ci.json -j $(nproc)
-          ldd demo/addons/godot-git-plugin/linux/libgitapi.so
-      - uses: actions/upload-artifact@v2
+      - uses: actions/checkout@v4
         with:
-          name: godot-git-plugin-linux-release-x64-${{ github.sha }}
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: linux-x86_64
+        continue-on-error: true
+      - name: Build for Linux editor x86_64
+        run: |
+          pip3 install scons
+          scons platform=linux arch=x86_64 target=editor generate_bindings=yes
+          ldd addons/godot-git-plugin/linux/*.so
+      - name: Prepare artifact
+        run: |
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: libgit_plugin.linux.x86_64.editor.so-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/
 
   windows-x64:
-    runs-on: windows-2019
+    runs-on: windows-2022
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v4
         with:
-          python-version: "3.x"
-          architecture: "x64"
-      - uses: ilammy/msvc-dev-cmd@v1
-      - name: build-windows-release-x64
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: windows-x86_64
+      - uses: ilammy/msvc-dev-cmd@v1  # For dumpbin.
+      - uses: ilammy/setup-nasm@v1
+      - name: Build for Windows editor x86_64
+        shell: powershell
         run: |
-          git submodule update --init --recursive
-          pip3 install --user scons
-          scons platform=windows target=release bits=64 godot_cpp=yes generate_bindings=yes use_custom_api_file=yes custom_api_file=api.ci.json -j $env:NUMBER_OF_PROCESSORS
-          dumpbin /dependents .\demo\addons\godot-git-plugin\win64\libgitapi.dll
-      - uses: actions/upload-artifact@v2
+          pip3 install scons
+          scons platform=windows arch=x86_64 target=editor generate_bindings=yes
+          dumpbin /dependents .\addons\godot-git-plugin\windows\*.dll
+      - name: Prepare artifact
+        shell: bash
+        run: |
+          # Not needed to use the plugin.
+          rm -f addons/godot-git-plugin/windows/*.{exp,lib}
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
         with:
-          name: godot-git-plugin-windows-release-x64-${{ github.sha }}
+          name: libgit_plugin.windows.x86_64.editor.dll-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/
 
-  macos-x64:
-    runs-on: macos-11
+  macos-universal:
+    runs-on: macos-15
     steps:
-      - uses: actions/checkout@v2
-      - name: build-macos-release-x64
-        run: |
-          git submodule update --init --recursive
-          brew install scons
-          scons platform=osx target=release bits=64 godot_cpp=yes generate_bindings=yes use_custom_api_file=yes custom_api_file=api.ci.json macos_arch=universal use_llvm=yes -j $(sysctl -n hw.logicalcpu)
-          otool -L demo/addons/godot-git-plugin/osx/libgitapi.dylib
-      - uses: actions/upload-artifact@v2
+      - uses: actions/checkout@v4
         with:
-          name: godot-git-plugin-macos-release-x64-${{ github.sha }}
+          submodules: recursive
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: macos-universal
+      - name: Build for macOS editor universal
+        run: |
+          pip install scons
+          scons platform=macos arch=universal target=editor generate_bindings=yes macos_deployment_target=10.13
+          otool -L addons/godot-git-plugin/macos/*.dylib
+      - name: Prepare artifact
+        run: |
+          mkdir out
+          mv addons out/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: libgit_plugin.macos.universal.editor.dylib-${{ github.sha }}
           if-no-files-found: error
           path: |
-            demo/
+            out/

.github/workflows/clang-format.yml

@@ -7,9 +7,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: DoozyX/clang-format-lint-action@v0.11
+      - uses: actions/checkout@v4
+      - uses: DoozyX/clang-format-lint-action@v0.18.2
         with:
           source: "godot-git-plugin/src"
           extensions: "h,cpp"
-          clangFormatVersion: 11
+          clangFormatVersion: 18

.gitignore

@@ -2,7 +2,8 @@
 *.dblite
 
 # Godot Serialisations
-api.json
+extension_api.json
+!/ci/extension_api.json
 
 # Visual Studio Cache
 .vs/
@@ -13,10 +14,14 @@ api.json
 # Mac stuff
 .DS_Store
 
+# Vim
+*.swp
+
 # Binaries
+__pycache__/
 build/
 bin/
-osx/
+macos/
 linux/
 win64/
 *.lib
@@ -25,4 +30,8 @@ win64/
 *.os
 *.ilk
 *.pdb
-!thirdparty/openssl/*
+*.pyc
+*.zip
+
+# Misc
+*.log

.gitmodules

@@ -2,9 +2,13 @@
 	path = godot-cpp
 	url = https://github.com/godotengine/godot-cpp
 	branch = 3.x
-[submodule "libgit2"]
+[submodule "thirdparty/git2/libgit2"]
 	path = thirdparty/git2/libgit2
 	url = https://github.com/libgit2/libgit2
+	ignore = untracked
 [submodule "thirdparty/ssh2/libssh2"]
 	path = thirdparty/ssh2/libssh2
 	url = https://github.com/libssh2/libssh2
+[submodule "thirdparty/openssl"]
+	path = thirdparty/openssl
+	url = https://github.com/openssl/openssl

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016-2022 The Godot Engine community
+Copyright (c) 2016-2023 The Godot Engine community
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,52 +1,59 @@
 [![C/C++ CI](https://github.com/godotengine/godot-git-plugin/actions/workflows/build.yml/badge.svg)](https://github.com/godotengine/godot-git-plugin/actions/workflows/build.yml)
 
-# GDNative Based Git Plugin for Godot Version Control Editor Plugin
+<img src="/icon.png" width="25%" />
+
+# Godot Git Plugin
 
 Git implementation of the Godot Engine VCS interface in Godot. We use [libgit2](https://libgit2.org) as our backend to simulate Git in code.
 
-> Planned for the upcoming version of Godot. Look for other branches for support in other Godot releases.
+## Installation
 
-## Installation Instructions
-
-1.  Grab the platform binaries here: <https://github.com/godotengine/godot-git-plugin/releases>
+1.  Grab the platform binaries here: https://github.com/godotengine/godot-git-plugin/releases
 2.  Then read the installation instructions: https://github.com/godotengine/godot-git-plugin/wiki
 
-## Build Instructions
+## Build
 
 This section onwards is only meant to be used if you intend to compile the plugin from source.
 
-### Required Tools
+### Required tools
 
-- Full copy of the source code. Remember to use `git clone --recursive`.
-- [SCons](https://scons.org/pages/download.html) (v3.0.1+)
+- Full copy of the source code. Remember to use `git clone --recursive`, or initialize submodules with `git submodule update --init`.
+- [SCons](https://scons.org/pages/download.html) (v3.1.2+), CMake, and Perl.
 - C++17 and C90 compilers detectable by SCons and present in `PATH`.
-- Platforms Specific Setup
-  - Windows
-    - No extra steps required other than setting up the compilers.
-  - MacOS
-    - For making universal builds targeting both Apple Silicon and x86_64, you can optionally run `build_openssl_universal_osx.sh` to build OpenSSL yourself and replace the already prebuilt libraries provided inside `thirdparty/openssl/`, otherwise, just run `brew install openssl@1.1`.
-  - Linux
-    - Run `sudo apt-get install libssl-dev`, or local package manager equivalent.
 
-### Build
+### Release build
 
 ```
-scons platform=<platform> target=release bits=64 -j 6
+scons platform=<platform> target=editor
 ```
 
+> You may get the GDExtension dump yourself from Godot using the instructions in the next section, or use the ones provided in `godot-cpp`.
+
 For more build options, run `scons platform=<platform> -h`
 
-## Bleeding Edge
+## Dev builds
 
-Most of the times when new features are being worked on for the Godot VCS Integration, it requires developers to make changes in the Godot Editor source code along with this plugin. This means we need to manually generate the GDNative API from the custom Godot builds and then use it to compile godot-cpp.
+When new features are being worked on for the Godot VCS Integration, the build process sometimes requires developers to make changes in the GDExtension API along with this plugin. This means we need to manually generate the GDExtension API from the custom Godot builds and use it to compile godot-cpp, and then finally link the resulting godot-cpp binary into this plugin.
 
-To build using custom GDNative API definition JSON files, run the below helper command:
+If you need to use a custom GDExtension API:
 
-```
-scons platform=<platform> target=debug godot_cpp=yes generate_bindings=yes bits=64 use_custom_api_file=yes custom_api_file=path/to/api.json -j 6
+1. Dump the new bindings from the custom Godot build.
+
+```shell
+./path/to/godot/bin/godot.<platform>.editor.<arch> --headless --dump-gdextension-interface --dump-extension-api
 ```
 
-Once this command can completed successfully, the standard build commands in the above section can be run without recompiling godot-cpp. To stop godot-cpp from recompiling, do not use the `godot_cpp` option in SCons arguments. To view more options available while recompiling godot-cpp, run `scons platform=<platform> godot_cpp=yes -h`.
+2. Build the plugin along with the godot-cpp library.
+
+```
+scons platform=<platform> target=editor generate_bindings=yes dev_build=yes
+```
+
+> You only need to build godot-cpp once every change in the GDExtension API, hence, `generate_bindings=yes` should only be passed in during the first time after generating a new GDExtension API dump.
+
+3. To test the plugin, set up a testing project with Godot, and copy or symlink the `addons` folder.
+
+To view more options available while recompiling godot-git-plugin, run `scons platform=<platform> -h`.
 
 ---
 

SConstruct

@@ -2,63 +2,51 @@
 
 import os
 
-EnsureSConsVersion(3, 0, 0)
-EnsurePythonVersion(3, 5)
+EnsureSConsVersion(3, 1, 2)
+EnsurePythonVersion(3, 6)
 
 opts = Variables([], ARGUMENTS)
 
 env = Environment(ENV=os.environ)
 
 # Define our options
-opts.Add(EnumVariable("target", "Compilation target",
-         "debug", ["d", "debug", "r", "release"]))
-opts.Add(EnumVariable("platform", "Compilation platform",
-         "", ["", "windows", "linux", "osx"]))
-opts.Add(EnumVariable("p", "Compilation target, alias for \"platform\"",
-         "", ["", "windows", "linux", "osx"]))
-opts.Add(BoolVariable(
-    "godot_cpp", "Build godot-cpp by forwarding arguments to it.", "no"))
-opts.Add(BoolVariable("use_llvm",
-         "Use the LLVM / Clang compiler - only effective when targeting Linux or FreeBSD.", "no"))
 opts.Add(PathVariable("target_path",
-         "The path where the lib is installed.", "demo/addons/godot-git-plugin/"))
+         "The path where the lib is installed.", "addons/godot-git-plugin/"))
 opts.Add(PathVariable("target_name", "The library name.",
-         "libgitapi", PathVariable.PathAccept))
-opts.Add(EnumVariable("bits", "The bit architecture.", "64", ["64"]))
-opts.Add(EnumVariable("macos_arch", "Target macOS architecture",
-         "universal", ["universal", "x86_64", "arm64"]))
-opts.Add(PathVariable("macos_openssl", "Path to OpenSSL library root - only used in macOS builds.",
-                      "/usr/local/opt/openssl@1.1/", PathVariable.PathAccept))  # TODO: Find a way to configure this to use the cloned OpenSSL source code, based on `macos_arch`.
-opts.Add(PathVariable("macos_openssl_static_ssl", "Path to OpenSSL libssl.a library - only used in macOS builds.",
-         os.path.join(os.path.abspath(os.getcwd()), "thirdparty/openssl/libssl.a"), PathVariable.PathAccept))
-opts.Add(PathVariable("macos_openssl_static_crypto", "Path to OpenSSL libcrypto.a library - only used in macOS builds.",
-         os.path.join(os.path.abspath(os.getcwd()), "thirdparty/openssl/libcrypto.a"), PathVariable.PathAccept))
+         "libgit_plugin", PathVariable.PathAccept))
 
 # Updates the environment with the option variables.
 opts.Update(env)
 
-if env["platform"] == "osx":
-    # Use only clang on osx because we need to do universal builds
-    env["CXX"] = "clang++"
-    env["CC"] = "clang"
+if ARGUMENTS.get("custom_api_file", "") != "":
+    ARGUMENTS["custom_api_file"] = "../" + ARGUMENTS["custom_api_file"]
 
-    if env["macos_arch"] == "universal":
-        env.Append(LINKFLAGS=["-arch", "x86_64", "-arch", "arm64"])
-        env.Append(CCFLAGS=["-arch", "x86_64", "-arch", "arm64"])
-    else:
-        env.Append(LINKFLAGS=["-arch", env["macos_arch"]])
-        env.Append(CCFLAGS=["-arch", env["macos_arch"]])
+ARGUMENTS["target"] = "editor"
+env = SConscript("godot-cpp/SConstruct").Clone()
+env.PrependENVPath("PATH", os.getenv("PATH"))  # Prepend PATH, done upstream in recent godot-cpp verions.
 
+# Force linking with LTO on windows MSVC, silence the linker complaining that libgit uses LTO but we are not linking with it.
+if env["platform"] == "windows" and env.get("is_msvc", False):
+    env.AppendUnique(LINKFLAGS=["/LTCG"])
+
+# OpenSSL Builder
+env.Tool("openssl", toolpath=["tools"])
+
+# SSH2 Builder
+env.Tool("cmake", toolpath=["tools"])
+env.Tool("ssh2", toolpath=["tools"])
+env.Tool("git2", toolpath=["tools"])
+
+opts.Update(env)
+
+ssl = env.OpenSSL()
+ssh2 = env.BuildSSH2(ssl)
+ssl += ssh2
+git2 = env.BuildGIT2(ssl)
+
+Export("ssl")
 Export("env")
 
-SConscript("thirdparty/SCsub")
-
-if env["godot_cpp"]:
-    if ARGUMENTS.get("use_custom_api_file", False) and ARGUMENTS.get("custom_api_file", "") != "":
-        ARGUMENTS["custom_api_file"] = "../" + ARGUMENTS["custom_api_file"]
-
-    SConscript("godot-cpp/SConstruct")
-
 SConscript("godot-git-plugin/SCsub")
 
 # Generates help for the -h scons option.

THIRDPARTY.md

@@ -2,13 +2,10 @@
 
 The Godot Git Plugin source code uses the following third-party source code:
 
-1. godotengine/godot-cpp - MIT License - https://github.com/godotengine/godot-cpp/tree/99e9dd1d9396ed3af40678263b509078e5265ffc
+1. godotengine/godot-cpp - MIT License - https://github.com/godotengine/godot-cpp/tree/02336831735fd6affbe0a6fa252ec98d3e78120c
 2. libgit2/libgit2 - GPLv2 with a special Linking Exception - https://github.com/libgit2/libgit2/tree/b7bad55e4bb0a285b073ba5e02b01d3f522fc95d
 3. libssh2/libssh2 - BSD-3-Clause License - https://github.com/libssh2/libssh2/tree/635caa90787220ac3773c1d5ba11f1236c22eae8
-
-We also link to these third-party libraries (only in the compiled binary form):
-
-1. OpenSSL - Only on Linux and MacOS - OpenSSL License - http://www.openssl.org/source/openssl-1.1.1i.tar.gz
+4. openssl - OpenSSL License - https://github.com/openssl/openssl/tree/26baecb28ce461696966dac9ac889629db0b3b96
 
 ## License Texts
 
@@ -17,7 +14,7 @@ We also link to these third-party libraries (only in the compiled binary form):
 ```
 # MIT License
 
-Copyright (c) 2017-2021 Godot Engine contributors.
+Copyright (c) 2017-2022 Godot Engine contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

addons/godot-git-plugin/git_plugin.gdextension

@@ -0,0 +1,10 @@
+[configuration]
+
+entry_symbol = "git_plugin_init"
+compatibility_minimum = "4.2.0"
+
+[libraries]
+
+linux.editor.x86_64 = "linux/libgit_plugin.linux.editor.x86_64.so"
+macos.editor = "macos/libgit_plugin.macos.editor.universal.dylib"
+windows.editor.x86_64 = "windows/libgit_plugin.windows.editor.x86_64.dll"

build_openssl_universal_osx.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-OPENSSL_VERSION="1.1.1i"
-
-curl -OL http://www.openssl.org/source/openssl-$OPENSSL_VERSION.tar.gz
-tar -xzvf openssl-$OPENSSL_VERSION.tar.gz
-mv openssl-$OPENSSL_VERSION openssl_arm64
-tar -xzvf openssl-$OPENSSL_VERSION.tar.gz
-mv openssl-$OPENSSL_VERSION openssl_x86_64
-cd openssl_arm64
-./Configure darwin64-arm64-cc
-make
-cd ../
-cd openssl_x86_64
-./Configure darwin64-x86_64-cc
-make
-cd ../
-lipo -create openssl_arm64/libcrypto.a openssl_x86_64/libcrypto.a -output libcrypto.a
-lipo -create openssl_arm64/libssl.a openssl_x86_64/libssl.a -output libssl.a
-rm openssl-$OPENSSL_VERSION.tar.gz

demo/.gitattributes

@@ -1,17 +0,0 @@
-# Set the default behavior, in case people don't have core.autocrlf set.
-* text=auto
-
-# Explicitly declare text files you want to always be normalized and converted
-# to native line endings on checkout.
-*.cpp text
-*.c text
-*.h text
-*.gd text
-*.cs text
-
-# Declare files that will always have CRLF line endings on checkout.
-*.sln text eol=crlf
-
-# Denote all files that are truly binary and should not be modified.
-*.png binary
-*.jpg binary

demo/.gitignore

@@ -1,11 +0,0 @@
-# Godot-specific ignores
-.import/
-export.cfg
-export_presets.cfg
-
-# Imported translations (automatically generated from CSV files)
-*.translation
-
-# Mono-specific ignores
-.mono/
-data_*/

demo/addons/godot-git-plugin/git_api.gdnlib

@@ -1,18 +0,0 @@
-[general]
-
-load_once=true
-symbol_prefix="godot_"
-reloadable=false
-singleton=false
-
-[entry]
-
-OSX.64="res://addons/godot-git-plugin/osx/libgitapi.dylib"
-Windows.64="res://addons/godot-git-plugin/win64/libgitapi.dll"
-X11.64="res://addons/godot-git-plugin/linux/libgitapi.so"
-
-[dependencies]
-
-OSX.64=[  ]
-Windows.64=[  ]
-X11.64=[  ]

demo/addons/godot-git-plugin/git_api.gdns

@@ -1,9 +0,0 @@
-[gd_resource type="NativeScript" load_steps=2 format=2]
-
-[ext_resource path="res://addons/godot-git-plugin/git_api.gdnlib" type="GDNativeLibrary" id=1]
-
-[resource]
-resource_name = "GitAPI"
-class_name = "GitAPI"
-library = ExtResource( 1 )
-script_class_name = "GitAPI"

demo/addons/godot-git-plugin/plugin.cfg

@@ -1,7 +0,0 @@
-[plugin]
-
-name="Godot Git Plugin"
-description="This plugin lets you interact with Git without leaving the Godot editor. More information can be found at https://github.com/godotengine/godot-git-plugin/wiki"
-author="ChronicallySerious"
-version="v2.0.0"
-script="git_api.gdns"

demo/default_env.tres

@@ -1,7 +0,0 @@
-[gd_resource type="Environment" load_steps=2 format=2]
-
-[sub_resource type="ProceduralSky" id=1]
-
-[resource]
-background_mode = 2
-background_sky = SubResource( 1 )

demo/demo.tscn

@@ -1,3 +0,0 @@
-[gd_scene format=2]
-
-[node name="Node2D" type="Node2D"]

demo/icon.png.import

@@ -1,35 +0,0 @@
-[remap]
-
-importer="texture"
-type="StreamTexture"
-path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex"
-metadata={
-"vram_texture": false
-}
-
-[deps]
-
-source_file="res://icon.png"
-dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" ]
-
-[params]
-
-compress/mode=0
-compress/lossy_quality=0.7
-compress/hdr_mode=0
-compress/bptc_ldr=0
-compress/normal_map=0
-flags/repeat=0
-flags/filter=true
-flags/mipmaps=false
-flags/anisotropic=false
-flags/srgb=2
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/HDR_as_SRGB=false
-process/invert_color=false
-process/normal_map_invert_y=false
-stream=false
-size_limit=0
-detect_3d=true
-svg/scale=1.0

demo/new_script.gd

@@ -1,16 +0,0 @@
-extends Node
-
-
-# Declare member variables here. Examples:
-# var a = 2
-# var b = "text"
-
-
-# Called when the node enters the scene tree for the first time.
-func _ready():
-	print("Hello Godot!")
-	pass # Replace with function body.
-
-# Called every frame. 'delta' is the elapsed time since the previous frame.
-#func _process(delta):
-#	pass

demo/project.godot

@@ -1,34 +0,0 @@
-; Engine configuration file.
-; It's best edited using the editor UI and not directly,
-; since the parameters that go here are not all obvious.
-;
-; Format:
-;   [section] ; section goes between []
-;   param=value ; assign values to parameters
-
-config_version=4
-
-_global_script_classes=[ {
-"base": "EditorVCSInterface",
-"class": "GitAPI",
-"language": "NativeScript",
-"path": "res://addons/godot-git-plugin/git_api.gdns"
-} ]
-_global_script_class_icons={
-"GitAPI": ""
-}
-
-[application]
-
-config/name="demo"
-run/main_scene="res://demo.tscn"
-config/icon="res://icon.png"
-
-[editor]
-
-version_control/autoload_on_startup=true
-version_control/plugin_name="GitAPI"
-
-[rendering]
-
-environment/default_environment="res://default_env.tres"

godot-git-plugin/SCsub

@@ -4,23 +4,7 @@ import os
 
 env = {}
 Import("env")
-
-godot_headers_path = "../godot-cpp/godot-headers/"
-cpp_bindings_path = "../godot-cpp/"
-cpp_library = "libgodot-cpp"
-bits = env["bits"]
-
-# Process some arguments
-if env["use_llvm"]:
-    env["CC"] = "clang"
-    env["CXX"] = "clang++"
-
-if env["p"] != "":
-    env["platform"] = env["p"]
-
-if env["platform"] == "":
-    print("No valid target platform selected.")
-    quit()
+Import("ssl")
 
 env["target_path"] = "../" + env["target_path"]
 
@@ -28,65 +12,27 @@ if not os.path.isdir(env["target_path"]):
     os.mkdir(env["target_path"])
 
 # Check our platform specifics
-if env["platform"] == "osx":
-    env["target_path"] += "osx/"
-    cpp_library += ".osx"
-
-    # Force static linkage (https://stackoverflow.com/a/2995999/7370948)
-    static_ssl = File(env["macos_openssl_static_ssl"])
-    static_crypto = File(env["macos_openssl_static_crypto"])
-    env.Append(LIBS=[static_ssl, static_crypto])
-
-    if env["target"] in ("debug", "d"):
-        env.Append(CCFLAGS=["-g", "-O2", "-std=c++17"])
-    else:
-        env.Append(CCFLAGS=["-g", "-O3", "-std=c++17"])
-
-elif env["platform"] == "linux":
-    env["target_path"] += "linux/"
-    cpp_library += ".linux"
-    env.Append(LIBS=["ssl", "crypto"])
-
-    if env["target"] in ("debug", "d"):
-        env.Append(CCFLAGS=["-fPIC", "-g3", "-Og", "-std=c++17"])
-    else:
-        env.Append(CCFLAGS=["-fPIC", "-g", "-O3", "-std=c++17"])
+env["target_path"] += env["platform"] + "/"
 
+if env["platform"] == "macos":
+    if env["macos_deployment_target"] != "default":
+        env.Append(CCFLAGS=["-mmacosx-version-min=" +
+                            env["macos_deployment_target"]])
+        env.Append(LINKFLAGS=["-mmacosx-version-min=" +
+                              env["macos_deployment_target"]])
 elif env["platform"] == "windows":
-    env["target_path"] += "win64/"
-    cpp_library += ".windows"
-    # This makes sure to keep the session environment variables on windows,
-    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
-    env.Append(ENV=os.environ)
-
-    env.Append(CCFLAGS=["-DWIN32", "-D_WIN32", "-D_WINDOWS",
-               "-W3", "-GR", "-D_CRT_SECURE_NO_WARNINGS", "/std:c++17"])
-    env.Append(LIBS=["Advapi32", "Winhttp", "Rpcrt4",
-               "crypt32", "OLE32", "user32"])
-    if env["target"] in ("debug", "d"):
-        env.Append(CCFLAGS=["-EHsc", "-D_DEBUG", "-MDd", "/DEBUG"])
-        env["PDB"] = env["target_name"] + ".pdb"
-    else:
-        env.Append(CCFLAGS=["-O2", "-EHsc", "-DNDEBUG", "-MD"])
-
-if env["target"] in ("debug", "d"):
-    cpp_library += ".debug"
-else:
-    cpp_library += ".release"
-
-if env['platform'] == 'osx' and env['macos_arch'] != 'universal':
-    cpp_library += "." + env['macos_arch']
-else:
-    cpp_library += "." + str(bits)
+    env.Append(LIBS=["advapi32", "winhttp", "rpcrt4", "crypt32",
+               "ole32", "user32", "wsock32", "ws2_32", "bcrypt"])
 
 env.Append(CPPPATH=[".", "src/"])
-env.Append(CPPPATH=[godot_headers_path, cpp_bindings_path + "include/",
-           cpp_bindings_path + "include/core/", cpp_bindings_path + "include/gen/"])
-env.Append(CPPPATH=["../thirdparty/git2/libgit2/include/"])
-env.Append(LIBPATH=[cpp_bindings_path + "bin/", "../thirdparty/bin/"])
-env.Prepend(LIBS=[cpp_library, "git2", "ssh2"])
 
+env.Append(CPPPATH=["#thirdparty/git2/libgit2/include/"])
+
+lib_sources = Glob("src/*.cpp")
+env.Depends(lib_sources, ssl)
 library = env.SharedLibrary(
-    target=env["target_path"] + env["target_name"],
-    source=Glob("src/*.cpp"))
+    target=env["target_path"] +
+    "{}{}{}".format(env["target_name"], env["suffix"], env["SHLIBSUFFIX"]),
+    source=lib_sources
+)
 Default(library)

godot-git-plugin/src/allocation_defs.h

@@ -1,7 +0,0 @@
-#ifndef ALLOCATION_DEF_H
-#define ALLOCATION_DEF_H
-
-#define memnew(klass) new klass()
-#define memdelete(pointer) pointer ? delete pointer : WARN_PRINT("GitAPI: Tried to delete a NULL object");
-
-#endif // !ALLOCATION_DEF_H

godot-git-plugin/src/gdlibrary.cpp

@@ -1,20 +1,31 @@
-#include "git_api.h"
+#include "git_plugin.h"
 
-#include <Godot.hpp>
+#include "godot_cpp/core/class_db.hpp"
+#include "godot_cpp/godot.hpp"
 
-extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
-	godot::Godot::gdnative_init(o);
+void initialize_git_plugin_module(godot::ModuleInitializationLevel p_level) {
+	if (p_level != godot::MODULE_INITIALIZATION_LEVEL_EDITOR) {
+		return;
+	}
+
+	godot::ClassDB::register_class<GitPlugin>();
 }
 
-extern "C" void GDN_EXPORT godot_gdnative_singleton(godot_gdnative_init_options *o) {
+void uninitialize_git_plugin_module(godot::ModuleInitializationLevel p_level) {
+	if (p_level != godot::MODULE_INITIALIZATION_LEVEL_EDITOR) {
+		return;
+	}
 }
 
-extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
-	godot::Godot::gdnative_terminate(o);
-}
+extern "C" {
 
-extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
-	godot::Godot::nativescript_init(handle);
+GDExtensionBool GDE_EXPORT git_plugin_init(const GDExtensionInterfaceGetProcAddress p_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
+	godot::GDExtensionBinding::InitObject init_obj(p_address, p_library, r_initialization);
 
-	godot::register_tool_class<godot::GitAPI>();
+	init_obj.register_initializer(initialize_git_plugin_module);
+	init_obj.register_terminator(uninitialize_git_plugin_module);
+	init_obj.set_minimum_library_initialization_level(godot::MODULE_INITIALIZATION_LEVEL_EDITOR);
+
+	return init_obj.init();
+}
 }

godot-git-plugin/src/git_api.h

@@ -1,153 +0,0 @@
-#ifndef GIT_API_H
-#define GIT_API_H
-
-#include <memory>
-#include <vector>
-
-#include <GodotGlobal.hpp>
-#include <AcceptDialog.hpp>
-#include <Button.hpp>
-#include <Control.hpp>
-#include <Directory.hpp>
-#include <EditorVCSInterface.hpp>
-#include <File.hpp>
-#include <Godot.hpp>
-#include <LineEdit.hpp>
-#include <OS.hpp>
-
-#include <allocation_defs.h>
-#include <git_common.h>
-
-#include <git2.h>
-
-namespace godot {
-
-class GitAPI;
-
-struct DiffHelper {
-	Array *diff_hunks;
-	GitAPI *git_api;
-};
-
-struct CString {
-	char *data = nullptr;
-
-	CString() = delete;
-	CString(const String &string) :
-			data(string.alloc_c_string()) {}
-	CString(CString &&) = delete;
-	CString &operator=(const CString &) = delete;
-	CString &operator=(CString &&) = delete;
-
-	~CString() {
-		if (data) {
-			godot::api->godot_free(data);
-			data = nullptr;
-		}
-	}
-};
-
-template <class T>
-class Capture {
-	T &smart_ptr = nullptr;
-
-	using Raw = decltype(smart_ptr.get());
-
-	Raw raw = nullptr;
-
-public:
-	Capture() = delete;
-	Capture(T &ptr) :
-			smart_ptr(ptr) {}
-	Capture(Capture &&) = delete;
-	Capture &operator=(const Capture &) = delete;
-	Capture &operator=(Capture &&) = delete;
-
-	operator Raw *() {
-		return &raw;
-	}
-
-	~Capture() {
-		if (raw) {
-			smart_ptr.reset(raw);
-		}
-	}
-};
-
-template <auto DeleteFn>
-struct FunctionDeleter {
-	template <class T>
-	void operator()(T *ptr) {
-		DeleteFn(ptr);
-	}
-};
-
-template <class T, auto DeleteFn>
-using unique_ptr_deleter = std::unique_ptr<T, FunctionDeleter<DeleteFn>>;
-
-using git_annotated_commit_ptr = unique_ptr_deleter<git_annotated_commit, git_annotated_commit_free>;
-using git_blob_ptr = unique_ptr_deleter<git_blob, git_blob_free>;
-using git_branch_iterator_ptr = unique_ptr_deleter<git_branch_iterator, git_branch_iterator_free>;
-using git_commit_ptr = unique_ptr_deleter<git_commit, git_commit_free>;
-using git_diff_ptr = unique_ptr_deleter<git_diff, git_diff_free>;
-using git_index_ptr = unique_ptr_deleter<git_index, git_index_free>;
-using git_object_ptr = unique_ptr_deleter<git_object, git_object_free>;
-using git_patch_ptr = unique_ptr_deleter<git_patch, git_patch_free>;
-using git_reference_ptr = unique_ptr_deleter<git_reference, git_reference_free>;
-using git_remote_ptr = unique_ptr_deleter<git_remote, git_remote_free>;
-using git_repository_ptr = unique_ptr_deleter<git_repository, git_repository_free>;
-using git_revwalk_ptr = unique_ptr_deleter<git_revwalk, git_revwalk_free>;
-using git_signature_ptr = unique_ptr_deleter<git_signature, git_signature_free>;
-using git_status_list_ptr = unique_ptr_deleter<git_status_list, git_status_list_free>;
-using git_tree_ptr = unique_ptr_deleter<git_tree, git_tree_free>;
-
-class GitAPI : public EditorVCSInterface {
-	GODOT_CLASS(GitAPI, EditorVCSInterface)
-
-	Credentials creds;
-	bool has_merge = false;
-	git_repository_ptr repo;
-	git_oid pull_merge_oid = {};
-
-	// Endpoints
-	bool _checkout_branch(const String branch_name);
-	void _commit(const String msg);
-	void _create_branch(const String branch_name);
-	void _create_remote(const String remote_name, const String remote_url);
-	void _discard_file(const String file_path);
-	void _fetch(const String remote);
-	Array _get_branch_list();
-	String _get_current_branch_name();
-	Array _get_diff(const String identifier, const int64_t area);
-	Array _get_line_diff(const String file_path, const String text);
-	Array _get_modified_files_data();
-	Array _get_previous_commits(const int64_t max_commits);
-	Array _get_remotes();
-	String _get_vcs_name();
-	bool _initialize(const String project_path);
-	void _pull(const String remote);
-	void _push(const String remote, const bool force);
-	void _remove_branch(const String branch_name);
-	void _remove_remote(const String remote_name);
-	void _set_credentials(const String username, const String password, const String ssh_public_key_path, const String ssh_private_key_path, const String ssh_passphrase);
-	bool _shut_down();
-	void _stage_file(const String file_path);
-	void _unstage_file(const String file_path);
-
-	// Helpers
-	Array _parse_diff(git_diff *p_diff);
-
-public:
-	static void _register_methods();
-
-	bool check_errors(int error, String function, String file, int line, String message, const std::vector<git_error_code> &ignores = {});
-	void create_gitignore_and_gitattributes();
-	bool create_initial_commit();
-	String get_commit_date(const git_time *intime);
-
-	void _init();
-};
-
-} // namespace godot
-
-#endif // !GIT_API_H

godot-git-plugin/src/git_callbacks.cpp

@@ -0,0 +1,109 @@
+#include <iostream>
+#include <cstring>
+
+#include "git_callbacks.h"
+#include "git_plugin.h"
+
+#include "godot_cpp/godot.hpp"
+#include "godot_cpp/variant/utility_functions.hpp"
+
+extern "C" int progress_cb(const char *str, int len, void *data) {
+	(void)data;
+
+	godot::UtilityFunctions::print("remote: ", godot::String::utf8(str, len).strip_edges());
+
+	return 0;
+}
+
+extern "C" int update_cb(const char *refname, const git_oid *a, const git_oid *b, void *data) {
+	constexpr int short_commit_length = 8;
+	char a_str[short_commit_length + 1];
+	char b_str[short_commit_length + 1];
+	(void)data;
+
+	git_oid_tostr(b_str, short_commit_length, b);
+	if (git_oid_is_zero(a)) {
+		godot::UtilityFunctions::print("* [new] ", godot::String::utf8(b_str), " ", godot::String::utf8(refname));
+	} else {
+		git_oid_tostr(a_str, short_commit_length, a);
+		godot::UtilityFunctions::print("[updated] ", godot::String::utf8(a_str), "...", godot::String::utf8(b_str), " ", godot::String::utf8(refname));
+	}
+
+	return 0;
+}
+
+extern "C" int transfer_progress_cb(const git_indexer_progress *stats, void *payload) {
+	(void)payload;
+
+	if (stats->received_objects == stats->total_objects) {
+		godot::UtilityFunctions::print("Resolving deltas ", uint32_t(stats->indexed_deltas), "/", uint32_t(stats->total_deltas));
+	} else if (stats->total_objects > 0) {
+		godot::UtilityFunctions::print(
+				"Received ", uint32_t(stats->received_objects), "/", uint32_t(stats->total_objects),
+				" objects (", uint32_t(stats->indexed_objects), ") in ", uint32_t(stats->received_bytes), " bytes");
+	}
+	return 0;
+}
+
+extern "C" int fetchhead_foreach_cb(const char *ref_name, const char *remote_url, const git_oid *oid, unsigned int is_merge, void *payload) {
+	if (is_merge) {
+		git_oid_cpy((git_oid *)payload, oid);
+	}
+	return 0;
+}
+
+extern "C" int push_transfer_progress_cb(unsigned int current, unsigned int total, size_t bytes, void *payload) {
+	int64_t progress = 100;
+
+	if (total != 0) {
+		progress = (current * 100) / total;
+	}
+
+	godot::UtilityFunctions::print("Writing Objects: ", uint32_t(progress), "% (", uint32_t(current), "/", uint32_t(total), ", ", uint32_t(bytes), " bytes done.)");
+	return 0;
+}
+
+extern "C" int push_update_reference_cb(const char *refname, const char *status, void *data) {
+	if (status != NULL) {
+		godot::String status_str = godot::String::utf8(status);
+		godot::UtilityFunctions::print("[rejected] ", godot::String::utf8(refname), " ", status_str);
+	} else {
+		godot::UtilityFunctions::print("[updated] ", godot::String::utf8(refname));
+	}
+	return 0;
+}
+
+extern "C" int credentials_cb(git_cred **out, const char *url, const char *username_from_url, unsigned int allowed_types, void *payload) {
+	Credentials *creds = (Credentials *)payload;
+
+	godot::String proper_username = username_from_url ? username_from_url : creds->username;
+
+	if (!creds->ssh_public_key_path.is_empty()) {
+		if (allowed_types & GIT_CREDENTIAL_SSH_KEY) {
+			return git_credential_ssh_key_new(out,
+					CString(proper_username).data,
+					CString(creds->ssh_public_key_path).data,
+					CString(creds->ssh_private_key_path).data,
+					CString(creds->ssh_passphrase).data);
+		}
+	}
+
+	if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
+		return git_cred_userpass_plaintext_new(out, CString(proper_username).data, CString(creds->password).data);
+	}
+
+	if (allowed_types & GIT_CREDENTIAL_USERNAME) {
+		return git_credential_username_new(out, CString(proper_username).data);
+	}
+
+	return GIT_EUSER;
+}
+
+extern "C" int diff_hunk_cb(const git_diff_delta *delta, const git_diff_hunk *range, void *payload) {
+	DiffHelper *diff_helper = (DiffHelper *)payload;
+
+	godot::Dictionary hunk = diff_helper->git_plugin->create_diff_hunk(range->old_start, range->new_start, range->old_lines, range->new_lines);
+	diff_helper->diff_hunks->push_back(hunk);
+
+	return 1;
+}

godot-git-plugin/src/git_callbacks.h

@@ -1,18 +1,13 @@
-#ifndef GIT_COMMON_H
-#define GIT_COMMON_H
+#pragma once
 
-#include <cstdio>
+#include "godot_cpp/variant/array.hpp"
+#include "git2.h"
 
-#include <Godot.hpp>
+class GitPlugin;
 
-#include <git2.h>
-
-struct Credentials {
-	godot::String username;
-	godot::String password;
-	godot::String ssh_public_key_path;
-	godot::String ssh_private_key_path;
-	godot::String ssh_passphrase;
+struct DiffHelper {
+	godot::Array *diff_hunks;
+	GitPlugin *git_plugin;
 };
 
 extern "C" int progress_cb(const char *str, int len, void *data);
@@ -23,5 +18,3 @@ extern "C" int credentials_cb(git_cred **out, const char *url, const char *usern
 extern "C" int push_transfer_progress_cb(unsigned int current, unsigned int total, size_t bytes, void *payload);
 extern "C" int push_update_reference_cb(const char *refname, const char *status, void *data);
 extern "C" int diff_hunk_cb(const git_diff_delta *delta, const git_diff_hunk *range, void *payload);
-
-#endif // !GIT_COMMON_H

godot-git-plugin/src/git_common.cpp

@@ -1,106 +0,0 @@
-#include <git_common.h>
-
-#include <git_api.h>
-
-extern "C" int progress_cb(const char *str, int len, void *data) {
-	(void)data;
-
-	char *progress_str = new char[len + 1];
-	memcpy(progress_str, str, len);
-	progress_str[len] = '\0';
-	godot::Godot::print("remote: " + godot::String(progress_str).strip_edges());
-	delete[] progress_str;
-
-	return 0;
-}
-
-extern "C" int update_cb(const char *refname, const git_oid *a, const git_oid *b, void *data) {
-	constexpr int short_commit_length = 8;
-	char a_str[short_commit_length + 1];
-	char b_str[short_commit_length + 1];
-	(void)data;
-
-	git_oid_tostr(b_str, short_commit_length, b);
-	if (git_oid_is_zero(a)) {
-		godot::Godot::print("* [new] " + godot::String(b_str) + " " + godot::String(refname));
-	} else {
-		git_oid_tostr(a_str, short_commit_length, a);
-		godot::Godot::print("[updated] " + godot::String(a_str) + "..." + godot::String(b_str) + " " + godot::String(refname));
-	}
-
-	return 0;
-}
-
-extern "C" int transfer_progress_cb(const git_indexer_progress *stats, void *payload) {
-	(void)payload;
-
-	if (stats->received_objects == stats->total_objects) {
-		godot::Godot::print("Resolving deltas " + godot::String::num_int64(stats->indexed_deltas) + "/" + godot::String::num_int64(stats->total_deltas));
-	} else if (stats->total_objects > 0) {
-		godot::Godot::print("Received " + godot::String::num_int64(stats->received_objects) + "/" + godot::String::num_int64(stats->total_objects) + " objects (" + godot::String::num_int64(stats->indexed_objects) + ") in " + godot::String::num_int64(static_cast<int>(stats->received_bytes)) + " bytes");
-	}
-	return 0;
-}
-
-extern "C" int fetchhead_foreach_cb(const char *ref_name, const char *remote_url, const git_oid *oid, unsigned int is_merge, void *payload) {
-	if (is_merge) {
-		git_oid_cpy((git_oid *)payload, oid);
-	}
-	return 0;
-}
-
-extern "C" int push_transfer_progress_cb(unsigned int current, unsigned int total, size_t bytes, void *payload) {
-	int64_t progress = 100;
-
-	if (total != 0) {
-		progress = (current * 100) / total;
-	}
-
-	godot::Godot::print("Writing Objects: " +
-						godot::String::num_int64(progress) + "% (" +
-						godot::String::num_int64((int)current) + "/" + godot::String::num_int64((int)total) + "), " + godot::String::num_int64(bytes) + " bytes, done.");
-	return 0;
-}
-
-extern "C" int push_update_reference_cb(const char *refname, const char *status, void *data) {
-	godot::String status_str = status;
-	if (status_str == "") {
-		godot::Godot::print("[rejected] " + godot::String(refname) + " " + status_str);
-	} else {
-		godot::Godot::print("[updated] " + godot::String(refname));
-	}
-	return 0;
-}
-
-extern "C" int credentials_cb(git_cred **out, const char *url, const char *username_from_url, unsigned int allowed_types, void *payload) {
-	Credentials *creds = (Credentials *)payload;
-
-	godot::String proper_username = username_from_url ? username_from_url : creds->username;
-
-	if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
-		return git_cred_userpass_plaintext_new(out, godot::CString(proper_username).data, godot::CString(creds->password).data);
-	}
-
-	if (allowed_types & GIT_CREDENTIAL_SSH_KEY) {
-		return git_credential_ssh_key_new(out,
-				godot::CString(proper_username).data,
-				godot::CString(creds->ssh_public_key_path).data,
-				godot::CString(creds->ssh_private_key_path).data,
-				godot::CString(creds->ssh_passphrase).data);
-	}
-
-	if (allowed_types & GIT_CREDENTIAL_USERNAME) {
-		return git_credential_username_new(out, godot::CString(proper_username).data);
-	}
-
-	return GIT_EUSER;
-}
-
-extern "C" int diff_hunk_cb(const git_diff_delta *delta, const git_diff_hunk *range, void *payload) {
-	godot::DiffHelper *diff_helper = (godot::DiffHelper *)payload;
-
-	godot::Dictionary hunk = diff_helper->git_api->create_diff_hunk(range->old_start, range->new_start, range->old_lines, range->new_lines);
-	diff_helper->diff_hunks->push_back(hunk);
-
-	return 1;
-}

godot-git-plugin/src/git_plugin.cpp

@@ -1,4 +1,11 @@
-#include "git_api.h"
+#include "git_plugin.h"
+
+#include <cstring>
+
+#include <git2/tree.h>
+#include "godot_cpp/core/class_db.hpp"
+#include "godot_cpp/classes/file_access.hpp"
+#include "godot_cpp/variant/utility_functions.hpp"
 
 #define GIT2_CALL(error, msg)                                         \
 	if (check_errors(error, __FUNCTION__, __FILE__, __LINE__, msg)) { \
@@ -22,35 +29,25 @@
 
 #define COMMA ,
 
-namespace godot {
-
-void GitAPI::_register_methods() {
-	register_method("_commit", &GitAPI::_commit);
-	register_method("_get_modified_files_data", &GitAPI::_get_modified_files_data);
-	register_method("_get_remotes", &GitAPI::_get_remotes);
-	register_method("_get_diff", &GitAPI::_get_diff);
-	register_method("_get_vcs_name", &GitAPI::_get_vcs_name);
-	register_method("_initialize", &GitAPI::_initialize);
-	register_method("_shut_down", &GitAPI::_shut_down);
-	register_method("_stage_file", &GitAPI::_stage_file);
-	register_method("_discard_file", &GitAPI::_discard_file);
-	register_method("_unstage_file", &GitAPI::_unstage_file);
-	register_method("_get_previous_commits", &GitAPI::_get_previous_commits);
-	register_method("_get_branch_list", &GitAPI::_get_branch_list);
-	register_method("_create_branch", &GitAPI::_create_branch);
-	register_method("_create_remote", &GitAPI::_create_remote);
-	register_method("_remove_branch", &GitAPI::_remove_branch);
-	register_method("_remove_remote", &GitAPI::_remove_remote);
-	register_method("_get_current_branch_name", &GitAPI::_get_current_branch_name);
-	register_method("_checkout_branch", &GitAPI::_checkout_branch);
-	register_method("_fetch", &GitAPI::_fetch);
-	register_method("_pull", &GitAPI::_pull);
-	register_method("_push", &GitAPI::_push);
-	register_method("_get_line_diff", &GitAPI::_get_line_diff);
-	register_method("_set_credentials", &GitAPI::_set_credentials);
+void GitPlugin::_bind_methods() {
+	// Doesn't seem to require binding functions for now
 }
 
-bool GitAPI::check_errors(int error, String function, String file, int line, String message, const std::vector<git_error_code> &ignores) {
+GitPlugin::GitPlugin() {
+	map_changes[GIT_STATUS_WT_NEW] = CHANGE_TYPE_NEW;
+	map_changes[GIT_STATUS_INDEX_NEW] = CHANGE_TYPE_NEW;
+	map_changes[GIT_STATUS_WT_MODIFIED] = CHANGE_TYPE_MODIFIED;
+	map_changes[GIT_STATUS_INDEX_MODIFIED] = CHANGE_TYPE_MODIFIED;
+	map_changes[GIT_STATUS_WT_RENAMED] = CHANGE_TYPE_RENAMED;
+	map_changes[GIT_STATUS_INDEX_RENAMED] = CHANGE_TYPE_RENAMED;
+	map_changes[GIT_STATUS_WT_DELETED] = CHANGE_TYPE_DELETED;
+	map_changes[GIT_STATUS_INDEX_DELETED] = CHANGE_TYPE_DELETED;
+	map_changes[GIT_STATUS_WT_TYPECHANGE] = CHANGE_TYPE_TYPECHANGE;
+	map_changes[GIT_STATUS_INDEX_TYPECHANGE] = CHANGE_TYPE_TYPECHANGE;
+	map_changes[GIT_STATUS_CONFLICTED] = CHANGE_TYPE_UNMERGED;
+}
+
+bool GitPlugin::check_errors(int error, godot::String function, godot::String file, int line, godot::String message, const std::vector<git_error_code> &ignores) {
 	const git_error *lg2err;
 
 	if (error == 0) {
@@ -63,18 +60,17 @@ bool GitAPI::check_errors(int error, String function, String file, int line, Str
 		}
 	}
 
-	message += ".";
+	message = message + ".";
 	if ((lg2err = git_error_last()) != nullptr && lg2err->message != nullptr) {
-		message += " Error " + String::num_int64(error) + ": ";
-		message += String(lg2err->message);
+		message = message + " Error " + godot::String::num_int64(error) + ": ";
+		message = message + godot::String::utf8(lg2err->message);
 	}
 
-	Godot::print_error("GitAPI: " + message, function, file, line);
-	popup_error(message);
+	godot::UtilityFunctions::push_error("GitPlugin: ", message, " in ", file, ":", function, "#L", line);
 	return true;
 }
 
-void GitAPI::_set_credentials(const String username, const String password, const String ssh_public_key_path, const String ssh_private_key_path, const String ssh_passphrase) {
+void GitPlugin::_set_credentials(const godot::String &username, const godot::String &password, const godot::String &ssh_public_key_path, const godot::String &ssh_private_key_path, const godot::String &ssh_passphrase) {
 	creds.username = username;
 	creds.password = password;
 	creds.ssh_public_key_path = ssh_public_key_path;
@@ -82,7 +78,7 @@ void GitAPI::_set_credentials(const String username, const String password, cons
 	creds.ssh_passphrase = ssh_passphrase;
 }
 
-void GitAPI::_discard_file(const String file_path) {
+void GitPlugin::_discard_file(const godot::String &file_path) {
 	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	CString c_path(file_path);
 	char *paths[] = { c_path.data };
@@ -92,7 +88,7 @@ void GitAPI::_discard_file(const String file_path) {
 	GIT2_CALL(git_checkout_index(repo.get(), nullptr, &opts), "Could not checkout index");
 }
 
-void GitAPI::_commit(const String msg) {
+void GitPlugin::_commit(const godot::String &msg) {
 	git_index_ptr repo_index;
 	GIT2_CALL(git_repository_index(Capture(repo_index), repo.get()), "Could not get repository index");
 
@@ -152,7 +148,7 @@ void GitAPI::_commit(const String msg) {
 	}
 }
 
-void GitAPI::_stage_file(const String file_path) {
+void GitPlugin::_stage_file(const godot::String &file_path) {
 	CString c_path(file_path);
 	char *paths[] = { c_path.data };
 	git_strarray array = { paths, 1 };
@@ -163,7 +159,7 @@ void GitAPI::_stage_file(const String file_path) {
 	GIT2_CALL(git_index_write(index.get()), "Could not write changes to disk");
 }
 
-void GitAPI::_unstage_file(const String file_path) {
+void GitPlugin::_unstage_file(const godot::String &file_path) {
 	CString c_path(file_path);
 	char *paths[] = { c_path.data };
 	git_strarray array = { paths, 1 };
@@ -187,28 +183,18 @@ void GitAPI::_unstage_file(const String file_path) {
 	}
 }
 
-void GitAPI::create_gitignore_and_gitattributes() {
-	File *file = File::_new();
-
-	if (!file->file_exists("res://.gitignore")) {
-		file->open("res://.gitignore", File::ModeFlags::WRITE);
+void GitPlugin::create_gitignore_and_gitattributes() {
+	if (!godot::FileAccess::file_exists(repo_project_path + "/.gitignore")) {
+		godot::Ref<godot::FileAccess> file = godot::FileAccess::open(repo_project_path + "/.gitignore", godot::FileAccess::ModeFlags::WRITE);
+		ERR_FAIL_COND(file.is_null());
 		file->store_string(
-				"# Godot-specific ignores\n"
-				".import/\n"
-				"export.cfg\n"
-				"export_presets.cfg\n\n"
-
-				"# Imported translations (automatically generated from CSV files)\n"
-				"*.translation\n\n"
-
-				"# Mono-specific ignores\n"
-				".mono/\n"
-				"data_*/\n");
-		file->close();
+				"# Godot 4+ specific ignores\n"
+				".godot/\n");
 	}
 
-	if (!file->file_exists("res://.gitattributes")) {
-		file->open("res://.gitattributes", File::ModeFlags::WRITE);
+	if (!godot::FileAccess::file_exists(repo_project_path + "/.gitattributes")) {
+		godot::Ref<godot::FileAccess> file = godot::FileAccess::open(repo_project_path + "/.gitattributes", godot::FileAccess::ModeFlags::WRITE);
+		ERR_FAIL_COND(file.is_null());
 		file->store_string(
 				"# Set the default behavior, in case people don't have core.autocrlf set.\n"
 				"* text=auto\n\n"
@@ -227,39 +213,11 @@ void GitAPI::create_gitignore_and_gitattributes() {
 				"# Denote all files that are truly binary and should not be modified.\n"
 				"*.png binary\n"
 				"*.jpg binary\n");
-		file->close();
 	}
-
-	file->free();
 }
 
-String GitAPI::get_commit_date(const git_time *intime) {
-	char sign, out[32];
-	struct tm *intm;
-	int offset, hours, minutes;
-	time_t t;
-
-	offset = intime->offset;
-	if (offset < 0) {
-		sign = '-';
-		offset = -offset;
-	} else {
-		sign = '+';
-	}
-
-	hours = offset / 60;
-	minutes = offset % 60;
-
-	t = (time_t)intime->time + (intime->offset * 60);
-
-	intm = gmtime(&t);
-	strftime(out, sizeof(out), "%a %b %e %T %Y", intm);
-
-	return String(out) + " " + sign + (hours < 10 ? "0" : "") + String::num(hours) + ":" + (minutes < 10 ? "0" : "") + String::num(minutes);
-}
-
-Array GitAPI::_get_modified_files_data() {
-	Array stats_files;
+godot::TypedArray<godot::Dictionary> GitPlugin::_get_modified_files_data() {
+	godot::TypedArray<godot::Dictionary> stats_files;
 
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 	opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
@@ -267,45 +225,32 @@ Array GitAPI::_get_modified_files_data() {
 	opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX | GIT_STATUS_OPT_SORT_CASE_SENSITIVELY | GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
 
 	git_status_list_ptr statuses;
-	GIT2_CALL_R(git_status_list_new(Capture(statuses), repo.get(), &opts), "Could not get status information from repository", Array());
+	GIT2_CALL_R(git_status_list_new(Capture(statuses), repo.get(), &opts), "Could not get status information from repository", godot::TypedArray<godot::Dictionary>());
 
 	size_t count = git_status_list_entrycount(statuses.get());
 	for (size_t i = 0; i < count; ++i) {
 		const git_status_entry *entry = git_status_byindex(statuses.get(), i);
-		String path;
+		godot::String path;
 		if (entry->index_to_workdir) {
-			path = entry->index_to_workdir->new_file.path;
+			path = godot::String::utf8(entry->index_to_workdir->new_file.path);
 		} else {
-			path = entry->head_to_index->new_file.path;
+			path = godot::String::utf8(entry->head_to_index->new_file.path);
 		}
 
-		static Dictionary map_changes = Dictionary::make(
-				GIT_STATUS_WT_NEW, CHANGE_TYPE_NEW,
-				GIT_STATUS_INDEX_NEW, CHANGE_TYPE_NEW,
-				GIT_STATUS_WT_MODIFIED, CHANGE_TYPE_MODIFIED,
-				GIT_STATUS_INDEX_MODIFIED, CHANGE_TYPE_MODIFIED,
-				GIT_STATUS_WT_RENAMED, CHANGE_TYPE_RENAMED,
-				GIT_STATUS_INDEX_RENAMED, CHANGE_TYPE_RENAMED,
-				GIT_STATUS_WT_DELETED, CHANGE_TYPE_DELETED,
-				GIT_STATUS_INDEX_DELETED, CHANGE_TYPE_DELETED,
-				GIT_STATUS_WT_TYPECHANGE, CHANGE_TYPE_TYPECHANGE,
-				GIT_STATUS_INDEX_TYPECHANGE, CHANGE_TYPE_TYPECHANGE,
-				GIT_STATUS_CONFLICTED, CHANGE_TYPE_UNMERGED);
-
 		const static int git_status_wt = GIT_STATUS_WT_NEW | GIT_STATUS_WT_MODIFIED | GIT_STATUS_WT_DELETED | GIT_STATUS_WT_TYPECHANGE | GIT_STATUS_WT_RENAMED | GIT_STATUS_CONFLICTED;
 		const static int git_status_index = GIT_STATUS_INDEX_NEW | GIT_STATUS_INDEX_MODIFIED | GIT_STATUS_INDEX_DELETED | GIT_STATUS_INDEX_RENAMED | GIT_STATUS_INDEX_TYPECHANGE;
 
 		if (entry->status & git_status_wt) {
-			stats_files.push_back(create_status_file(path, map_changes[entry->status & git_status_wt], TREE_AREA_UNSTAGED));
+			stats_files.push_back(create_status_file(path, map_changes[git_status_t(entry->status & git_status_wt)], TREE_AREA_UNSTAGED));
 		}
 
 		if (entry->status & git_status_index) {
-			if (entry->status == GIT_STATUS_INDEX_RENAMED) {
-				String old_path = entry->head_to_index->old_file.path;
-				stats_files.push_back(create_status_file(old_path, map_changes[GIT_STATUS_INDEX_DELETED], TREE_AREA_STAGED));
-				stats_files.push_back(create_status_file(path, map_changes[GIT_STATUS_INDEX_NEW], TREE_AREA_STAGED));
+			if (entry->status & GIT_STATUS_INDEX_RENAMED) {
+				godot::String old_path = godot::String::utf8(entry->head_to_index->old_file.path);
+				stats_files.push_back(create_status_file(old_path, map_changes.at(GIT_STATUS_INDEX_DELETED), TREE_AREA_STAGED));
+				stats_files.push_back(create_status_file(path, map_changes.at(GIT_STATUS_INDEX_NEW), TREE_AREA_STAGED));
 			} else {
-				stats_files.push_back(create_status_file(path, map_changes[entry->status & git_status_index], TREE_AREA_STAGED));
+				stats_files.push_back(create_status_file(path, map_changes.at(git_status_t(entry->status & git_status_index)), TREE_AREA_STAGED));
 			}
 		}
 	}
@@ -313,31 +258,31 @@ Array GitAPI::_get_modified_files_data() {
 	return stats_files;
 }
 
-Array GitAPI::_get_branch_list() {
+godot::TypedArray<godot::String> GitPlugin::_get_branch_list() {
 	git_branch_iterator_ptr it;
-	GIT2_CALL_R(git_branch_iterator_new(Capture(it), repo.get(), GIT_BRANCH_LOCAL), "Could not create branch iterator", Array());
+	GIT2_CALL_R(git_branch_iterator_new(Capture(it), repo.get(), GIT_BRANCH_LOCAL), "Could not create branch iterator", godot::TypedArray<godot::Dictionary>());
 
-	Array branch_names;
+	godot::TypedArray<godot::String> branch_names;
 
 	git_reference_ptr ref;
 	git_branch_t type;
 	while (git_branch_next(Capture(ref), &type, it.get()) != GIT_ITEROVER) {
 		const char *name = nullptr;
 
-		GIT2_CALL_R(git_branch_name(&name, ref.get()), "Could not get branch name", Array());
+		GIT2_CALL_R(git_branch_name(&name, ref.get()), "Could not get branch name", godot::TypedArray<godot::String>());
 
 		if (git_branch_is_head(ref.get())) {
 			// Always send the current branch as the first branch in list
-			branch_names.push_front(name);
+			branch_names.push_front(godot::String::utf8(name));
 		} else {
-			branch_names.push_back(String(name));
+			branch_names.push_back(godot::String::utf8(name));
 		}
 	}
 
 	return branch_names;
 }
 
-void GitAPI::_create_branch(const String branch_name) {
+void GitPlugin::_create_branch(const godot::String &branch_name) {
 	git_oid head_commit_id;
 	GIT2_CALL(git_reference_name_to_id(&head_commit_id, repo.get(), "HEAD"), "Could not get HEAD commit ID");
 
@@ -348,51 +293,51 @@ void GitAPI::_create_branch(const String branch_name) {
 	GIT2_CALL(git_branch_create(Capture(branch_ref), repo.get(), CString(branch_name).data, head_commit.get(), 0), "Could not create branch from HEAD");
 }
 
-void GitAPI::_create_remote(const String remote_name, const String remote_url) {
+void GitPlugin::_create_remote(const godot::String &remote_name, const godot::String &remote_url) {
 	git_remote_ptr remote;
 	GIT2_CALL(git_remote_create(Capture(remote), repo.get(), CString(remote_name).data, CString(remote_url).data), "Could not create remote");
 }
 
-void GitAPI::_remove_branch(const String branch_name) {
+void GitPlugin::_remove_branch(const godot::String &branch_name) {
 	git_reference_ptr branch;
 	GIT2_CALL(git_branch_lookup(Capture(branch), repo.get(), CString(branch_name).data, GIT_BRANCH_LOCAL), "Could not find branch " + branch_name);
 	GIT2_CALL(git_branch_delete(branch.get()), "Could not delete branch reference of " + branch_name);
 }
 
-void GitAPI::_remove_remote(const String remote_name) {
+void GitPlugin::_remove_remote(const godot::String &remote_name) {
 	GIT2_CALL(git_remote_delete(repo.get(), CString(remote_name).data), "Could not delete remote " + remote_name);
 }
 
-Array GitAPI::_get_line_diff(String file_path, String text) {
+godot::TypedArray<godot::Dictionary> GitPlugin::_get_line_diff(const godot::String &file_path, const godot::String &text) {
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 
 	opts.context_lines = 0;
 	opts.flags = GIT_DIFF_DISABLE_PATHSPEC_MATCH | GIT_DIFF_INCLUDE_UNTRACKED;
 
 	git_index_ptr index;
-	GIT2_CALL_R(git_repository_index(Capture(index), repo.get()), "Failed to get repository index", Array());
-	GIT2_CALL_R(git_index_read(index.get(), 0), "Failed to read index", Array());
+	GIT2_CALL_R(git_repository_index(Capture(index), repo.get()), "Failed to get repository index", godot::TypedArray<godot::Dictionary>());
+	GIT2_CALL_R(git_index_read(index.get(), 0), "Failed to read index", godot::TypedArray<godot::Dictionary>());
 
 	const git_index_entry *entry = git_index_get_bypath(index.get(), CString(file_path).data, GIT_INDEX_STAGE_NORMAL);
 	if (!entry) {
-		return Array();
+		return godot::TypedArray<godot::Dictionary>();
 	}
 
 	git_reference_ptr head;
-	GIT2_CALL_R(git_repository_head(Capture(head), repo.get()), "Failed to load repository head", Array());
+	GIT2_CALL_R(git_repository_head(Capture(head), repo.get()), "Failed to load repository head", godot::TypedArray<godot::Dictionary>());
 
 	git_blob_ptr blob;
-	GIT2_CALL_R(git_blob_lookup(Capture(blob), repo.get(), &entry->id), "Failed to load head blob", Array());
+	GIT2_CALL_R(git_blob_lookup(Capture(blob), repo.get(), &entry->id), "Failed to load head blob", godot::TypedArray<godot::Dictionary>());
 
-	Array diff_contents;
+	godot::TypedArray<godot::Dictionary> diff_contents;
 
 	DiffHelper diff_helper = { &diff_contents, this };
-	GIT2_CALL_R(git_diff_blob_to_buffer(blob.get(), nullptr, CString(text).data, text.length(), nullptr, &opts, nullptr, nullptr, diff_hunk_cb, nullptr, &diff_helper), "Failed to make diff", Array());
+	GIT2_CALL_R(git_diff_blob_to_buffer(blob.get(), nullptr, CString(text).data, text.length(), nullptr, &opts, nullptr, nullptr, diff_hunk_cb, nullptr, &diff_helper), "Failed to make diff", godot::TypedArray<godot::Dictionary>());
 
 	return diff_contents;
 }
 
-String GitAPI::_get_current_branch_name() {
+godot::String GitPlugin::_get_current_branch_name() {
 	git_reference_ptr head;
 	GIT2_CALL_R_IGNORE(git_repository_head(Capture(head), repo.get()), "Could not find repository HEAD", "", { GIT_ENOTFOUND COMMA GIT_EUNBORNBRANCH });
 
@@ -407,49 +352,49 @@ String GitAPI::_get_current_branch_name() {
 	const char *name = "";
 	GIT2_CALL_R(git_branch_name(&name, branch.get()), "Could not get branch name from current branch reference", "");
 
-	return name;
+	return godot::String::utf8(name);
 }
 
-Array GitAPI::_get_remotes() {
+godot::TypedArray<godot::String> GitPlugin::_get_remotes() {
 	git_strarray remote_array;
-	GIT2_CALL_R(git_remote_list(&remote_array, repo.get()), "Could not get list of remotes", Array());
+	GIT2_CALL_R(git_remote_list(&remote_array, repo.get()), "Could not get list of remotes", godot::TypedArray<godot::Dictionary>());
 
-	Array remotes;
+	godot::TypedArray<godot::String> remotes;
 	for (int i = 0; i < remote_array.count; i++) {
-		remotes.push_back(remote_array.strings[i]);
+		remotes.push_back(godot::String::utf8(remote_array.strings[i]));
 	}
 
 	return remotes;
 }
 
-Array GitAPI::_get_previous_commits(const int64_t max_commits) {
+godot::TypedArray<godot::Dictionary> GitPlugin::_get_previous_commits(int32_t max_commits) {
 	git_revwalk_ptr walker;
-	GIT2_CALL_R(git_revwalk_new(Capture(walker), repo.get()), "Could not create new revwalk", Array());
-	GIT2_CALL_R(git_revwalk_sorting(walker.get(), GIT_SORT_TIME), "Could not sort revwalk by time", Array());
+	GIT2_CALL_R(git_revwalk_new(Capture(walker), repo.get()), "Could not create new revwalk", godot::TypedArray<godot::Dictionary>());
+	GIT2_CALL_R(git_revwalk_sorting(walker.get(), GIT_SORT_TIME), "Could not sort revwalk by time", godot::TypedArray<godot::Dictionary>());
 
-	GIT2_CALL_R_IGNORE(git_revwalk_push_head(walker.get()), "Could not push HEAD to revwalk", Array(), { GIT_ENOTFOUND COMMA GIT_ERROR });
+	GIT2_CALL_R_IGNORE(git_revwalk_push_head(walker.get()), "Could not push HEAD to revwalk", godot::TypedArray<godot::Dictionary>(), { GIT_ENOTFOUND COMMA GIT_ERROR });
 
 	git_oid oid;
-	Array commits;
+	godot::TypedArray<godot::Dictionary> commits;
 	char commit_id[GIT_OID_HEXSZ + 1];
 	for (int i = 0; !git_revwalk_next(&oid, walker.get()) && i <= max_commits; i++) {
 		git_commit_ptr commit;
 		GIT2_CALL_R(git_commit_lookup(Capture(commit), repo.get(), &oid), "Failed to lookup the commit", commits);
 
 		git_oid_tostr(commit_id, GIT_OID_HEXSZ + 1, git_commit_id(commit.get()));
-		String msg = git_commit_message(commit.get());
+		godot::String msg = godot::String::utf8(git_commit_message(commit.get()));
 
 		const git_signature *sig = git_commit_author(commit.get());
-		String author = String() + sig->name + " <" + sig->email + ">";
+		godot::String author = godot::String::utf8(sig->name) + " <" + godot::String::utf8(sig->email) + ">";
 
-		commits.push_back(create_commit(msg, author, commit_id, get_commit_date(&sig->when)));
+		commits.push_back(create_commit(msg, author, commit_id, sig->when.time, sig->when.offset));
 	}
 
 	return commits;
 }
 
-void GitAPI::_fetch(String remote) {
-	Godot::print("GitAPI: Performing fetch from " + remote);
+void GitPlugin::_fetch(const godot::String &remote) {
+	godot::UtilityFunctions::print("GitPlugin: Performing fetch from ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -469,11 +414,11 @@ void GitAPI::_fetch(String remote) {
 	opts.callbacks = remote_cbs;
 	GIT2_CALL(git_remote_fetch(remote_object.get(), nullptr, &opts, "fetch"), "Could not fetch data from remote");
 
-	Godot::print("GitAPI: Fetch ended");
+	godot::UtilityFunctions::print("GitPlugin: Fetch ended");
 }
 
-void GitAPI::_pull(String remote) {
-	Godot::print("GitAPI: Performing pull from " + remote);
+void GitPlugin::_pull(const godot::String &remote) {
+	godot::UtilityFunctions::print("GitPlugin: Performing pull from ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -492,7 +437,7 @@ void GitAPI::_pull(String remote) {
 	git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
 	fetch_opts.callbacks = remote_cbs;
 
-	String branch_name = _get_current_branch_name();
+	godot::String branch_name = _get_current_branch_name();
 
 	CString ref_spec_str("refs/heads/" + branch_name);
 
@@ -505,7 +450,7 @@ void GitAPI::_pull(String remote) {
 	GIT2_CALL(git_repository_fetchhead_foreach(repo.get(), fetchhead_foreach_cb, &pull_merge_oid), "Could not read \"FETCH_HEAD\" file");
 
 	if (git_oid_is_zero(&pull_merge_oid)) {
-		popup_error("GitAPI: Could not find remote branch HEAD for " + branch_name + ". Try pushing the branch first.");
+		godot::UtilityFunctions::push_error("GitPlugin: Could not find remote branch HEAD for " + branch_name + ". Try pushing the branch first.");
 		return;
 	}
 
@@ -526,7 +471,7 @@ void GitAPI::_pull(String remote) {
 		GIT2_CALL(git_repository_head(Capture(target_ref), repo.get()), "Failed to get HEAD reference");
 
 		git_object_ptr target;
-		GIT2_CALL(git_object_lookup(Capture(target), repo.get(), &pull_merge_oid, GIT_OBJECT_COMMIT), "Failed to lookup OID " + String(git_oid_tostr_s(&pull_merge_oid)));
+		GIT2_CALL(git_object_lookup(Capture(target), repo.get(), &pull_merge_oid, GIT_OBJECT_COMMIT), "Failed to lookup OID " + godot::String(git_oid_tostr_s(&pull_merge_oid)));
 
 		ff_checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
 		GIT2_CALL(git_checkout_tree(repo.get(), target.get(), &ff_checkout_options), "Failed to checkout HEAD reference");
@@ -534,7 +479,7 @@ void GitAPI::_pull(String remote) {
 		git_reference_ptr new_target_ref;
 		GIT2_CALL(git_reference_set_target(Capture(new_target_ref), target_ref.get(), &pull_merge_oid, nullptr), "Failed to move HEAD reference");
 
-		Godot::print("GitAPI: Fast Forwarded");
+		godot::UtilityFunctions::print("GitPlugin: Fast Forwarded");
 		GIT2_CALL(git_repository_state_cleanup(repo.get()), "Could not clean repository state");
 
 	} else if (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL) {
@@ -550,27 +495,27 @@ void GitAPI::_pull(String remote) {
 		GIT2_CALL(git_repository_index(Capture(index), repo.get()), "Could not get repository index");
 
 		if (git_index_has_conflicts(index.get())) {
-			popup_error("GitAPI: Index has conflicts, Solve conflicts and make a merge commit.");
+			godot::UtilityFunctions::push_error("GitPlugin: Index has conflicts. Solve conflicts and make a merge commit.");
 		} else {
-			popup_error("GitAPI: Change are staged, make a merge commit.");
+			godot::UtilityFunctions::push_error("GitPlugin: Changes are staged. Make a merge commit.");
 		}
 
 		has_merge = true;
 
 	} else if (merge_analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE) {
-		Godot::print("GitAPI: Already up to date");
+		godot::UtilityFunctions::print("GitPlugin: Already up to date");
 
 		GIT2_CALL(git_repository_state_cleanup(repo.get()), "Could not clean repository state");
 
 	} else {
-		Godot::print("GitAPI: Can not merge");
+		godot::UtilityFunctions::push_error("GitPlugin: Can not merge");
 	}
 
-	Godot::print("GitAPI: Pull ended");
+	godot::UtilityFunctions::print("GitPlugin: Pull ended");
 }
 
-void GitAPI::_push(const String remote, const bool force) {
-	Godot::print("GitAPI: Performing push to " + remote);
+void GitPlugin::_push(const godot::String &remote, bool force) {
+	godot::UtilityFunctions::print("GitPlugin: Performing push to ", remote);
 
 	git_remote_ptr remote_object;
 	GIT2_CALL(git_remote_lookup(Capture(remote_object), repo.get(), CString(remote).data), "Could not lookup remote \"" + remote + "\"");
@@ -584,11 +529,12 @@ void GitAPI::_push(const String remote, const bool force) {
 	remote_cbs.push_transfer_progress = &push_transfer_progress_cb;
 	remote_cbs.push_update_reference = &push_update_reference_cb;
 
-	GIT2_CALL(git_remote_connect(remote_object.get(), GIT_DIRECTION_PUSH, &remote_cbs, nullptr, nullptr), "Could not connect to remote \"" + remote + "\". Are your credentials correct? Try using a PAT token (in case you are using Github) as your password");
+	godot::String msg = "Could not connect to remote \"" + remote + "\". Are your credentials correct? Try using a PAT token (in case you are using Github) as your password";
+	GIT2_CALL(git_remote_connect(remote_object.get(), GIT_DIRECTION_PUSH, &remote_cbs, nullptr, nullptr), msg);
 
-	String branch_name = _get_current_branch_name();
+	godot::String branch_name = _get_current_branch_name();
 
-	CString pushspec(String() + (force ? "+" : "") + "refs/heads/" + branch_name);
+	CString pushspec(godot::String() + (force ? "+" : "") + "refs/heads/" + branch_name);
 	const git_strarray refspec = { &pushspec.data, 1 };
 
 	git_push_options push_options = GIT_PUSH_OPTIONS_INIT;
@@ -596,10 +542,10 @@ void GitAPI::_push(const String remote, const bool force) {
 
 	GIT2_CALL(git_remote_push(remote_object.get(), &refspec, &push_options), "Failed to push");
 
-	Godot::print("GitAPI: Push ended");
+	godot::UtilityFunctions::print("GitPlugin: Push ended");
 }
 
-bool GitAPI::_checkout_branch(String branch_name) {
+bool GitPlugin::_checkout_branch(const godot::String &branch_name) {
 	git_reference_ptr branch;
 	GIT2_CALL_R(git_branch_lookup(Capture(branch), repo.get(), CString(branch_name).data, GIT_BRANCH_LOCAL), "Could not find branch", false);
 	const char *branch_ref_name = git_reference_name(branch.get());
@@ -615,9 +561,9 @@ bool GitAPI::_checkout_branch(String branch_name) {
 	return true;
 }
 
-Array GitAPI::_get_diff(const String identifier, const int64_t area) {
+godot::TypedArray<godot::Dictionary> GitPlugin::_get_diff(const godot::String &identifier, const int32_t area) {
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	Array diff_contents;
+	godot::TypedArray<godot::Dictionary> diff_contents;
 
 	opts.context_lines = 2;
 	opts.interhunk_lines = 0;
@@ -676,34 +622,36 @@ Array GitAPI::_get_diff(const String identifier, const int64_t area) {
 	return diff_contents;
 }
 
-Array GitAPI::_parse_diff(git_diff *diff) {
-	Array diff_contents;
+godot::TypedArray<godot::Dictionary> GitPlugin::_parse_diff(git_diff *diff) {
+	godot::TypedArray<godot::Dictionary> diff_contents;
 	for (int i = 0; i < git_diff_num_deltas(diff); i++) {
 		const git_diff_delta *delta = git_diff_get_delta(diff, i);
 
 		git_patch_ptr patch;
-		GIT2_CALL_R(git_patch_from_diff(Capture(patch), diff, i), "Could not create patch from diff", Array());
+		GIT2_CALL_R(git_patch_from_diff(Capture(patch), diff, i), "Could not create patch from diff", godot::TypedArray<godot::Dictionary>());
 
-		Dictionary diff_file = create_diff_file(delta->new_file.path, delta->old_file.path);
+		godot::Dictionary diff_file = create_diff_file(godot::String::utf8(delta->new_file.path), godot::String::utf8(delta->old_file.path));
 
-		Array diff_hunks;
+		godot::TypedArray<godot::Dictionary> diff_hunks;
 		for (int j = 0; j < git_patch_num_hunks(patch.get()); j++) {
 			const git_diff_hunk *git_hunk;
 			size_t line_count;
-			GIT2_CALL_R(git_patch_get_hunk(&git_hunk, &line_count, patch.get(), j), "Could not get hunk from patch", Array());
+			GIT2_CALL_R(git_patch_get_hunk(&git_hunk, &line_count, patch.get(), j), "Could not get hunk from patch", godot::TypedArray<godot::Dictionary>());
 
-			Dictionary diff_hunk = create_diff_hunk(git_hunk->old_start, git_hunk->new_start, git_hunk->old_lines, git_hunk->new_lines);
+			godot::Dictionary diff_hunk = create_diff_hunk(git_hunk->old_start, git_hunk->new_start, git_hunk->old_lines, git_hunk->new_lines);
 
-			Array diff_lines;
+			godot::TypedArray<godot::Dictionary> diff_lines;
 			for (int k = 0; k < line_count; k++) {
 				const git_diff_line *git_diff_line;
-				GIT2_CALL_R(git_patch_get_line_in_hunk(&git_diff_line, patch.get(), j, k), "Could not get line from hunk in patch", Array());
+				GIT2_CALL_R(git_patch_get_line_in_hunk(&git_diff_line, patch.get(), j, k), "Could not get line from hunk in patch", godot::TypedArray<godot::Dictionary>());
 
 				char *content = new char[git_diff_line->content_len + 1];
-				memcpy(content, git_diff_line->content, git_diff_line->content_len);
+				std::memcpy(content, git_diff_line->content, git_diff_line->content_len);
 				content[git_diff_line->content_len] = '\0';
 
-				diff_lines.push_back(create_diff_line(git_diff_line->new_lineno, git_diff_line->old_lineno, String(content), String(git_diff_line->origin)));
+				godot::String status = " "; // We reserve 1 null terminated space to fill the + or the - character at git_diff_line->origin
+				status[0] = git_diff_line->origin;
+				diff_lines.push_back(create_diff_line(git_diff_line->new_lineno, git_diff_line->old_lineno, godot::String::utf8(content), status));
 
 				delete[] content;
 			}
@@ -717,11 +665,13 @@ Array GitAPI::_parse_diff(git_diff *diff) {
 	return diff_contents;
 }
 
-String GitAPI::_get_vcs_name() {
+godot::String GitPlugin::_get_vcs_name() {
 	return "Git";
 }
 
-bool GitAPI::_initialize(String project_path) {
+bool GitPlugin::_initialize(const godot::String &project_path) {
+	using namespace godot;
+
 	ERR_FAIL_COND_V(project_path == "", false);
 
 	int init = git_libgit2_init();
@@ -729,7 +679,20 @@ bool GitAPI::_initialize(String project_path) {
 		WARN_PRINT("Multiple libgit2 instances are running");
 	}
 
-	GIT2_CALL_R(git_repository_init(Capture(repo), CString(project_path).data, 0), "Could not initialize repository", false);
+	git_buf discovered_repo_path = {};
+	if (git_repository_discover(&discovered_repo_path, CString(project_path).data, 1, nullptr) == 0) {
+		repo_project_path = godot::String::utf8(discovered_repo_path.ptr);
+
+		godot::UtilityFunctions::print("Found a repository at " + repo_project_path + ".");
+		git_buf_dispose(&discovered_repo_path);
+	} else {
+		repo_project_path = project_path;
+
+		godot::UtilityFunctions::push_warning("Could not find any higher level repositories.");
+	}
+
+	godot::UtilityFunctions::print("Selected repository path: " + repo_project_path + ".");
+	GIT2_CALL_R(git_repository_init(Capture(repo), CString(repo_project_path).data, 0), "Could not initialize repository", false);
 
 	git_reference_ptr head;
 	GIT2_CALL_R_IGNORE(git_repository_head(Capture(head), repo.get()), "Could not get repository HEAD", false, { GIT_EUNBORNBRANCH COMMA GIT_ENOTFOUND });
@@ -741,13 +704,8 @@ bool GitAPI::_initialize(String project_path) {
 	return true;
 }
 
-bool GitAPI::_shut_down() {
+bool GitPlugin::_shut_down() {
 	repo.reset(); // Destroy repo object before libgit2 shuts down
 	GIT2_CALL_R(git_libgit2_shutdown(), "Could not shutdown Git Plugin", false);
 	return true;
 }
-
-void GitAPI::_init() {
-}
-
-} // namespace godot

godot-git-plugin/src/git_plugin.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "git_callbacks.h"
+#include "git_wrappers.h"
+
+#include "godot_cpp/classes/editor_vcs_interface.hpp"
+#include "git2.h"
+
+struct Credentials {
+	godot::String username;
+	godot::String password;
+	godot::String ssh_public_key_path;
+	godot::String ssh_private_key_path;
+	godot::String ssh_passphrase;
+};
+
+class GitPlugin : public godot::EditorVCSInterface {
+	GDCLASS(GitPlugin, godot::EditorVCSInterface);
+
+protected:
+	static void _bind_methods();
+
+public:
+	Credentials creds;
+	bool has_merge = false;
+	git_repository_ptr repo;
+	git_oid pull_merge_oid = {};
+	godot::String repo_project_path;
+	std::unordered_map<git_status_t, ChangeType> map_changes;
+
+	GitPlugin();
+
+	// Endpoints
+	bool _initialize(const godot::String &project_path) override;
+	void _set_credentials(const godot::String &username, const godot::String &password, const godot::String &ssh_public_key_path, const godot::String &ssh_private_key_path, const godot::String &ssh_passphrase) override;
+	godot::TypedArray<godot::Dictionary> _get_modified_files_data() override;
+	void _stage_file(const godot::String &file_path) override;
+	void _unstage_file(const godot::String &file_path) override;
+	void _discard_file(const godot::String &file_path) override;
+	void _commit(const godot::String &msg) override;
+	godot::TypedArray<godot::Dictionary> _get_diff(const godot::String &identifier, int32_t area) override;
+	bool _shut_down() override;
+	godot::String _get_vcs_name() override;
+	godot::TypedArray<godot::Dictionary> _get_previous_commits(int32_t max_commits) override;
+	godot::TypedArray<godot::String> _get_branch_list() override;
+	godot::TypedArray<godot::String> _get_remotes() override;
+	void _create_branch(const godot::String &branch_name) override;
+	void _remove_branch(const godot::String &branch_name) override;
+	void _create_remote(const godot::String &remote_name, const godot::String &remote_url) override;
+	void _remove_remote(const godot::String &remote_name) override;
+	godot::String _get_current_branch_name() override;
+	bool _checkout_branch(const godot::String &branch_name) override;
+	void _pull(const godot::String &remote) override;
+	void _push(const godot::String &remote, bool force) override;
+	void _fetch(const godot::String &remote) override;
+	godot::TypedArray<godot::Dictionary> _get_line_diff(const godot::String &file_path, const godot::String &text) override;
+
+	// Helpers
+	godot::TypedArray<godot::Dictionary> _parse_diff(git_diff *p_diff);
+	bool check_errors(int error, godot::String function, godot::String file, int line, godot::String message, const std::vector<git_error_code> &ignores = {});
+	void create_gitignore_and_gitattributes();
+	bool create_initial_commit();
+};

godot-git-plugin/src/git_wrappers.cpp

@@ -0,0 +1,18 @@
+#include "git_wrappers.h"
+
+#include <cstring>
+
+CString::CString(const godot::String &string) {
+	godot::CharString godot_char_str = string.utf8();
+
+	data = new char[godot_char_str.length() + 1];
+	std::memcpy(data, (void *)godot_char_str.get_data(), godot_char_str.length());
+	data[godot_char_str.length()] = '\0';
+}
+
+CString::~CString() {
+	if (data) {
+		delete[] data;
+		data = nullptr;
+	}
+}

godot-git-plugin/src/git_wrappers.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <memory>
+
+#include "godot_cpp/variant/string.hpp"
+#include "git2.h"
+
+class GitPlugin;
+
+struct CString {
+	char *data = nullptr;
+
+	CString(const godot::String &string);
+	~CString();
+	CString() = delete;
+	CString(CString &&) = delete;
+	CString &operator=(const CString &) = delete;
+	CString &operator=(CString &&) = delete;
+};
+
+template <class T>
+class Capture {
+	T &smart_ptr = nullptr;
+
+	using Raw = decltype(smart_ptr.get());
+
+	Raw raw = nullptr;
+
+public:
+	Capture() = delete;
+	Capture(T &ptr) :
+			smart_ptr(ptr) {}
+	Capture(Capture &&) = delete;
+	Capture &operator=(const Capture &) = delete;
+	Capture &operator=(Capture &&) = delete;
+
+	operator Raw *() {
+		return &raw;
+	}
+
+	~Capture() {
+		if (raw) {
+			smart_ptr.reset(raw);
+		}
+	}
+};
+
+template <auto DeleteFn>
+struct FunctionDeleter {
+	template <class T>
+	void operator()(T *ptr) {
+		DeleteFn(ptr);
+	}
+};
+
+template <class T, auto DeleteFn>
+using unique_ptr_deleter = std::unique_ptr<T, FunctionDeleter<DeleteFn>>;
+
+using git_annotated_commit_ptr = unique_ptr_deleter<git_annotated_commit, git_annotated_commit_free>;
+using git_blob_ptr = unique_ptr_deleter<git_blob, git_blob_free>;
+using git_branch_iterator_ptr = unique_ptr_deleter<git_branch_iterator, git_branch_iterator_free>;
+using git_commit_ptr = unique_ptr_deleter<git_commit, git_commit_free>;
+using git_diff_ptr = unique_ptr_deleter<git_diff, git_diff_free>;
+using git_index_ptr = unique_ptr_deleter<git_index, git_index_free>;
+using git_object_ptr = unique_ptr_deleter<git_object, git_object_free>;
+using git_patch_ptr = unique_ptr_deleter<git_patch, git_patch_free>;
+using git_reference_ptr = unique_ptr_deleter<git_reference, git_reference_free>;
+using git_remote_ptr = unique_ptr_deleter<git_remote, git_remote_free>;
+using git_repository_ptr = unique_ptr_deleter<git_repository, git_repository_free>;
+using git_revwalk_ptr = unique_ptr_deleter<git_revwalk, git_revwalk_free>;
+using git_signature_ptr = unique_ptr_deleter<git_signature, git_signature_free>;
+using git_status_list_ptr = unique_ptr_deleter<git_status_list, git_status_list_free>;
+using git_tree_ptr = unique_ptr_deleter<git_tree, git_tree_free>;
+using git_tree_entry_ptr = unique_ptr_deleter<git_tree_entry, git_tree_entry_free>;

icon.svg

@@ -0,0 +1,144 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="1024"
+   width="1024"
+   version="1.1"
+   id="svg47"
+   sodipodi:docname="icon_color.svg"
+   inkscape:version="1.2.1 (9c6d41e410, 2022-07-14)"
+   inkscape:export-filename="icon_color.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs51">
+    <mask
+       maskUnits="userSpaceOnUse"
+       id="mask11953">
+      <rect
+         style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.754231;stroke-opacity:1"
+         id="rect11955"
+         width="43.98111"
+         height="4.7610822"
+         x="490.15945"
+         y="230.63536" />
+    </mask>
+  </defs>
+  <sodipodi:namedview
+     id="namedview49"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="true"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     shape-rendering="auto"
+     inkscape:zoom="1"
+     inkscape:cx="304"
+     inkscape:cy="521"
+     inkscape:window-width="2560"
+     inkscape:window-height="1387"
+     inkscape:window-x="1912"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg47">
+    <inkscape:grid
+       type="xygrid"
+       id="grid2088" />
+  </sodipodi:namedview>
+  <path
+     d="m0 0s-.325 1.994-.515 1.976l-36.182-3.491c-2.879-.278-5.115-2.574-5.317-5.459l-.994-14.247-27.992-1.997-1.904 12.912c-.424 2.872-2.932 5.037-5.835 5.037h-38.188c-2.902 0-5.41-2.165-5.834-5.037l-1.905-12.912-27.992 1.997-.994 14.247c-.202 2.886-2.438 5.182-5.317 5.46l-36.2 3.49c-.187.018-.324-1.978-.511-1.978l-.049-7.83 30.658-4.944 1.004-14.374c.203-2.91 2.551-5.263 5.463-5.472l38.551-2.75c.146-.01.29-.016.434-.016 2.897 0 5.401 2.166 5.825 5.038l1.959 13.286h28.005l1.959-13.286c.423-2.871 2.93-5.037 5.831-5.037.142 0 .284.005.423.015l38.556 2.75c2.911.209 5.26 2.562 5.463 5.472l1.003 14.374 30.645 4.966z"
+     fill="#fff"
+     transform="matrix(4.162611 0 0 -4.162611 919.24059 673.152141)"
+     id="path31" />
+  <path
+     d="m0 0v-47.514-6.035-5.492c.108-.001.216-.005.323-.015l36.196-3.49c1.896-.183 3.382-1.709 3.514-3.609l1.116-15.978 31.574-2.253 2.175 14.747c.282 1.912 1.922 3.329 3.856 3.329h38.188c1.933 0 3.573-1.417 3.855-3.329l2.175-14.747 31.575 2.253 1.115 15.978c.133 1.9 1.618 3.425 3.514 3.609l36.182 3.49c.107.01.214.014.322.015v4.711l.015.005v54.325c5.09692 6.4164715 9.92323 13.494208 13.621 19.449-5.651 9.62-12.575 18.217-19.976 26.182-6.864-3.455-13.531-7.369-19.828-11.534-3.151 3.132-6.7 5.694-10.186 8.372-3.425 2.751-7.285 4.768-10.946 7.118 1.09 8.117 1.629 16.108 1.846 24.448-9.446 4.754-19.519 7.906-29.708 10.17-4.068-6.837-7.788-14.241-11.028-21.479-3.842.642-7.702.88-11.567.926v.006c-.027 0-.052-.006-.075-.006-.024 0-.049.006-.073.006v-.006c-3.872-.046-7.729-.284-11.572-.926-3.238 7.238-6.956 14.642-11.03 21.479-10.184-2.264-20.258-5.416-29.703-10.17.216-8.34.755-16.331 1.848-24.448-3.668-2.35-7.523-4.367-10.949-7.118-3.481-2.678-7.036-5.24-10.188-8.372-6.297 4.165-12.962 8.079-19.828 11.534-7.401-7.965-14.321-16.562-19.974-26.182 4.4426579-6.973692 9.2079702-13.9828876 13.621-19.449z"
+     fill="#478cbf"
+     transform="matrix(4.162611 0 0 -4.162611 104.69892 427.387251)"
+     id="path33"
+     style="fill:#ef5132;fill-opacity:1" />
+  <path
+     d="m0 0-1.121-16.063c-.135-1.936-1.675-3.477-3.611-3.616l-38.555-2.751c-.094-.007-.188-.01-.281-.01-1.916 0-3.569 1.406-3.852 3.33l-2.211 14.994h-31.459l-2.211-14.994c-.297-2.018-2.101-3.469-4.133-3.32l-38.555 2.751c-1.936.139-3.476 1.68-3.611 3.616l-1.121 16.063-32.547 3.138c.015-3.498.06-7.33.06-8.093 0-34.374 43.605-50.896 97.781-51.086h.066.067c54.176.19 97.766 16.712 97.766 51.086 0 .777.047 4.593.063 8.093z"
+     fill="#478cbf"
+     transform="matrix(4.162611 0 0 -4.162611 784.07144 718.723121)"
+     id="path35"
+     style="fill:#ef5132;fill-opacity:1" />
+  <path
+     d="m0 0c0-12.052-9.765-21.815-21.813-21.815-12.042 0-21.81 9.763-21.81 21.815 0 12.044 9.768 21.802 21.81 21.802 12.048 0 21.813-9.758 21.813-21.802"
+     fill="#fff"
+     transform="matrix(4.162611 0 0 -4.162611 389.21484 527.151321)"
+     id="path37" />
+  <path
+     d="m0 0c0-7.994-6.479-14.473-14.479-14.473-7.996 0-14.479 6.479-14.479 14.473s6.483 14.479 14.479 14.479c8 0 14.479-6.485 14.479-14.479"
+     fill="#414042"
+     transform="matrix(4.162611 0 0 -4.162611 367.36686 532.537071)"
+     id="path39" />
+  <path
+     d="m0 0c-3.878 0-7.021 2.858-7.021 6.381v20.081c0 3.52 3.143 6.381 7.021 6.381s7.028-2.861 7.028-6.381v-20.081c0-3.523-3.15-6.381-7.028-6.381"
+     fill="#fff"
+     transform="matrix(4.162611 0 0 -4.162611 511.99336 626.219821)"
+     id="path41" />
+  <path
+     d="m0 0c0-12.052 9.765-21.815 21.815-21.815 12.041 0 21.808 9.763 21.808 21.815 0 12.044-9.767 21.802-21.808 21.802-12.05 0-21.815-9.758-21.815-21.802"
+     fill="#fff"
+     transform="matrix(4.162611 0 0 -4.162611 634.78706 527.151321)"
+     id="path43" />
+  <path
+     d="m0 0c0-7.994 6.477-14.473 14.471-14.473 8.002 0 14.479 6.479 14.479 14.473s-6.477 14.479-14.479 14.479c-7.994 0-14.471-6.485-14.471-14.479"
+     fill="#414042"
+     transform="matrix(4.162611 0 0 -4.162611 656.64056 532.537071)"
+     id="path45" />
+  <path
+     style="fill:#ef5132;fill-opacity:1"
+     d="m 104.57536,667.20303 -0.15289,43.87884 145.09067,135.30584 582.80887,-29.96604 87.13745,-108.31356 -0.43243,-43.78378 -494.37838,-12.64865 z"
+     id="path265" />
+  <path
+     style="fill:#ef5132;fill-opacity:1"
+     d="m 181.01934,403.62419 666.59147,9.78483 -13.45414,250.73625 -659.25285,-11.00794 z"
+     id="path1205" />
+  <g
+     id="g6283"
+     transform="matrix(1.325853,0,0,1.325853,-167.12939,-143.97607)"
+     style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-opacity:1">
+    <ellipse
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-opacity:1"
+       id="path2034"
+       cx="511.42264"
+       cy="380.99677"
+       rx="54.428112"
+       ry="56.874317" />
+    <ellipse
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-opacity:1"
+       id="path2034-8"
+       cx="512.48041"
+       cy="716.73877"
+       rx="54.428112"
+       ry="56.874317" />
+    <ellipse
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-opacity:1"
+       id="path2034-8-0"
+       cx="653.41595"
+       cy="520.51215"
+       rx="54.428112"
+       ry="56.874317" />
+    <path
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-opacity:1"
+       d="m 490.15878,667.66169 h 44.03173 V 432.76846 l 72.41241,72.41241 31.15384,-31.15384 -84.5946,-84.5946 h -63 z"
+       id="path5896" />
+    <path
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:3.20357;stroke-opacity:1"
+       d="m 490.16216,232.8165 h 44 V 336 h -44 z"
+       id="path6276" />
+    <path
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.754231;stroke-opacity:1"
+       d="m 475.66408,234.00582 h 73.09797 c 0,0 -32.71498,-6.71602 -73.09797,0 z"
+       id="path11529"
+       sodipodi:nodetypes="ccc"
+       mask="url(#mask11953)" />
+  </g>
+</svg>

release.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+# This script is used to create releases for this plugin. This is mostly a helper script for the maintainer.
+
+echo "Enter the new version number (e.g. 1.2.1):"
+read version
+
+echo "Enter the Windows x64 release ZIP artifact ID or URL:"
+read windowsArtifactID
+
+echo "Enter the Linux x64 release ZIP artifact ID or URL:"
+read linuxArtifactID
+
+echo "Enter the MacOS universal release ZIP artifact ID or URL:"
+read macArtifactID
+
+# wget-ing the github.com URL gives a 404, so we use the method proposed here - https://github.com/actions/upload-artifact/issues/51#issuecomment-735989475
+# The ${foo##*/} syntax extracts the string after the last '/' in case it's a full artifact URL.
+baseURL=https://nightly.link/godotengine/godot-git-plugin/actions/artifacts/
+windowsZIPURL=${baseURL}${windowsArtifactID##*/}.zip
+linuxZIPURL=${baseURL}${linuxArtifactID##*/}.zip
+macZIPURL=${baseURL}${macArtifactID##*/}.zip
+
+wget -O windows.zip $windowsZIPURL
+wget -O linux.zip $linuxZIPURL
+wget -O mac.zip $macZIPURL
+
+unzip windows.zip -d windows/
+unzip linux.zip -d linux/
+unzip mac.zip -d mac/
+
+releasePath=godot-git-plugin-v$version
+mkdir $releasePath
+
+cp -r windows/addons/ $releasePath
+addonsPath=$releasePath/addons
+pluginPath=$addonsPath/godot-git-plugin
+
+mkdir $pluginPath/linux
+mkdir $pluginPath/macos
+cp -r linux/addons/godot-git-plugin/linux/ $pluginPath/
+cp -r mac/addons/godot-git-plugin/macos/ $pluginPath/
+
+sed -i "s/version=\"[^\"]*\"/version=\"v${version}\"/g" $pluginPath/plugin.cfg
+cp LICENSE $pluginPath/LICENSE
+cp THIRDPARTY.md $pluginPath/THIRDPARTY.md
+
+zip -r $releasePath.zip $addonsPath
+
+rm -rf $releasePath
+rm -rf windows
+rm -rf linux
+rm -rf mac
+rm windows.zip
+rm linux.zip
+rm mac.zip

thirdparty/SCsub

@@ -1,4 +0,0 @@
-#!/usr/bin/env python
-
-SConscript("ssh2/SCsub")
-SConscript("git2/SCsub")

thirdparty/git2/SCsub

@@ -1,135 +0,0 @@
-#!/usr/bin/env python
-
-# Adopted from https://github.com/goostengine/goost/blob/20d8ce4c7d74c26832d69283305b25a72165784a/modules/git/SCsub
-
-Import("env")
-
-env_git = env.Clone()
-
-# Thirdparty source files.
-libgit2_sources = []
-libgit2_sources += Glob("libgit2/src/" + "*.c")
-libgit2_sources += Glob("libgit2/src/allocators/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/sha1dc/sha1.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/sha1dc/ubc_check.c")
-libgit2_sources += Glob("libgit2/src/hash/sha1/collisiondetect.c")
-libgit2_sources += Glob("libgit2/src/transports/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/transports/" + "*.c")
-libgit2_sources += Glob("libgit2/src/hash/xdiff/" + "*.c")
-libgit2_sources += Glob("libgit2/src/xdiff/" + "*.c")
-libgit2_sources += Glob("libgit2/src/streams/" + "*.c")
-
-libgit2_sources += Glob("libgit2/deps/http-parser/" + "*.c")
-libgit2_sources += Glob("libgit2/deps/pcre/" + "*.c")
-libgit2_sources += Glob("libgit2/deps/zlib/" + "*.c")
-
-if env_git["bits"] == 64:
-    env_git.Prepend(CPPDEFINES=["GIT_ARCH_64"])
-elif env_git["bits"] == 32:
-    env_git.Prepend(CPPDEFINES=["GIT_ARCH_32"])
-
-env_git.Prepend(
-    CPPPATH=[
-        "libgit2/include/",
-        "libgit2/src/",
-        "libgit2/deps/http-parser/",
-        "libgit2/deps/pcre/",
-        "libgit2/deps/zlib/",
-        "libgit2/deps/ntlmclient/",
-        "../ssh2/libssh2/include/",
-    ]
-)
-
-env_git.Prepend(
-    CPPDEFINES=[
-        "GIT_THREADS",
-        "GIT_SSH",
-        "GIT_SSH_MEMORY_CREDENTIALS",
-        "LIBGIT2_NO_FEATURES_H",
-        "GIT_SHA1_COLLISIONDETECT",
-        "GIT_HTTPS",
-        "SRC_UTIL_H_",
-        "GIT_REGEX_BUILTIN",
-    ]
-)
-
-if env_git["platform"] == "windows":
-    libgit2_sources += Glob("libgit2/src/win32/" + "*.c")
-    env_git.Prepend(
-        CPPDEFINES=[
-            "GIT_WINHTTP",
-            "HAVE_SYS_STAT_H",
-            "HAVE_SYS_TYPES_H",
-            "HAVE_WINDOWS_H",
-            "HAVE_STDINT_H",
-            "HAVE_INTTYPES_H",
-            "HAVE_MEMMOVE",
-            "HAVE_STRERROR",
-            "HAVE_STRTOLL",
-            "HAVE__STRTOI64",
-            "SUPPORT_PCRE8",
-            "NO_RECURSE",
-            "HAVE_LONG_LONG",
-            "HAVE_UNSIGNED_LONG_LONG",
-            ("NEWLINE", "10"),
-            ("POSIX_MALLOC_THRESHOLD", "10"),
-            ("LINK_SIZE", "2"),
-            ("PARENS_NEST_LIMIT", "250"),
-            ("MATCH_LIMIT", "10000000"),
-            ("MATCH_LIMIT_RECURSION", "10000000"),
-            "PCREGREP_BUFSIZE",
-            ("MAX_NAME_SIZE", "32"),
-            ("MAX_NAME_COUNT", "10000"),
-            "HAVE_WINCNG",
-            "LIBSSH2_WINCNG"
-        ]
-    )
-
-if env_git["platform"] in ["linux", "osx"]:
-    env_git.Append(CCFLAGS="-fPIC")
-    libgit2_sources += Glob("libgit2/src/unix/" + "*.c")
-    libgit2_sources += [
-        "libgit2/deps/ntlmclient/crypt_openssl.c",
-        "libgit2/deps/ntlmclient/unicode_builtin.c"
-    ]
-    env_git.Prepend(
-        CPPDEFINES=[
-            "HAVE_DIRENT_H",
-            "HAVE_SYS_STAT_H",
-            "HAVE_SYS_TYPES_H",
-            "HAVE_UNISTD_H",
-            "HAVE_STDINT_H",
-            "HAVE_INTTYPES_H",
-            "HAVE_BCOPY",
-            "HAVE_MEMMOVE",
-            "HAVE_STRERROR",
-            "HAVE_STRTOLL",
-            "HAVE_STRTOQ",
-            "SUPPORT_PCRE8",
-            "NO_RECURSE",
-            "HAVE_LONG_LONG",
-            "HAVE_UNSIGNED_LONG_LONG",
-            ("NEWLINE", "10"),
-            ("POSIX_MALLOC_THRESHOLD", "10"),
-            ("LINK_SIZE", "2"),
-            ("PARENS_NEST_LIMIT", "250"),
-            ("MATCH_LIMIT", "10000000"),
-            ("MATCH_LIMIT_RECURSION", "10000000"),
-            "PCREGREP_BUFSIZE",
-            ("MAX_NAME_SIZE", "32"),
-            ("MAX_NAME_COUNT", "10000"),
-            "GIT_OPENSSL",
-            "GIT_USE_FUTIMENS",
-            "GIT_USE_STAT_MTIM",
-            "CRYPT_OPENSSL",
-            "UNICODE_BUILTIN"
-        ]
-    )
-
-if env_git["platform"] == "osx":
-    env_git.Prepend(CPPPATH=[env_git["macos_openssl"] + "include/"])
-    static_ssl = File(env_git["macos_openssl_static_ssl"])
-    static_crypto = File(env_git["macos_openssl_static_crypto"])
-    env_git.Append(LIBS=[static_ssl, static_crypto])
-
-env_git.StaticLibrary(target="../bin/" + "git2", source=libgit2_sources)

thirdparty/ssh2/SCsub

@@ -1,113 +0,0 @@
-#!/usr/bin/env python
-
-# Adopted from https://github.com/nodegit/nodegit/blob/4561dcb7c120474a4553baa27e4c4c2f4be23a2b/vendor/libgit2.gyp
-
-Import("env")
-
-env_ssh2 = env.Clone()
-
-# Thirdparty source files.
-libssh2_sources = [
-    "libssh2/src/agent.c",
-    "libssh2/src/bcrypt_pbkdf.c",
-    "libssh2/src/blowfish.c",
-    "libssh2/src/crypt.c",
-    "libssh2/src/keepalive.c",
-    "libssh2/src/libgcrypt.c",
-    "libssh2/src/openssl.c",
-    "libssh2/src/publickey.c",
-    "libssh2/src/sftp.c",
-    "libssh2/src/version.c",
-    "libssh2/src/channel.c",
-    "libssh2/src/global.c",
-    "libssh2/src/kex.c",
-    "libssh2/src/mac.c",
-    "libssh2/src/packet.c",
-    "libssh2/src/scp.c",
-    "libssh2/src/transport.c",
-    "libssh2/src/comp.c",
-    "libssh2/src/hostkey.c",
-    "libssh2/src/knownhost.c",
-    "libssh2/src/misc.c",
-    "libssh2/src/pem.c",
-    "libssh2/src/session.c",
-    "libssh2/src/userauth.c",
-]
-
-env_ssh2.Prepend(
-    CPPPATH=[
-        "libssh2/include/"
-        "libssh2/src/"
-    ]
-)
-
-if env_ssh2["platform"] == "windows":
-    env_ssh2.Append(
-        CPPPATH=[
-            "libssh2/include/",
-            "libssh2/win32/"
-        ]
-    )
-    libssh2_sources += ["libssh2/src/agent_win.c", "libssh2/src/wincng.c"]
-    env_ssh2.Append(
-        CPPDEFINES=[
-            "LIBSSH2_WINCNG",
-            "HAVE_WINCNG"
-        ]
-    )
-    env_ssh2.Append(LIBS=["crypt32", "user32"])
-
-if env_ssh2["platform"] in ["linux", "osx"]:
-    env_ssh2.Append(CCFLAGS="-fPIC")
-    env_ssh2.Append(
-        CPPPATH=[
-            ".",
-            "libssh2/include/",
-        ]
-    )
-    libssh2_sources += ["libssh2/src/openssl.c"]
-    env_ssh2.Append(
-        CPPDEFINES=[
-            "LIBSSH2_CONFIG_H",
-            "HAVE_SYS_UIO_H",
-            ("HAVE_ALLOCA", 1),
-            ("HAVE_ALLOCA_H", 1),
-            ("HAVE_ARPA_INET_H", 1),
-            ("HAVE_ERRNO_H", 1),
-            ("HAVE_FCNTL_H", 1),
-            ("HAVE_GETTIMEOFDAY", 1),
-            ("HAVE_GETTIMEOFDAY", 1),
-            ("HAVE_INTTYPES_H", 1),
-            ("HAVE_LONGLONG", 1),
-            ("HAVE_NETINET_IN_H", 1),
-            ("HAVE_O_NONBLOCK", 1),
-            ("HAVE_SELECT", 1),
-            ("HAVE_STDINT_H", 1),
-            ("HAVE_STDIO_H", 1),
-            ("HAVE_STDLIB_H", 1),
-            ("HAVE_STRINGS_H", 1),
-            ("HAVE_STRING_H", 1),
-            ("HAVE_STRTOLL", 1),
-            ("HAVE_SYS_IOCTL_H", 1),
-            ("HAVE_SYS_SOCKET_H", 1),
-            ("HAVE_SYS_STAT_H", 1),
-            ("HAVE_SYS_TIME_H", 1),
-            ("HAVE_SYS_TYPES_H", 1),
-            ("HAVE_SYS_UIO_H", 1),
-            ("HAVE_SYS_UN_H", 1),
-            ("HAVE_UNISTD_H", 1),
-            ("LIBSSH2_CLEAR_MEMORY", 1),
-            ("LIBSSH2_DH_GEX_NEW", 1),
-            ("LIBSSH2_OPENSSL", 1),
-            ("LT_OBJDIR", ".libs/"),
-            ("STDC_HEADERS", 1)
-        ]
-    )
-
-if env_ssh2["platform"] == "osx":
-    env_ssh2.Append(CPPPATH=[env_ssh2["macos_openssl"] + "include/"])
-    static_ssl = File(env_ssh2["macos_openssl_static_ssl"])
-    static_crypto = File(env_ssh2["macos_openssl_static_crypto"])
-    env_ssh2.Append(LIBS=[static_ssl, static_crypto])
-
-env_ssh2.StaticLibrary(target="../bin/" + "ssh2", source=libssh2_sources)

tools/cmake.py

@@ -0,0 +1,177 @@
+import os
+import shlex
+import sys
+
+import SCons.Action
+import SCons.Builder
+import SCons.Util
+
+
+# This must be kept in sync with the value in https://github.com/godotengine/godot/blob/master/platform/android/detect.py#L58.
+def get_ndk_version():
+    return "23.2.8568313"
+
+
+def cmake_default_flags(env):
+    if env.get("cmake_default_flags", ""):
+        return shlex.split(env["cmake_default_flags"])
+
+    config = {}
+
+    if "CC" in env:
+        config["CMAKE_C_COMPILER"] = env["CC"]
+    if "CXX" in env:
+        config["CMAKE_CXX_COMPILER"] = env["CXX"]
+
+    if env["platform"] == "android":
+        api = env["android_api_level"]
+        abi = {
+            "arm64": "arm64-v8a",
+            "arm32": "armeabi-v7a",
+            "x86_32": "x86",
+            "x86_64": "x86_64",
+        }[env["arch"]]
+        config["CMAKE_SYSTEM_NAME"] = "Android"
+        config["CMAKE_SYSTEM_VERSION"] = api
+        config["CMAKE_ANDROID_ARCH_ABI"] = abi
+        config["ANDROID_ABI"] = abi
+        ndk_root = os.environ.get("ANDROID_NDK_ROOT", env.get("ANDROID_HOME", "") + "/ndk/" + get_ndk_version())
+        config["CMAKE_TOOLCHAIN_FILE"] = "%s/build/cmake/android.toolchain.cmake" % ndk_root
+        config["CMAKE_ANDROID_STL_TYPE"] = "c++_static"
+
+    elif env["platform"] == "linux":
+        linux_flags = {
+            "x86_64": "-m64",
+            "x86_32": "-m32",
+            "arm32": "-march=armv7-a",
+            "arm64": "-march=armv8-a",
+        }.get(env["arch"], "")
+        if linux_flags:
+            config["CMAKE_C_FLAGS"] = linux_flags
+            config["CMAKE_CXX_FLAGS"] = linux_flags
+
+    elif env["platform"] == "macos":
+        if env["arch"] == "universal":
+            config["CMAKE_OSX_ARCHITECTURES"] = '"x86_64;arm64"'
+        else:
+            config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("macos_deployment_target", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+            config["CMAKE_AR"] = env["AR"]
+            config["CMAKE_RANLIB"] = env["RANLIB"]
+            if env["arch"] == "universal":
+                flags = "-arch x86_64 -arch arm64"
+            else:
+                flags = "-arch " + env["arch"]
+            if env["macos_deployment_target"] != "default":
+                flags += " -mmacosx-version-min=" + env["macos_deployment_target"]
+            config["CMAKE_C_FLAGS"] = flags
+            config["CMAKE_CXX_FLAGS"] = flags
+
+    elif env["platform"] == "ios":
+        if env["arch"] == "universal":
+            raise ValueError("iOS architecture not supported: %s" % env["arch"])
+        config["CMAKE_SYSTEM_NAME"] = "iOS"
+        config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("ios_min_version", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["ios_min_version"]
+        if env["ios_simulator"]:
+            config["CMAKE_OSX_SYSROOT"] = "iphonesimulator"
+
+    elif env["platform"] == "windows":
+        config["CMAKE_SYSTEM_NAME"] = "Windows"
+        if env.get("is_msvc", False):
+            config["CMAKE_POLICY_DEFAULT_CMP0091"] = "NEW"
+            if env.get("debug_crt", False):
+                config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDebugDLL"
+            else:
+                if env.get("use_static_cpp", False):
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreaded"
+                else:
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDLL"
+
+    return ["-D%s=%s" % it for it in config.items()]
+
+
+def cmake_emitter(target, source, env):
+    return [str(target[0]) + "/CMakeCache.txt"] + target[1:], [str(source[0]) + "/CMakeLists.txt"] + source[1:]
+
+
+def cmake_generator(target, source, env, for_signature):
+    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
+    build = env["CMAKEBUILDCOM"].replace("-j$CMAKEBUILDJOBS", "") if for_signature else env["CMAKEBUILDCOM"]
+    actions = [
+        SCons.Action.Action("$CMAKECONFCOM", "$CMAKECONFCOMSTR"),
+        SCons.Action.Action(build, "$CMAKEBUILDCOMSTR"),
+    ]
+    if env["CMAKE_INSTALL"]:
+        actions.append(
+            SCons.Action.Action("$CMAKEINSTALLCOM", "$CMAKEINSTALLCOMSTR"),
+        )
+    return actions
+
+
+def cmake_build(
+    env, target_dir, source_dir, cmake_outputs=[], cmake_targets=[], cmake_options=[], dependencies=[], install=False
+):
+    cmake_env = env.Clone()
+    target = env.Dir("{}/{}/{}".format(target_dir, env["platform"], env["arch"]))
+    source = env.Dir(source_dir)
+    builder_targets = [target] + [str(target) + "/" + f for f in cmake_outputs]
+    builder_sources = [source] + dependencies
+    default_flags = cmake_default_flags(env)
+
+    # Merge flags
+    flags = []
+    for df in default_flags:
+        if not df.startswith("-D"):
+            flags.append(df)
+        else:
+            f = df[2:].split("=")[0]
+            if f in cmake_options:
+                df += " " + cmake_options[f]
+                cmake_options.pop(f)
+            flags.append(df)
+    for opt in cmake_options:
+        flags.append("-D%s=%s" % (opt, cmake_options[opt]))
+
+    # Select generator
+    if env["cmake_generator"]:
+        flags.extend(["-G", env["cmake_generator"]])
+    elif env["platform"] == "windows":
+        if env.get("is_msvc", False):
+            flags.extend(["-G", "NMake Makefiles"])
+        elif sys.platform in ["win32", "msys", "cygwin"]:
+            flags.extend(["-G", "Ninja"])
+        else:
+            flags.extend(["-G", "Unix Makefiles"])
+
+    cmake_env.Append(CMAKECONFFLAGS=flags)
+    if len(cmake_targets) > 0:
+        cmake_env.Append(CMAKEBUILDFLAGS=["-t"] + [t for t in cmake_targets])
+    cmake_env["CMAKE_INSTALL"] = install
+    return cmake_env.CMake(builder_targets, builder_sources)
+
+
+def options(opts):
+    opts.Add("cmake_default_flags", "Default CMake platform flags override, will be autodetected if not specified.", "")
+    opts.Add("cmake_generator", "CMake generator override, will be autodetected from platform if not specified.", "")
+    opts.Add("cmake", "CMake binary to use", "cmake")
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    env["CMAKE"] = env["cmake"]
+    env["CMAKECONFFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKECONFCOM"] = "$CMAKE -B ${TARGET.dir} $CMAKECONFFLAGS ${SOURCE.dir}"
+    env["CMAKEBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
+    env["CMAKEBUILDFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEINSTALLFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEBUILDCOM"] = "$CMAKE --build ${TARGET.dir} $CMAKEBUILDFLAGS -j$CMAKEBUILDJOBS"
+    env["CMAKEINSTALLCOM"] = "$CMAKE --install ${TARGET.dir} $CMAKEINSTALLFLAGS"
+    env["BUILDERS"]["CMake"] = SCons.Builder.Builder(generator=cmake_generator, emitter=cmake_emitter)
+    env.AddMethod(cmake_build, "CMakeBuild")

tools/git2.py

@@ -0,0 +1,69 @@
+import os
+
+
+def build_library(env, deps):
+    config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "OPENSSL_USE_STATIC_LIBS": 1,
+        "OPENSSL_INCLUDE_DIR": env["SSL_INCLUDE"],
+        "OPENSSL_SSL_LIBRARY": env["SSL_LIBRARY"],
+        "OPENSSL_CRYPTO_LIBRARY": env["SSL_CRYPTO_LIBRARY"],
+        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
+        "BUILD_TESTS": 0,
+        "BUILD_CLI": 0,
+        "BUILD_EXAMPLES": 0,
+        "BUILD_FUZZERS": 0,
+        "USE_SSH": 1,
+        "USE_HTTPS": 1,
+        "USE_SHA1": 1,
+        "USE_BUNDLED_ZLIB": 1,
+        "USE_HTTP_PARSER": "builtin",
+        "REGEX_BACKEND": "builtin",
+        "USE_HTTPS": "OpenSSL",
+        "USE_SHA1": "OpenSSL",
+        "BUILD_SHARED_LIBS": 0,
+        "LINK_WITH_STATIC_LIBRARIES": 1,
+        "LIBSSH2_INCLUDE_DIR": env.Dir("#thirdparty/ssh2/libssh2/include").abspath,
+        "LIBSSH2_LIBRARY": deps[-1],
+        "USE_WINHTTP": 0,
+        "STATIC_CRT": env.get("use_static_cpp", True),
+        "CMAKE_DISABLE_FIND_PACKAGE_ZLIB": 1,
+        "CMAKE_DISABLE_FIND_PACKAGE_OPENSSL": 1,
+    }
+
+    if env["platform"] != "windows":
+        config["CMAKE_C_FLAGS"] = "-fPIC"
+    else:
+        config["OPENSSL_ROOT_DIR"] = env["SSL_BUILD"]
+
+    is_msvc = env.get("is_msvc", False)
+    lib_ext = ".lib" if is_msvc else ".a"
+    lib_prefix = "" if is_msvc else "lib"
+    libs = ["{}git2{}".format(lib_prefix, lib_ext)]
+
+    source = env.Dir("#thirdparty/git2/libgit2").abspath
+    target = env.Dir("#bin/thirdparty/libgit2").abspath
+
+    git2 = env.CMakeBuild(
+        "#bin/thirdparty/git2/",
+        "#thirdparty/git2/libgit2",
+        cmake_options=config,
+        cmake_outputs=libs,
+        cmake_targets=[],
+        dependencies=deps,
+    )
+
+    env.Append(CPPPATH=["#thirdparty/git2/libgit2/include"])
+    env.Prepend(LIBS=git2[1:])
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["secur32"])
+
+    return git2
+
+
+def exists(env):
+    return "CMake" in env
+
+
+def generate(env):
+    env.AddMethod(build_library, "BuildGIT2")

tools/openssl.py

@@ -0,0 +1,288 @@
+import os, sys
+import SCons.Util
+import SCons.Builder
+import SCons.Action
+from SCons.Defaults import Mkdir
+from SCons.Variables import PathVariable, BoolVariable
+
+
+def ssl_platform_target(env):
+    targets = {}
+    platform = env["platform"]
+    if platform == "linux":
+        targets = {
+            "x86_32": "linux-x86",
+            "x86_64": "linux-x86_64",
+            "arm64": "linux-aarch64",
+            "arm32": "linux-armv4",
+            "rv64": "linux64-riscv64",
+        }
+    elif platform == "android":
+        targets = {
+            "arm64": "android-arm64",
+            "arm32": "android-arm",
+            "x86_32": "android-x86",
+            "x86_64": "android-x86_64",
+        }
+    elif platform == "macos":
+        targets = {
+            "x86_64": "darwin64-x86_64",
+            "arm64": "darwin64-arm64",
+        }
+    elif platform == "ios":
+        if env["ios_simulator"]:
+            targets = {
+                "x86_64": "iossimulator-xcrun",
+                "arm64": "iossimulator-xcrun",
+            }
+        else:
+            targets = {
+                "arm64": "ios64-xcrun",
+                "arm32": "ios-xcrun",
+            }
+    elif platform == "windows":
+        if env.get("is_msvc", False):
+            targets = {
+                "x86_32": "VC-WIN32",
+                "x86_64": "VC-WIN64A",
+            }
+        else:
+            targets = {
+                "x86_32": "mingw",
+                "x86_64": "mingw64",
+            }
+
+    arch = env["arch"]
+    target = targets.get(arch, "")
+    if target == "":
+        raise ValueError("Architecture '%s' not supported for platform: '%s'" % (arch, platform))
+    return target
+
+
+def ssl_platform_options(env):
+    ssl_config_options = [
+        "no-ssl2",
+        "no-ssl3",
+        "no-weak-ssl-ciphers",
+        "no-legacy",
+        "no-shared",
+        "no-tests",
+    ]
+    if env["platform"] == "windows":
+        ssl_config_options.append("enable-capieng")
+    return ssl_config_options
+
+
+def ssl_platform_flags(env):
+    args = []
+    if env["platform"] == "android":
+        if env.get("android_api_level", ""):
+            api = int(env["android_api_level"])
+            args.append("-D__ANDROID_API__=%s" % api)
+    elif env["platform"] == "macos":
+        if env["macos_deployment_target"] != "default":
+            args.append("-mmacosx-version-min=%s" % env["macos_deployment_target"])
+        # OSXCross toolchain setup.
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+            for k in ["CC", "CXX", "AR", "AS", "RANLIB"]:
+                args.append("%s=%s" % (k, env[k]))
+    elif env["platform"] == "windows":
+        is_win_host = sys.platform in ["win32", "msys", "cygwin"]
+        if not (is_win_host or env.get("is_msvc", False)):
+            mingw_prefixes = {
+                "x86_32": "--cross-compile-prefix=i686-w64-mingw32-",
+                "x86_64": "--cross-compile-prefix=x86_64-w64-mingw32-",
+            }
+            args.append(mingw_prefixes[env["arch"]])
+    return args
+
+
+def ssl_configure_args(env):
+    if env.get("openssl_configure_options", ""):
+        opts = SCons.Util.CLVar(env["openssl_configure_options"])
+    else:
+        opts = ssl_platform_options(env)
+
+    if env.get("openssl_configure_target", ""):
+        target = [env["openssl_configure_target"]]
+    else:
+        target = [ssl_platform_target(env)]
+
+    if env.get("openssl_configure_flags", ""):
+        flags = SCons.Util.CLVar(env["openssl_configure_flags"])
+    else:
+        flags = ssl_platform_flags(env)
+
+    return opts + target + flags
+
+
+def ssl_emitter(target, source, env):
+    return env["SSL_LIBS"], [env.File(env["SSL_SOURCE"] + "/Configure"), env.File(env["SSL_SOURCE"] + "/VERSION.dat")]
+
+
+def build_openssl(env, jobs=None):
+    if env["SSL_EXTERNAL"]:
+        # Setup the env to use the provided libraries, and return them without building.
+        env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
+        env.Prepend(LIBPATH=[env["SSL_BUILD"]])
+        if env["platform"] == "windows":
+            env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
+        env.Prepend(LIBS=env["SSL_LIBS"])
+        return [env["SSL_CRYPTO_LIBRARY"], env["SSL_LIBRARY"]]
+
+    if jobs is None:
+        jobs = int(env.GetOption("num_jobs"))
+
+    # Since the OpenSSL build system does not support macOS universal binaries, we first need to build the two libraries
+    # separately, then we join them together using lipo.
+    if env["platform"] == "macos" and env["arch"] == "universal":
+        build_envs = {
+            "x86_64": env.Clone(),
+            "arm64": env.Clone(),
+        }
+        arch_ssl = []
+        for arch in build_envs:
+            benv = build_envs[arch]
+            benv["arch"] = arch
+            generate(benv)
+            benv["SSLBUILDJOBS"] = max([1, int(jobs / len(build_envs))])
+            ssl = benv.OpenSSLBuilder()
+            arch_ssl.extend(ssl)
+            benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
+
+        # x86_64 and arm64 includes are equivalent.
+        env["SSL_INCLUDE"] = build_envs["arm64"]["SSL_INCLUDE"]
+
+        # Join libraries using lipo.
+        lipo_action = "lipo $SOURCES -create -output $TARGET"
+        ssl_libs = list(map(lambda arch: build_envs[arch]["SSL_LIBRARY"], build_envs))
+        ssl_crypto_libs = list(map(lambda arch: build_envs[arch]["SSL_CRYPTO_LIBRARY"], build_envs))
+        ssl = env.Command(env["SSL_LIBRARY"], ssl_libs, lipo_action)
+        ssl += env.Command(env["SSL_CRYPTO_LIBRARY"], ssl_crypto_libs, lipo_action)
+        env.Depends(ssl, arch_ssl)
+    else:
+        benv = env.Clone()
+        benv["SSLBUILDJOBS"] = jobs
+        ssl = benv.OpenSSLBuilder()
+        benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
+
+    # Setup the environment to use the freshly built openssl.
+    env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
+    env.Prepend(LIBPATH=[env["SSL_BUILD"]])
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
+    env.Prepend(LIBS=env["SSL_LIBS"])
+
+    return ssl
+
+
+def ssl_generator(target, source, env, for_signature):
+    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
+    build = env["SSLBUILDCOM"].replace("-j$SSLBUILDJOBS", "") if for_signature else env["SSLBUILDCOM"]
+    return [
+        Mkdir("$SSL_BUILD"),
+        Mkdir("$SSL_INSTALL"),
+        SCons.Action.Action("$SSLCONFIGCOM", "$SSLCONFIGCOMSTR"),
+        SCons.Action.Action(build, "$SSLBUILDCOMSTR"),
+    ]
+
+
+def options(opts):
+    opts.Add(PathVariable("openssl_source", "Path to the openssl sources.", "thirdparty/openssl"))
+    opts.Add("openssl_build", "Destination path of the openssl build.", "bin/thirdparty/openssl")
+    opts.Add(
+        "openssl_configure_options",
+        "OpenSSL configure options override. Will use a reasonable default if not specified.",
+        "",
+    )
+    opts.Add(
+        "openssl_configure_target", "OpenSSL configure target override, will be autodetected if not specified.", ""
+    )
+    opts.Add(
+        "openssl_configure_flags",
+        "OpenSSL configure compiler flags override. Will be autodetected if not specified.",
+        "",
+    )
+    opts.Add(
+        "openssl_external_crypto",
+        'An external libcrypto static library (e.g. "/usr/lib/x86_64-linux-gnu/libcrypto.a"). If not provided, OpenSSL will be built from source.',
+        "",
+    )
+    opts.Add(
+        "openssl_external_ssl",
+        'An external libssl static library (e.g. "/usr/lib/x86_64-linux-gnu/libssl.a"). If not provided, OpenSSL will be built from source.',
+        "",
+    )
+    opts.Add(
+        "openssl_external_include",
+        'An external OpenSSL "include" folder (e.g. "/usr/include/openssl").',
+        "",
+    )
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    env.AddMethod(build_openssl, "OpenSSL")
+
+    # Check if the user specified infos about external OpenSSL files.
+    external_opts = ["openssl_external_crypto", "openssl_external_ssl", "openssl_external_include"]
+    is_set = lambda k: env.get(k, "") != ""
+    if any(map(is_set, external_opts)):
+        # Need provide the whole (crypto, ssl, include) triple to proceed.
+        if not all(map(is_set, external_opts)):
+            print('Error: The options "%s" must all be set to use a external library.' % '", "'.join(external_opts))
+            sys.exit(255)
+
+        env["SSL_CRYPTO_LIBRARY"] = env.File("${openssl_external_crypto}")
+        env["SSL_LIBRARY"] = env.File("${openssl_external_ssl}")
+        env["SSL_BUILD"] = env.Dir("${SSL_LIBRARY.dir}").abspath
+        env["SSL_INSTALL"] = env.Dir("${SSL_LIBRARY.dir}").abspath
+        env["SSL_INCLUDE"] = env.Dir("${openssl_external_include}").abspath
+        env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
+        env["SSL_EXTERNAL"] = True
+        return
+
+    # We will need to build our own OpenSSL library.
+    env["SSL_EXTERNAL"] = False
+
+    # Android needs the NDK in ENV, and proper PATH setup.
+    if env["platform"] == "android" and env["ENV"].get("ANDROID_NDK_ROOT", "") == "":
+        cc_path = os.path.dirname(env["CC"])
+        if cc_path and cc_path not in env["ENV"]:
+            env.PrependENVPath("PATH", cc_path)
+        if "ANDROID_NDK_ROOT" not in env["ENV"]:
+            env["ENV"]["ANDROID_NDK_ROOT"] = env.get("ANDROID_NDK_ROOT", os.environ.get("ANDROID_NDK_ROOT", ""))
+
+    env["SSL_SOURCE"] = env.Dir(env["openssl_source"]).abspath
+    env["SSL_BUILD"] = env.Dir(env["openssl_build"] + "/{}/{}".format(env["platform"], env["arch"])).abspath
+    env["SSL_INSTALL"] = env.Dir(env["SSL_BUILD"] + "/dest").abspath
+    env["SSL_INCLUDE"] = env.Dir(env["SSL_INSTALL"] + "/include").abspath
+    lib_ext = ".lib" if env.get("is_msvc", False) else ".a"
+    env["SSL_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libssl" + lib_ext)
+    env["SSL_CRYPTO_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libcrypto" + lib_ext)
+    env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
+
+    # Configure action
+    env["PERL"] = env.get("PERL", "perl")
+    env["_ssl_configure_args"] = ssl_configure_args
+    env["SSLPLATFORMCONFIG"] = "${_ssl_configure_args(__env__)}"
+    env["SSLCONFFLAGS"] = SCons.Util.CLVar("")
+    # fmt: off
+    env["SSLCONFIGCOM"] = 'cd ${TARGET.dir} && $PERL -- ${SOURCE.abspath} --prefix="${SSL_INSTALL}" --openssldir="${SSL_INSTALL}" $SSLPLATFORMCONFIG $SSLCONFFLAGS'
+    # fmt: on
+
+    # Build action
+    env["SSLBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
+    # fmt: off
+    env["SSLBUILDCOM"] = "make -j$SSLBUILDJOBS -C ${TARGET.dir} && make -j$SSLBUILDJOBS -C ${TARGET.dir} install_sw install_ssldirs"
+    # fmt: on
+
+    # Windows MSVC needs to build using NMake
+    if env["platform"] == "windows" and env.get("is_msvc", False):
+        env["SSLBUILDCOM"] = "cd ${TARGET.dir} && nmake install_sw install_ssldirs"
+
+    env["BUILDERS"]["OpenSSLBuilder"] = SCons.Builder.Builder(generator=ssl_generator, emitter=ssl_emitter)
+    env.AddMethod(build_openssl, "OpenSSL")

tools/ssh2.py

@@ -0,0 +1,52 @@
+import os
+
+
+def build_library(env, deps):
+    config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "OPENSSL_USE_STATIC_LIBS": 1,
+        "OPENSSL_INCLUDE_DIR": env["SSL_INCLUDE"],
+        "OPENSSL_SSL_LIBRARY": env["SSL_LIBRARY"].abspath,
+        "OPENSSL_CRYPTO_LIBRARY": env["SSL_CRYPTO_LIBRARY"].abspath,
+        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
+        "BUILD_EXAMPLES": 0,
+        "BUILD_TESTING": 0,
+        "BUILD_SHARED_LIBS": 0,
+        "CMAKE_DISABLE_FIND_PACKAGE_ZLIB": 1,
+        "CMAKE_DISABLE_FIND_PACKAGE_OPENSSL": 1,
+        "CRYPTO_BACKEND": "OpenSSL",
+    }
+
+    if env["platform"] != "windows":
+        config["CMAKE_C_FLAGS"] = "-fPIC"
+    else:
+        config["OPENSSL_ROOT_DIR"] = env["SSL_BUILD"]
+
+    is_msvc = env.get("is_msvc", False)
+    lib_ext = ".lib" if is_msvc else ".a"
+    libs = ["src/libssh2{}".format(lib_ext)]
+
+    source = env.Dir("#thirdparty/ssh2/libssh2").abspath
+    target = env.Dir("#bin/thirdparty/libssh2").abspath
+
+    ssh2 = env.CMakeBuild(
+        "#bin/thirdparty/ssh2/",
+        "#thirdparty/ssh2/libssh2",
+        cmake_options=config,
+        cmake_outputs=libs,
+        cmake_targets=[],
+        dependencies=deps,
+    )
+
+    env.Append(CPPPATH=["#thirdparty/ssh2/libssh2/include"])
+    env.Prepend(LIBS=ssh2[1:])
+
+    return ssh2
+
+
+def exists(env):
+    return "CMake" in env
+
+
+def generate(env):
+    env.AddMethod(build_library, "BuildSSH2")