@reactiive/ennio 0.0.1

package/ios/EnnioAutoInit.mm

@@ -0,0 +1,338 @@
+//
+// EnnioAutoInit.mm
+// Automatic initialization of Ennio by hooking into React Native setup
+//
+
+#import <Foundation/Foundation.h>
+#import <objc/runtime.h>
+#import <objc/message.h>
+#import "EnnioRuntimeHelper.h"
+#import "EnnioDebugBanner.h"
+
+#if __has_include(<React/RCTSurfacePresenter.h>)
+#import <React/RCTSurfacePresenter.h>
+#endif
+
+#include <jsi/jsi.h>
+#include <functional>
+#include "../cpp/HybridEnnio.hpp"
+
+#if __has_include(<ReactCommon/RCTInstance.h>)
+#import <ReactCommon/RCTInstance.h>
+#define ENNIO_HAVE_RCTINSTANCE 1
+#endif
+
+// Flag to track if Ennio has been initialized
+static BOOL _ennioInitialized = NO;
+
+// Distribution channel detection. Ennio is a dev / QA tool and must
+// refuse to start on App Store production or Enterprise builds. The
+// pod is already excluded from Release configurations at the
+// CocoaPods level, so this is a runtime backstop in case a custom
+// build setup links Ennio into a production binary anyway.
+typedef NS_ENUM(NSInteger, EnnioDistribution) {
+    EnnioDistDev,
+    EnnioDistAdHoc,
+    EnnioDistTestFlight,
+    EnnioDistAppStore,
+    EnnioDistEnterprise,
+};
+
+static EnnioDistribution ennioDetectDistribution(void) {
+#if TARGET_OS_SIMULATOR
+    // Simulator builds ship a placeholder StoreKit receipt named
+    // "receipt" (same name App Store production builds use), which the
+    // logic below would mis-classify as App Store and refuse to start.
+    // The Simulator runs no production binary by definition, so short-
+    // circuit to Dev before anything else.
+    return EnnioDistDev;
+#else
+    NSURL* receiptURL = [NSBundle mainBundle].appStoreReceiptURL;
+    NSString* receiptName = receiptURL.lastPathComponent;
+
+    NSString* profilePath = [[NSBundle mainBundle] pathForResource:@"embedded" ofType:@"mobileprovision"];
+    NSData* profileData = profilePath ? [NSData dataWithContentsOfFile:profilePath] : nil;
+    // .mobileprovision is a CMS-signed blob; the embedded plist XML is
+    // ASCII inside binary noise. Latin-1 makes containsString: work
+    // without decode failures on the surrounding bytes.
+    NSString* profileStr = profileData
+        ? [[NSString alloc] initWithData:profileData encoding:NSISOLatin1StringEncoding]
+        : nil;
+
+    BOOL provisionsAllDevices = [profileStr containsString:@"<key>ProvisionsAllDevices</key>"];
+    BOOL hasProvisionedDevices = [profileStr containsString:@"<key>ProvisionedDevices</key>"];
+    BOOL hasProfile = (profileStr.length > 0);
+
+    // Enterprise: profile claims to provision all devices.
+    if (provisionsAllDevices) return EnnioDistEnterprise;
+
+    // Receipt-based channel detection (the device chose this at install
+    // time, not the build).
+    if ([receiptName isEqualToString:@"receipt"]) return EnnioDistAppStore;
+    if ([receiptName isEqualToString:@"sandboxReceipt"]) return EnnioDistTestFlight;
+
+    // Ad-Hoc: profile names a specific device list.
+    if (hasProvisionedDevices) return EnnioDistAdHoc;
+
+    // App Store distribution profile: no ProvisionedDevices, no
+    // ProvisionsAllDevices, and no receipt yet. This catches the
+    // sideloaded-production-IPA edge case where the build is signed
+    // with the App Store profile but Xcode/Configurator pushed it
+    // straight to a device without going through TestFlight or App
+    // Store, so no receipt was fetched.
+    if (hasProfile && !hasProvisionedDevices && !provisionsAllDevices) return EnnioDistAppStore;
+
+    // Xcode-attached debug builds on real hardware with no embedded
+    // profile at all. Treat as Dev.
+    return EnnioDistDev;
+#endif
+}
+
+static NSString* ennioDistributionName(EnnioDistribution d) {
+    switch (d) {
+        case EnnioDistDev:        return @"Development";
+        case EnnioDistAdHoc:      return @"Ad-Hoc";
+        case EnnioDistTestFlight: return @"TestFlight";
+        case EnnioDistAppStore:   return @"App Store";
+        case EnnioDistEnterprise: return @"Enterprise";
+    }
+}
+
+/**
+ * Hook into RCTHost's start method to capture the surface presenter
+ */
+@interface EnnioAutoInit : NSObject
+@end
+
+@implementation EnnioAutoInit
+
++ (void)load {
+    NSLog(@"[Ennio] EnnioAutoInit +load called");
+    // Diagnostic marker: when stdout/NSLog gets swallowed (idevicesyslog
+    // sometimes drops app debug lines on device), the file proves +load ran.
+    NSString* mark = [NSString stringWithFormat:@"%@/Library/_ennio_load_fired.txt", NSHomeDirectory()];
+    [@"loaded" writeToFile:mark atomically:YES encoding:NSUTF8StringEncoding error:nil];
+
+    // Try to swizzle RCTHost's start method
+    Class hostClass = NSClassFromString(@"RCTHost");
+    if (!hostClass) {
+        NSLog(@"[Ennio] RCTHost class not found, trying alternative...");
+
+        // Try RCTFabricSurface's start method as alternative
+        Class surfaceClass = NSClassFromString(@"RCTFabricSurface");
+        if (surfaceClass) {
+            [self swizzleFabricSurfaceStart:surfaceClass];
+        } else {
+            NSLog(@"[Ennio] No suitable class found for auto-init");
+        }
+        return;
+    }
+
+    NSLog(@"[Ennio] Found RCTHost class, setting up swizzling...");
+
+    SEL originalSelector = @selector(start);
+    SEL swizzledSelector = @selector(ennio_start);
+
+    Method originalMethod = class_getInstanceMethod(hostClass, originalSelector);
+    Method swizzledMethod = class_getInstanceMethod(self, swizzledSelector);
+
+    if (!originalMethod) {
+        NSLog(@"[Ennio] Could not find RCTHost start method");
+        return;
+    }
+
+    // Add swizzled method to RCTHost class
+    BOOL didAddMethod = class_addMethod(
+        hostClass,
+        swizzledSelector,
+        method_getImplementation(swizzledMethod),
+        method_getTypeEncoding(swizzledMethod)
+    );
+
+    if (!didAddMethod) {
+        NSLog(@"[Ennio] Could not add swizzled method to RCTHost");
+        return;
+    }
+
+    // Exchange implementations
+    Method newSwizzledMethod = class_getInstanceMethod(hostClass, swizzledSelector);
+    method_exchangeImplementations(originalMethod, newSwizzledMethod);
+    NSLog(@"[Ennio] RCTHost.start swizzle installed successfully");
+}
+
++ (void)swizzleFabricSurfaceStart:(Class)surfaceClass {
+    SEL originalSelector = @selector(start);
+    SEL swizzledSelector = @selector(ennio_surfaceStart);
+
+    Method originalMethod = class_getInstanceMethod(surfaceClass, originalSelector);
+    Method swizzledMethod = class_getInstanceMethod(self, swizzledSelector);
+
+    if (!originalMethod) {
+        NSLog(@"[Ennio] Could not find RCTFabricSurface start method");
+        return;
+    }
+
+    BOOL didAddMethod = class_addMethod(
+        surfaceClass,
+        swizzledSelector,
+        method_getImplementation(swizzledMethod),
+        method_getTypeEncoding(swizzledMethod)
+    );
+
+    if (didAddMethod) {
+        Method newSwizzledMethod = class_getInstanceMethod(surfaceClass, swizzledSelector);
+        method_exchangeImplementations(originalMethod, newSwizzledMethod);
+        NSLog(@"[Ennio] RCTFabricSurface.start swizzle installed successfully");
+    }
+}
+
+// Swizzled RCTHost start method
+- (void)ennio_start {
+    NSLog(@"[Ennio] RCTHost.start called");
+
+    // Call original implementation
+    [self ennio_start];
+
+    // Distribution gate. Even if the CocoaPods `:configurations`
+    // gate slipped and Ennio is linked into an App Store / Enterprise
+    // binary, refuse to install `__ennioDispatch`, the commit hook,
+    // or the ribbon. Runtime backstop on top of the build-time gate.
+    EnnioDistribution dist = ennioDetectDistribution();
+    if (dist == EnnioDistAppStore || dist == EnnioDistEnterprise) {
+        NSLog(@"[Ennio] REFUSING to start: %@ distribution detected. "
+              @"Ennio must never run in App Store or Enterprise builds. "
+              @"Your build pipeline is leaking a remote-control surface — fix it.",
+              ennioDistributionName(dist));
+        return;
+    }
+    NSLog(@"[Ennio] Distribution: %@ — starting", ennioDistributionName(dist));
+
+    // Pure-native bootstrap: pull RCTInstance from RCTHost's `_instance`
+    // ivar, ask it to run a block on the JS thread once the runtime is
+    // ready. Inside that block we have a `jsi::Runtime&` — capture it,
+    // install the commit-signal walker + the `__ennioDispatch` JSI host
+    // function. After this, the user's app never has to import `ennio`;
+    // the package autolinks via Pod and bootstraps entirely from native,
+    // and the CLI drives it over Hermes Inspector CDP.
+    Ivar instanceIvar = class_getInstanceVariable([self class], "_instance");
+    if (instanceIvar) {
+        id rctInstance = object_getIvar(self, instanceIvar);
+#ifdef ENNIO_HAVE_RCTINSTANCE
+        if ([rctInstance isKindOfClass:[RCTInstance class]]) {
+            __strong RCTInstance* strongInstance = (RCTInstance*)rctInstance;
+            // Background dispatch workers need to schedule the
+            // response-write back onto the JS thread (jsi::Runtime is
+            // not thread-safe). RCTInstance.callFunctionOnBufferedRuntimeExecutor
+            // is the only sanctioned scheduler that hands us a
+            // Runtime& on the JS thread; wrap it as a std::function
+            // and stash it via HybridEnnio for the worker thread to
+            // pick up.
+            margelo::nitro::ennio::HybridEnnio::JSThreadExecutor exec =
+                [strongInstance](std::function<void(facebook::jsi::Runtime&)>&& fn) {
+                    [strongInstance callFunctionOnBufferedRuntimeExecutor:std::move(fn)];
+                };
+            margelo::nitro::ennio::HybridEnnio::setJSThreadExecutor(std::move(exec));
+
+            // Bootstrap (capture runtime, install commit signal +
+            // `__ennioDispatch` JSI host function) once the JS thread
+            // is ready. RCTInstance delivers our C++ lambda onto the
+            // JS thread.
+            std::function<void(facebook::jsi::Runtime&)> boot =
+                [](facebook::jsi::Runtime& rt) {
+                    NSString* m = [NSString stringWithFormat:@"%@/Library/_ennio_jsthread_fired.txt", NSHomeDirectory()];
+                    [@"jsthread" writeToFile:m atomically:YES encoding:NSUTF8StringEncoding error:nil];
+                    margelo::nitro::ennio::HybridEnnio::nativeBootstrap(rt);
+                    NSString* m2 = [NSString stringWithFormat:@"%@/Library/_ennio_bootstrap_returned.txt", NSHomeDirectory()];
+                    [@"returned" writeToFile:m2 atomically:YES encoding:NSUTF8StringEncoding error:nil];
+                };
+            [strongInstance callFunctionOnBufferedRuntimeExecutor:std::move(boot)];
+            NSLog(@"[Ennio] Scheduled nativeBootstrap on JS thread");
+            // Diagnostic marker: confirms ennio_start ran AND nativeBootstrap was scheduled.
+            NSString* mark2 = [NSString stringWithFormat:@"%@/Library/_ennio_bootstrap_scheduled.txt", NSHomeDirectory()];
+            [[NSString stringWithFormat:@"dist=%@", ennioDistributionName(dist)]
+                writeToFile:mark2 atomically:YES encoding:NSUTF8StringEncoding error:nil];
+
+            // Loud, greppable announce. If this line ever shows up in
+            // Console.app on a non-dev device, the build pipeline has
+            // leaked Ennio into a build it shouldn't be in.
+            NSLog(@"[Ennio] __ennioDispatch host function installed (distribution: %@) — "
+                  @"if you see this in production, your build pipeline is broken.",
+                  ennioDistributionName(dist));
+
+            // Show the top-right "E2E" ribbon — opt-in via the
+            // `ENNIORibbonEnabled` Info.plist key (written by
+            // `ennio-expo-plugin` when `showRibbon: true`). Default
+            // off so devs iterating on UI don't get an always-on
+            // overlay. Release builds don't compile this file at all
+            // (CocoaPods :configurations gate), so the check is only
+            // ever reached in Debug.
+            id ribbonFlag = [[NSBundle mainBundle].infoDictionary objectForKey:@"ENNIORibbonEnabled"];
+            BOOL showRibbon = [ribbonFlag isKindOfClass:[NSNumber class]] && [(NSNumber*)ribbonFlag boolValue];
+            if (showRibbon) {
+                [EnnioDebugBanner show];
+            }
+        } else {
+            NSLog(@"[Ennio] _instance is not an RCTInstance (got %@)", [rctInstance class]);
+        }
+#else
+        NSLog(@"[Ennio] RCTInstance.h not available — falling back to JS-side bootstrap");
+        (void)rctInstance;
+#endif
+    } else {
+        NSLog(@"[Ennio] Could not find RCTHost._instance ivar");
+    }
+
+    // Get surface presenter from RCTHost
+    if (!_ennioInitialized) {
+        // Use performSelector to avoid compile-time dependency
+        SEL surfacePresenterSel = @selector(surfacePresenter);
+        if ([self respondsToSelector:surfacePresenterSel]) {
+            #pragma clang diagnostic push
+            #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+            id surfacePresenter = [self performSelector:surfacePresenterSel];
+            #pragma clang diagnostic pop
+
+            if (surfacePresenter) {
+                EnnioSetSurfacePresenter((__bridge RCTSurfacePresenter *)(__bridge void *)surfacePresenter);
+                _ennioInitialized = YES;
+                NSLog(@"[Ennio] Surface presenter captured from RCTHost");
+            } else {
+                NSLog(@"[Ennio] RCTHost.surfacePresenter returned nil");
+            }
+        } else {
+            NSLog(@"[Ennio] RCTHost does not respond to surfacePresenter");
+        }
+    }
+}
+
+// Swizzled RCTFabricSurface start method (alternative path)
+- (void)ennio_surfaceStart {
+    NSLog(@"[Ennio] RCTFabricSurface.start called");
+
+    // Call original implementation
+    [self ennio_surfaceStart];
+
+    // Try to get surface presenter from the surface
+    if (!_ennioInitialized) {
+        // The surface should have access to its presenter
+        // This is a fallback - not all surfaces expose this
+        NSLog(@"[Ennio] Attempting to find surface presenter from RCTFabricSurface...");
+
+        // Check if there's a presenter property
+        SEL presenterSel = @selector(surfacePresenter);
+        if ([self respondsToSelector:presenterSel]) {
+            #pragma clang diagnostic push
+            #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+            id presenter = [self performSelector:presenterSel];
+            #pragma clang diagnostic pop
+
+            if (presenter) {
+                EnnioSetSurfacePresenter((__bridge RCTSurfacePresenter *)(__bridge void *)presenter);
+                _ennioInitialized = YES;
+                NSLog(@"[Ennio] Surface presenter captured from RCTFabricSurface");
+            }
+        }
+    }
+}
+
+@end

