@glassly/engine 0.3.5-dev.743 → 0.3.5-dev.746

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.3.5",
-  "releaseIdentity": "0.3.5-dev.743",
-  "releaseSetId": "glassly-0.3.5-dev.743",
-  "sourceCommit": "b3beb3b281e76f6c9e4f5b8ee34888628fa33135",
+  "releaseIdentity": "0.3.5-dev.746",
+  "releaseSetId": "glassly-0.3.5-dev.746",
+  "sourceCommit": "cac52fa70073682f25120d73f6485c77c4117efe",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/services/GlassesTouchInput.ts

@@ -5,6 +5,7 @@ import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 import {useAppStatusStore} from "../stores/apps"
 import {useGlassesStore} from "../stores/glasses"
 import {BgTimer} from "../utils/timers"
+import {hasInput2d} from "./controllers"
 import dashboardOpenTrace from "./debug/DashboardOpenTrace"
 import gestureDotsService from "./GestureDotsService"
 import {isGlassesConnected} from "./GlassesReadiness"
@@ -43,6 +44,19 @@ function shouldForwardScroll(event: TouchEvent): boolean {
   return true
 }
 
+/**
+ * Miniapps' copy of the touch: `input2d: true` when it came from a controller
+ * that swipes in two dimensions (the Neural Band), the field absent otherwise,
+ * so a 1D swipe from the temples or the ring stays tellable while a band is
+ * connected under the same gesture names.
+ */
+function toMiniapps(event: TouchEvent): TouchEvent & {input2d?: true} {
+  const id = event.controllerId
+  if (id === undefined) return event
+  const model = useGlassesStore.getState().controllers?.[id]?.model
+  return model !== undefined && hasInput2d(model) ? {...event, input2d: true} : event
+}
+
 /**
  * Route both real glasses input and phone mirror controls through the same
  * policy. A claimed gesture goes to the app holding the claim, alone; an
@@ -88,7 +102,7 @@ export function dispatchTouchEvent(event: TouchEvent): void {
     // The press may have started before this app claimed its release edge.
     gestureDotsService.noteGesture(gesture, true, event.index, event.controllerId)
     if (!shouldForwardScroll(event)) return
-    localMiniappRuntime.forwardEvent("touch_event", event, undefined, claimant)
+    localMiniappRuntime.forwardEvent("touch_event", toMiniapps(event), undefined, claimant)
     return
   }
 
@@ -98,7 +112,7 @@ export function dispatchTouchEvent(event: TouchEvent): void {
   gestureDotsService.noteGesture(gesture, false, event.index, event.controllerId)
 
   if (!shouldForwardScroll(event)) return
-  localMiniappRuntime.forwardEvent("touch_event", event)
+  localMiniappRuntime.forwardEvent("touch_event", toMiniapps(event))
 
   // Nobody claimed a double tap or a head-up: the glasses' native dashboard.
   // On eligible Glassly CFW glasses the dashboard miniapp claims both while it

package/src/services/LocalMiniappRuntime.ts

@@ -162,6 +162,13 @@ import {invokeScanQrSeam} from "../runtime/scanQrSeam"
 import {invokeWebLoginSeam} from "../runtime/webLoginSeam"
 import {normalizeStreamAudioConfig, normalizeStreamVideoConfig} from "../runtime/streamConfig"
 import {visibleActionRows} from "./manifestActions"
+import {
+  actionFailure,
+  appDeclaresAction,
+  checkActionAccess,
+  PendingActionCalls,
+  type ActionOutcome,
+} from "./actionInvoke"
 import {toLanguageHint} from "@glassly/cloud-protocol/languages"
 import {buildMiniappManifestSnapshot, type MiniappRuntimeDiagnosticSnapshot} from "../utils/miniappDiagnostics"
 import ttsModelManager from "./TTSModelManager"
@@ -6021,10 +6028,7 @@ class LocalMiniappRuntime {
   private static readonly ACTION_PAYLOAD_CAP = 256 * 1024
 
   /** Outstanding action invocations, keyed by host-generated callId. */
