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

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";
@@ -5253,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;
@@ -5785,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",
@@ -5891,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,
@@ -5911,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)