package/ios/EnnioDebugBanner.h

@@ -0,0 +1,19 @@
+//
+// EnnioDebugBanner.h
+// Flutter-style top-right diagonal "E2E" ribbon, shown whenever Ennio
+// is active in the running build. Touches pass through — the ribbon
+// never intercepts user interaction or test-runner taps.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EnnioDebugBanner : NSObject
+
+/// Idempotent. Safe to call from any thread; attach happens on main.
++ (void)show;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EnnioDebugBanner.mm

@@ -0,0 +1,178 @@
+//
+// EnnioDebugBanner.mm
+//
+
+#import "EnnioDebugBanner.h"
+#import <UIKit/UIKit.h>
+
+// ─────────────────────────────────────────────────────────────────────
+// Pass-through window: hit-test always nil, so taps never land on the
+// banner — they fall through to whatever app view is below. Same trick
+// Flutter uses for its DEBUG ribbon.
+// ─────────────────────────────────────────────────────────────────────
+
+@interface EnnioPassthroughWindow : UIWindow
+@end
+
+@implementation EnnioPassthroughWindow
+- (UIView*)hitTest:(CGPoint)point withEvent:(UIEvent*)event { return nil; }
+@end
+
+// ─────────────────────────────────────────────────────────────────────
+// Ribbon view: 150x150 container anchored top-right. A red UIView
+// "stripe" subview sits diagonally across the corner via a +45°
+// rotation transform — same orientation as Flutter's debug banner.
+// A bold white UILabel inside the stripe reads naturally along the
+// diagonal. No custom drawRect → CALayer handles all the geometry,
+// shadow, and text rasterisation cleanly.
+// ─────────────────────────────────────────────────────────────────────
+
+static CGFloat const kEnnioBannerSize        = 130.0;
+static CGFloat const kEnnioStripeWidth       = 160.0; // longer than diagonal
+static CGFloat const kEnnioStripeHeight      = 18.0;
+static CGFloat const kEnnioStripeFromCorner  = 42.0;  // px from corner (along diagonal)
+
+@interface EnnioRibbonView : UIView
+@end
+
+@implementation EnnioRibbonView
+
+- (instancetype)init {
+    self = [super initWithFrame:CGRectMake(0, 0, kEnnioBannerSize, kEnnioBannerSize)];
+    if (self) {
+        self.backgroundColor = [UIColor clearColor];
+        self.userInteractionEnabled = NO;
+        self.clipsToBounds = NO;
+
+        // Stripe — solid red, with a soft shadow so it stays visible
+        // on any background.
+        UIView* stripe = [[UIView alloc] initWithFrame:
+            CGRectMake(0, 0, kEnnioStripeWidth, kEnnioStripeHeight)];
+        stripe.backgroundColor = [UIColor systemRedColor];
+        stripe.layer.shadowColor   = [UIColor blackColor].CGColor;
+        stripe.layer.shadowOpacity = 0.30;
+        stripe.layer.shadowOffset  = CGSizeMake(0, 1);
+        stripe.layer.shadowRadius  = 2.5;
+        stripe.userInteractionEnabled = NO;
+
+        // Label — bold white "E2E", filling the stripe bounds, drawn
+        // in unrotated coordinates so the rotation transform applies
+        // to label + background as one unit.
+        UILabel* label = [[UILabel alloc] initWithFrame:stripe.bounds];
+        label.text = @"E2E";
+        label.font = [UIFont systemFontOfSize:10 weight:UIFontWeightHeavy];
+        label.textColor = [UIColor whiteColor];
+        label.textAlignment = NSTextAlignmentCenter;
+        label.adjustsFontSizeToFitWidth = NO;
+        label.userInteractionEnabled = NO;
+        // 1.5pt letter-spacing for slightly more breathing room.
+        NSMutableAttributedString* attr =
+            [[NSMutableAttributedString alloc] initWithString:label.text];
+        [attr addAttribute:NSKernAttributeName value:@1.0
+                     range:NSMakeRange(0, label.text.length)];
+        [attr addAttribute:NSFontAttributeName value:label.font
+                     range:NSMakeRange(0, label.text.length)];
+        [attr addAttribute:NSForegroundColorAttributeName value:label.textColor
+                     range:NSMakeRange(0, label.text.length)];
+        label.attributedText = attr;
+        [stripe addSubview:label];
+
+        [self addSubview:stripe];
+
+        // Position stripe so its centre sits on the diagonal that runs
+        // from top-right corner toward the lower-left of the view.
+        // Distance `kEnnioStripeFromCorner` along that diagonal from
+        // the corner: (corner.x - d/√2, corner.y + d/√2).
+        const CGFloat half = kEnnioStripeFromCorner * M_SQRT1_2;
+        stripe.center = CGPointMake(kEnnioBannerSize - half, half);
+
+        // +45° rotation = clockwise from the stripe's natural
+        // horizontal orientation. With the stripe's centre on the
+        // top-right diagonal, the rotated stripe lies along that
+        // diagonal and "E2E" reads naturally with a 45° head tilt to
+        // the right — matches Flutter's topEnd debug banner.
+        stripe.transform = CGAffineTransformMakeRotation(M_PI_4);
+    }
+    return self;
+}
+
+@end
+
+// ─────────────────────────────────────────────────────────────────────
+// Public banner singleton.
+// ─────────────────────────────────────────────────────────────────────
+
+@interface EnnioDebugBanner ()
+@property (nonatomic, strong, nullable) UIWindow* window;
+@end
+
+@implementation EnnioDebugBanner
+
++ (instancetype)shared {
+    static EnnioDebugBanner* instance;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        instance = [[EnnioDebugBanner alloc] init];
+    });
+    return instance;
+}
+
++ (void)show {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[self shared] attach];
+    });
+}
+
+- (void)attach {
+    if (self.window) return;
+
+    UIWindowScene* scene = [self foregroundScene];
+    if (!scene) {
+        // Scene not ready yet — retry shortly. RCTHost.start fires
+        // before the first scene activates on cold launch.
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 250 * NSEC_PER_MSEC),
+                       dispatch_get_main_queue(),
+                       ^{ [self attach]; });
+        return;
+    }
+
+    UIWindow* w = [[EnnioPassthroughWindow alloc] initWithWindowScene:scene];
+    w.windowLevel = UIWindowLevelStatusBar + 1;
+    w.backgroundColor = [UIColor clearColor];
+    w.userInteractionEnabled = NO;
+
+    UIViewController* vc = [[UIViewController alloc] init];
+    vc.view.backgroundColor = [UIColor clearColor];
+    vc.view.userInteractionEnabled = NO;
+
+    EnnioRibbonView* ribbon = [[EnnioRibbonView alloc] init];
+    ribbon.translatesAutoresizingMaskIntoConstraints = NO;
+    [vc.view addSubview:ribbon];
+
+    // Pin to top-right corner of the window — outside the safe area on
+    // purpose, matching Flutter's DEBUG banner that runs into the
+    // status bar / notch area.
+    [NSLayoutConstraint activateConstraints:@[
+        [ribbon.topAnchor      constraintEqualToAnchor:vc.view.topAnchor],
+        [ribbon.trailingAnchor constraintEqualToAnchor:vc.view.trailingAnchor],
+        [ribbon.widthAnchor    constraintEqualToConstant:kEnnioBannerSize],
+        [ribbon.heightAnchor   constraintEqualToConstant:kEnnioBannerSize],
+    ]];
+
+    w.rootViewController = vc;
+    w.hidden = NO;
+    self.window = w;
+}
+
+- (UIWindowScene*)foregroundScene {
+    for (UIScene* s in [UIApplication sharedApplication].connectedScenes) {
+        if (![s isKindOfClass:[UIWindowScene class]]) continue;
+        if (s.activationState == UISceneActivationStateForegroundActive ||
+            s.activationState == UISceneActivationStateForegroundInactive) {
+            return (UIWindowScene*)s;
+        }
+    }
+    return nil;
+}
+
+@end