@fressh/react-native-terminal 0.1.0

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,180 @@
+// JNI bridge for the single package .so:
+//  1. Render plane: HybridTerminal.kt <-> the Rust render C-ABI (attach/draw/
+//     resize/send_input/destroy) in libshim_uniffi.so.
+//  2. Control plane install: ReactNativeTerminalModule.nativeInstallRustCrate ->
+//     NativeShimUniffi::registerModule (installs globalThis.NativeShimUniffi so the
+//     ubrn-generated TS bindings can call the uniffi scaffolding). See docs §8/§10.
+
+#include <android/native_window_jni.h>
+#include <cstddef>
+#include <cstdint>
+#include <jni.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include "shim_uniffi.hpp" // generated: NativeShimUniffi::registerModule
+#include "ReactNativeTerminalOnLoad.hpp" // generated: registerAllNatives()
+
+namespace jsi = facebook::jsi;
+namespace jni = facebook::jni;
+
+// ─────────────────────────── render plane (C-ABI) ───────────────────────────
+
+extern "C" {
+void *fressh_terminal_attach(void *window, const char *font_path,
+                             const char *config_json, const char *shell_id);
+void fressh_terminal_set_shell(void *handle, const char *shell_id);
+void fressh_terminal_set_config(void *handle, const char *config_json);
+void fressh_terminal_draw(void *handle);
+void fressh_terminal_resize(void *handle);
+void fressh_terminal_send_input(void *handle, const uint8_t *data, size_t len);
+void fressh_terminal_destroy(void *handle);
+}
+
+// Track the ANativeWindow alongside the Rust handle so we can release the window
+// reference (taken by ANativeWindow_fromSurface) on teardown.
+namespace {
+struct TerminalHandle {
+  ANativeWindow *window;
+  void *rust;
+};
+
+const char *orNull(JNIEnv *env, jstring s, const char **owned) {
+  if (s == nullptr) {
+    *owned = nullptr;
+    return nullptr;
+  }
+  *owned = env->GetStringUTFChars(s, nullptr);
+  return *owned;
+}
+} // namespace
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeAttach(
+    JNIEnv *env, jobject /* this */, jobject surface, jstring font_path,
+    jstring config_json, jstring shell_id) {
+  ANativeWindow *window = ANativeWindow_fromSurface(env, surface);
+  if (window == nullptr) {
+    return 0;
+  }
+
+  const char *fontOwned = nullptr;
+  const char *configOwned = nullptr;
+  const char *shellOwned = nullptr;
+  const char *font = orNull(env, font_path, &fontOwned);
+  const char *config = orNull(env, config_json, &configOwned);
+  const char *shell = orNull(env, shell_id, &shellOwned);
+
+  void *rust = fressh_terminal_attach(window, font, config, shell);
+
+  if (fontOwned) env->ReleaseStringUTFChars(font_path, fontOwned);
+  if (configOwned) env->ReleaseStringUTFChars(config_json, configOwned);
+  if (shellOwned) env->ReleaseStringUTFChars(shell_id, shellOwned);
+
+  if (rust == nullptr) {
+    ANativeWindow_release(window);
+    return 0;
+  }
+  auto *handle = new TerminalHandle{window, rust};
+  return reinterpret_cast<jlong>(handle);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeSetShell(
+    JNIEnv *env, jobject /* this */, jlong handle, jstring shell_id) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h == nullptr) return;
+  const char *owned = nullptr;
+  const char *shell = orNull(env, shell_id, &owned);
+  fressh_terminal_set_shell(h->rust, shell);
+  if (owned) env->ReleaseStringUTFChars(shell_id, owned);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeSetConfig(
+    JNIEnv *env, jobject /* this */, jlong handle, jstring config_json) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h == nullptr) return;
+  const char *owned = nullptr;
+  const char *config = orNull(env, config_json, &owned);
+  fressh_terminal_set_config(h->rust, config);
+  if (owned) env->ReleaseStringUTFChars(config_json, owned);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeDraw(
+    JNIEnv * /* env */, jobject /* this */, jlong handle) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h != nullptr) fressh_terminal_draw(h->rust);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeResize(
+    JNIEnv * /* env */, jobject /* this */, jlong handle) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h != nullptr) fressh_terminal_resize(h->rust);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeSendInput(
+    JNIEnv *env, jobject /* this */, jlong handle, jbyteArray data) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h == nullptr || data == nullptr) return;
+  const jsize len = env->GetArrayLength(data);
+  if (len <= 0) return;
+  jbyte *bytes = env->GetByteArrayElements(data, nullptr);
+  fressh_terminal_send_input(h->rust, reinterpret_cast<const uint8_t *>(bytes),
+                             static_cast<size_t>(len));
+  env->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_fressh_HybridTerminal_nativeDestroy(
+    JNIEnv * /* env */, jobject /* this */, jlong handle) {
+  auto *h = reinterpret_cast<TerminalHandle *>(handle);
+  if (h != nullptr) {
+    fressh_terminal_destroy(h->rust);
+    ANativeWindow_release(h->window);
+    delete h;
+  }
+}
+
+// ─────────────────────────── control plane install ───────────────────────────
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_margelo_nitro_fressh_ReactNativeTerminalModule_nativeInstallRustCrate(
+    JNIEnv * /* env */, jobject /* this */, jlong jsiRuntimePtr,
+    jobject callInvokerHolderJavaObj) {
+  if (jsiRuntimePtr == 0 || callInvokerHolderJavaObj == nullptr) {
+    return JNI_FALSE;
+  }
+  // RN 0.85 removed CallInvokerHolderImpl.mHybridData; reach the C++ instance via
+  // fbjni cthis() instead of the (gone) field.
+  using JCallInvokerHolder = facebook::react::CallInvokerHolder;
+  auto holderLocal = jni::make_local(callInvokerHolderJavaObj);
+  auto holderRef =
+      jni::static_ref_cast<JCallInvokerHolder::javaobject>(holderLocal);
+  auto *holderCxx = holderRef->cthis();
+  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker =
+      holderCxx->getCallInvoker();
+
+  auto *runtime = reinterpret_cast<jsi::Runtime *>(jsiRuntimePtr);
+  NativeShimUniffi::registerModule(*runtime, jsCallInvoker);
+  return JNI_TRUE;
+}
+
+// ─────────────────────────── Nitro view registration ───────────────────────────
+
+// Nitro registers the "Terminal" Fabric component descriptor (plus the HybridObject
+// constructor and the fbjni natives) in registerAllNatives(). It MUST run from this
+// library's JNI_OnLoad — without it, Fabric never learns about the "Terminal"
+// component and falls back to legacy ViewManager interop, which creates the view but
+// silently drops every prop (so `shellId` never reaches HybridTerminal and the
+// renderer draws an unbound/black frame). See ReactNativeTerminalOnLoad.hpp.
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void * /* reserved */) {
+  return facebook::jni::initialize(
+      vm, [] { margelo::nitro::fressh::registerAllNatives(); });
+}

