@glassly/engine 0.3.5-beta.710 → 0.3.5-beta.760

package/build/services/LocalMiniappRuntime.js

@@ -82,6 +82,7 @@ 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, } from "./actionInvoke";
 import { toLanguageHint } from "@glassly/cloud-protocol/languages";
 import { buildMiniappManifestSnapshot } from "../utils/miniappDiagnostics";
 import ttsModelManager from "./TTSModelManager";
@@ -438,6 +439,10 @@ class LocalMiniappRuntime {
     connectedApps = new Map();
     /** Claimed gestures (CLAIM_GESTURES): a stack per gesture, the most recent claimer holding it. */
     gestureClaims = emptyGestureClaims();
+    // The last main-view frame each app asked to render. Widget mode refuses
+    // frames and demotion clears them, and an app that has drawn once may not
+    // draw again on its own, so promotion replays this.
+    retainedRenders = new Map();
     /**
      * Packages that have completed their CONNECT handshake (sent
      * `miniapp_connect`, got `CONNECT_ACK`). Distinct from `connectedApps`,
@@ -490,7 +495,14 @@ class LocalMiniappRuntime {
     // secret never leaves the device.
     localSecret = `miniapp_${Date.now()}_${Math.random().toString(36).slice(2, 14)}`;
     usedTokens = new Set();
-    constructor() { }
+    constructor() {
+        miniappWidgetMode.subscribe((packageName, widgetOnly) => {
+            // Promotion happens inside the apps store's start(); the core-app slot
+            // settles with that store write, so replay once it has.
+            if (!widgetOnly)
+                queueMicrotask(() => this.replayRetainedRender(packageName));
+        });
+    }
     /** Snapshot of miniapps actively subscribed to hardware button events. */
     getButtonPressSubscribers() {
         return [...(this.streamSubscribers.get(MiniappStreamType.BUTTON_PRESS) ?? [])].sort();
@@ -874,7 +886,11 @@ class LocalMiniappRuntime {
         // window ends early once this app pushes its first display (see
         // LocalDisplayManager.request), or after ~1.5s. Fires once per spawn —
         // including a crash-respawn, since each spawn is a fresh "app is starting".
-        localDisplayManager.onMount(packageName, installedManifest?.name ?? packageName);
+        // A spawn for a dashboard widget is not the wearer starting the app: it draws
+        // nothing of its own, so it shows no boot text either.
+        if (!miniappWidgetMode.isWidgetOnly(packageName)) {
+            localDisplayManager.onMount(packageName, installedManifest?.name ?? packageName);
+        }
     }
     /**
      * Resolve once `packageName` has completed its CONNECT handshake. If it has
@@ -996,6 +1012,7 @@ class LocalMiniappRuntime {
         }
         // Its gesture claims go back to whoever claimed them before.
         this.applyGestureClaimChanges(dropGestureClaims(this.gestureClaims, packageName));
+        this.retainedRenders.delete(packageName);
         // Warm-up is a request-owned camera lease. Cancel it even if the app record was already
         // removed so a close racing the camera-open promise cannot leave the sensor running.
         // Keep camera teardown ordered: restoring FOV can restart the HAL, so the warm-up lease must
@@ -2124,11 +2141,6 @@ class LocalMiniappRuntime {
                 this.sendResult(packageName, requestId, true, { status: "blocked", reason: "app stopped" });
                 return;
             }
-            // A widget-only app draws through its widget alone.
-            if (miniappWidgetMode.isWidgetOnly(packageName)) {
-                this.sendResult(packageName, requestId, true, { status: "blocked", reason: "widget mode" });
-                return;
-            }
             if (!Array.isArray(payload.elements)) {
                 this.sendResult(packageName, requestId, false, undefined, {
                     code: MiniappErrorCode.INTERNAL,
@@ -2136,6 +2148,17 @@ class LocalMiniappRuntime {
                 });
                 return;
             }
+            if (payload.view !== "dashboard") {
+                if (payload.elements.length === 0)
+                    this.retainedRenders.delete(packageName);
+                else
+                    this.retainedRenders.set(packageName, payload);
+            }
+            // A widget-only app draws through its widget alone; the frame waits for promotion.
+            if (miniappWidgetMode.isWidgetOnly(packageName)) {
+                this.sendResult(packageName, requestId, true, { status: "blocked", reason: "widget mode" });
+                return;
+            }
             // The dashboard view is the overlay app's alone; anyone else's frame
             // is dropped, reported rather than silently lost.
             if (payload.view === "dashboard" && !isOverlayApp(packageName)) {
@@ -2160,6 +2183,13 @@ class LocalMiniappRuntime {
             });
         }
     }
+    /** Put a promoted app's last main-view frame on the glasses; widget mode had refused it. */
+    replayRetainedRender(packageName) {
+        const payload = this.retainedRenders.get(packageName);
+        if (!payload || !this.connectedApps.has(packageName) || miniappWidgetMode.isWidgetOnly(packageName))
+            return;
+        this.handleRender(packageName, payload);
+    }
     /**
      * display.showView: the active dashboard takes or releases the overlay
      * slot. Refused (NOT_PERMITTED) for an app that is not a dashboard;
@@ -5224,7 +5254,7 @@ class LocalMiniappRuntime {
     /** Max serialized size of an action call's params / result (256 KB). */
     static ACTION_PAYLOAD_CAP = 256 * 1024;
     /** Outstanding action invocations, keyed by host-generated callId. */
-    actionCalls = new Map();
+    actionCalls = new PendingActionCalls(BgTimer, (value) => this.actionPayloadTooLarge(value));
     actionCallSeq = 0;
     interopApps() {
         return useAppStatusStore.getState().apps;
@@ -5564,10 +5594,12 @@ class LocalMiniappRuntime {
         }
         const provider = app.packageName;
         // Record the placement before the wake so the spawn lands in widget mode
-        // and an unplace racing it cannot stop the provider early.
+        // and an unplace racing it cannot stop the provider early. A provider the
+        // store already runs (a wearer's launch still spawning, say) stays a
+        // normal run; the registry alone lags that launch.
         this.widgetPlacements = placeWidget(this.widgetPlacements, { hostPackageName, providerPackageName: provider, widgetId, box });
         miniappWidgetMode.setPlaced(provider, true);
-        if (!miniappRunningRegistry.has(provider))
+        if (!app.running && !miniappRunningRegistry.has(provider))
             miniappWidgetMode.setWidgetOnly(provider, true);
         try {
             await this.wakeInteropApp(provider);
@@ -5754,104 +5786,82 @@ class LocalMiniappRuntime {
             return false;
         }
     }
+    /** 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. */
+    static clampActionTimeout(raw) {
+        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). */
+    static HOST_ACTION_CALLER = "host";
+    /** Installed, compatible, and declares the action — the same gates `invokeActionFromHost` applies up front. */
+    hostActionAvailable(targetPackageName, actionId) {
+        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.
      */
+    async invokeActionFromHost(targetPackageName, actionId, params = {}, timeoutMs) {
+        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. */
     async handleActionInvoke(callerPackageName, payload, requestId) {
-        const target = payload.targetPackageName;
-        const actionId = payload.actionId;
-        const params = payload.params ?? {};
-        // 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, payload.actionId, payload.params ?? {}, 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.
+     */
+    async runActionInvoke(callerPackageName, callerIsSystem, target, actionId, params, timeoutMs) {
+        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?.message ?? `failed to wake ${target}`,
-            });
-            return;
+            return fail(MiniappErrorCode.WAKE_FAILED, e?.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",
@@ -5860,18 +5870,11 @@ 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,
@@ -5880,40 +5883,11 @@ 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. */
     handleActionResult(targetPackageName, payload) {
-        const callId = payload.callId;
-        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 ?? {
-                code: MiniappErrorCode.INTERNAL,
-                message: "action handler error",
-            };
-            this.sendResult(pending.callerPackageName, pending.callerRequestId, false, undefined, error);
-        }
+        this.actionCalls.handleResult(targetPackageName, payload);
     }
     sendResult(packageName, requestId, ok, data, error) {
         if (!requestId)