expo-tiddlywiki-filesystem-android-external-storage 2.6.0 → 2.8.0

package/android/src/main/java/expo/modules/externalstorage/ExternalStorageModule.kt

@@ -568,6 +568,10 @@ class ExternalStorageModule : Module() {
       GitHelper.gitPush(gitRootDir, remoteName, localBranch, remoteBranch, force, headers)
     }
 
+    AsyncFunction("gitCreateBundle") { gitRootDir: String, remoteName: String, localBranch: String, remoteBranch: String ->
+      GitHelper.gitCreateBundle(gitRootDir, remoteName, localBranch, remoteBranch)
+    }
+
     AsyncFunction("gitFetch") { gitRootDir: String, remoteName: String, branch: String, headers: String? ->
       GitHelper.gitFetch(gitRootDir, remoteName, branch, headers)
     }

package/android/src/main/java/expo/modules/externalstorage/GitHelper.kt

@@ -84,17 +84,48 @@ internal object GitHelper {
   }
 
   /**
-   * Ensure repository git config forces protocol.version=0.
+   * Ensure repository git config forces protocol.version=0 and
+   * constrains pack memory for Android's limited heap.
+   *
    * TidGi Desktop's git server uses `git --stateless-rpc` which only speaks V0/V1.
    * JGit defaults to V2 negotiation, which causes the error:
    *   "Starting read stage without written request data pending is not supported"
    * because the server doesn't handle V2 capability advertisements.
+   *
+   * Pack memory limits prevent OOM on large repos (Android heap is ~268MB).
+   * Default JGit settings: deltaCacheSize=50MB, windowMemory=unlimited,
+   * bigFileThreshold=50MB — far too much for a mobile device.
    */
   private fun ensureProtocolV0(repo: Repository) {
     val config = repo.config
+    var dirty = false
     val current = config.getString("protocol", null, "version")
     if (current != "0") {
       config.setString("protocol", null, "version", "0")
+      dirty = true
+    }
+    // Limit pack memory to avoid OOM on push
+    // pack.windowMemory: max bytes for delta search window (per thread), default unlimited
+    if (config.getLong("pack", "windowmemory", 0) == 0L) {
+      config.setLong("pack", null, "windowmemory", 10L * 1024 * 1024) // 10MB
+      dirty = true
+    }
+    // pack.deltaCacheSize: total delta cache, default 50MB
+    if (config.getLong("pack", "deltacachesize", 50L * 1024 * 1024) >= 50L * 1024 * 1024) {
+      config.setLong("pack", null, "deltacachesize", 5L * 1024 * 1024) // 5MB
+      dirty = true
+    }
+    // pack.threads: limit to 1 to reduce memory pressure
+    if (config.getInt("pack", "threads", 0) == 0) {
+      config.setInt("pack", null, "threads", 1)
+      dirty = true
+    }
+    // pack.window: reduce from 10 to 5
+    if (config.getInt("pack", "window", 10) > 5) {
+      config.setInt("pack", null, "window", 5)
+      dirty = true
+    }
+    if (dirty) {
       config.save()
     }
   }
@@ -338,6 +369,80 @@ internal object GitHelper {
     return result.toString()
   }
 
+  // ─── Git bundle creation (for push via HTTP POST) ───────────────
+
+  /**
+   * Create a git bundle containing commits on localBranch that are ahead of
+   * remoteName/remoteBranch. Returns a base64-encoded bundle string, or
+   * a JSON error if there's nothing to bundle.
+   *
+   * This avoids JGit's broken SmartHttpPushConnection (which throws
+   * "Starting read stage without written request data pending is not supported"
+   * due to MultiRequestService not marking finalRequest=true for push).
+   *
+   * The bundle is sent by the JS layer via HTTP POST to the desktop's
+   * /receive-bundle endpoint, which runs `git fetch <bundle> master:mobile-incoming`.
+   */
+  fun gitCreateBundle(
+    gitRootDir: String,
+    remoteName: String,
+    localBranch: String,
+    remoteBranch: String
+  ): String {
+    val result = JSONObject()
+    try {
+      val repo = openRepo(gitRootDir)
+      try {
+        ensureProtocolV0(repo)
+        val localRef = repo.resolve("refs/heads/$localBranch")
+          ?: throw Exception("Local branch $localBranch not found")
+        val remoteRef = repo.resolve("refs/remotes/$remoteName/$remoteBranch")
+
+        val revWalk = RevWalk(repo)
+        try {
+          val localCommit = revWalk.parseCommit(localRef)
+
+          val bundleWriter = org.eclipse.jgit.transport.BundleWriter(repo)
+
+          // Include the local branch tip
+          bundleWriter.include("refs/heads/$localBranch", localRef)
+
+          // If we have a remote tracking ref, mark it as assumed (prerequisite).
+          // The receiving end must have this commit.
+          if (remoteRef != null) {
+            val remoteCommit = revWalk.parseCommit(remoteRef)
+            bundleWriter.assume(remoteCommit)
+          }
+
+          // Configure pack for low memory (Android)
+          val packConfig = org.eclipse.jgit.storage.pack.PackConfig(repo)
+          bundleWriter.setPackConfig(packConfig)
+
+          // Write bundle to memory
+          val baos = ByteArrayOutputStream()
+          bundleWriter.writeBundle(org.eclipse.jgit.lib.NullProgressMonitor.INSTANCE, baos)
+
+          val bundleBytes = baos.toByteArray()
+          val base64Bundle = Base64.encodeToString(bundleBytes, Base64.NO_WRAP)
+
+          result.put("ok", true)
+          result.put("bundle", base64Bundle)
+          result.put("bundleSize", bundleBytes.size)
+          android.util.Log.i("GitBundle", "Bundle created: ${bundleBytes.size} bytes, local=$localBranch remote=$remoteName/$remoteBranch")
+        } finally {
+          revWalk.close()
+        }
+      } finally {
+        repo.close()
+      }
+    } catch (e: Exception) {
+      result.put("ok", false)
+      result.put("error", e.message ?: "Unknown bundle error")
+      android.util.Log.e("GitBundle", "Bundle creation failed: ${e.message}", e)
+    }
+    return result.toString()
+  }
+
   // ─── Git fetch (JGit) ───────────────────────────────────────────
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-tiddlywiki-filesystem-android-external-storage",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "Expo native module for TidGi-Mobile: filesystem I/O + TiddlyWiki .tid/.meta/.json batch parsing + git status in Kotlin (Android) and Swift (iOS)",
   "main": "build/index.js",
   "types": "build/index.d.ts",