-  private actionCalls = new Map<
-    string,
-    {callerPackageName: string; targetPackageName: string; callerRequestId?: string; timer: number}
-  >()
+  private actionCalls = new PendingActionCalls(BgTimer, (value) => this.actionPayloadTooLarge(value))
   private actionCallSeq = 0
 
   private interopApps(): ClientApp[] {
@@ -6596,111 +6600,118 @@ class LocalMiniappRuntime {
     }
   }
 
+  /** Floored at 6s: a freshly-woken target buffers an undelivered ACTION_CALL for 5s (HANDLER_WAIT_MS in @glassly/miniapp's actions module) + 1s for the reply. Keep in sync. */
+  private static clampActionTimeout(raw: unknown): number {
+    return Math.min(Math.max(Number(raw) || 30_000, 6_000), 120_000)
+  }
+
+  /** Caller identity the host presents for host-initiated actions (a system caller). */
+  private static readonly HOST_ACTION_CALLER = "host"
+
+  /** Installed, compatible, and declares the action — the same gates `invokeActionFromHost` applies up front. */
+  public hostActionAvailable(targetPackageName: string, actionId: string): boolean {
+    return appDeclaresAction(
+      this.interopApps().find((a) => a.packageName === targetPackageName),
+      actionId,
+    )
+  }
+
   /**
-   * session.actions.invoke → wake the target headlessly, deliver an ACTION_CALL,
-   * and correlate its ACTION_RESULT back to the caller's pending request.
+   * Host-initiated action call (e.g. the watch remote): same gates, headless
+   * wake and ACTION_CALL/ACTION_RESULT correlation as a miniapp's
+   * session.actions.invoke, with the host as a system caller.
+   * Rejects with an Error whose `code` is a MiniappErrorCode.
    */
+  public async invokeActionFromHost(
+    targetPackageName: string,
+    actionId: string,
+    params: Record<string, unknown> = {},
+    timeoutMs?: number,
+  ): Promise<unknown> {
+    const outcome = await this.runActionInvoke(
+      LocalMiniappRuntime.HOST_ACTION_CALLER,
+      true,
+      targetPackageName,
+      actionId,
+      params,
+      LocalMiniappRuntime.clampActionTimeout(timeoutMs),
+    )
+    if (outcome.ok) return outcome.data
+    throw Object.assign(new Error(outcome.error.message), {code: outcome.error.code})
+  }
+
+  /** session.actions.invoke → run the call, then relay the outcome to the caller's pending request. */
   private async handleActionInvoke(
     callerPackageName: string,
     payload: Record<string, unknown>,
     requestId?: string,
   ): Promise<void> {
-    const target = payload.targetPackageName as string | undefined
-    const actionId = payload.actionId as string | undefined
-    const params = (payload.params as Record<string, unknown> | undefined) ?? {}
-    // Floor the timeout at 6s so the host never rejects with ACTION_TIMEOUT before
-    // the target SDK's handler-registration window closes. A freshly-woken miniapp
-    // buffers an undelivered ACTION_CALL for HANDLER_WAIT_MS (5s in @glassly/miniapp's
-    // actions module) waiting for session.actions.handle; a shorter host timeout
-    // could fire while the target is still registering, then the action would run
-    // with no caller left to receive its result. 6s = that 5s buffer + 1s for the
-    // ACTION_RESULT/NO_ACTION_HANDLER reply to travel back. Keep these in sync.
-    const timeoutMs = Math.min(Math.max(Number(payload.timeoutMs) || 30_000, 6_000), 120_000)
+    const outcome = await this.runActionInvoke(
+      callerPackageName,
+      this.isSystemPackage(callerPackageName),
+      payload.targetPackageName as string | undefined,
+      payload.actionId as string | undefined,
+      (payload.params as Record<string, unknown> | undefined) ?? {},
+      LocalMiniappRuntime.clampActionTimeout(payload.timeoutMs),
+    )
+    if (outcome.ok) this.sendResult(callerPackageName, requestId, true, outcome.data)
+    else this.sendResult(callerPackageName, requestId, false, undefined, outcome.error)
+  }
+
+  /**
+   * Gate, wake the target headlessly, deliver an ACTION_CALL, and resolve when
+   * its ACTION_RESULT (or the timeout) arrives. Never rejects.
+   */
+  private async runActionInvoke(
+    callerPackageName: string,
+    callerIsSystem: boolean,
+    target: string | undefined,
+    actionId: string | undefined,
+    params: Record<string, unknown>,
+    timeoutMs: number,
+  ): Promise<ActionOutcome> {
+    const fail = actionFailure
 
     if (this.actionPayloadTooLarge(params)) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.PAYLOAD_TOO_LARGE,
-        message: "action params exceeded the 256 KB cap",
-      })
-      return
+      return fail(MiniappErrorCode.PAYLOAD_TOO_LARGE, "action params exceeded the 256 KB cap")
     }
 
     const app = target ? this.interopApps().find((a) => a.packageName === target) : undefined
