feat(expo): silent-disable when projectKey or intakeUrl is empty

- normalizeConfig returns null for empty keys/urls instead of throwing
- ReproProvider splits into ActiveProvider + DisabledProvider so host apps
  can opt out via env-var fallback (`projectKey: process.env.X ?? ""`)
- useRepro().disabled flag + all methods no-op in the disabled path
- ReproLauncher hides when disabled
- Singleton still resolves cleanly in dev (no "provider not mounted" warning)
- Typos in a non-empty key still throw so mistakes are caught

Author: Ripwords

packages/expo/src/config.test.ts

@@ -1,11 +1,13 @@
 import { test, expect } from "bun:test"
 import { normalizeConfig } from "./config"
 
+const VALID_KEY = "rp_pk_" + "a".repeat(24)
+const VALID_URL = "https://example.com/api/intake"
+
 test("normalizeConfig fills sensible defaults", () => {
-  const cfg = normalizeConfig({
-    projectKey: "rp_pk_" + "a".repeat(24),
-    intakeUrl: "https://example.com/api/intake",
-  })
+  const cfg = normalizeConfig({ projectKey: VALID_KEY, intakeUrl: VALID_URL })
+  expect(cfg).not.toBeNull()
+  if (!cfg) return
   expect(cfg.collectors.console).toBe(true)
   expect(cfg.collectors.network.enabled).toBe(true)
   expect(cfg.queue.maxReports).toBe(5)
@@ -15,19 +17,27 @@ test("normalizeConfig fills sensible defaults", () => {
 })
 
 test("normalizeConfig rejects malformed projectKey at runtime", () => {
-  expect(() =>
-    normalizeConfig({ projectKey: "nope", intakeUrl: "https://example.com/api/intake" }),
-  ).toThrow(/projectKey/)
+  expect(() => normalizeConfig({ projectKey: "nope", intakeUrl: VALID_URL })).toThrow(/projectKey/)
 })
 
 test("normalizeConfig respects overrides", () => {
   const cfg = normalizeConfig({
-    projectKey: "rp_pk_" + "a".repeat(24),
-    intakeUrl: "https://example.com/api/intake",
+    projectKey: VALID_KEY,
+    intakeUrl: VALID_URL,
     queue: { maxReports: 3 },
     collectors: { network: { enabled: false } },
   })
+  expect(cfg).not.toBeNull()
+  if (!cfg) return
   expect(cfg.queue.maxReports).toBe(3)
   expect(cfg.queue.maxBytes).toBe(10 * 1024 * 1024)
   expect(cfg.collectors.network.enabled).toBe(false)
 })
+
+test("normalizeConfig returns null when projectKey is empty (silent disable)", () => {
+  expect(normalizeConfig({ projectKey: "", intakeUrl: VALID_URL })).toBeNull()
+})
+
+test("normalizeConfig returns null when intakeUrl is empty (silent disable)", () => {
+  expect(normalizeConfig({ projectKey: VALID_KEY, intakeUrl: "" })).toBeNull()
+})

packages/expo/src/config.ts

@@ -50,11 +50,23 @@ export interface ReproConfig {
   metadata: Record<string, string | number | boolean>
 }
 
-export function normalizeConfig(input: ReproConfigInput): ReproConfig {
+/**
+ * Normalize a ReproConfigInput to a fully-defaulted ReproConfig.
+ *
+ * Returns `null` when `projectKey` or `intakeUrl` are empty — this is the
+ * silent-disable path that lets hosts turn the SDK off by simply leaving
+ * their env vars unset (e.g. `projectKey: process.env.EXPO_PUBLIC_KEY ?? ""`).
+ *
+ * Throws only when a non-empty value is malformed (typo protection).
+ */
+export function normalizeConfig(input: ReproConfigInput): ReproConfig | null {
+  if (!input.projectKey || !input.intakeUrl) {
+    return null
+  }
   if (!PROJECT_KEY_PATTERN.test(input.projectKey)) {
     throw new Error(`Repro: invalid projectKey shape`)
   }
-  if (!input.intakeUrl || !/^https?:\/\//.test(input.intakeUrl)) {
+  if (!/^https?:\/\//.test(input.intakeUrl)) {
     throw new Error(`Repro: invalid intakeUrl — must be http(s)`)
   }
   return {

packages/expo/src/context.ts

@@ -4,7 +4,12 @@ import type { Breadcrumb } from "@reprojs/sdk-utils"
 import type { ReporterIdentity } from "@reprojs/shared"
 
 export interface ReproInternalContext {
-  config: ReproConfig
+  /**
+   * `null` indicates the silent-disable state — the provider rendered but
+   * neither `projectKey` nor `intakeUrl` were supplied. All callback methods
+   * on this context are no-ops; `useRepro().disabled` reflects this flag.
+   */
+  config: ReproConfig | null
   getReporter: () => ReporterIdentity | null
   setReporter: (r: ReporterIdentity | null) => void
   getMetadata: () => Record<string, string | number | boolean>

packages/expo/src/launcher.tsx

@@ -108,6 +108,7 @@ export function ReproLauncher({
   const gesture = draggable ? Gesture.Race(pan, tap) : tap
 
   if (hideWhen?.()) return null
+  if (repro.disabled) return null
 
   const posStyles = {
     position: "absolute" as const,

packages/expo/src/provider.tsx

@@ -1,7 +1,7 @@
 import React, { useEffect, useMemo, useRef, useState } from "react"
 import { AppState, View } from "react-native"
 import { ReproContext, type ReproInternalContext } from "./context"
-import { normalizeConfig, type ReproConfigInput } from "./config"
+import { normalizeConfig, type ReproConfig, type ReproConfigInput } from "./config"
 import { createConsoleCollector } from "./collectors/console"
 import { createNetworkCollector } from "./collectors/network"
 import { createBreadcrumbsCollector } from "@reprojs/sdk-utils"
@@ -20,8 +20,44 @@ interface Props {
   children: React.ReactNode
 }
 
+/**
+ * When `projectKey` or `intakeUrl` are empty, the SDK silently disables itself
+ * and renders children untouched — no collectors, no launcher, no network. Let
+ * hosts opt out with `projectKey: process.env.X ?? ""` rather than a separate
+ * `enabled: false` flag.
+ */
+const DISABLED_CONTEXT: ReproInternalContext = {
+  config: null,
+  getReporter: () => null,
+  setReporter: () => undefined,
+  getMetadata: () => ({}),
+  setMetadata: () => undefined,
+  logBreadcrumb: () => undefined,
+  openWizard: () => undefined,
+  closeWizard: () => undefined,
+  captureRoot: async () => ({ uri: "", width: 0, height: 0 }),
+  snapshotBreadcrumbs: () => [],
+  queueStatus: () => ({ pending: 0, lastError: null }),
+  flushQueue: async () => undefined,
+}
+
+function DisabledProvider({ children }: { children: React.ReactNode }) {
+  useEffect(() => {
+    setSingletonHandle(DISABLED_CONTEXT)
+    return () => clearSingletonHandle()
+  }, [])
+  return <ReproContext.Provider value={DISABLED_CONTEXT}>{children}</ReproContext.Provider>
+}
+
 export function ReproProvider({ config: rawConfig, children }: Props) {
   const config = useMemo(() => normalizeConfig(rawConfig), [rawConfig])
+  if (config === null) {
+    return <DisabledProvider>{children}</DisabledProvider>
+  }
+  return <ActiveProvider config={config}>{children}</ActiveProvider>
+}
+
+function ActiveProvider({ config, children }: { config: ReproConfig; children: React.ReactNode }) {
   const rootRef = useRef<View | null>(null)
   const [reporter, setReporter] = useState<ReporterIdentity | null>(config.reporter)
   const [metadata, setMetadata] = useState<Record<string, string | number | boolean>>(

packages/expo/src/use-repro.ts

@@ -5,6 +5,10 @@ import type { ReporterIdentity } from "@reprojs/shared"
 declare const __DEV__: boolean
 
 export interface ReproHandle {
+  /** True when the provider is in silent-disable mode (empty projectKey or
+   *  intakeUrl). Callers that render UI based on Repro availability can gate
+   *  on this — e.g. `<ReproLauncher />` returns null when disabled. */
+  disabled: boolean
   open: (opts?: { initialTitle?: string; initialDescription?: string }) => void
   close: () => void
   identify: (reporter: ReporterIdentity | null) => void
@@ -13,23 +17,31 @@ export interface ReproHandle {
   queue: { pending: number; lastError: string | null; flush: () => Promise<void> }
 }
 
+const NOOP_HANDLE: ReproHandle = {
+  disabled: true,
+  open: () => undefined,
+  close: () => undefined,
+  identify: () => undefined,
+  log: () => undefined,
+  setMetadata: () => undefined,
+  queue: { pending: 0, lastError: null, flush: async () => undefined },
+}
+
 export function useRepro(): ReproHandle {
   const ctx = useContext(ReproContext)
   if (!ctx) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       throw new Error("Repro: useRepro() must be called inside <ReproProvider>")
     }
-    return {
-      open: () => undefined,
-      close: () => undefined,
-      identify: () => undefined,
-      log: () => undefined,
-      setMetadata: () => undefined,
-      queue: { pending: 0, lastError: null, flush: async () => undefined },
-    }
+    return NOOP_HANDLE
+  }
+  // Silent-disable: provider rendered but projectKey/intakeUrl were empty.
+  if (ctx.config === null) {
+    return NOOP_HANDLE
   }
   const status = ctx.queueStatus()
   return {
+    disabled: false,
     open: ctx.openWizard,
     close: ctx.closeWizard,
     identify: ctx.setReporter,