expo-tiddlywiki-filesystem-android-external-storage 2.2.3 → 2.2.4

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

@@ -13,11 +13,15 @@ import okhttp3.RequestBody.Companion.toRequestBody
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.BufferedInputStream
+import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.security.MessageDigest
 import java.util.concurrent.TimeUnit
+import java.util.zip.InflaterInputStream
 
 /**
  * Expo native module that performs raw java.io.File I/O on external storage.
@@ -741,6 +745,93 @@ class ExternalStorageModule : Module() {
       result.toString()
     }
 
+    /**
+     * Build a .git/index file from scratch by:
+     * 1. Resolving HEAD → commit SHA → tree SHA
+     * 2. Walking the tree recursively to enumerate (path, mode, blobSHA)
+     * 3. Stat'ing each file on disk natively
+     * 4. Writing a v2 binary .git/index file
+     *
+     * This is MUCH faster than isomorphic-git checkout because everything
+     * runs natively without JS↔Kotlin bridge per-file overhead.
+     *
+     * @param gitRootDir  The repo root (parent of .git/)
+     * @return JSON string with status: {"ok":true,"entries":N} or {"ok":false,"error":"..."}
+     */
+    AsyncFunction("buildGitIndex") { gitRootDir: String ->
+      val root = File(gitRootDir)
+      val gitDir = File(root, ".git")
+      if (!gitDir.isDirectory) throw Exception("Not a git repository: $gitRootDir")
+
+      try {
+        // 1. Resolve HEAD to a commit SHA
+        val headFile = File(gitDir, "HEAD")
+        val headContent = headFile.readText(Charsets.UTF_8).trim()
+        val commitSha: String = if (headContent.startsWith("ref: ")) {
+          val refPath = headContent.removePrefix("ref: ")
+          val refFile = File(gitDir, refPath)
+          if (refFile.exists()) {
+            refFile.readText(Charsets.UTF_8).trim()
+          } else {
+            // Try packed-refs
+            resolvePackedRef(gitDir, refPath)
+              ?: throw Exception("Cannot resolve HEAD ref: $refPath")
+          }
+        } else {
+          headContent // Detached HEAD — already a SHA
+        }
+        android.util.Log.i("BuildGitIndex", "HEAD commit: $commitSha")
+
+        // 2. Read the commit object → get tree SHA
+        val commitBytes = readGitObject(gitDir, commitSha)
+          ?: throw Exception("Cannot read commit object: $commitSha")
+        val treeSha = parseCommitTreeSha(commitBytes)
+          ?: throw Exception("Cannot find tree SHA in commit: $commitSha")
+        android.util.Log.i("BuildGitIndex", "Root tree: $treeSha")
+
+        // 3. Walk the tree recursively → collect all entries
+        val entries = mutableListOf<GitTreeEntry>()
+        fun walkTree(sha: String, prefix: String) {
+          val treeBytes = readGitObject(gitDir, sha)
+            ?: throw Exception("Cannot read tree object: $sha")
+          parseTreeEntries(treeBytes).forEach { (name, entryMode, entrySha) ->
+            val fullPath = if (prefix.isEmpty()) name else "$prefix/$name"
+            if (entryMode == 0x4000 || entryMode == 0o40000) {
+              // Directory — recurse
+              walkTree(bytesToHex(entrySha), fullPath)
+            } else {
+              entries.add(GitTreeEntry(fullPath, entryMode, entrySha))
+            }
+          }
+        }
+        walkTree(treeSha, "")
+        android.util.Log.i("BuildGitIndex", "Tree walk found ${entries.size} entries")
+
+        // 4. Sort entries by path (git index requires sorted order)
+        entries.sortBy { it.path }
+
+        // 5. Build the binary index
+        val indexBytes = buildIndexBinary(root, entries)
+
+        // 6. Write to .git/index
+        val indexFile = File(gitDir, "index")
+        indexFile.writeBytes(indexBytes)
+        android.util.Log.i("BuildGitIndex", "Wrote index: ${indexBytes.size} bytes, ${entries.size} entries")
+
+        val result = JSONObject()
+        result.put("ok", true)
+        result.put("entries", entries.size)
+        result.put("indexSize", indexBytes.size)
+        result.toString()
+      } catch (e: Exception) {
+        android.util.Log.e("BuildGitIndex", "Failed: ${e.message}", e)
+        val result = JSONObject()
+        result.put("ok", false)
+        result.put("error", e.message ?: "Unknown error")
+        result.toString()
+      }
+    }
+
     // ─── TiddlyWiki batch file parsing ─────────────────────────────────
 
     /**
@@ -1061,6 +1152,409 @@ class ExternalStorageModule : Module() {
     }
   }
 
+  // ─── Git byte-conversion helpers ─────────────────────────────────
+
+  /** Convert a byte array to a lowercase hex string */
+  private fun bytesToHex(bytes: ByteArray): String {
+    return bytes.joinToString("") { "%02x".format(it) }
+  }
+
+  /** Convert a hex string to a byte array */
+  private fun hexToBytes(hex: String): ByteArray {
+    val len = hex.length
+    val data = ByteArray(len / 2)
+    var i = 0
+    while (i < len) {
+      data[i / 2] = ((Character.digit(hex[i], 16) shl 4) + Character.digit(hex[i + 1], 16)).toByte()
+      i += 2
+    }
+    return data
+  }
+
+  /** Compare two 20-byte SHA-1 arrays lexicographically (unsigned) */
+  private fun compareSha(a: ByteArray, b: ByteArray): Int {
+    for (i in a.indices) {
+      val av = a[i].toInt() and 0xFF
+      val bv = b[i].toInt() and 0xFF
+      if (av != bv) return av - bv
+    }
+    return 0
+  }
+
+  // ─── Git object reading helpers ──────────────────────────────────
+
+  /** Resolve a ref from .git/packed-refs */
+  private fun resolvePackedRef(gitDir: File, refPath: String): String? {
+    val packedRefs = File(gitDir, "packed-refs")
+    if (!packedRefs.exists()) return null
+    for (line in packedRefs.readLines(Charsets.UTF_8)) {
+      if (line.startsWith("#") || line.isBlank()) continue
+      val parts = line.split(" ", limit = 2)
+      if (parts.size == 2 && parts[1].trim() == refPath) {
+        return parts[0].trim()
+      }
+    }
+    return null
+  }
+
+  /**
+   * Read a git object by its SHA-1 hex string.
+   * Tries loose objects first (.git/objects/ab/cdef...),
+   * then falls back to pack files (.git/objects/pack/*.pack).
+   * Returns the raw object content (after the "type size\0" header is stripped).
+   */
+  private fun readGitObject(gitDir: File, sha: String): ByteArray? {
+    // Try loose object first
+    val looseFile = File(gitDir, "objects/${sha.substring(0, 2)}/${sha.substring(2)}")
+    if (looseFile.exists()) {
+      return readLooseObject(looseFile)
+    }
+    // Try pack files
+    val packDir = File(gitDir, "objects/pack")
+    if (!packDir.isDirectory) return null
+    val idxFiles = packDir.listFiles { _, name -> name.endsWith(".idx") } ?: return null
+    for (idxFile in idxFiles) {
+      val packFile = File(idxFile.absolutePath.replace(".idx", ".pack"))
+      if (!packFile.exists()) continue
+      val offset = findObjectInPackIndex(idxFile, sha)
+      if (offset != null) {
+        return readObjectFromPack(packFile, offset, gitDir)
+      }
+    }
+    return null
+  }
+
+  /** Read and decompress a loose git object, returning raw content after header. */
+  private fun readLooseObject(file: File): ByteArray {
+    val compressed = file.readBytes()
+    val inflated = java.util.zip.Inflater().let { inflater ->
+      inflater.setInput(compressed)
+      val buf = ByteArray(8192)
+      val baos = ByteArrayOutputStream()
+      while (!inflater.finished()) {
+        val n = inflater.inflate(buf)
+        baos.write(buf, 0, n)
+      }
+      inflater.end()
+      baos.toByteArray()
+    }
+    // Skip "type size\0" header
+    val nullIdx = inflated.indexOf(0.toByte())
+    return if (nullIdx >= 0) inflated.copyOfRange(nullIdx + 1, inflated.size) else inflated
+  }
+
+  /**
+   * Find an object's offset in a pack index file (v2 format).
+   * Returns the byte offset within the .pack file, or null if not found.
+   */
+  private fun findObjectInPackIndex(idxFile: File, sha: String): Long? {
+    val shaBytes = hexToBytes(sha)
+    RandomAccessFile(idxFile, "r").use { raf ->
+      // V2 index starts with 0xff744f63 magic + 4-byte version
+      val magic = ByteArray(4)
+      raf.readFully(magic)
+      if (magic[0] != 0xFF.toByte() || magic[1] != 0x74.toByte() ||
+        magic[2] != 0x4F.toByte() || magic[3] != 0x63.toByte()) {
+        return null // Not a v2 index
+      }
+      raf.readInt() // version (should be 2)
+
+      // Fanout table: 256 entries of 4-byte big-endian counts
+      val fanout = IntArray(256)
+      for (i in 0 until 256) {
+        fanout[i] = raf.readInt()
+      }
+      val totalObjects = fanout[255]
+
+      // Binary search for the SHA in the sorted SHA table
+      val firstByte = shaBytes[0].toInt() and 0xFF
+      val lo = if (firstByte == 0) 0 else fanout[firstByte - 1]
+      val hi = fanout[firstByte]
+
+      // SHA table starts at offset 8 + 256*4 = 1032
+      val shaTableStart = 8L + 256 * 4
+      // Each SHA entry is 20 bytes
+      var low = lo
+      var high = hi - 1
+      while (low <= high) {
+        val mid = (low + high) / 2
+        raf.seek(shaTableStart + mid * 20L)
+        val entry = ByteArray(20)
+        raf.readFully(entry)
+        val cmp = compareSha(entry, shaBytes)
+        when {
+          cmp < 0 -> low = mid + 1
+          cmp > 0 -> high = mid - 1
+          else -> {
+            // Found! Read the offset from the offset table
+            // CRC table: after SHA table, totalObjects * 4 bytes
+            // Offset table: after CRC table, totalObjects * 4 bytes
+            val offsetTableStart = shaTableStart + totalObjects * 20L + totalObjects * 4L
+            raf.seek(offsetTableStart + mid * 4L)
+            val offset = raf.readInt().toLong() and 0xFFFFFFFFL
+            return if (offset and 0x80000000L != 0L) {
+              // Large offset — read from 8-byte table
+              val largeOffsetTableStart = offsetTableStart + totalObjects * 4L
+              val idx = (offset and 0x7FFFFFFFL).toInt()
+              raf.seek(largeOffsetTableStart + idx * 8L)
+              raf.readLong()
+            } else {
+              offset
+            }
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  /**
+   * Read a single object from a .pack file at the given byte offset.
+   * Handles types: commit, tree, blob, and OFS_DELTA / REF_DELTA.
+   */
+  private fun readObjectFromPack(packFile: File, offset: Long, gitDir: File): ByteArray? {
+    RandomAccessFile(packFile, "r").use { raf ->
+      raf.seek(offset)
+      // Read variable-length object header
+      var byte = raf.read()
+      val type = (byte shr 4) and 0x07
+      var size = (byte and 0x0F).toLong()
+      var shift = 4
+      while (byte and 0x80 != 0) {
+        byte = raf.read()
+        size = size or ((byte and 0x7F).toLong() shl shift)
+        shift += 7
+      }
+
+      return when (type) {
+        1, 2, 3, 4 -> { // commit, tree, blob, tag — just decompress
+          decompressFromRaf(raf, size)
+        }
+        6 -> { // OFS_DELTA
+          // Read negative offset
+          var b = raf.read()
+          var deltaOffset = (b and 0x7F).toLong()
+          while (b and 0x80 != 0) {
+            b = raf.read()
+            deltaOffset = ((deltaOffset + 1) shl 7) or (b and 0x7F).toLong()
+          }
+          val baseOffset = offset - deltaOffset
+          val base = readObjectFromPack(packFile, baseOffset, gitDir) ?: return null
+          val delta = decompressFromRaf(raf, size)
+          applyDelta(base, delta)
+        }
+        7 -> { // REF_DELTA
+          val baseSha = ByteArray(20)
+          raf.readFully(baseSha)
+          val base = readGitObject(gitDir, bytesToHex(baseSha)) ?: return null
+          val delta = decompressFromRaf(raf, size)
+          applyDelta(base, delta)
+        }
+        else -> null
+      }
+    }
+  }
+
+  /** Decompress zlib data from current RAF position */
+  private fun decompressFromRaf(raf: RandomAccessFile, expectedSize: Long): ByteArray {
+    // Read remaining data from current position for decompression
+    val pos = raf.filePointer
+    val remaining = (raf.length() - pos).coerceAtMost(expectedSize * 4 + 4096)
+    val compressed = ByteArray(remaining.toInt())
+    raf.readFully(compressed)
+    val inflater = java.util.zip.Inflater()
+    inflater.setInput(compressed)
+    val baos = ByteArrayOutputStream(expectedSize.toInt())
+    val buf = ByteArray(8192)
+    while (!inflater.finished()) {
+      val n = inflater.inflate(buf)
+      if (n == 0 && inflater.needsInput()) break
+      baos.write(buf, 0, n)
+    }
+    inflater.end()
+    return baos.toByteArray()
+  }
+
+  /** Apply a git delta to a base object */
+  private fun applyDelta(base: ByteArray, delta: ByteArray): ByteArray {
+    var pos = 0
+    // Read base size (variable-length)
+    var baseSize = 0L
+    var shift = 0
+    do {
+      val b = delta[pos++].toInt() and 0xFF
+      baseSize = baseSize or ((b and 0x7F).toLong() shl shift)
+      shift += 7
+    } while (b and 0x80 != 0)
+
+    // Read result size (variable-length)
+    var resultSize = 0L
+    shift = 0
+    do {
+      val b = delta[pos++].toInt() and 0xFF
+      resultSize = resultSize or ((b and 0x7F).toLong() shl shift)
+      shift += 7
+    } while (b and 0x80 != 0)
+
+    val result = ByteArray(resultSize.toInt())
+    var resultPos = 0
+
+    while (pos < delta.size) {
+      val cmd = delta[pos++].toInt() and 0xFF
+      if (cmd and 0x80 != 0) {
+        // Copy from base
+        var copyOffset = 0
+        var copySize = 0
+        if (cmd and 0x01 != 0) copyOffset = delta[pos++].toInt() and 0xFF
+        if (cmd and 0x02 != 0) copyOffset = copyOffset or ((delta[pos++].toInt() and 0xFF) shl 8)
+        if (cmd and 0x04 != 0) copyOffset = copyOffset or ((delta[pos++].toInt() and 0xFF) shl 16)
+        if (cmd and 0x08 != 0) copyOffset = copyOffset or ((delta[pos++].toInt() and 0xFF) shl 24)
+        if (cmd and 0x10 != 0) copySize = delta[pos++].toInt() and 0xFF
+        if (cmd and 0x20 != 0) copySize = copySize or ((delta[pos++].toInt() and 0xFF) shl 8)
+        if (cmd and 0x40 != 0) copySize = copySize or ((delta[pos++].toInt() and 0xFF) shl 16)
+        if (copySize == 0) copySize = 0x10000
+        System.arraycopy(base, copyOffset, result, resultPos, copySize)
+        resultPos += copySize
+      } else if (cmd != 0) {
+        // Insert literal data
+        System.arraycopy(delta, pos, result, resultPos, cmd)
+        pos += cmd
+        resultPos += cmd
+      }
+    }
+    return result
+  }
+
+  /** Parse a commit object to extract the tree SHA (first line: "tree <sha>\n") */
+  private fun parseCommitTreeSha(commitData: ByteArray): String? {
+    val str = String(commitData, Charsets.UTF_8)
+    for (line in str.lineSequence()) {
+      if (line.startsWith("tree ")) {
+        return line.removePrefix("tree ").trim()
+      }
+      if (line.isBlank()) break
+    }
+    return null
+  }
+
+  /**
+   * Parse a tree object into a list of (name, mode, sha-bytes) entries.
+   *
+   * Tree format: repeated entries of "mode name\0<20-byte SHA>"
+   */
+  private fun parseTreeEntries(treeData: ByteArray): List<Triple<String, Int, ByteArray>> {
+    val entries = mutableListOf<Triple<String, Int, ByteArray>>()
+    var pos = 0
+    while (pos < treeData.size) {
+      // Read "mode " (space-separated)
+      var spaceIdx = pos
+      while (spaceIdx < treeData.size && treeData[spaceIdx] != ' '.code.toByte()) spaceIdx++
+      if (spaceIdx >= treeData.size) break
+      val modeStr = String(treeData, pos, spaceIdx - pos, Charsets.US_ASCII)
+      val mode = modeStr.toInt(8)
+      pos = spaceIdx + 1
+
+      // Read name until NUL
+      var nullIdx = pos
+      while (nullIdx < treeData.size && treeData[nullIdx] != 0.toByte()) nullIdx++
+      if (nullIdx >= treeData.size) break
+      val name = String(treeData, pos, nullIdx - pos, Charsets.UTF_8)
+      pos = nullIdx + 1
+
+      // Read 20-byte SHA
+      if (pos + 20 > treeData.size) break
+      val sha = treeData.copyOfRange(pos, pos + 20)
+      pos += 20
+
+      entries.add(Triple(name, mode, sha))
+    }
+    return entries
+  }
+
+  /** Data class for a tree entry (file path, mode, blob SHA bytes) */
+  private data class GitTreeEntry(val path: String, val mode: Int, val sha: ByteArray)
+
+  /**
+   * Build a version 2 .git/index binary from tree entries and disk stats.
+   *
+   * Index v2 format:
+   *   - 12-byte header: "DIRC" + version(4) + numEntries(4)
+   *   - Sorted entries, each:
+   *       ctime_s(4) + ctime_ns(4) + mtime_s(4) + mtime_ns(4) +
+   *       dev(4) + ino(4) + mode(4) + uid(4) + gid(4) +
+   *       file_size(4) + SHA-1(20) + flags(2) + path(variable) + NUL padding to 8-byte boundary
+   *   - 20-byte SHA-1 checksum over the entire index (header + entries)
+   */
+  private fun buildIndexBinary(root: File, entries: List<GitTreeEntry>): ByteArray {
+    val baos = ByteArrayOutputStream()
+
+    fun writeInt32(value: Int) {
+      baos.write((value shr 24) and 0xFF)
+      baos.write((value shr 16) and 0xFF)
+      baos.write((value shr 8) and 0xFF)
+      baos.write(value and 0xFF)
+    }
+
+    // Header: "DIRC" + version 2 + entry count
+    baos.write("DIRC".toByteArray(Charsets.US_ASCII))
+    writeInt32(2) // version
+    writeInt32(entries.size)
+
+    for (entry in entries) {
+      val workFile = File(root, entry.path)
+      val mtimeMs = if (workFile.exists()) workFile.lastModified() else 0L
+      val mtimeS = (mtimeMs / 1000).toInt()
+      val mtimeNs = ((mtimeMs % 1000) * 1_000_000).toInt()
+      val fileSize = if (workFile.exists()) workFile.length().toInt() else 0
+
+      // ctime (same as mtime for simplicity)
+      writeInt32(mtimeS)
+      writeInt32(mtimeNs)
+      // mtime
+      writeInt32(mtimeS)
+      writeInt32(mtimeNs)
+      // dev, ino (0 — not available on Android)
+      writeInt32(0)
+      writeInt32(0)
+      // mode: entry.mode is octal (e.g., 0o100644), needs to be stored as-is
+      writeInt32(entry.mode)
+      // uid, gid (0)
+      writeInt32(0)
+      writeInt32(0)
+      // file size
+      writeInt32(fileSize)
+      // 20-byte SHA-1 of the blob
+      baos.write(entry.sha)
+      // flags: assume flag = (pathLen & 0xFFF)
+      val pathBytes = entry.path.toByteArray(Charsets.UTF_8)
+      val flags = pathBytes.size.coerceAtMost(0xFFF)
+      baos.write((flags shr 8) and 0xFF)
+      baos.write(flags and 0xFF)
+      // path + NUL + padding to 8-byte boundary
+      baos.write(pathBytes)
+      baos.write(0) // NUL terminator
+      // Pad to 8-byte boundary (entry starts at header end or previous entry end)
+      // Total entry size so far = 62 + pathBytes.size + 1
+      val entrySize = 62 + pathBytes.size + 1
+      val padding = (8 - (entrySize % 8)) % 8
+      for (i in 0 until padding) {
+        baos.write(0)
+      }
+    }
+
+    val content = baos.toByteArray()
+
+    // Compute SHA-1 checksum over everything
+    val digest = java.security.MessageDigest.getInstance("SHA-1")
+    val checksum = digest.digest(content)
+
+    // Final result: content + checksum
+    val result = ByteArrayOutputStream(content.size + 20)
+    result.write(content)
+    result.write(checksum)
+    return result.toByteArray()
+  }
+
   // ─── Git index parser ─────────────────────────────────────────────
 
   /**

package/build/index.d.ts

@@ -133,6 +133,22 @@ interface IExternalStorageModule {
      * @returns JSON string: `[{"path":"tiddlers/foo.tid","type":"add"|"modify"|"delete"}, ...]`
      */
     gitStatus(gitRootDir: string): Promise<string>;
+    /**
+     * Debug function returning diagnostic info about the git repository state.
+     * @returns JSON string with root/gitDir/index existence and git dir children
+     */
+    gitStatusDebug(gitRootDir: string): Promise<string>;
+    /**
+     * Build `.git/index` natively by reading the HEAD tree from pack files,
+     * stat'ing all files on disk, and writing a v2 index file.
+     *
+     * This is used after archive clone where TidGi Desktop's tar export
+     * doesn't include `.git/index`.
+     *
+     * @param gitRootDir The root directory of the git repository (parent of .git/)
+     * @returns JSON string: `{"ok":true,"entries":N,"indexSize":M}` or `{"ok":false,"error":"..."}`
+     */
+    buildGitIndex(gitRootDir: string): Promise<string>;
 }
 export declare const ExternalStorage: IExternalStorageModule;
 /**

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,IAAI,OAA2C,CAAC;AAEhD;;;;GAIG;AACH,SAAS,eAAe;IACtB,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;IACD,iEAAiE;IACjE,MAAM,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAsE,CAAC;IAClI,OAAO,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC;AAoKD,MAAM,CAAC,MAAM,eAAe,GAA2B,IAAI,KAAK,CAAC,EAA4B,EAAE;IAC7F,GAAG,CAAC,OAAO,EAAE,QAAQ;QACnB,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;QAC9B,OAAQ,GAAmD,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC;CACF,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,SAAiB;IAC3C,IAAI,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,OAAO,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n * TypeScript bindings for the ExternalStorage native module.\n *\n * This module uses raw java.io.File on Android to bypass Expo FileSystem's\n * directory whitelist. It allows reading/writing to shared external storage\n * when MANAGE_EXTERNAL_STORAGE permission is granted.\n *\n * All path arguments are plain filesystem paths (e.g. \"/storage/emulated/0/Documents/TidGi/\").\n * Do NOT pass file:// URIs — strip the scheme before calling.\n */\nimport { Platform } from 'react-native';\n\nlet _module: IExternalStorageModule | undefined;\n\n/**\n * Lazily load the native module. Wrapped in a function so that the app does NOT\n * crash at import time if the native module is missing (e.g. on iOS or when the\n * binary was built without it).\n */\nfunction getNativeModule(): IExternalStorageModule {\n  if (_module) return _module;\n  if (Platform.OS !== 'android') {\n    throw new Error('ExternalStorage native module is only available on Android');\n  }\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const { requireNativeModule } = require('expo-modules-core') as { requireNativeModule: (name: string) => IExternalStorageModule };\n  _module = requireNativeModule('ExternalStorage');\n  return _module;\n}\n\ninterface FileInfo {\n  exists: boolean;\n  isDirectory: boolean;\n  size: number;\n  /** Milliseconds since epoch */\n  modificationTime: number;\n}\n\ninterface BatchWriteResult {\n  writtenCount: number;\n}\n\ninterface HttpPostToFileResult {\n  statusCode: number;\n  headers: Record<string, string>;\n  bytesWritten: number;\n}\n\ninterface DownloadFileResumableResult {\n  statusCode: number;\n  /** Final size of the file on disk after download */\n  totalBytes: number;\n  /** true if the download resumed from a partial file (HTTP 206) */\n  resumed: boolean;\n}\n\ninterface ExtractTarResult {\n  filesExtracted: number;\n}\n\ninterface ReadFileChunkResult {\n  /** Base64-encoded chunk data */\n  data: string;\n  bytesRead: number;\n}\n\ninterface IExternalStorageModule {\n  exists(path: string): Promise<boolean>;\n  getInfo(path: string): Promise<FileInfo>;\n\n  mkdir(path: string): Promise<void>;\n  readDir(path: string): Promise<string[]>;\n  /** Recursively list all files under a directory, returning relative paths. Skips .git etc. */\n  readDirRecursive(path: string): Promise<string[]>;\n  rmdir(path: string): Promise<void>;\n\n  readFileUtf8(path: string): Promise<string>;\n  readFileBase64(path: string): Promise<string>;\n  writeFileUtf8(path: string, content: string): Promise<void>;\n  writeFileBase64(path: string, base64Content: string): Promise<void>;\n  /**\n   * Append a Base64-encoded chunk to a file, optionally truncating first.\n   *\n   * Designed for streaming large writes from JS in bounded-memory chunks\n   * (e.g. 512 KB each) so the JVM never allocates the full file content,\n   * avoiding OOM on 50+ MB git pack files.\n   *\n   * @param truncateFirst Pass `true` for the first chunk to create/truncate\n   *                      the file, then `false` for subsequent chunks.\n   */\n  appendFileBase64(path: string, base64Content: string, truncateFirst: boolean): Promise<void>;\n  writeFilesBase64(paths: string[], base64Contents: string[]): Promise<BatchWriteResult>;\n  deleteFile(path: string): Promise<void>;\n\n  isExternalStorageWritable(): Promise<boolean>;\n  getExternalStorageDirectory(): Promise<string>;\n  /** Android 11+ (API 30): check if MANAGE_EXTERNAL_STORAGE is granted. Pre-30 returns true. */\n  isExternalStorageManager(): Promise<boolean>;\n\n  /**\n   * HTTP POST with the response body streamed directly to a file on disk,\n   * **never buffering the full response in JVM/Hermes heap**.\n   *\n   * Designed for git-upload-pack which can return 100+ MB packfiles.\n   *\n   * @param url         Target URL\n   * @param headers     HTTP headers as `{ key: value }`\n   * @param bodyBase64  Request body encoded as Base64 (binary git protocol data)\n   * @param destPath    Plain filesystem path to write the response body to\n   * @param contentType MIME type for the request body\n   */\n  httpPostToFile(\n    url: string,\n    headers: Record<string, string>,\n    bodyBase64: string,\n    destPath: string,\n    contentType: string,\n  ): Promise<HttpPostToFileResult>;\n\n  /**\n   * Read a chunk of a file starting at `offset` for up to `length` bytes.\n   * Returns Base64-encoded data and actual bytes read.\n   *\n   * Use this to stream a large file into JS in bounded-memory chunks.\n   */\n  readFileChunk(path: string, offset: number, length: number): Promise<ReadFileChunkResult>;\n\n  /**\n   * Download a file via HTTP GET with resumable download support.\n   *\n   * If `destPath` already exists on disk (from a previous interrupted download),\n   * sends `Range: bytes=<existingSize>-` to resume. The server must respond\n   * with 206 Partial Content for resume to work; otherwise the file is\n   * overwritten from scratch (200 response).\n   *\n   * @param url       Target URL\n   * @param headers   Extra HTTP headers (e.g. Authorization, ETag)\n   * @param destPath  Plain filesystem path for the downloaded file\n   */\n  downloadFileResumable(\n    url: string,\n    headers: Record<string, string>,\n    destPath: string,\n  ): Promise<DownloadFileResumableResult>;\n\n  /**\n   * Extract an uncompressed tar archive to a destination directory.\n   * Uses a native tar parser — no third-party dependency.\n   * Supports POSIX ustar and GNU long-name extensions.\n   * Validates paths to prevent directory traversal attacks.\n   *\n   * @param tarPath  Path to the .tar file\n   * @param destDir  Destination directory (created if needed)\n   */\n  extractTar(tarPath: string, destDir: string): Promise<ExtractTarResult>;\n\n  /**\n   * Parse a batch of TiddlyWiki tiddler files entirely in native Kotlin.\n   *\n   * This is the critical performance optimization for initial wiki loading:\n   * a single bridge call processes 100+ files in parallel, returning a\n   * ready-to-inject JSON array string. Eliminates per-file bridge round-trips.\n   *\n   * Supports .tid, .json, and .meta files. Applies skinny logic:\n   * - System tiddlers ($:/) → always full text\n   * - Plugins (application/json + plugin-type) → always full text\n   * - Module tiddlers (module-type) → always full text\n   * - Small tiddlers (< 10KB body) → full text\n   * - Large user tiddlers → skinny (_is_skinny: \"yes\", text omitted)\n   *\n   * @param filePaths     Array of absolute filesystem paths\n   * @param quickLoadMode If true, all tiddlers returned as skinny\n   * @returns JSON string: serialized array of tiddler field objects\n   */\n  batchParseTidFiles(filePaths: string[], quickLoadMode: boolean): Promise<string>;\n\n  /**\n   * Lightweight native git status using direct git-index parsing.\n   *\n   * Parses `.git/index` to get tracked files and their stat-cache entries,\n   * then compares against the working directory using file size and mtime.\n   * Orders of magnitude faster than isomorphic-git's `statusMatrix` because:\n   * - No JS↔Native bridge round-trips per file\n   * - Uses stat-cache (size+mtime) instead of SHA-1 re-hashing\n   * - Parallel file walking in Java\n   *\n   * @param gitRootDir The root directory of the git repository (parent of .git/)\n   * @returns JSON string: `[{\"path\":\"tiddlers/foo.tid\",\"type\":\"add\"|\"modify\"|\"delete\"}, ...]`\n   */\n  gitStatus(gitRootDir: string): Promise<string>;\n}\n\nexport const ExternalStorage: IExternalStorageModule = new Proxy({} as IExternalStorageModule, {\n  get(_target, property) {\n    const mod = getNativeModule();\n    return (mod as unknown as Record<string | symbol, unknown>)[property];\n  },\n});\n\n/**\n * Strip file:// prefix from a URI to produce a plain filesystem path.\n * Safe to call on paths that are already plain.\n */\nexport function toPlainPath(uriOrPath: string): string {\n  if (uriOrPath.startsWith('file://')) {\n    return uriOrPath.slice('file://'.length);\n  }\n  return uriOrPath;\n}\n\nexport type { BatchWriteResult, DownloadFileResumableResult, ExtractTarResult, FileInfo, HttpPostToFileResult, IExternalStorageModule, ReadFileChunkResult };\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,IAAI,OAA2C,CAAC;AAEhD;;;;GAIG;AACH,SAAS,eAAe;IACtB,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;IACD,iEAAiE;IACjE,MAAM,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAsE,CAAC;IAClI,OAAO,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC;AAsLD,MAAM,CAAC,MAAM,eAAe,GAA2B,IAAI,KAAK,CAAC,EAA4B,EAAE;IAC7F,GAAG,CAAC,OAAO,EAAE,QAAQ;QACnB,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;QAC9B,OAAQ,GAAmD,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC;CACF,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,SAAiB;IAC3C,IAAI,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,OAAO,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n * TypeScript bindings for the ExternalStorage native module.\n *\n * This module uses raw java.io.File on Android to bypass Expo FileSystem's\n * directory whitelist. It allows reading/writing to shared external storage\n * when MANAGE_EXTERNAL_STORAGE permission is granted.\n *\n * All path arguments are plain filesystem paths (e.g. \"/storage/emulated/0/Documents/TidGi/\").\n * Do NOT pass file:// URIs — strip the scheme before calling.\n */\nimport { Platform } from 'react-native';\n\nlet _module: IExternalStorageModule | undefined;\n\n/**\n * Lazily load the native module. Wrapped in a function so that the app does NOT\n * crash at import time if the native module is missing (e.g. on iOS or when the\n * binary was built without it).\n */\nfunction getNativeModule(): IExternalStorageModule {\n  if (_module) return _module;\n  if (Platform.OS !== 'android') {\n    throw new Error('ExternalStorage native module is only available on Android');\n  }\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const { requireNativeModule } = require('expo-modules-core') as { requireNativeModule: (name: string) => IExternalStorageModule };\n  _module = requireNativeModule('ExternalStorage');\n  return _module;\n}\n\ninterface FileInfo {\n  exists: boolean;\n  isDirectory: boolean;\n  size: number;\n  /** Milliseconds since epoch */\n  modificationTime: number;\n}\n\ninterface BatchWriteResult {\n  writtenCount: number;\n}\n\ninterface HttpPostToFileResult {\n  statusCode: number;\n  headers: Record<string, string>;\n  bytesWritten: number;\n}\n\ninterface DownloadFileResumableResult {\n  statusCode: number;\n  /** Final size of the file on disk after download */\n  totalBytes: number;\n  /** true if the download resumed from a partial file (HTTP 206) */\n  resumed: boolean;\n}\n\ninterface ExtractTarResult {\n  filesExtracted: number;\n}\n\ninterface ReadFileChunkResult {\n  /** Base64-encoded chunk data */\n  data: string;\n  bytesRead: number;\n}\n\ninterface IExternalStorageModule {\n  exists(path: string): Promise<boolean>;\n  getInfo(path: string): Promise<FileInfo>;\n\n  mkdir(path: string): Promise<void>;\n  readDir(path: string): Promise<string[]>;\n  /** Recursively list all files under a directory, returning relative paths. Skips .git etc. */\n  readDirRecursive(path: string): Promise<string[]>;\n  rmdir(path: string): Promise<void>;\n\n  readFileUtf8(path: string): Promise<string>;\n  readFileBase64(path: string): Promise<string>;\n  writeFileUtf8(path: string, content: string): Promise<void>;\n  writeFileBase64(path: string, base64Content: string): Promise<void>;\n  /**\n   * Append a Base64-encoded chunk to a file, optionally truncating first.\n   *\n   * Designed for streaming large writes from JS in bounded-memory chunks\n   * (e.g. 512 KB each) so the JVM never allocates the full file content,\n   * avoiding OOM on 50+ MB git pack files.\n   *\n   * @param truncateFirst Pass `true` for the first chunk to create/truncate\n   *                      the file, then `false` for subsequent chunks.\n   */\n  appendFileBase64(path: string, base64Content: string, truncateFirst: boolean): Promise<void>;\n  writeFilesBase64(paths: string[], base64Contents: string[]): Promise<BatchWriteResult>;\n  deleteFile(path: string): Promise<void>;\n\n  isExternalStorageWritable(): Promise<boolean>;\n  getExternalStorageDirectory(): Promise<string>;\n  /** Android 11+ (API 30): check if MANAGE_EXTERNAL_STORAGE is granted. Pre-30 returns true. */\n  isExternalStorageManager(): Promise<boolean>;\n\n  /**\n   * HTTP POST with the response body streamed directly to a file on disk,\n   * **never buffering the full response in JVM/Hermes heap**.\n   *\n   * Designed for git-upload-pack which can return 100+ MB packfiles.\n   *\n   * @param url         Target URL\n   * @param headers     HTTP headers as `{ key: value }`\n   * @param bodyBase64  Request body encoded as Base64 (binary git protocol data)\n   * @param destPath    Plain filesystem path to write the response body to\n   * @param contentType MIME type for the request body\n   */\n  httpPostToFile(\n    url: string,\n    headers: Record<string, string>,\n    bodyBase64: string,\n    destPath: string,\n    contentType: string,\n  ): Promise<HttpPostToFileResult>;\n\n  /**\n   * Read a chunk of a file starting at `offset` for up to `length` bytes.\n   * Returns Base64-encoded data and actual bytes read.\n   *\n   * Use this to stream a large file into JS in bounded-memory chunks.\n   */\n  readFileChunk(path: string, offset: number, length: number): Promise<ReadFileChunkResult>;\n\n  /**\n   * Download a file via HTTP GET with resumable download support.\n   *\n   * If `destPath` already exists on disk (from a previous interrupted download),\n   * sends `Range: bytes=<existingSize>-` to resume. The server must respond\n   * with 206 Partial Content for resume to work; otherwise the file is\n   * overwritten from scratch (200 response).\n   *\n   * @param url       Target URL\n   * @param headers   Extra HTTP headers (e.g. Authorization, ETag)\n   * @param destPath  Plain filesystem path for the downloaded file\n   */\n  downloadFileResumable(\n    url: string,\n    headers: Record<string, string>,\n    destPath: string,\n  ): Promise<DownloadFileResumableResult>;\n\n  /**\n   * Extract an uncompressed tar archive to a destination directory.\n   * Uses a native tar parser — no third-party dependency.\n   * Supports POSIX ustar and GNU long-name extensions.\n   * Validates paths to prevent directory traversal attacks.\n   *\n   * @param tarPath  Path to the .tar file\n   * @param destDir  Destination directory (created if needed)\n   */\n  extractTar(tarPath: string, destDir: string): Promise<ExtractTarResult>;\n\n  /**\n   * Parse a batch of TiddlyWiki tiddler files entirely in native Kotlin.\n   *\n   * This is the critical performance optimization for initial wiki loading:\n   * a single bridge call processes 100+ files in parallel, returning a\n   * ready-to-inject JSON array string. Eliminates per-file bridge round-trips.\n   *\n   * Supports .tid, .json, and .meta files. Applies skinny logic:\n   * - System tiddlers ($:/) → always full text\n   * - Plugins (application/json + plugin-type) → always full text\n   * - Module tiddlers (module-type) → always full text\n   * - Small tiddlers (< 10KB body) → full text\n   * - Large user tiddlers → skinny (_is_skinny: \"yes\", text omitted)\n   *\n   * @param filePaths     Array of absolute filesystem paths\n   * @param quickLoadMode If true, all tiddlers returned as skinny\n   * @returns JSON string: serialized array of tiddler field objects\n   */\n  batchParseTidFiles(filePaths: string[], quickLoadMode: boolean): Promise<string>;\n\n  /**\n   * Lightweight native git status using direct git-index parsing.\n   *\n   * Parses `.git/index` to get tracked files and their stat-cache entries,\n   * then compares against the working directory using file size and mtime.\n   * Orders of magnitude faster than isomorphic-git's `statusMatrix` because:\n   * - No JS↔Native bridge round-trips per file\n   * - Uses stat-cache (size+mtime) instead of SHA-1 re-hashing\n   * - Parallel file walking in Java\n   *\n   * @param gitRootDir The root directory of the git repository (parent of .git/)\n   * @returns JSON string: `[{\"path\":\"tiddlers/foo.tid\",\"type\":\"add\"|\"modify\"|\"delete\"}, ...]`\n   */\n  gitStatus(gitRootDir: string): Promise<string>;\n\n  /**\n   * Debug function returning diagnostic info about the git repository state.\n   * @returns JSON string with root/gitDir/index existence and git dir children\n   */\n  gitStatusDebug(gitRootDir: string): Promise<string>;\n\n  /**\n   * Build `.git/index` natively by reading the HEAD tree from pack files,\n   * stat'ing all files on disk, and writing a v2 index file.\n   *\n   * This is used after archive clone where TidGi Desktop's tar export\n   * doesn't include `.git/index`.\n   *\n   * @param gitRootDir The root directory of the git repository (parent of .git/)\n   * @returns JSON string: `{\"ok\":true,\"entries\":N,\"indexSize\":M}` or `{\"ok\":false,\"error\":\"...\"}`\n   */\n  buildGitIndex(gitRootDir: string): Promise<string>;\n}\n\nexport const ExternalStorage: IExternalStorageModule = new Proxy({} as IExternalStorageModule, {\n  get(_target, property) {\n    const mod = getNativeModule();\n    return (mod as unknown as Record<string | symbol, unknown>)[property];\n  },\n});\n\n/**\n * Strip file:// prefix from a URI to produce a plain filesystem path.\n * Safe to call on paths that are already plain.\n */\nexport function toPlainPath(uriOrPath: string): string {\n  if (uriOrPath.startsWith('file://')) {\n    return uriOrPath.slice('file://'.length);\n  }\n  return uriOrPath;\n}\n\nexport type { BatchWriteResult, DownloadFileResumableResult, ExtractTarResult, FileInfo, HttpPostToFileResult, IExternalStorageModule, ReadFileChunkResult };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-tiddlywiki-filesystem-android-external-storage",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "description": "Expo native module for TidGi-Mobile: external storage I/O + TiddlyWiki .tid/.meta/.json batch parsing in Kotlin",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/src/index.ts

@@ -188,6 +188,24 @@ interface IExternalStorageModule {
    * @returns JSON string: `[{"path":"tiddlers/foo.tid","type":"add"|"modify"|"delete"}, ...]`
    */
   gitStatus(gitRootDir: string): Promise<string>;
+
+  /**
+   * Debug function returning diagnostic info about the git repository state.
+   * @returns JSON string with root/gitDir/index existence and git dir children
+   */
+  gitStatusDebug(gitRootDir: string): Promise<string>;
+
+  /**
+   * Build `.git/index` natively by reading the HEAD tree from pack files,
+   * stat'ing all files on disk, and writing a v2 index file.
+   *
+   * This is used after archive clone where TidGi Desktop's tar export
+   * doesn't include `.git/index`.
+   *
+   * @param gitRootDir The root directory of the git repository (parent of .git/)
+   * @returns JSON string: `{"ok":true,"entries":N,"indexSize":M}` or `{"ok":false,"error":"..."}`
+   */
+  buildGitIndex(gitRootDir: string): Promise<string>;
 }
 
 export const ExternalStorage: IExternalStorageModule = new Proxy({} as IExternalStorageModule, {