-    if (!target || !app) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.APP_NOT_FOUND,
-        message: `Miniapp not found: ${target ?? "(missing targetPackageName)"}`,
-      })
-      return
-    }
-    if (!actionId) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.ACTION_NOT_FOUND,
-        message: "invoke requires an actionId",
-      })
-      return
-    }
-    if (app.compatibility && app.compatibility.isCompatible === false) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.APP_NOT_COMPATIBLE,
-        message: `${target} is not compatible with the connected glasses`,
-      })
-      islandNotifications.emit({
-        kind: "version_incompatible",
-        packageName: target,
-        reason: `${target} is not compatible with the connected glasses`,
-        metadata: {missingRequired: app.compatibility.missingRequired ?? [], via: "miniapps.invoke"},
-        timestamp: Date.now(),
-      })
-      return
-    }
-    // Declared-action gate: the target must declare the action in its manifest.
-    const declared = (app.actions ?? []).find((a) => a.id === actionId)
-    if (!declared) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.ACTION_NOT_FOUND,
-        message: `${target} does not declare action "${actionId}"`,
-      })
-      return
-    }
-    // Visibility gate: declared actions are public by default; ones marked
-    // `visibility: "system"` stay restricted to system/dev callers.
-    if (declared.visibility === "system" && !this.isSystemPackage(callerPackageName)) {
-      this.auditInterop({
-        caller: callerPackageName,
-        op: "invoke",
-        target,
-        actionId,
-        ok: false,
-        errorCode: MiniappErrorCode.NOT_PERMITTED,
-      })
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.NOT_PERMITTED,
-        message: `Action "${actionId}" on ${target} is restricted to system apps`,
-      })
-      return
+    const denied = checkActionAccess(app, target, actionId, callerIsSystem)
+    if (denied) {
+      if (denied.code === MiniappErrorCode.APP_NOT_COMPATIBLE && target && app) {
+        islandNotifications.emit({
+          kind: "version_incompatible",
+          packageName: target,
+          reason: denied.message,
+          metadata: {missingRequired: app.compatibility?.missingRequired ?? [], via: "miniapps.invoke"},
+          timestamp: Date.now(),
+        })
+      } else if (denied.code === MiniappErrorCode.NOT_PERMITTED) {
+        this.auditInterop({
+          caller: callerPackageName,
+          op: "invoke",
+          target,
+          actionId,
+          ok: false,
+          errorCode: MiniappErrorCode.NOT_PERMITTED,
+        })
+      }
+      return {ok: false, error: denied}
     }
+    if (!target || !actionId) return fail(MiniappErrorCode.INTERNAL, "unreachable")
 
     // Headless wake + wait for CONNECT (idempotent / fast if already connected).
     try {
       await this.wakeInteropApp(target)
     } catch (e) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.WAKE_FAILED,
-        message: (e as Error)?.message ?? `failed to wake ${target}`,
-      })
-      return
+      return fail(MiniappErrorCode.WAKE_FAILED, (e as Error)?.message ?? `failed to wake ${target}`)
     }
 
     // The wake waited for CONNECT, but the target could have dropped in the gap
     // before delivery — fail fast rather than arming a timer for a call that
