@glassly/engine 0.1.0-dev.0

package/src/utils/devLogging.ts

@@ -0,0 +1,140 @@
+import {LogBox} from "react-native"
+import {configureReanimatedLogger, ReanimatedLogLevel} from "react-native-reanimated"
+
+export interface LogEntry {
+  timestamp: number
+  level: "debug" | "info" | "warn" | "error"
+  message: string
+  source?: string
+  metadata?: Record<string, unknown>
+}
+
+class LogRingBuffer {
+  private logs: LogEntry[] = []
+  private maxAgeMs = 10 * 60 * 1000
+  private maxEntries = 10000
+  private isIntercepting = false
+
+  append(entry: Omit<LogEntry, "timestamp">) {
+    this.logs.push({...entry, timestamp: Date.now()})
+    this.prune()
+  }
+
+  getRecentLogs(): LogEntry[] {
+    this.prune()
+    return [...this.logs]
+  }
+
+  clear() {
+    this.logs = []
+  }
+
+  getStats(): {count: number; oldestTimestamp: number | null; newestTimestamp: number | null} {
+    this.prune()
+    return {
+      count: this.logs.length,
+      oldestTimestamp: this.logs.length > 0 ? this.logs[0].timestamp : null,
+      newestTimestamp: this.logs.length > 0 ? this.logs[this.logs.length - 1].timestamp : null,
+    }
+  }
+
+  private prune() {
+    const cutoff = Date.now() - this.maxAgeMs
+    this.logs = this.logs.filter((l) => l.timestamp > cutoff)
+    if (this.logs.length > this.maxEntries) {
+      this.logs = this.logs.slice(-this.maxEntries)
+    }
+  }
+
+  startConsoleInterception() {
+    if (this.isIntercepting) return
+    this.isIntercepting = true
+
+    const ignoredLogs = [
+      /Failed to open debugger. Please check that the dev server is running and reload the app./,
+      /Require cycle:/,
+      /is missing the required default export./,
+      /Attempted to import the module/,
+      /The action 'RESET' with payload/,
+      /The action 'POP_TO_TOP' was not handled/,
+      /socket-0 binding/,
+      /socket-0 bound to/,
+      /Error while flushing PostHog/,
+      /backTitleFontFamily prop is not available on Android/,
+      /disableBackButtonMenu prop is not available on Android/,
+      /backTitleVisible prop is not available on Android/,
+      /topInsetEnabled prop is not available on Android/,
+      /largeTitleHideShadow prop is not available on Android/,
+      /largeTitleFontWeight prop is not available on Android/,
+      /userInterfaceStyle prop is not available on Android/,
+      /largeTitleFontFamily prop is not available on Android/,
+      /Points are coincident/,
+    ]
+
+    LogBox.ignoreLogs(ignoredLogs)
+
+    if (__DEV__) {
+      const withoutIgnored =
+        (logger: (...args: unknown[]) => void) =>
+        (...args: unknown[]) => {
+          const output = args.join(" ")
+          if (!ignoredLogs.some((log) => log.test(output))) {
+            logger(...args)
+          }
+        }
+
+      console.log = withoutIgnored(console.log)
+      console.info = withoutIgnored(console.info)
+      console.warn = withoutIgnored(console.warn)
+      console.error = withoutIgnored(console.error)
+    }
+
+    configureReanimatedLogger({
+      level: ReanimatedLogLevel.warn,
+      strict: false,
+    })
+
+    const originalConsole = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+      debug: console.debug,
+    }
+
+    const appendToBuffer = this.append.bind(this)
+
+    const createInterceptor =
+      (level: "debug" | "info" | "warn" | "error", originalFn: (...args: unknown[]) => void) =>
+      (...args: unknown[]) => {
+        originalFn.apply(console, args)
+        appendToBuffer({
+          level,
+          message: args
+            .map((a) => {
+              if (a === null) return "null"
+              if (a === undefined) return "undefined"
+              if (typeof a === "object") {
+                try {
+                  return JSON.stringify(a)
+                } catch {
+                  return String(a)
+                }
+              }
+              return String(a)
+            })
+            .join(" "),
+          source: "console",
+        })
+      }
+
+    console.log = createInterceptor("info", originalConsole.log)
+    console.info = createInterceptor("info", originalConsole.info)
+    console.warn = createInterceptor("warn", originalConsole.warn)
+    console.error = createInterceptor("error", originalConsole.error)
+    console.debug = createInterceptor("debug", originalConsole.debug)
+  }
+}
+
+export const logBuffer = new LogRingBuffer()
+export default logBuffer

package/src/utils/devMiniappLaunch.ts