package/android/src/main/java/com/margelo/nitro/fressh/HybridTerminal.kt

@@ -0,0 +1,146 @@
+package com.margelo.nitro.fressh
+
+import android.view.Choreographer
+import android.view.Surface
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.view.View
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * Native terminal view (Nitro HybridView, the render plane §10). Owns a
+ * [SurfaceView]; on surface creation it hands the `ANativeWindow` + the bound
+ * `shellId` to the Rust render C-ABI (via JNI) and drives a Choreographer (vsync)
+ * loop that draws the shell's durable `Term` from fressh-core's registry. The
+ * byte stream never reaches JS. See docs §5/§10.
+ */
+@Keep
+@DoNotStrip
+class HybridTerminal(
+  val context: ThemedReactContext,
+) : HybridTerminalSpec() {
+  // Plain SurfaceView: the buffer auto-tracks the view bounds. Keeping the grid in
+  // lockstep with the on-screen size when the keyboard opens/closes is handled on the
+  // Rust side, which polls the *settled* surface size from the draw loop (eglQuerySurface
+  // lags the new geometry by a frame, so a one-shot read in surfaceChanged is unreliable
+  // — esp. on GROW). The JS side (terminal flex:1 + the toolbar's keyboard-height-driven
+  // marginBottom) is what actually resizes this view in both directions. See
+  // docs/projects/complete/renderer-mismatched-selection-cutoff-scrollback.md.
+  private val surfaceView = SurfaceView(context)
+
+  /** Opaque pointer to the native render handle (0 = none). */
+  private var nativeHandle: Long = 0L
+  private var frameCallback: Choreographer.FrameCallback? = null
+
+  override val view: View = surfaceView
+
+  // Prop: bundled monospace font file path (no fontconfig on mobile, §6).
+  override var fontPath: String = ""
+
+  // Prop: render config as a JSON blob (physical px), assembled by the JS
+  // <Terminal config={...}> wrapper. Carries color scheme, padding, cursor style,
+  // bold-is-bright, font size. Live changes reflow the shell — a bonus over
+  // desktop alacritty's restart-to-apply. We just forward the string; the renderer
+  // parses + diffs it.
+  override var configJson: String? = null
+    set(value) {
+      field = value
+      if (nativeHandle != 0L) {
+        nativeSetConfig(nativeHandle, value)
+      }
+    }
+
+  // Prop: the durable shell to render. Rebinds the native view on change so the
+  // same surface can follow a (re)started shell without a remount.
+  override var shellId: String? = null
+    set(value) {
+      field = value
+      if (nativeHandle != 0L) {
+        nativeSetShell(nativeHandle, value)
+      }
+    }
+
+  init {
+    surfaceView.holder.addCallback(
+      object : SurfaceHolder.Callback {
+        override fun surfaceCreated(holder: SurfaceHolder) {
+          nativeHandle = nativeAttach(holder.surface, resolveFontPath(), configJson, shellId)
+          if (nativeHandle != 0L) startRenderLoop()
+        }
+
+        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
+          if (nativeHandle != 0L) nativeResize(nativeHandle)
+        }
+
+        override fun surfaceDestroyed(holder: SurfaceHolder) {
+          stopRenderLoop()
+          if (nativeHandle != 0L) {
+            nativeDestroy(nativeHandle)
+            nativeHandle = 0L
+          }
+        }
+      },
+    )
+  }
+
+  /**
+   * The native renderer needs a font *file* path. If RN didn't supply one, fall
+   * back to the bundled DejaVu Sans Mono asset, extracted to filesDir once.
+   */
+  private fun resolveFontPath(): String {
+    if (fontPath.isNotEmpty()) return fontPath
+    val out = java.io.File(context.filesDir, "DejaVuSansMono.ttf")
+    if (!out.exists()) {
+      context.assets.open("fonts/DejaVuSansMono.ttf").use { input ->
+        out.outputStream().use { output -> input.copyTo(output) }
+      }
+    }
+    return out.absolutePath
+  }
+
+  private fun startRenderLoop() {
+    val callback =
+      object : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+          if (nativeHandle == 0L) return
+          nativeDraw(nativeHandle)
+          Choreographer.getInstance().postFrameCallback(this)
+        }
+      }
+    frameCallback = callback
+    Choreographer.getInstance().postFrameCallback(callback)
+  }
+
+  private fun stopRenderLoop() {
+    frameCallback?.let { Choreographer.getInstance().removeFrameCallback(it) }
+    frameCallback = null
+  }
+
+  // JNI bridge -> Rust render C-ABI (see android/src/main/cpp/cpp-adapter.cpp).
+  private external fun nativeAttach(
+    surface: Surface,
+    fontPath: String,
+    configJson: String?,
+    shellId: String?,
+  ): Long
+
+  private external fun nativeSetShell(handle: Long, shellId: String?)
+
+  private external fun nativeSetConfig(handle: Long, configJson: String?)
+
+  private external fun nativeDraw(handle: Long)
+
+  private external fun nativeResize(handle: Long)
+
+  private external fun nativeSendInput(handle: Long, data: ByteArray)
+
+  private external fun nativeDestroy(handle: Long)
+
+  companion object {
+    init {
+      System.loadLibrary("ReactNativeTerminal")
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/fressh/ReactNativeTerminalModule.kt

@@ -0,0 +1,43 @@
+package com.margelo.nitro.fressh
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+/**
+ * Installs the uniffi control-plane JSI bindings (the `globalThis.NativeShimUniffi`
+ * host object the ubrn-generated TS calls). JS invokes [installRustCrate] once at
+ * startup (see `src/ssh.ts`), which hands the JSI runtime pointer + the
+ * `CallInvokerHolder` to native; `nativeInstallRustCrate` (cpp-adapter.cpp) reaches
+ * the C++ CallInvoker via fbjni `cthis()` (RN 0.85 dropped the old field) and calls
+ * `NativeShimUniffi::registerModule`. Lives in the SAME .so as the Nitro render
+ * plane so both share one `fressh-core` registry. (§8/§10)
+ */
+@ReactModule(name = ReactNativeTerminalModule.NAME)
+class ReactNativeTerminalModule(
+  private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  override fun getName() = NAME
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun installRustCrate(): Boolean {
+    val runtimePointer = reactContext.javaScriptContextHolder?.get() ?: return false
+    val callInvokerHolder = reactContext.jsCallInvokerHolder ?: return false
+    return nativeInstallRustCrate(runtimePointer, callInvokerHolder)
+  }
+
+  private external fun nativeInstallRustCrate(
+    runtimePointer: Long,
+    callInvokerHolder: CallInvokerHolder,
+  ): Boolean
+
+  companion object {
+    const val NAME = "ReactNativeTerminalUniffi"
+
+    init {
+      System.loadLibrary("ReactNativeTerminal")
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/fressh/ReactNativeTerminalPackage.kt

@@ -0,0 +1,32 @@
+package com.margelo.nitro.fressh
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.fressh.views.HybridTerminalManager
+
+/**
+ * ReactPackage for the terminal package. Three jobs:
+ *  1. Its mere presence lets React Native autolinking detect this package and
+ *     build/link its `android/build.gradle` (and thus libReactNativeTerminal.so).
+ *  2. Registers the "Terminal" Nitro HybridView's generated ViewManager so Fabric
+ *     can resolve <Terminal/> (else: "Can't find ViewManager 'Terminal'").
+ *  3. Registers [ReactNativeTerminalModule], whose `installRustCrate()` installs
+ *     the uniffi control-plane JSI bindings (globalThis.NativeShimUniffi).
+ * The Nitro native C++ side (HybridObjects) is registered via [ReactNativeTerminalOnLoad]
+ * in the static initializer below.
+ */
+class ReactNativeTerminalPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(ReactNativeTerminalModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf(HybridTerminalManager())
+
+  companion object {
+    init {
+      ReactNativeTerminalOnLoad.initializeNative()
+    }
+  }
+}

package/babel.config.js

@@ -0,0 +1,12 @@
+export default {
+	overrides: [
+		{
+			exclude: /\/node_modules\//,
+			presets: ['module:react-native-builder-bob/babel-preset'],
+		},
+		{
+			include: /\/node_modules\//,
+			presets: ['module:@react-native/babel-preset'],
+		},
+	],
+};

package/cpp/README.md

@@ -0,0 +1,14 @@
+# `cpp/` — native umbrella glue
+
+Hand-authored C++ that ties the package's one `.so`/framework together (§8):
+
+- the umbrella adapter that registers the TurboModule + Nitro view
+- the Nitro view's C++ that calls **fressh-core's C-ABI** for the render plane
+  (`attach(shellId, surface)`, `render_frame`, `send_input`, `detach`)
+
+Generated C++ (regenerated, gitignored) lands in `cpp/generated/` (ubrn shim)
+and `nitrogen/generated/` (Nitro view). This dir holds only the hand-written
+adapter sources.
+
+> Scaffold stub — empty until the umbrella build is wired (see
+> `../android/CMakeLists.txt`).