-    // sendToMiniapp would silently drop (the caller would otherwise wait the
-    // full invoke timeout for an ACTION_CALL that was never delivered).
+    // sendToMiniapp would silently drop.
     if (!this.connectedApps.has(target)) {
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.WAKE_FAILED,
-        message: `${target} disconnected before the action could be delivered`,
-      })
       this.auditInterop({
         caller: callerPackageName,
         op: "invoke",
@@ -6709,19 +6720,12 @@ class LocalMiniappRuntime {
         ok: false,
         errorCode: MiniappErrorCode.WAKE_FAILED,
       })
-      return
+      return fail(MiniappErrorCode.WAKE_FAILED, `${target} disconnected before the action could be delivered`)
     }
 
-    // Deliver the call and arm the handler timeout; ACTION_RESULT resolves it.
+    // Deliver the call and arm the handler timeout; ACTION_RESULT settles it.
     const callId = `act-${Date.now().toString(36)}-${this.actionCallSeq++}`
-    const timer = BgTimer.setTimeout(() => {
-      this.actionCalls.delete(callId)
-      this.sendResult(callerPackageName, requestId, false, undefined, {
-        code: MiniappErrorCode.ACTION_TIMEOUT,
-        message: `action "${actionId}" timed out after ${timeoutMs}ms`,
-      })
-    }, timeoutMs)
-    this.actionCalls.set(callId, {callerPackageName, targetPackageName: target, callerRequestId: requestId, timer})
+    const outcome = this.actionCalls.register(callId, target, actionId, timeoutMs)
     this.sendToMiniapp(target, {
       type: MiniappResponseType.ACTION_CALL,
       callId,
@@ -6730,38 +6734,12 @@ class LocalMiniappRuntime {
       callerPackageName,
     })
     this.auditInterop({caller: callerPackageName, op: "invoke", target, actionId, ok: true})
+    return outcome
   }
 
