@glassly/engine 0.1.0-dev.99 → 0.2.8-dev.445

package/src/services/LocalSttFallbackCoordinator.ts

@@ -46,6 +46,7 @@ class LocalSttFallbackCoordinator {
    */
   private cloudConnected = true
   private localActive = false
+  private starting: Promise<void> | null = null
   private cloudAdapterAttached = false
   /**
    * Soniox-direct (user API key) state, pushed by SonioxDirectService. While
@@ -71,6 +72,17 @@ class LocalSttFallbackCoordinator {
     // registered a subscription.
     useSettingsStore.getState().setSetting(ISLAND_SETTINGS_KEYS.localSttFallbackActive, false)
     useSettingsStore.getState().setSetting(ISLAND_SETTINGS_KEYS.localSttFallbackReason, "")
+    sttModelManager.onModelReady(() => {
+      void this.retryAfterModelReady()
+    })
+  }
+
+  private async retryAfterModelReady(): Promise<void> {
+    // A model can finish downloading while the initial availability check is
+    // still pending. Wait for that attempt before retrying so readiness is
+    // never lost and native restarts cannot overlap.
+    await this.starting
+    await this.reconcile()
   }
 
   /**
@@ -170,7 +182,12 @@ class LocalSttFallbackCoordinator {
     this.attachCloudAdapterIfReady()
     const shouldBeActive = this.shouldUseLocalStt()
     if (shouldBeActive && !this.localActive) {
-      await this.startLocalStt()
+      if (!this.starting) {
+        this.starting = this.startLocalStt().finally(() => {
+          this.starting = null
+        })
+      }
+      await this.starting
     } else if (!shouldBeActive && this.localActive) {
       this.stopLocalStt(this.hasTranscriptionSubscription ? "primary transcription recovered" : "subscription gone")
     } else if (shouldBeActive && this.localActive) {
@@ -203,6 +220,14 @@ class LocalSttFallbackCoordinator {
 
   private async startLocalStt(): Promise<void> {
     this.log("starting local stt")
+    try {
+      await this.activateLocalStt()
+    } catch (err) {
+      this.log(`local stt startup failed: ${err}`)
+    }
+  }
+
+  private async activateLocalStt(): Promise<void> {
     const modelAvailable = await sttModelManager.isModelAvailable()
     if (!modelAvailable) {
       this.log("local stt model is not available yet — skipping activation")
@@ -212,12 +237,8 @@ class LocalSttFallbackCoordinator {
       this.log("local stt activation skipped: routing changed before start completed")
       return
     }
-    try {
-      // Direct btsdk call now (was a host restartTranscriber hook).
-      await BluetoothSdk.restartTranscriber()
-    } catch (err) {
-      this.log(`restartTranscriber failed: ${err}`)
-    }
+    // Native rejects unless the recognizer and its processing loop are ready.
+    await BluetoothSdk.restartTranscriber()
     if (!this.shouldUseLocalStt()) {
       this.log("local stt activation skipped: routing changed during transcriber restart")
       return

package/src/services/MemoryStore.ts

@@ -21,11 +21,18 @@ import type {MemoryEntry, MemoryNoteSource, MemorySession, MemorySummary} from "
 
 import {searchMemoryEntries} from "../utils/memory/search"
 
+import {BgTimer} from "../utils/timers"
+
 const KEY_ROOT = "memory_"
 const LOG_SUFFIX = "log"
 const SUMMARY_SUFFIX = "summaries"
 
-/** The pre-memory-layer Assist miniapp whose storage namespace we migrate. */
+/**
+ * The pre-memory-layer Assist miniapp whose storage namespace we migrate.
+ * Assist now ships as com.glassly.assistant; the timeline it reads is
+ * user-scoped (KEY_ROOT below), so the rename needs no second migration and
+ * this constant stays pinned to the old namespace.
+ */
 const LEGACY_ASSIST_PACKAGE = "com.tetramo.assistant"
 const LEGACY_STORAGE_ROOT = "localstorage_"
 const LEGACY_LOG_KEY = "assistant:session-log"
@@ -36,36 +43,17 @@ const LEGACY_TRANSCRIPT_KEY = "assistant:transcript-log"
 const LEGACY_NOTES_KEY = "assistant:notes"
 
 const HOUR_MS = 60 * 60 * 1000
-const DAY_MS = 24 * HOUR_MS
-
-/**
- * How much timeline a tier can SEE. Retention gating is a read window, not a
- * delete: pruning always keeps {@link EXTENDED_RETENTION}'s worth of data, and
- * the active policy decides how far back reads reach. A lapsed subscriber's
- * older timeline is frozen, not lost — upgrading again restores it instantly.
- */
-export interface MemoryRetentionPolicy {
-  maxAgeMs: number
-  maxEntries: number
-  maxSummaries: number
-}
-
-/** Free-tier visibility: a 14-day rolling window. */
-export const STANDARD_RETENTION: MemoryRetentionPolicy = {
-  maxAgeMs: 14 * DAY_MS,
-  maxEntries: 4000,
-  maxSummaries: 24 * 14,
-}
 
 /**
- * Plus/Pro visibility — and the store's PHYSICAL bounds for every tier. The
- * entry cap also bounds the write cost — every persist re-serializes the
- * whole timeline, so this cap is a perf ceiling as much as a product number.
+ * Physical bounds. There is no age cap: the timeline stays until the user
+ * deletes it (clear()/removeScope). The entry cap bounds the write cost —
+ * every persist re-serializes the whole timeline, so it is a perf ceiling as
+ * much as a product number — and the summary cap keeps one row per hour for
+ * about half a year of round-the-clock use, far longer at a normal pace.
  */
-export const EXTENDED_RETENTION: MemoryRetentionPolicy = {
-  maxAgeMs: 180 * DAY_MS,
+export const MEMORY_BOUNDS = {
   maxEntries: 24_000,
-  maxSummaries: 24 * 180,
+  maxSummaries: 4320,
 }
 const QUERY_LIMIT_CAP = 200
 const QUERY_LIMIT_DEFAULT = 60
@@ -92,13 +80,6 @@ export interface MemoryStoreHooks {
    * utterance. Set to 0 to persist synchronously (tests).
    */
   writeDebounceMs?: number
-  /**
-   * Visibility policy resolver, consulted at every read. A function (not a
-   * value) so the host can flip between STANDARD and EXTENDED as the user's
-   * subscription changes without rebuilding the store. Absent = standard.
-   * Never affects what is STORED — pruning is fixed at EXTENDED bounds.
-   */
-  getRetention?: () => MemoryRetentionPolicy
 }
 
 export interface MemoryStats {
@@ -132,7 +113,7 @@ export class MemoryStore {
   private loadPromise: Promise<void> | null = null
   private readonly changeListeners = new Set<() => void>()
   /** Pending debounced log write (transcript appends), if any. */
-  private logFlushTimer: ReturnType<typeof setTimeout> | null = null
+  private logFlushTimer: number | null = null
   private logDirty = false
 
   constructor(private readonly hooks: MemoryStoreHooks) {}
@@ -143,7 +124,7 @@ export class MemoryStore {
    */
   async flush(): Promise<void> {
     if (this.logFlushTimer) {
-      clearTimeout(this.logFlushTimer)
+      BgTimer.clearTimeout(this.logFlushTimer)
       this.logFlushTimer = null
     }
     if (this.logDirty) await this.persistLog()
@@ -257,7 +238,7 @@ export class MemoryStore {
 
   async addSummary(summary: MemorySummary): Promise<void> {
     await this.ensureLoaded()
-    const {maxSummaries} = EXTENDED_RETENTION
+    const {maxSummaries} = MEMORY_BOUNDS
     this.summaries = this.summaries.filter((s) => s.hourStart !== summary.hourStart)
     this.summaries.push(summary)
     if (this.summaries.length > maxSummaries) {
@@ -267,35 +248,29 @@ export class MemoryStore {
     this.emitChanged()
   }
 
-  // === Reads ===
-  //
-  // Every read goes through the VISIBLE view: entries inside the active
-  // tier's window. Older data may still be stored (see prune) — it is frozen,
-  // not deleted, so an upgrade widens these views instantly.
+  // === Reads === (the whole stored timeline; nothing is hidden by age)
 
   /** Entries in [sinceMs, untilMs), newest last. */
   async window(sinceMs: number, untilMs: number = Date.now()): Promise<MemoryEntry[]> {
     await this.ensureLoaded()
-    return this.visibleEntries().filter((e) => e.at >= sinceMs && e.at < untilMs)
+    return this.entries.filter((e) => e.at >= sinceMs && e.at < untilMs)
   }
 
   /** All note entries, newest first (Settings > Memory list). */
   async notes(): Promise<MemoryEntry[]> {
     await this.ensureLoaded()
-    return this.visibleEntries()
-      .filter((e) => e.kind === "note")
-      .sort((a, b) => b.at - a.at)
+    return this.entries.filter((e) => e.kind === "note").sort((a, b) => b.at - a.at)
   }
 
   async stats(): Promise<MemoryStats> {
     await this.ensureLoaded()
-    const visible = this.visibleEntries()
+    const visible = this.entries
     const noteCount = visible.filter((e) => e.kind === "note").length
     return {
       entryCount: visible.length,
       lineCount: visible.length - noteCount,
       noteCount,
-      summaryCount: this.visibleSummaries().filter((s) => s.text.trim()).length,
+      summaryCount: this.summaries.filter((s) => s.text.trim()).length,
       oldestAt: visible.length > 0 ? visible[0].at : null,
     }
   }
@@ -304,13 +279,13 @@ export class MemoryStore {
   async sessionList(): Promise<MemorySession[]> {
     await this.ensureLoaded()
     const byHour = new Map<number, MemoryEntry[]>()
-    for (const e of this.visibleEntries()) {
+    for (const e of this.entries) {
       const h = hourStartOf(e.at)
       const list = byHour.get(h) ?? []
       list.push(e)
       byHour.set(h, list)
     }
-    const summaryByHour = new Map(this.visibleSummaries().map((s) => [s.hourStart, s.text]))
+    const summaryByHour = new Map(this.summaries.map((s) => [s.hourStart, s.text]))
     return [...byHour.entries()]
       .map(([hourStart, entries]) => {
         entries.sort((a, b) => a.at - b.at)
@@ -355,7 +330,7 @@ export class MemoryStore {
   }): Promise<{entries: MemoryEntry[]; windowCount: number}> {
     await this.ensureLoaded()
     const limit = q.limit && q.limit > 0 ? Math.min(q.limit, QUERY_LIMIT_CAP) : QUERY_LIMIT_DEFAULT
-    return searchMemoryEntries(this.visibleEntries(), {
+    return searchMemoryEntries(this.entries, {
       sinceMs: q.sinceMs,
       untilMs: q.untilMs,
       contains: q.contains,
@@ -366,7 +341,7 @@ export class MemoryStore {
 
   async summaryList(): Promise<MemorySummary[]> {
     await this.ensureLoaded()
-    return this.visibleSummaries().sort((a, b) => b.hourStart - a.hourStart)
+    return [...this.summaries].sort((a, b) => b.hourStart - a.hourStart)
   }
 
   /** Most recent COMPLETED hour with lines but no summary, or null. */
@@ -375,7 +350,7 @@ export class MemoryStore {
     const currentHour = hourStartOf(nowMs)
     const summarized = new Set(this.summaries.map((s) => s.hourStart))
     const hours = new Set<number>()
-    for (const e of this.visibleEntries()) {
+    for (const e of this.entries) {
       if (e.kind !== "line") continue
       const h = hourStartOf(e.at)
       if (h < currentHour && !summarized.has(h)) hours.add(h)
@@ -513,32 +488,9 @@ export class MemoryStore {
     }
   }
 
-  private retention(): MemoryRetentionPolicy {
-    return this.hooks.getRetention?.() ?? STANDARD_RETENTION
-  }
-
-  /** Entries inside the active tier's visibility window, oldest first. */
-  private visibleEntries(): MemoryEntry[] {
-    const cutoff = Date.now() - this.retention().maxAgeMs
-    return this.entries.filter((e) => e.at >= cutoff)
-  }
-
-  private visibleSummaries(): MemorySummary[] {
-    const cutoff = Date.now() - this.retention().maxAgeMs
-    return this.summaries.filter((s) => s.hourStart >= cutoff)
-  }
-
-  /**
-   * Physical bounds, ALWAYS the extended policy regardless of tier. A free or
-   * lapsed user's older timeline stays on disk (reads just can't see past
-   * their window) so upgrading — or re-upgrading — restores it rather than
-   * finding it deleted. Deleting remains the user's call: clear()/removeScope
-   * operate on the physical store.
-   */
+  /** Keep the newest MEMORY_BOUNDS.maxEntries; nothing goes for age — deleting is the user's call. */
   private prune(): void {
-    const {maxAgeMs, maxEntries} = EXTENDED_RETENTION
-    const cutoff = Date.now() - maxAgeMs
-    this.entries = this.entries.filter((e) => e.at >= cutoff)
+    const {maxEntries} = MEMORY_BOUNDS
     if (this.entries.length > maxEntries) this.entries = this.entries.slice(-maxEntries)
   }
 
@@ -560,7 +512,7 @@ export class MemoryStore {
     }
     this.logDirty = true
     if (this.logFlushTimer) return
-    this.logFlushTimer = setTimeout(() => {
+    this.logFlushTimer = BgTimer.setTimeout(() => {
       this.logFlushTimer = null
       void this.persistLog().catch((err) =>
         console.warn("MemoryStore: debounced log write failed:", err instanceof Error ? err.message : err),
@@ -572,7 +524,7 @@ export class MemoryStore {
     // Any write of the full array satisfies whatever the debounce was holding.
     this.logDirty = false
     if (this.logFlushTimer) {
-      clearTimeout(this.logFlushTimer)
+      BgTimer.clearTimeout(this.logFlushTimer)
       this.logFlushTimer = null
     }
     if (this.loadedUserId == null) return

package/src/services/MiniappEngine.ts

@@ -1,5 +1,5 @@
 /**
- * MiniappEngine — constructs the GlasslyJS router singletons (crash controller,
+ * MiniappEngine — constructs the JSRuntime router singletons (crash controller,
  * UI router, JS router), binds them to the native Crust module + the launcher,
  * wires the dev-server background-respawn signal, and starts the message pump.
  *
@@ -40,7 +40,7 @@ function wireDevServerRespawnBackground(router: JSRouter, uiRouter: UIRouter): v
       // hot-reload.
       const resolved = await miniappLauncher.resolveBundle(packageName)
       if (!resolved) {
-        console.warn(`GlasslyJS: respawn-bg could not resolve bundle for ${packageName}`)
+        console.warn(`JSRuntime: respawn-bg could not resolve bundle for ${packageName}`)
         return
       }
       // Force a respawn (kill + spawn) rather than launcher.ensureRunning,
@@ -51,7 +51,7 @@ function wireDevServerRespawnBackground(router: JSRouter, uiRouter: UIRouter): v
         installedManifest: resolved.installedManifest,
       })
       if (!ok) {
-        console.warn(`GlasslyJS: respawn-bg failed for ${packageName}`)
+        console.warn(`JSRuntime: respawn-bg failed for ${packageName}`)
         return
       }
       // The respawned JSContext is a fresh MiniappSession with ui.bound false.
@@ -60,13 +60,13 @@ function wireDevServerRespawnBackground(router: JSRouter, uiRouter: UIRouter): v
       // instead of being dropped while unbound.
       uiRouter.notifyReopen(packageName)
     } catch (e) {
-      console.warn(`GlasslyJS: respawn-bg threw for ${packageName}:`, e)
+      console.warn(`JSRuntime: respawn-bg threw for ${packageName}:`, e)
     }
   })
 }
 
 /**
- * Construct (once) and return the GlasslyJS engine singletons. Starts the router's
+ * Construct (once) and return the JSRuntime engine singletons. Starts the router's
  * message pump on first call. Subsequent calls return the same instances.
  */
 export function ensureMiniappEngine(): MiniappEngine {
@@ -112,7 +112,7 @@ export function ensureMiniappEngine(): MiniappEngine {
   return engine
 }
 
-/** Stop the GlasslyJS message pump and tear down router-managed JSContexts. */
+/** Stop the JSRuntime message pump and tear down router-managed JSContexts. */
 export async function stopMiniappEngine(): Promise<void> {
   const current = engine
   if (!current) return
@@ -131,7 +131,7 @@ export async function stopMiniappEngine(): Promise<void> {
       try {
         await current.router.unregister(packageName)
       } catch (err) {
-        console.warn(`GlasslyJS: failed to unregister ${packageName} during stop:`, err)
+        console.warn(`JSRuntime: failed to unregister ${packageName} during stop:`, err)
       }
     }),
   )

package/src/services/MiniappLauncher.ts

@@ -25,11 +25,13 @@
 
 import {File} from "expo-file-system"
 
+import {permissions} from "../facades/permissions"
 import {decideDevLaunchRoute} from "../utils/devMiniappLaunch"
 import {storage} from "../utils/storage/storage"
 import appRegistry, {getLocalAppRunningState, saveLocalAppRunningState} from "./AppRegistry"
 import devServerBridge from "./DevServerBridge"
 import localMiniappRuntime, {type InstalledMiniappManifest} from "./LocalMiniappRuntime"
+import type {MiniappLaunchSource} from "@glassly/miniapp"
 import type {JSRouter} from "./JSRouter"
 
 interface LauncherDeps {
@@ -42,6 +44,8 @@ export interface LaunchHints {
   devUrl?: string
   version?: string
   devPort?: string
+  /** Who started the app; reported to the miniapp on connect. */
+  launchSource?: MiniappLaunchSource
 }
 
 /** Everything the launcher resolved for a package — bg source + UI entry. */
@@ -257,6 +261,7 @@ class MiniappLauncher {
       const ok = await router.spawnAndRegister(packageName, resolved.bgSource, {
         permissions: resolved.declaredPermissions,
         installedManifest: resolved.installedManifest,
+        launchSource: hints?.launchSource,
       })
       if (!ok) {
         throw new Error(`MiniappLauncher: spawn failed for ${packageName}`)
@@ -298,6 +303,11 @@ class MiniappLauncher {
    * Not compatibility-gated: a previously-running background app shouldn't be
    * dropped just because glasses are momentarily disconnected at boot — it
    * resumes when they reconnect, same as mid-session.
+   *
+   * Persistent apps (the dashboard) start whether or not they were running
+   * when the app was last killed, and get a switcher card like any other app.
+   * Both restore paths skip apps missing required OS permissions without
+   * prompting or clearing their saved running/persistent choice.
    */
   async autostartLocalMiniapps(): Promise<void> {
     const apps = await appRegistry.getInstalledMiniapps()
@@ -306,8 +316,22 @@ class MiniappLauncher {
       // built-ins (`local:false, offline:true`) restore their native running
       // state elsewhere and have no bundle to launch.
       if (!app.local) continue
-      if (!getLocalAppRunningState(app.packageName)) continue
+      if (!app.persistent && !getLocalAppRunningState(app.packageName)) continue
       if (this.isRunning(app.packageName)) continue
+      try {
+        const missing = await permissions.missingRequired(app.permissions ?? [])
+        if (missing.length > 0) {
+          console.info(
+            `MiniappLauncher: skipping autostart for ${app.packageName} — missing required permissions: ${missing.join(
+              ", ",
+            )}`,
+          )
+          continue
+        }
+      } catch (e) {
+        console.warn(`MiniappLauncher: skipping autostart for ${app.packageName} — permission check failed`, e)
+        continue
+      }
       try {
         await this.ensureRunning(app.packageName)
       } catch (e) {

package/src/services/MirrorService.ts

@@ -0,0 +1,139 @@
+import type {MirrorSnapshot} from "@glassly/miniapp"
+
+import {displayMirror} from "../facades/displayMirror"
+import {useDisplayStore} from "../stores/display"
+import {useGlassesStore} from "../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../stores/settings"
+import {DeviceTypes} from "../types"
+import {BgTimer} from "../utils/timers"
+import displayProcessor from "./DisplayProcessor"
+import {getEffectiveCapabilities} from "./effectiveCapabilities"
+import {isGlassesConnected} from "./GlassesReadiness"
+import {buildMirrorSnapshot} from "./mirrorSnapshot"
+
+/** One host-wide preview producer, observed only while miniapps subscribe. */
+class MirrorService {
+  private revision = 0
+  private lastKey = ""
+  private lastEvent: unknown
+  private snapshot: MirrorSnapshot | null = null
+  private model: string | null = null
+  private initialized = false
+  private listeners = new Set<(snapshot: MirrorSnapshot) => void>()
+  private stops: Array<() => void> = []
+  private lastEmittedRevision = 0
+  private pendingEvent: unknown
+  private pendingFrames = 0
+  private timer: ReturnType<typeof BgTimer.setTimeout> | null = null
+
+  private selectedModel(): string | null {
+    return (
+      (useSettingsStore.getState().getSetting(SETTINGS.default_wearable.key) as string) ||
+      useGlassesStore.getState().deviceModel ||
+      null
+    )
+  }
+
+  initialize(): void {
+    if (this.initialized) return
+    this.initialized = true
+    this.model = this.selectedModel()
+    // Keep stale content from a previous pair out of queries, even when no
+    // preview is open. No frame serialization runs in these observers.
+    const invalidateModel = () => {
+      const model = this.selectedModel()
+      if (model === this.model) return
+      this.model = model
+      this.invalidate("device-changed")
+    }
+    useGlassesStore.subscribe(invalidateModel)
+    useSettingsStore.subscribe(invalidateModel)
+  }
+
+  invalidate(reason: string): void {
+    useDisplayStore.getState().setDisplayEvent({layout: {layoutType: "unavailable", reason}})
+  }
+
+  current(): MirrorSnapshot {
+    this.initialize()
+    const gs = useGlassesStore.getState()
+    const model = this.selectedModel()
+    const event = useDisplayStore.getState().currentEvent
+    const connected = isGlassesConnected(gs.connection)
+    const canvas = getEffectiveCapabilities((model ?? DeviceTypes.NONE) as DeviceTypes)?.display
+      ? displayMirror.canvas()
+      : null
+    const now = Date.now()
+    const key = JSON.stringify([model, connected, canvas, gs.batteryLevel, Math.floor(now / 60000)])
+    if (!this.snapshot || event !== this.lastEvent || key !== this.lastKey) {
+      this.lastEvent = event
+      this.lastKey = key
+      this.snapshot = buildMirrorSnapshot(
+        {
+          event,
+          canvas,
+          connected,
+          model,
+          battery: gs.batteryLevel,
+          measureChar: (char) => displayProcessor.measureChar(char),
+          now,
+        },
+        ++this.revision,
+      )
+    }
+    return this.snapshot
+  }
+
+  subscribe(cb: (snapshot: MirrorSnapshot) => void): () => void {
+    this.initialize()
+    this.listeners.add(cb)
+    if (this.listeners.size === 1) {
+      // Coalesce to the newest state at most every 33ms. The SDK renderer snaps
+      // across skipped revisions rather than replaying obsolete transitions.
+      const schedule = () => {
+        const event = useDisplayStore.getState().currentEvent
+        if (event !== this.pendingEvent) {
+          this.pendingEvent = event
+          this.pendingFrames++
+        }
+        if (this.timer) return
+        this.timer = BgTimer.setTimeout(() => {
+          this.timer = null
+          let next = this.current()
+          if (this.pendingFrames > 1 && next.content.kind === "scene") {
+            next = {
+              ...next,
+              content: {
+                ...next.content,
+                elements: next.content.elements.map((element) => ({...element, change: "created" as const})),
+              },
+            }
+          }
+          this.pendingFrames = 0
+          if (next.revision !== this.lastEmittedRevision) {
+            this.lastEmittedRevision = next.revision
+            for (const listener of this.listeners) listener(next)
+          }
+        }, 33)
+      }
+      this.pendingEvent = useDisplayStore.getState().currentEvent
+      this.pendingFrames = 0
+      this.stops = [
+        useDisplayStore.subscribe(schedule),
+        useGlassesStore.subscribe(schedule),
+        useSettingsStore.subscribe(schedule),
+      ]
+      const clock = BgTimer.setInterval(schedule, 1000)
+      this.stops.push(() => BgTimer.clearInterval(clock))
+    }
+    return () => {
+      this.listeners.delete(cb)
+      if (this.listeners.size) return
+      this.stops.splice(0).forEach((stop) => stop())
+      if (this.timer) BgTimer.clearTimeout(this.timer)
+      this.timer = null
+    }
+  }
+}
+
+export const mirrorService = new MirrorService()