@@ -0,0 +1,196 @@
+/**
+ * decideDevLaunchRoute — pre-flight reachability + manifest fetch for dev
+ * miniapp launches.
+ *
+ * Every entry point that wants to launch a dev miniapp (home tile, QR
+ * scan, URL screen, dev-offline "Try again" button) calls this BEFORE
+ * navigating, so:
+ *
+ *   1. We land on the right destination in a single transition
+ *      (live mount vs offline takeover) — no flash through /applet/local.
+ *   2. Callers that need the manifest (permission gate, name/icon read)
+ *      get it in the same round trip — no second fetch.
+ *
+ * Pre-flighting at the call site keeps /applet/local a pure mount route.
+ *
+ * When the laptop's Wi-Fi IP changes, the URL stored from the last QR scan
+ * goes stale. We then retry alternate hosts (Metro / EXPO_PUBLIC_LOCAL_MINIAPP_HOST,
+ * plus an mDNS name captured at scan time) and persist the working URL so
+ * the next launch doesn't need a re-scan.
+ */
+
+import {configuredDevHost} from "./configuredDevHost"
+import {storage} from "./storage/storage"
+
+const REACHABILITY_TIMEOUT_MS = 1500
+
+// A single dropped DNS lookup or momentary Wi-Fi blip (AP roam, DHCP renewal,
+// phone hopping to cellular for a beat) looks identical to a dead dev server —
+// both throw out of fetch(). Retrying once absorbs that transient case instead
+// of bouncing straight to the offline screen. We do NOT retry a real HTTP
+// response (res.ok === false): that's the server telling us something
+// definitive, not a network-layer hiccup.
+const REACHABILITY_MAX_ATTEMPTS = 2
+const REACHABILITY_RETRY_DELAY_MS = 400
+
+export type DevManifest = {
+  packageName?: string
+  name?: string
+  /** First-found of `icon` / `iconUrl` / `logoUrl` (relative or absolute). */
+  icon?: string
+  permissions?: unknown
+  hardwareRequirements?: unknown
+  [key: string]: unknown
+}
+
+export type DevLaunchResult =
+  | {decision: "live"; manifest: DevManifest; resolvedUrl: string}
+  | {decision: "offline"; manifest: null; resolvedUrl?: undefined}
+
+export type DecideDevLaunchOptions = {
+  /** Extra hostnames / IPs to try if `devUrl` is unreachable (no scheme/port). */
+  alternateHosts?: string[]
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/** Single GET <devUrl>/miniapp.json attempt with a hard timeout. */
+async function fetchManifestOnce(devUrl: string): Promise<DevManifest | null> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), REACHABILITY_TIMEOUT_MS)
+  try {
+    const res = await fetch(`${devUrl.replace(/\/$/, "")}/miniapp.json`, {
+      method: "GET",
+      signal: controller.signal,
+    })
+    if (!res.ok) return null
+    return (await res.json()) as DevManifest
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+function rewriteHost(devUrl: string, host: string): string | null {
+  const trimmed = host.trim()
+  if (!trimmed) return null
+  try {
+    const url = new URL(devUrl)
+    if (url.hostname === trimmed) return null
+    url.hostname = trimmed
+    return url.toString().replace(/\/$/, "")
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Point an http(s) icon at the host that actually answered. Cached dev icons are
+ * local `file://` paths and third-party icons live on unrelated hosts, so only
+ * icons still served by the stale dev host are rewritten.
+ */
+function rewriteIconHost(iconUrl: string, staleDevUrl: string, resolvedDevUrl: string): string | null {
+  try {
+    const icon = new URL(iconUrl)
+    if (icon.protocol !== "http:" && icon.protocol !== "https:") return null
+    const stale = new URL(staleDevUrl)
+    const resolved = new URL(resolvedDevUrl)
+    // Compare host (hostname+port) so an icon on the same hostname but a
+    // different service port is left alone.
+    if (icon.host !== stale.host) return null
+    icon.host = resolved.host
+    return icon.toString()
+  } catch {
+    return null
+  }
+}
+
+function collectAlternateHosts(packageName: string, extra?: string[]): string[] {
+  const hosts: string[] = []
+  const push = (h: string | undefined | null) => {
+    const v = h?.trim()
+    if (v && !hosts.includes(v)) hosts.push(v)
+  }
+
+  push(configuredDevHost())
+
+  if (packageName) {
+    const mdns = storage.load<string>(`${packageName}_dev_mdns`)
+    if (mdns.is_ok()) push(mdns.value)
+  }
+
+  for (const h of extra ?? []) push(h)
+  return hosts
+}
+
+async function probeUrl(devUrl: string): Promise<DevManifest | null | "network-error"> {
+  for (let attempt = 1; attempt <= REACHABILITY_MAX_ATTEMPTS; attempt++) {
+    try {
+      const manifest = await fetchManifestOnce(devUrl)
+      // Definitive HTTP failure — do not retry this URL further.
+      if (!manifest) return null
+      return manifest
+    } catch {
+      if (attempt < REACHABILITY_MAX_ATTEMPTS) {
+        await delay(REACHABILITY_RETRY_DELAY_MS)
+        continue
+      }
+      return "network-error"
+    }
+  }
+  return "network-error"
+}
+
+/**
+ * GET <devUrl>/miniapp.json with a hard timeout, retrying once on a
+ * network-layer failure (DNS/connection/abort) before trying alternate
+ * hosts (Metro laptop IP, mDNS name from the QR). Returns the parsed
+ * manifest on success ("live") or null ("offline").
+ *
+ * Side effects on success:
+ *   - writes <packageName>_dev_last_reachable
+ *   - if an alternate host worked, rewrites <packageName>_dev_url so the
+ *     next launch skips the stale IP
+ */
+export async function decideDevLaunchRoute(
+  packageName: string,
+  devUrl: string,
+  options?: DecideDevLaunchOptions,
+): Promise<DevLaunchResult> {
+  const candidates: string[] = [devUrl]
+  for (const host of collectAlternateHosts(packageName, options?.alternateHosts)) {
+    const rewritten = rewriteHost(devUrl, host)
+    if (rewritten && !candidates.includes(rewritten)) candidates.push(rewritten)
+  }
+
+  for (const candidate of candidates) {
+    const result = await probeUrl(candidate)
+    if (result === "network-error" || result === null) continue
+
+    if (packageName) {
+      storage.save(`${packageName}_dev_last_reachable`, Date.now())
+      if (candidate !== devUrl) {
+        storage.save(`${packageName}_dev_url`, candidate)
+        // Keep _dev_meta.devUrl in sync when present so home-tile reads match.
+        const metaRes = storage.load<string>(`${packageName}_dev_meta`)
+        if (metaRes.is_ok()) {
+          try {
+            const meta = JSON.parse(metaRes.value) as {devUrl?: string; iconUrl?: string}
+            meta.devUrl = candidate
+            if (typeof meta.iconUrl === "string") {
+              const rewritten = rewriteIconHost(meta.iconUrl, devUrl, candidate)
+              if (rewritten) meta.iconUrl = rewritten
+            }
+            storage.save(`${packageName}_dev_meta`, JSON.stringify(meta))
+          } catch {
+            /* ignore malformed meta */
+          }
+        }
+      }
+    }
+    return {decision: "live", manifest: result, resolvedUrl: candidate}
+  }
+
+  return {decision: "offline", manifest: null}
+}

package/src/utils/diagnosticContext.ts

@@ -0,0 +1,159 @@
+import NetInfo from "@react-native-community/netinfo"
+import Constants from "expo-constants"
+import * as Location from "expo-location"
+import {Platform} from "react-native"
+import type {ReportContext} from "@glassly/cloud-client"
+
+import appRegistry from "../services/AppRegistry"
+import localMiniappRuntime from "../services/LocalMiniappRuntime"
+import {getLastOpenTime, useAppStatusStore} from "../stores/apps"
+import {useConnectionStore} from "../stores/connection"
+import {useCoreStore} from "../stores/core"
+import {useGlassesStore} from "../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {buildMiniappDiagnosticContext} from "./miniappDiagnostics"
+
+const SENSITIVE_SETTINGS_KEYS = ["core_token", "auth_token", "auth_email"] as const
+
+/** Provider API keys (`*_api_key`, e.g. soniox_api_key) are secrets; match by
+ *  suffix so future keys can't leak into bug reports by omission. */
+function isSensitiveSettingKey(key: string): boolean {
+  return SENSITIVE_SETTINGS_KEYS.includes(key as (typeof SENSITIVE_SETTINGS_KEYS)[number]) || key.endsWith("_api_key")
+}
+const SENSITIVE_GLASSES_KEYS = ["hotspotPassword"] as const
+
+/**
+ * The glasses store keeps hotspot credentials NESTED (`hotspot: {state, ssid,
+ * password, localIp}`), not just on the legacy top-level `hotspotPassword` key —
+ * strip the password before the state is attached to a report.
+ */
+function redactNestedCredentials(glasses: Record<string, unknown>): Record<string, unknown> {
+  const hotspot = glasses.hotspot
+  if (hotspot && typeof hotspot === "object" && "password" in hotspot) {
+    const {password: _password, ...rest} = hotspot as Record<string, unknown>
+    return {...glasses, hotspot: {...rest, password: "[REDACTED]"}}
+  }
+  return glasses
+}
+
+export async function collectDiagnosticContext(extra?: Partial<ReportContext>): Promise<ReportContext> {
+  const appletState = useAppStatusStore.getState()
+  const settingsState = useSettingsStore.getState()
+  const {setCoreInfo: _setCoreInfo, reset: _resetBluetooth, ...coreState} = useCoreStore.getState()
+  const {
+    setStatus: _setConnectionStatus,
+    setUrl: _setConnectionUrl,
+    setError: _setConnectionError,
+    incrementReconnectAttempts: _incrementReconnectAttempts,
+    resetReconnectAttempts: _resetReconnectAttempts,
+    reset: _resetConnection,
+    ...connectionState
+  } = useConnectionStore.getState()
+  const {
+    setGlassesInfo: _setGlassesInfo,
+    setBatteryInfo: _setBatteryInfo,
+    setWifiInfo: _setWifiInfo,
+    setHotspotInfo: _setHotspotInfo,
+    setOtaUpdateAvailable: _setOtaUpdateAvailable,
+    setOtaProgress: _setOtaProgress,
+    setOtaInProgress: _setOtaInProgress,
+    setMtkUpdatedThisSession: _setMtkUpdatedThisSession,
+    clearOtaState: _clearOtaState,
+    reset: _resetGlasses,
+    ...glassesState
+  } = useGlassesStore.getState()
+
+  const filteredGlasses = redactNestedCredentials(
+    Object.fromEntries(
+      Object.entries(glassesState).filter(
+        ([key]) => !SENSITIVE_GLASSES_KEYS.includes(key as (typeof SENSITIVE_GLASSES_KEYS)[number]),
+      ),
+    ),
+  )
+  const filteredSettings = Object.fromEntries(
+    Object.entries(settingsState.settings || {}).filter(([key]) => !isSensitiveSettingKey(key)),
+  )
+
+  let networkInfo: Record<string, unknown> = {type: "unknown", isConnected: false, isInternetReachable: false}
+  try {
+    const netState = await NetInfo.fetch()
+    networkInfo = {
+      type: netState.type,
+      isConnected: netState.isConnected ?? false,
+      isInternetReachable: netState.isInternetReachable ?? false,
+    }
+  } catch (error) {
+    console.log("diagnosticContext: failed to get network info:", error)
+  }
+
+  let locationInfo: Record<string, unknown> | undefined
+  try {
+    const {status} = await Location.getForegroundPermissionsAsync()
+    if (status === "granted") {
+      const location = await Location.getLastKnownPositionAsync()
+      if (location) {
+        locationInfo = {
+          latitude: Number(location.coords.latitude.toFixed(4)),
+          longitude: Number(location.coords.longitude.toFixed(4)),
+        }
+        try {
+          const [place] = await Location.reverseGeocodeAsync({
+            latitude: location.coords.latitude,
+            longitude: location.coords.longitude,
+          })
+          if (place) {
+            locationInfo.place = [place.city, place.region, place.country].filter(Boolean).join(", ")
+          }
+        } catch (error) {
+          console.log("diagnosticContext: failed to reverse geocode:", error)
+        }
+      }
+    }
+  } catch (error) {
+    console.log("diagnosticContext: failed to get location:", error)
+  }
+
+  const offlineMode = await useSettingsStore.getState().getSetting(SETTINGS.offline_mode.key)
+  const defaultWearable = await useSettingsStore.getState().getSetting(SETTINGS.default_wearable.key)
+  const miniappRuntime = localMiniappRuntime.getDiagnosticSnapshot()
+  const miniapps = buildMiniappDiagnosticContext({
+    apps: appletState.apps,
+    foregroundedPackage: appletState.foregroundedPackage,
+    runtime: miniappRuntime,
+    getLastOpenedAtMs: (app) => getLastOpenTime(app.packageName),
+    getManifest: (app) =>
+      app.local && app.version ? appRegistry.getMiniappManifest(app.packageName, app.version) : undefined,
+    getReleaseIdentity: (app) =>
+      app.local && app.version ? appRegistry.getReleaseIdentity(app.packageName, app.version) : undefined,
+  })
+
+  return {
+    app: {
+      appVersion: process.env.EXPO_PUBLIC_OS_VERSION || "version",
+      buildCommit: process.env.EXPO_PUBLIC_BUILD_COMMIT || "commit",
+      buildBranch: process.env.EXPO_PUBLIC_BUILD_BRANCH || "branch",
+      buildTime: process.env.EXPO_PUBLIC_BUILD_TIME || "time",
+      buildUser: process.env.EXPO_PUBLIC_BUILD_USER || "user",
+    },
+    phone: {
+      deviceName: Constants.deviceName || "deviceName",
+      osVersion: `${Platform.OS} ${Platform.Version}`,
+      platform: Platform.OS,
+      network: networkInfo,
+      location: locationInfo,
+    },
+    glasses: filteredGlasses,
+    runtime: {
+      core: coreState,
+      connection: connectionState,
+      miniapps: miniappRuntime,
+    },
+    apps: miniapps,
+    settings: {
+      ...filteredSettings,
+      offlineMode: !!offlineMode,
+      defaultWearable,
+    },
+    ...extra,
+  }
+}