@glassly/engine 0.3.7-dev.888 → 0.3.7-dev.891

package/src/services/MiniappEngine.ts

@@ -29,42 +29,77 @@ export interface MiniappEngine {
 
 let engine: MiniappEngine | null = null
 
+/**
+ * Kill and re-spawn a miniapp's background JSContext from its installed bundle
+ * (dev: the dev server's fresh build). Resolves false when it isn't installed
+ * or the spawn failed.
+ */
+async function respawnBackground(router: JSRouter, uiRouter: UIRouter, packageName: string): Promise<boolean> {
+  // Re-resolve the freshly built bundle (dev: HTTP off the dev server;
+  // released: file:// snapshot) via the launcher's shared recipe. Carries
+  // the declared permissions + manifest across the respawn — omitting them
+  // would respawn the JSContext with no permissions, so SUBSCRIBE gates and
+  // per-call dispatch checks would start rejecting after a background
+  // hot-reload.
+  const resolved = await miniappLauncher.resolveBundle(packageName)
+  if (!resolved) {
+    console.warn(`JSRuntime: respawn-bg could not resolve bundle for ${packageName}`)
+    return false
+  }
+  // Force a respawn (kill + spawn) rather than launcher.ensureRunning,
+  // which is idempotent and would no-op an already-registered context.
+  await router.unregister(packageName)
+  const ok = await router.spawnAndRegister(packageName, resolved.bgSource, {
+    permissions: resolved.declaredPermissions,
+    installedManifest: resolved.installedManifest,
+  })
+  if (!ok) {
+    console.warn(`JSRuntime: respawn-bg failed for ${packageName}`)
+    return false
+  }
+  // The respawned JSContext is a fresh MiniappSession with ui.bound false.
+  // The mounted WebView won't re-fire glassly.ready() (it's latched), so
+  // re-announce it so RPC replies (glassly.request) reach the UI again
+  // instead of being dropped while unbound.
+  uiRouter.notifyReopen(packageName)
+  return true
+}
+
 function wireDevServerRespawnBackground(router: JSRouter, uiRouter: UIRouter): void {
   devServerBridge.onRespawnBackground(async (packageName) => {
     try {
-      // Re-resolve the freshly built bundle (dev: HTTP off the dev server;
-      // released: file:// snapshot) via the launcher's shared recipe. Carries
-      // the declared permissions + manifest across the respawn — omitting them
-      // would respawn the JSContext with no permissions, so SUBSCRIBE gates and
-      // per-call dispatch checks would start rejecting after a background
-      // hot-reload.
-      const resolved = await miniappLauncher.resolveBundle(packageName)
-      if (!resolved) {
-        console.warn(`JSRuntime: respawn-bg could not resolve bundle for ${packageName}`)
-        return
-      }
-      // Force a respawn (kill + spawn) rather than launcher.ensureRunning,
-      // which is idempotent and would no-op an already-registered context.
-      await router.unregister(packageName)
-      const ok = await router.spawnAndRegister(packageName, resolved.bgSource, {
-        permissions: resolved.declaredPermissions,
-        installedManifest: resolved.installedManifest,
-      })
-      if (!ok) {
-        console.warn(`JSRuntime: respawn-bg failed for ${packageName}`)
-        return
-      }
-      // The respawned JSContext is a fresh MiniappSession with ui.bound false.
-      // The mounted WebView won't re-fire glassly.ready() (it's latched), so
-      // re-announce it so RPC replies (glassly.request) reach the UI again
-      // instead of being dropped while unbound.
-      uiRouter.notifyReopen(packageName)
+      await respawnBackground(router, uiRouter, packageName)
     } catch (e) {
       console.warn(`JSRuntime: respawn-bg threw for ${packageName}:`, e)
     }
   })
 }
 
+/** Packages with a live background JSContext. */
+export function runningMiniappPackages(): string[] {
+  return engine?.router.registeredPackages() ?? []
+}
+
+/** Tear down a miniapp's background JSContext; a no-op when it isn't running. */
+export async function stopMiniapp(packageName: string): Promise<void> {
+  await engine?.router.unregister(packageName)
+}
+
+/**
+ * Start (or restart) a miniapp's background so it reads its storage afresh (an
+ * app state restore). Resolves false when the engine isn't up or the spawn failed.
+ */
+export async function respawnMiniapp(packageName: string): Promise<boolean> {
+  const current = engine
+  if (!current) return false
+  try {
+    return await respawnBackground(current.router, current.uiRouter, packageName)
+  } catch (e) {
+    console.warn(`JSRuntime: respawn threw for ${packageName}:`, e)
+    return false
+  }
+}
+
 /**
  * Construct (once) and return the JSRuntime engine singletons. Starts the router's
  * message pump on first call. Subsequent calls return the same instances.

package/src/services/NavigationService.ts

@@ -16,6 +16,7 @@ import CrustModule from "@glassly/crust"
 import {resolveMapboxAccessToken, resolveMapboxRenderToken, userMapboxApiKey} from "./MapboxTokenService"
 import {decodePolyline, parseDurationSeconds} from "./navigation/routesApiCodec"
 import {resolveStepRoads} from "./navigation/roadNameResolver"
+import {BgTimer} from "../utils/timers"
 
 const LOG_TAG = "NAV_SERVICE"
 
@@ -394,7 +395,7 @@ class NavigationService {
     sessionToken: string,
   ): Promise<{
     ok: boolean
-    suggestions?: Array<{placeId: string; mainText: string; secondaryText: string}>
+    suggestions?: Array<{placeId: string; mainText: string; secondaryText: string; distanceMeters?: number}>
     error?: string
   }> {
     return placeAutocompleteViaSearchBox(query, near, sessionToken)
@@ -506,6 +507,19 @@ export default navigationService
 const MAPBOX_DIRECTIONS_BASE = "https://api.mapbox.com/directions/v5/mapbox"
 const MAPBOX_GEOCODE_REVERSE = "https://api.mapbox.com/search/geocode/v6/reverse"
 const MAPBOX_SEARCHBOX_SUGGEST = "https://api.mapbox.com/search/searchbox/v1/suggest"
+
+/** Place search sits in front of a voice command; a stalled call must fail over, not hang. */
+const PLACE_SEARCH_TIMEOUT_MS = 6_000
+
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController()
+  const timer = BgTimer.setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(url, {method: "GET", signal: controller.signal})
+  } finally {
+    BgTimer.clearTimeout(timer)
+  }
+}
 const MAPBOX_SEARCHBOX_RETRIEVE = "https://api.mapbox.com/search/searchbox/v1/retrieve"
 
 /**
@@ -818,7 +832,7 @@ async function placeAutocompleteViaSearchBox(
   sessionToken: string,
 ): Promise<{
   ok: boolean
-  suggestions?: Array<{placeId: string; mainText: string; secondaryText: string}>
+  suggestions?: Array<{placeId: string; mainText: string; secondaryText: string; distanceMeters?: number}>
   error?: string
 }> {
   if (!query.trim()) return {ok: true, suggestions: []}
@@ -837,11 +851,14 @@ async function placeAutocompleteViaSearchBox(
     types: "poi,address,place,street",
     limit: "10",
   })
-  // Mapbox wants lng,lat for proximity bias.
-  if (near) params.set("proximity", `${near.lng},${near.lat}`)
+  // Mapbox wants lng,lat for proximity bias; `origin` adds per-suggestion distance.
+  if (near) {
+    params.set("proximity", `${near.lng},${near.lat}`)
+    params.set("origin", `${near.lng},${near.lat}`)
+  }
 
   try {
-    const res = await fetch(`${MAPBOX_SEARCHBOX_SUGGEST}?${params.toString()}`, {method: "GET"})
+    const res = await fetchWithTimeout(`${MAPBOX_SEARCHBOX_SUGGEST}?${params.toString()}`, PLACE_SEARCH_TIMEOUT_MS)
     if (!res.ok) return {ok: false, error: `Search Box suggest ${res.status}`}
     const json = (await res.json()) as {
       suggestions?: Array<{
@@ -849,6 +866,7 @@ async function placeAutocompleteViaSearchBox(
         name?: string
         place_formatted?: string
         full_address?: string
+        distance?: number
       }>
     }
     const suggestions = (json.suggestions ?? [])
@@ -857,6 +875,7 @@ async function placeAutocompleteViaSearchBox(
         placeId: s.mapbox_id,
         mainText: s.name ?? "",
         secondaryText: s.place_formatted ?? s.full_address ?? "",
+        ...(typeof s.distance === "number" ? {distanceMeters: s.distance} : {}),
       }))
     return {ok: true, suggestions}
   } catch (err) {
@@ -890,9 +909,10 @@ async function placeDetailsViaSearchBox(
   }
   const params = new URLSearchParams({access_token: token, session_token: sessionToken})
   try {
-    const res = await fetch(`${MAPBOX_SEARCHBOX_RETRIEVE}/${encodeURIComponent(placeId)}?${params.toString()}`, {
-      method: "GET",
-    })
+    const res = await fetchWithTimeout(
+      `${MAPBOX_SEARCHBOX_RETRIEVE}/${encodeURIComponent(placeId)}?${params.toString()}`,
+      PLACE_SEARCH_TIMEOUT_MS,
+    )
     if (!res.ok) return {ok: false, error: `Search Box retrieve ${res.status}`}
     const json = (await res.json()) as {
       features?: Array<{

package/src/services/appStateBackupFile.ts

@@ -0,0 +1,171 @@
+/**
+ * App state backup files: the share-sheet export and file-picker restore
+ * behind Settings > Profile > Backup. What goes in the file is decided in
+ * AppStateBackup.ts; this side reads and writes the live stores.
+ */
+
+import type {MemoryImportResult} from "@glassly/miniapp"
+import {File, Paths} from "expo-file-system"
+import {Platform} from "react-native"
+import Share from "react-native-share"
+
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {useAppStatusStore} from "../stores/apps"
+import {storage} from "../utils/storage/storage"
+import appRegistry, {saveAlwaysOnOverride, saveWidgetExpandChoice} from "./AppRegistry"
+import {
+  AppStateBackupError,
+  collectAppStateBackup,
+  miniappPrefs,
+  miniappsWithStorage,
+  parseAppStateBackup,
+  restorableSettings,
+  restoreMiniappStorage,
+  type AppStateBackupBackend,
+} from "./AppStateBackup"
+import {cloudClientService} from "./CloudClientService"
+import {memoryStore} from "./memoryStoreInstance"
+import {respawnMiniapp, runningMiniappPackages, stopMiniapp} from "./MiniappEngine"
+
+export interface AppStateExportResult {
+  success: boolean
+  cancelled?: boolean
+}
+
+export interface AppStateRestoreResult {
+  /** Settings written. */
+  settings: number
+  /** Miniapps whose storage was restored. */
+  miniapps: number
+  memory: MemoryImportResult | null
+  /** Installed when the backup was made but not on this phone now. */
+  missing: string[]
+}
+
+export interface AppStateRestoreOptions {
+  /**
+   * Install what the backup had installed and this phone lacks. Runs before
+   * the restored miniapps start again, so the dashboard comes back with every
+   * widget provider its saved layout names: it drops unknown widgets from the
+   * layout the next time it saves it.
+   */
+  reinstall?: (packageNames: string[]) => Promise<void>
+}
+
+const PICK_MIME_TYPES =
+  Platform.OS === "android" ? ["application/json", "application/octet-stream"] : ["application/json"]
+
+const backend: AppStateBackupBackend = {
+  get(key) {
+    const result = storage.load<unknown>(key)
+    return result.is_ok() ? result.value : null
+  },
+  set(key, value) {
+    const result = storage.save(key, value)
+    if (result.is_error()) throw result.error
+  },
+  keys: () => storage.getAllKeys(),
+}
+
+export async function exportAppStateFile(): Promise<AppStateExportResult> {
+  const userId = await cloudClientService.resolveUserId()
+  const installed: Array<{packageName: string; version: string; source?: string}> = []
+  for (const app of await appRegistry.getInstalledMiniapps()) {
+    const version = await appRegistry.getActiveVersion(app.packageName)
+    if (!version) continue
+    installed.push({
+      packageName: app.packageName,
+      version,
+      source: appRegistry.getReleaseIdentity(app.packageName, version)?.source,
+    })
+  }
+  const backup = collectAppStateBackup({
+    backend,
+    userId,
+    settings: Object.values(SETTINGS),
+    installed,
+    memory: await memoryStore.exportBackup(),
+    now: Date.now(),
+  })
+
+  const filename = `glassly-backup-${localDate(backup.exportedAt)}.json`
+  const file = new File(Paths.cache, filename)
+  file.writeSync(JSON.stringify(backup))
+  try {
+    await Share.open({url: file.uri, type: "application/json", filename, title: "Glassly backup"})
+    return {success: true}
+  } catch (error: any) {
+    // react-native-share rejects when the user dismisses the sheet.
+    if (error?.message?.includes("User did not share")) return {success: false, cancelled: true}
+    throw error
+  }
+}
+
+/** Resolves null when the user cancels the picker. */
+export async function importAppStateFile(opts: AppStateRestoreOptions = {}): Promise<AppStateRestoreResult | null> {
+  const picked = await File.pickFileAsync({mimeTypes: PICK_MIME_TYPES})
+  if (picked.canceled) return null
+  let data: unknown
+  try {
+    data = JSON.parse(await picked.result.text())
+  } catch {
+    throw new AppStateBackupError("Not a Glassly app state backup")
+  }
+  const backup = parseAppStateBackup(data)
+  const userId = await cloudClientService.resolveUserId()
+
+  // First, so a memory section this build rejects fails the restore before anything is written.
+  const memory = backup.memory ? await memoryStore.importBackup(backup.memory) : null
+
+  const {plain, indexed} = restorableSettings(backup, Object.values(SETTINGS))
+  const written = await useSettingsStore.getState().setManyLocally(plain)
+  if (written.is_error()) throw written.error
+  // setManyLocally only takes registry keys; `key:index` values go to storage and the store directly.
+  for (const [key, value] of Object.entries(indexed)) backend.set(key, value)
+  if (Object.keys(indexed).length > 0) {
+    useSettingsStore.setState((state) => ({settings: {...state.settings, ...indexed}}))
+  }
+
+  // A running miniapp holds its old values in memory and could write them back over the
+  // restore, so the ones getting storage stop now and start again at the end.
+  const running = new Set(runningMiniappPackages())
+  const restarting = miniappsWithStorage(backup).filter((packageName) => running.has(packageName))
+  for (const packageName of restarting) await stopMiniapp(packageName)
+
+  try {
+    const restored = restoreMiniappStorage(backend, userId, backup)
+
+    const apps = useAppStatusStore.getState()
+    for (const [packageName, record] of Object.entries(backup.miniapps)) {
+      const prefs = miniappPrefs(record)
+      if (prefs.hidden !== undefined) apps.setHiddenStatus(packageName, prefs.hidden)
+      if (prefs.alwaysOn !== undefined) saveAlwaysOnOverride(packageName, prefs.alwaysOn)
+      for (const [widgetId, expand] of Object.entries(prefs.widgetExpand)) {
+        saveWidgetExpandChoice(packageName, widgetId, expand)
+      }
+    }
+    appRegistry.markRefreshNeeded()
+    await apps.refresh()
+
+    const installedNow = new Set((await appRegistry.getInstalledMiniapps()).map((app) => app.packageName))
+    const missing = Object.entries(backup.miniapps)
+      .filter(([packageName, record]) => record.installed && !installedNow.has(packageName))
+      .map(([packageName]) => packageName)
+    if (missing.length > 0) await opts.reinstall?.(missing)
+
+    return {
+      settings: Object.keys(plain).length + Object.keys(indexed).length,
+      miniapps: restored.packages.length,
+      memory,
+      missing,
+    }
+  } finally {
+    for (const packageName of restarting) await respawnMiniapp(packageName)
+  }
+}
+
+function localDate(ms: number): string {
+  const d = new Date(ms)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}