@nebula-rn/cli 0.0.1 → 0.1.0

package/templates/runner/App.tsx

@@ -0,0 +1,515 @@
+import React, { useEffect, useState } from 'react';
+import {
+  ActivityIndicator,
+  Alert,
+  Image,
+  Linking,
+  Platform,
+  Pressable,
+  StyleSheet,
+  Text,
+} from 'react-native';
+import Animated, {
+  Easing,
+  FadeInUp,
+  FadeOut,
+  FadeOutDown,
+} from 'react-native-reanimated';
+import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
+import { defaultHostApis } from '@nebula-rn/host-apis';
+import type { MiniappLoadingResolveContext } from '@nebula-rn/sdk';
+import { NebulaAPI } from '@nebula-rn/sdk';
+import { RunnerHomeScreen } from './src/RunnerHomeScreen';
+import type { RunnerHistoryItem, RuntimeManifest } from './src/runnerTypes';
+
+const DEFAULT_RUNNER_BASE_URL = 'http://localhost:8082';
+
+type RunnerSessionTarget = {
+  baseUrl: string;
+  bundleUrl?: string | null;
+  manifestUrl?: string | null;
+};
+
+function normalizeRunnerBaseUrl(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return DEFAULT_RUNNER_BASE_URL;
+  }
+  return trimmed.replace(/\/$/, '');
+}
+
+function parseRunnerInput(value: string): RunnerSessionTarget {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return { baseUrl: DEFAULT_RUNNER_BASE_URL };
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.pathname.endsWith('.bundle')) {
+      return {
+        baseUrl: normalizeRunnerBaseUrl(parsed.origin),
+        bundleUrl: trimmed,
+      };
+    }
+    if (parsed.pathname.endsWith('.json')) {
+      return {
+        baseUrl: normalizeRunnerBaseUrl(parsed.origin),
+        manifestUrl: trimmed,
+      };
+    }
+  } catch {
+    return { baseUrl: normalizeRunnerBaseUrl(trimmed) };
+  }
+
+  return { baseUrl: normalizeRunnerBaseUrl(trimmed) };
+}
+
+function parseRunnerLaunchUrl(url: string): RunnerSessionTarget | null {
+  try {
+    const parsed = new URL(url);
+
+    if (parsed.protocol !== 'devrunner:' || parsed.hostname !== 'open') {
+      return null;
+    }
+
+    const manifestUrl = parsed.searchParams.get('manifestUrl');
+    const bundleUrl = parsed.searchParams.get('bundleUrl');
+    const baseUrl = parsed.searchParams.get('baseUrl');
+
+    if (manifestUrl) {
+      const manifest = new URL(manifestUrl);
+      return {
+        baseUrl: normalizeRunnerBaseUrl(manifest.origin),
+        manifestUrl,
+        bundleUrl,
+      };
+    }
+
+    if (bundleUrl) {
+      const bundle = new URL(bundleUrl);
+      return {
+        baseUrl: normalizeRunnerBaseUrl(bundle.origin),
+        bundleUrl,
+      };
+    }
+
+    if (baseUrl) {
+      return { baseUrl: normalizeRunnerBaseUrl(baseUrl) };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function getMiniappBundleUrl(
+  sessionTarget: RunnerSessionTarget,
+  manifest: RuntimeManifest | null,
+): string {
+  if (sessionTarget.bundleUrl) {
+    return sessionTarget.bundleUrl;
+  }
+
+  const baseUrl = normalizeRunnerBaseUrl(sessionTarget.baseUrl);
+  const bundlePath = manifest?.bundlePath || '/index.bundle';
+  return `${baseUrl}${bundlePath}?platform=${Platform.OS}&dev=true&minify=false`;
+}
+
+function buildHistoryItem(
+  sessionTarget: RunnerSessionTarget,
+  manifest: RuntimeManifest,
+): RunnerHistoryItem {
+  return {
+    appId: manifest.appId,
+    baseUrl: normalizeRunnerBaseUrl(sessionTarget.baseUrl),
+    bundleUrl: sessionTarget.bundleUrl ?? null,
+    manifestUrl: sessionTarget.manifestUrl ?? null,
+    title: manifest.window?.navigationBarTitleText || manifest.appId,
+    version: manifest.version,
+  };
+}
+
+function mergeHistory(
+  history: RunnerHistoryItem[],
+  item: RunnerHistoryItem,
+): RunnerHistoryItem[] {
+  const deduped = history.filter(
+    entry =>
+      !(
+        entry.appId === item.appId &&
+        entry.baseUrl === item.baseUrl &&
+        entry.bundleUrl === item.bundleUrl &&
+        entry.manifestUrl === item.manifestUrl
+      ),
+  );
+  return [item, ...deduped].slice(0, 6);
+}
+
+function showActionError(error: unknown) {
+  console.error('[NebulaRunner] Action failed', error);
+  Alert.alert(
+    'Action Failed',
+    error instanceof Error ? error.message : 'Unexpected runner error.',
+  );
+}
+
+function DefaultMiniappLoadingScreen({
+  appId,
+  title,
+  status,
+  iconUrl,
+}: MiniappLoadingResolveContext) {
+  const [closing, setClosing] = useState(false);
+  const message =
+    status === 'installing'
+      ? 'Installing miniapp...'
+      : status === 'error'
+        ? 'Failed to load miniapp.'
+        : 'Preparing miniapp...';
+
+  const closeMiniapp = async () => {
+    if (closing) {
+      return;
+    }
+
+    try {
+      setClosing(true);
+      await NebulaAPI.closeMiniApp(appId);
+    } catch (error) {
+      console.error('[NebulaRunner] Failed to close miniapp', error);
+      Alert.alert('Close Failed', 'Unable to close the miniapp right now.');
+    } finally {
+      setClosing(false);
+    }
+  };
+
+  return (
+    <Animated.View
+      exiting={FadeOut.duration(160)}
+      style={styles.loadingOverlay}
+    >
+      <Animated.View
+        entering={FadeInUp.duration(520)
+          .delay(40)
+          .easing(Easing.out(Easing.cubic))
+          .withInitialValues({
+            transform: [{ translateY: 96 }, { scale: 0.96 }],
+          })}
+        exiting={FadeOutDown.duration(220).withInitialValues({
+          opacity: 1,
+          transform: [{ translateY: 0 }, { scale: 1 }],
+        })}
+        style={styles.loadingCard}
+      >
+        <Text style={styles.loadingEyebrow}>Nebula Runner</Text>
+        <ActivityIndicator
+          size="large"
+          color="#2563eb"
+          style={styles.loadingIndicator}
+        />
+        {iconUrl ? (
+          <Image source={{ uri: iconUrl }} style={styles.loadingIcon} />
+        ) : null}
+        <Text style={styles.loadingTitle}>{title || appId}</Text>
+        <Text style={styles.loadingMessage}>{message}</Text>
+        <Pressable
+          accessibilityRole="button"
+          disabled={closing}
+          onPress={closeMiniapp}
+          style={({ pressed }) => [
+            styles.loadingCloseButton,
+            pressed && !closing ? styles.loadingCloseButtonPressed : null,
+            closing ? styles.loadingCloseButtonDisabled : null,
+          ]}
+        >
+          <Text style={styles.loadingCloseButtonText}>
+            {closing ? 'Closing...' : 'Close miniapp'}
+          </Text>
+        </Pressable>
+      </Animated.View>
+    </Animated.View>
+  );
+}
+
+function RunnerContent() {
+  const [baseUrl, setBaseUrl] = useState(DEFAULT_RUNNER_BASE_URL);
+  const [sessionTarget, setSessionTarget] = useState<RunnerSessionTarget>({
+    baseUrl: DEFAULT_RUNNER_BASE_URL,
+  });
+  const [manifest, setManifest] = useState<RuntimeManifest | null>(null);
+  const [status, setStatus] = useState('Ready to connect to a miniapp.');
+  const [loading, setLoading] = useState(false);
+  const [recentHistory, setRecentHistory] = useState<RunnerHistoryItem[]>([]);
+  const [urlExpanded, setUrlExpanded] = useState(true);
+  const bundleUrl = manifest
+    ? getMiniappBundleUrl(sessionTarget, manifest)
+    : '';
+
+  const loadManifest = async (
+    nextSessionTarget: RunnerSessionTarget,
+  ): Promise<RuntimeManifest> => {
+    const normalizedBaseUrl = normalizeRunnerBaseUrl(nextSessionTarget.baseUrl);
+    const manifestUrl =
+      nextSessionTarget.manifestUrl ??
+      `${normalizedBaseUrl}/.nebula/generated/app.json`;
+
+    const manifestResponse = await fetch(manifestUrl, {
+      headers: { 'Cache-Control': 'no-cache' },
+    });
+
+    if (!manifestResponse.ok) {
+      throw new Error(`Failed to load manifest (${manifestResponse.status})`);
+    }
+
+    return (await manifestResponse.json()) as RuntimeManifest;
+  };
+
+  const applySession = (
+    nextSessionTarget: RunnerSessionTarget,
+    nextManifest: RuntimeManifest,
+  ) => {
+    const normalizedBaseUrl = normalizeRunnerBaseUrl(nextSessionTarget.baseUrl);
+    const normalizedSession = {
+      baseUrl: normalizedBaseUrl,
+      bundleUrl: nextSessionTarget.bundleUrl ?? null,
+      manifestUrl: nextSessionTarget.manifestUrl ?? null,
+    };
+
+    setBaseUrl(
+      normalizedSession.bundleUrl ??
+        normalizedSession.manifestUrl ??
+        normalizedSession.baseUrl,
+    );
+    setSessionTarget(normalizedSession);
+    setManifest(nextManifest);
+    setStatus(`Connected to ${nextManifest.appId} v${nextManifest.version}`);
+    setRecentHistory(history =>
+      mergeHistory(history, buildHistoryItem(normalizedSession, nextManifest)),
+    );
+  };
+
+  const openMiniapp = async (
+    nextManifest: RuntimeManifest | null = manifest,
+    nextSessionTarget: RunnerSessionTarget = sessionTarget,
+  ) => {
+    if (!nextManifest) {
+      Alert.alert(
+        'Miniapp Not Ready',
+        'Connect to a miniapp first so the runner can load its manifest.',
+      );
+      return;
+    }
+
+    await NebulaAPI.openMiniAppWithBundleURL(
+      nextManifest.appId,
+      getMiniappBundleUrl(nextSessionTarget, nextManifest),
+      {
+        title:
+          nextManifest.window?.navigationBarTitleText || nextManifest.appId,
+      },
+      true,
+    );
+  };
+
+  const activateRunnerSession = async (
+    nextSessionTarget: RunnerSessionTarget,
+    options?: { openMiniapp?: boolean },
+  ) => {
+    setLoading(true);
+    try {
+      const nextManifest = await loadManifest(nextSessionTarget);
+      applySession(nextSessionTarget, nextManifest);
+      if (options?.openMiniapp) {
+        await openMiniapp(nextManifest, {
+          baseUrl: normalizeRunnerBaseUrl(nextSessionTarget.baseUrl),
+          bundleUrl: nextSessionTarget.bundleUrl ?? null,
+          manifestUrl: nextSessionTarget.manifestUrl ?? null,
+        });
+      }
+    } catch (error) {
+      setManifest(null);
+      setStatus(
+        error instanceof Error
+          ? error.message
+          : 'Failed to activate runner session.',
+      );
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const refreshRunner = async () => {
+    try {
+      await activateRunnerSession(sessionTarget);
+    } catch (error) {
+      console.error('[NebulaRunner] Failed to refresh runner', error);
+    }
+  };
+
+  useEffect(() => {
+    const handleUrl = (url: string) => {
+      const nextSessionTarget = parseRunnerLaunchUrl(url);
+
+      if (!nextSessionTarget) {
+        return;
+      }
+      activateRunnerSession(nextSessionTarget, { openMiniapp: true }).catch(
+        showActionError,
+      );
+    };
+
+    Linking.getInitialURL()
+      .then(initialUrl => {
+        if (initialUrl) {
+          handleUrl(initialUrl);
+        } else {
+          activateRunnerSession(parseRunnerInput(baseUrl)).catch(error => {
+            console.error(
+              '[NebulaRunner] Failed to refresh initial runner',
+              error,
+            );
+          });
+        }
+      })
+      .catch(error => {
+        console.error('[NebulaRunner] Failed to read initial URL', error);
+      });
+
+    const subscription = Linking.addEventListener('url', event => {
+      handleUrl(event.url);
+    });
+
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+
+  return (
+    <SafeAreaView edges={['top', 'left', 'right']} style={styles.screen}>
+      <RunnerHomeScreen
+        baseUrl={baseUrl}
+        setBaseUrl={setBaseUrl}
+        manifest={manifest}
+        status={status}
+        serviceOnline={manifest != null}
+        loading={loading}
+        bundleUrl={bundleUrl}
+        recentHistory={recentHistory}
+        clearRecentHistory={() => setRecentHistory([])}
+        urlExpanded={urlExpanded}
+        setUrlExpanded={setUrlExpanded}
+        onConnect={() => {
+          activateRunnerSession(parseRunnerInput(baseUrl), {
+            openMiniapp: true,
+          }).catch(showActionError);
+        }}
+        onRefresh={refreshRunner}
+        onOpenCurrent={() => {
+          openMiniapp().catch(error => {
+            console.error('[NebulaRunner] Failed to open miniapp', error);
+          });
+        }}
+        onSelectHistory={item => {
+          activateRunnerSession(
+            {
+              baseUrl: item.baseUrl,
+              bundleUrl: item.bundleUrl ?? null,
+              manifestUrl: item.manifestUrl ?? null,
+            },
+            { openMiniapp: true },
+          ).catch(showActionError);
+        }}
+      />
+    </SafeAreaView>
+  );
+}
+
+function RunnerApp() {
+  return (
+    <SafeAreaProvider>
+      <RunnerContent />
+    </SafeAreaProvider>
+  );
+}
+
+export default NebulaAPI.wrap({
+  hostApis: defaultHostApis,
+  miniappLoading: {
+    component: DefaultMiniappLoadingScreen,
+    delayMs: 300,
+    enterContentDelayMs: 120,
+  },
+})(RunnerApp);
+
+const styles = StyleSheet.create({
+  screen: {
+    flex: 1,
+    backgroundColor: '#f4f2ff',
+  },
+  loadingOverlay: {
+    flex: 1,
+    backgroundColor: 'rgba(15, 23, 42, 0.14)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: 24,
+  },
+  loadingCard: {
+    width: '100%',
+    maxWidth: 420,
+    borderRadius: 24,
+    backgroundColor: '#ffffff',
+    padding: 24,
+    gap: 10,
+  },
+  loadingEyebrow: {
+    fontSize: 12,
+    fontWeight: '700',
+    letterSpacing: 1.2,
+    color: '#2563eb',
+    textTransform: 'uppercase',
+  },
+  loadingIndicator: {
+    marginTop: 4,
+  },
+  loadingIcon: {
+    width: 56,
+    height: 56,
+    borderRadius: 14,
+  },
+  loadingTitle: {
+    fontSize: 24,
+    fontWeight: '700',
+    color: '#0f172a',
+  },
+  loadingMessage: {
+    fontSize: 15,
+    lineHeight: 22,
+    color: '#475569',
+  },
+  loadingMeta: {
+    fontSize: 13,
+    color: '#64748b',
+  },
+  loadingCloseButton: {
+    marginTop: 8,
+    borderRadius: 999,
+    backgroundColor: '#0f172a',
+    paddingVertical: 12,
+    paddingHorizontal: 18,
+    alignItems: 'center',
+  },
+  loadingCloseButtonPressed: {
+    opacity: 0.88,
+  },
+  loadingCloseButtonDisabled: {
+    opacity: 0.6,
+  },
+  loadingCloseButtonText: {
+    color: '#ffffff',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+});

package/templates/runner/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# You may use http://rbenv.org/ or https://rvm.io/ to install and use this version
+ruby ">= 2.6.10"
+
+# Exclude problematic versions of cocoapods and activesupport that causes build failures.
+gem 'cocoapods', '>= 1.13', '!= 1.15.0', '!= 1.15.1'
+gem 'activesupport', '>= 6.1.7.5', '!= 7.1.0'
+gem 'xcodeproj', '< 1.26.0'
+gem 'concurrent-ruby', '< 1.3.4'
+
+# Ruby 3.4.0 has removed some libraries from the standard library.
+gem 'bigdecimal'
+gem 'logger'
+gem 'benchmark'
+gem 'mutex_m'

package/templates/runner/__tests__/App.test.tsx

@@ -0,0 +1,13 @@
+/**
+ * @format
+ */
+
+import React from 'react';
+import ReactTestRenderer from 'react-test-renderer';
+import App from '../App';
+
+test('renders correctly', async () => {
+  await ReactTestRenderer.act(() => {
+    ReactTestRenderer.create(<App />);
+  });
+});

package/templates/runner/android/app/build.gradle

@@ -0,0 +1,55 @@
+apply plugin: "com.android.application"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+react {
+    autolinkLibrariesWithApp()
+}
+
+def enableProguardInReleaseBuilds = false
+def jscFlavor = 'io.github.react-native-community:jsc-android:2026004.+'
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
+    compileSdk rootProject.ext.compileSdkVersion
+
+    namespace "__BUNDLE_ID__"
+    defaultConfig {
+        applicationId "__BUNDLE_ID__"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+        manifestPlaceholders = [nebulaUrlScheme: "devrunner"]
+    }
+    signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+        }
+        release {
+            signingConfig signingConfigs.debug
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
+    }
+}
+
+dependencies {
+    implementation("com.facebook.react:react-android")
+    implementation("androidx.appcompat:appcompat:1.7.1")
+
+    if (hermesEnabled.toBoolean()) {
+        implementation("com.facebook.react:hermes-android")
+    } else {
+        implementation jscFlavor
+    }
+}

package/templates/runner/android/app/proguard-rules.pro

@@ -0,0 +1,10 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:

package/templates/runner/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,60 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.DETECT_SCREEN_CAPTURE" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+    <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" />
+
+    <application
+      android:name=".MainApplication"
+      android:label="@string/app_name"
+      android:icon="@mipmap/ic_launcher"
+      android:roundIcon="@mipmap/ic_launcher_round"
+      android:allowBackup="false"
+      android:theme="@style/AppTheme"
+      android:usesCleartextTraffic="${usesCleartextTraffic}"
+      android:supportsRtl="true">
+      <activity
+        android:name=".MainActivity"
+        android:label="@string/app_name"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+        android:launchMode="singleTask"
+        android:windowSoftInputMode="adjustResize"
+        android:exported="true">
+        <intent-filter>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+        <intent-filter>
+            <action android:name="android.intent.action.VIEW" />
+            <category android:name="android.intent.category.DEFAULT" />
+            <category android:name="android.intent.category.BROWSABLE" />
+            <data android:scheme="${nebulaUrlScheme}" android:host="review" android:pathPrefix="/install/" />
+            <data android:scheme="${nebulaUrlScheme}" android:host="miniapp" android:pathPrefix="/install/" />
+        </intent-filter>
+        <intent-filter>
+            <action android:name="android.intent.action.VIEW" />
+            <category android:name="android.intent.category.DEFAULT" />
+            <category android:name="android.intent.category.BROWSABLE" />
+            <data android:scheme="devrunner" android:host="open" />
+        </intent-filter>
+      </activity>
+      <activity
+        android:name="com.hectorzhuang.nebula.NebulaActivity"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+        android:windowSoftInputMode="adjustResize"
+        android:exported="false" />
+      <activity
+        android:name="com.hectorzhuang.nebula.NebulaHostModalActivity"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+        android:theme="@style/NebulaHostModalTheme"
+        android:windowSoftInputMode="adjustResize"
+        android:exported="false" />
+    </application>
+</manifest>

package/templates/runner/android/app/src/main/java/com/devrunner/MainActivity.kt

@@ -0,0 +1,14 @@
+package com.devrunner
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+
+class MainActivity : ReactActivity() {
+
+  override fun getMainComponentName(): String = "__COMPONENT_NAME__"
+
+  override fun createReactActivityDelegate(): ReactActivityDelegate =
+      DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
+}