-  /** Target → host: forward an ACTION_RESULT back to the caller's pending invoke. */
+  /** Target → host: settle the pending invoke for this ACTION_RESULT. */
   private handleActionResult(targetPackageName: string, payload: Record<string, unknown>): void {
-    const callId = payload.callId as string | undefined
-    if (!callId) return
-    const pending = this.actionCalls.get(callId)
-    if (!pending) return
-    // Only the invoked target may resolve this call. callIds are guessable
-    // (timestamp + seq), so a different connected miniapp must not be able to
-    // spoof a result/error for someone else's invoke.
-    if (pending.targetPackageName !== targetPackageName) return
-    this.actionCalls.delete(callId)
-    BgTimer.clearTimeout(pending.timer)
-
-    if (payload.ok === true) {
-      const result = payload.result
-      if (this.actionPayloadTooLarge(result)) {
-        this.sendResult(pending.callerPackageName, pending.callerRequestId, false, undefined, {
-          code: MiniappErrorCode.PAYLOAD_TOO_LARGE,
-          message: "action result exceeded the 256 KB cap",
-        })
-        return
-      }
-      this.sendResult(pending.callerPackageName, pending.callerRequestId, true, result ?? null)
-    } else {
-      const error = (payload.error as ({code: string; message: string} & Record<string, unknown>) | undefined) ?? {
-        code: MiniappErrorCode.INTERNAL,
-        message: "action handler error",
-      }
-      this.sendResult(pending.callerPackageName, pending.callerRequestId, false, undefined, error)
-    }
+    this.actionCalls.handleResult(targetPackageName, payload)
   }
 
   private sendResult(

package/src/services/actionInvoke.ts

@@ -0,0 +1,104 @@
+import {MiniappErrorCode} from "@glassly/miniapp"
+
+import type {ClientApp} from "../types/applet"
+
+export type ActionError = {code: string; message: string} & Record<string, unknown>
+export type ActionOutcome = {ok: true; data: unknown} | {ok: false; error: ActionError}
+
+export const actionFailure = (code: string, message: string): ActionOutcome => ({ok: false, error: {code, message}})
+
+/** Installed, compatible, and declares the action. */
+export function appDeclaresAction(app: ClientApp | undefined, actionId: string): boolean {
+  if (!app) return false
+  if (app.compatibility && app.compatibility.isCompatible === false) return false
+  return (app.actions ?? []).some((a) => a.id === actionId)
+}
+
+/**
+ * Gates shared by miniapp->miniapp invoke and host invoke. Declared actions are
+ * public by default; `visibility: "system"` ones need a system caller.
+ */
+export function checkActionAccess(
+  app: ClientApp | undefined,
+  target: string | undefined,
+  actionId: string | undefined,
+  callerIsSystem: boolean,
+): ActionError | null {
+  if (!target || !app) {
+    return {
+      code: MiniappErrorCode.APP_NOT_FOUND,
+      message: `Miniapp not found: ${target ?? "(missing targetPackageName)"}`,
+    }
+  }
+  if (!actionId) return {code: MiniappErrorCode.ACTION_NOT_FOUND, message: "invoke requires an actionId"}
+  if (app.compatibility && app.compatibility.isCompatible === false) {
+    return {
+      code: MiniappErrorCode.APP_NOT_COMPATIBLE,
+      message: `${target} is not compatible with the connected glasses`,
+    }
+  }
+  const declared = (app.actions ?? []).find((a) => a.id === actionId)
+  if (!declared) {
+    return {code: MiniappErrorCode.ACTION_NOT_FOUND, message: `${target} does not declare action "${actionId}"`}
+  }
+  if (declared.visibility === "system" && !callerIsSystem) {
+    return {
+      code: MiniappErrorCode.NOT_PERMITTED,
+      message: `Action "${actionId}" on ${target} is restricted to system apps`,
+    }
+  }
+  return null
+}
+
+export interface ActionTimers {
+  setTimeout(cb: () => void, ms: number): number
+  clearTimeout(id: number): void
+}
+
+/** Outstanding ACTION_CALLs awaiting an ACTION_RESULT, keyed by host-generated callId. */
+export class PendingActionCalls {
+  private readonly calls = new Map<string, {target: string; settle: (o: ActionOutcome) => void; timer: number}>()
+
+  constructor(
+    private readonly timers: ActionTimers,
+    private readonly payloadTooLarge: (value: unknown) => boolean,
+  ) {}
+
+  /** Register a call; resolves with its outcome, or ACTION_TIMEOUT. */
+  register(callId: string, target: string, actionId: string, timeoutMs: number): Promise<ActionOutcome> {
+    return new Promise((resolve) => {
+      const timer = this.timers.setTimeout(() => {
+        this.calls.delete(callId)
+        resolve(actionFailure(MiniappErrorCode.ACTION_TIMEOUT, `action "${actionId}" timed out after ${timeoutMs}ms`))
+      }, timeoutMs)
+      this.calls.set(callId, {target, settle: resolve, timer})
+    })
+  }
+
+  /** Settle from a target's ACTION_RESULT payload. Only the invoked target may resolve a call. */
+  handleResult(targetPackageName: string, payload: Record<string, unknown>): void {
+    const callId = payload.callId as string | undefined
+    if (!callId) return
+    const pending = this.calls.get(callId)
+    // callIds are guessable (timestamp + seq): a different miniapp must not spoof someone else's result.
+    if (!pending || pending.target !== targetPackageName) return
+    this.calls.delete(callId)
+    this.timers.clearTimeout(pending.timer)
+
+    if (payload.ok === true) {
+      if (this.payloadTooLarge(payload.result)) {
+        pending.settle(actionFailure(MiniappErrorCode.PAYLOAD_TOO_LARGE, "action result exceeded the 256 KB cap"))
+        return
+      }
+      pending.settle({ok: true, data: payload.result ?? null})
+      return
+    }
+    pending.settle({
+      ok: false,
+      error: (payload.error as ActionError | undefined) ?? {
+        code: MiniappErrorCode.INTERNAL,
+        message: "action handler error",
+      },
+    })
+  }
+}