@mentra/miniapp 0.3.0-dev.0

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"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"}

package/dist/session.js

@@ -0,0 +1,653 @@
+/**
+ * @fileoverview MiniappSession — central session object for a local miniapp.
+ *
+ * Owns the transport, the request/response correlation map, the readiness queue,
+ * the PONG auto-reply, the visibility state, and all per-module instances.
+ *
+ * Lifecycle:
+ *   const session = new MiniappSession()
+ *   await session.connect()          // sends CONNECT, resolves on CONNECT_ACK
+ *   session.display.render([...])
+ *   ...
+ *   session.disconnect()
+ */
+import { EventEmitter } from "eventemitter3";
+import { makeRequestId, parseEnvelope, serializeEnvelope } from "./envelope";
+import { getMentraOSGlobals } from "./globals";
+import { MiniappErrorCode, MiniappRequestType, MiniappResponseType } from "./protocol";
+import { createTransport } from "./transport/auto";
+import { CameraModule } from "./modules/camera";
+import { AuthModule } from "./modules/auth";
+import { CloudModule } from "./modules/cloud";
+import { DashboardAPI } from "./modules/dashboard";
+import { DisplayManager } from "./modules/display";
+import { EventManager } from "./modules/events";
+import { GlassesModule } from "./modules/glasses";
+import { HeadingModule } from "./modules/heading";
+import { ImuModule } from "./modules/imu";
+import { InputModule } from "./modules/input";
+import { LedModule } from "./modules/led";
+import { LocationModule } from "./modules/location";
+import { MicModule } from "./modules/mic";
+import { NavigationModule } from "./modules/navigation";
+import { PermissionsModule } from "./modules/permissions";
+import { PhoneModule } from "./modules/phone";
+import { TranscriptionModule } from "./modules/transcription";
+import { TranslationModule } from "./modules/translation";
+import { UIModuleImpl } from "./modules/ui";
+import { SimpleStorage } from "./modules/storage";
+import { SpeakerModule } from "./modules/speaker";
+import { StreamModule } from "./modules/stream";
+import { SystemModule } from "./modules/system";
+import { MiniappsModule } from "./modules/miniapps";
+import { ActionsModule } from "./modules/actions";
+import { BlobModule } from "./modules/blob";
+const ALL_PERMISSION_TYPES = [
+    "location",
+    "microphone",
+    "camera",
+    "notifications",
+    "calendar",
+];
+export class NotConnectedError extends Error {
+    constructor(message = "MiniappSession is not connected") {
+        super(message);
+        this.code = MiniappErrorCode.NOT_CONNECTED;
+        this.name = "NotConnectedError";
+    }
+}
+const DEFAULT_CONNECT_TIMEOUT_MS = 10000;
+// Hard ceiling on how long a single bridge request waits for the host's
+// REQUEST_RESULT. Without it, a host that never responds (a hung cloud call, a
+// GPS fix that never arrives, a native handler that stalls) leaves the request
+// promise pending FOREVER — which is what stalled navigation at "Starting…"
+// (the controller's `starting` guard never reset because start() never settled).
+// 60s is generous: it covers a slow route computation while still guaranteeing
+// the promise eventually rejects so callers can roll back / surface an error.
+const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
+export class MiniappSession {
+    constructor(options = {}) {
+        /** Phone-declared glasses capabilities. Null until CONNECT_ACK arrives. */
+        this.capabilities = null;
+        this.userId = "";
+        this.packageName = "";
+        this.visibility = "foreground";
+        /** Host color scheme. Seeded from window.MentraOS, updated via session events. */
+        this.colorScheme = "light";
+        /** True after CONNECT_ACK. Observe with waitForReady() or the "ready" event. */
+        this.ready = false;
+        this.emitter = new EventEmitter();
+        this.authState = null;
+        this.authWaiters = new Set();
+        this.authRefreshPromise = null;
+        /**
+         * Outbound queue for anything sent before CONNECT_ACK. Flushed in FIFO order
+         * once the phone responds with CONNECT_ACK.
+         */
+        this.outboundQueue = [];
+        this.pendingRequests = new Map();
+        this.connectPromise = null;
+        this.disposed = false;
+        /** Manifest-declared permission cache. Updated on CONNECT_ACK / PERMISSIONS_UPDATE. */
+        this._permissions = {
+            location: false,
+            microphone: false,
+            camera: false,
+            notifications: false,
+            calendar: false,
+        };
+        this.transport = createTransport(options);
+        this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        const injected = getMentraOSGlobals();
+        this.packageName = options.packageName ?? injected.packageName ?? "";
+        if (injected.colorScheme === "light" || injected.colorScheme === "dark") {
+            this.colorScheme = injected.colorScheme;
+        }
+        this.auth = new AuthModule(this);
+        this.events = new EventManager(this);
+        this.speaker = new SpeakerModule(this);
+        this.camera = new CameraModule(this);
+        this.cloud = new CloudModule(this);
+        this.dashboard = new DashboardAPI(this);
+        this.display = new DisplayManager(this);
+        this.glasses = new GlassesModule(this);
+        this.heading = new HeadingModule(this);
+        this.imu = new ImuModule(this);
+        this.input = new InputModule(this);
+        this.led = new LedModule(this);
+        this.location = new LocationModule(this);
+        this.mic = new MicModule(this);
+        this.navigation = new NavigationModule(this);
+        this.permissions = new PermissionsModule(this);
+        this.phone = new PhoneModule(this);
+        this.storage = new SimpleStorage(this);
+        this.blob = new BlobModule(this);
+        this.stream = new StreamModule(this);
+        this.system = new SystemModule(this);
+        this.transcription = new TranscriptionModule(this);
+        this.translation = new TranslationModule(this);
+        this.ui = new UIModuleImpl(this);
+        this.miniapps = new MiniappsModule(this);
+        this.actions = new ActionsModule(this);
+    }
+    /**
+     * @internal — synchronous lookup against the cached manifest-declared
+     * permission record from CONNECT_ACK / PERMISSIONS_UPDATE. Domain modules
+     * use this to expose their `hasPermission` getters without going to the
+     * wire. Returns false until CONNECT_ACK arrives.
+     *
+     * `manifestKey` is the manifest's UPPER_CASE permission name
+     * (MICROPHONE, CAMERA, LOCATION, READ_NOTIFICATIONS, etc.). Maps to v3's
+     * lowercase canonical keys internally.
+     */
+    _hasManifestPermission(manifestKey) {
+        const canonical = manifestKeyToCanonical(manifestKey);
+        if (!canonical)
+            return false;
+        return this._permissions[canonical] === true;
+    }
+    /**
+     * @internal — read the current manifest-declared permission record.
+     * Powers session.permissions.getAll(). Returns a fresh shallow copy so
+     * callers can't mutate internal state.
+     */
+    _getPermissions() {
+        return { ...this._permissions };
+    }
+    /** @internal — current miniapp-scoped backend auth, if the host provided one. */
+    _getAuth() {
+        return this.authState ? { ...this.authState } : null;
+    }
+    /**
+     * @internal — wait for a scoped miniapp token. Used by session.auth; not part
+     * of the public SDK surface because authors should never manage wire events.
+     */
+    _waitForAuth(minTtlMs, timeoutMs = 10000) {
+        const current = this.authState;
+        if (current && this.authHasTtl(current, minTtlMs)) {
+            return Promise.resolve({ ...current });
+        }
+        void this.requestAuthRefresh(minTtlMs);
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                minTtlMs,
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.authWaiters.delete(waiter);
+                    reject(new NotConnectedError("Miniapp auth token is not available"));
+                }, timeoutMs),
+            };
+            this.authWaiters.add(waiter);
+        });
+    }
+    /**
+     * @internal — subscribe to a raw stream type. Domain modules call this; it
+     * delegates to the EventManager registry. Underscore prefix signals "not
+     * part of the public SDK surface — use session.mic.onAudioChunk /
+     * session.transcription.on(...)
+     * etc. instead."
+     */
+    _subscribe(streamType, handler) {
+        return this.events.subscribe(streamType, handler);
+    }
+    // -------------------------------------------------------------------------
+    // Connection lifecycle
+    // -------------------------------------------------------------------------
+    /**
+     * Connect to LocalMiniappRuntime. Idempotent — calling multiple times
+     * returns the same Promise.
+     */
+    connect() {
+        if (this.disposed) {
+            return Promise.reject(new NotConnectedError("MiniappSession was disposed"));
+        }
+        if (this.connectPromise)
+            return this.connectPromise;
+        // Register the readiness listener BEFORE any awaits so that a synchronous
+        // CONNECT_ACK delivery in tests (or the phone) can't race the subscription.
+        const readyPromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const err = new Error("MiniappSession: CONNECT_ACK timeout");
+                this.failAllPending({ code: MiniappErrorCode.NOT_CONNECTED, message: err.message });
+                this.emitter.emit("error", err);
+                reject(err);
+            }, this.connectTimeoutMs);
+            this.emitter.once("ready", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            this.emitter.once("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+        this.connectPromise = (async () => {
+            this.transport.onMessage((raw) => this.handleIncoming(raw));
+            this.transport.onDisconnect((reason) => this.handleTransportDisconnect(reason));
+            await this.transport.open();
+            const requestId = makeRequestId();
+            const connectPayload = {
+                type: MiniappRequestType.CONNECT,
+                packageName: this.packageName,
+            };
+            this.transport.send(serializeEnvelope({ payload: connectPayload, requestId }));
+            await readyPromise;
+        })();
+        return this.connectPromise;
+    }
+    /** Resolves when `ready` becomes true, or rejects if connect failed. */
+    waitForReady() {
+        if (this.ready)
+            return Promise.resolve();
+        return this.connect();
+    }
+    isConnected() {
+        return this.ready && this.transport.isOpen();
+    }
+    disconnect() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        // Give listeners one synchronous chance to flush final messages
+        // (e.g. display.render([])) before we tear down the transport.
+        try {
+            this.emitter.emit("beforeDisconnect", "disconnect called");
+        }
+        catch (err) {
+            // A throwing handler must not block teardown.
+            console.warn("[MiniappSession] beforeDisconnect handler threw:", err);
+        }
+        this.failAllPending({ code: MiniappErrorCode.REQUEST_ABORTED, message: "Session disconnected" });
+        try {
+            this.transport.close();
+        }
+        catch {
+            // ignore
+        }
+        this.ready = false;
+        this.emitter.emit("disconnect", "disconnect called");
+    }
+    // -------------------------------------------------------------------------
+    // Outbound traffic — modules call these
+    // -------------------------------------------------------------------------
+    /** Send a fire-and-forget request that does not need a response. */
+    sendOneShot(payload) {
+        const envelope = { payload };
+        this.enqueueOrSend(serializeEnvelope(envelope));
+    }
+    /**
+     * Send a request and get a Promise that resolves with the REQUEST_RESULT payload.
+     * Rejects with a MiniappRequestError if the phone returns an error result.
+     *
+     * `opts.timeoutMs` overrides the default request timeout. Pass `0` to disable
+     * it entirely for inherently long-running requests whose duration is unbounded
+     * (e.g. audio playback that resolves only when the clip finishes) — those still
+     * settle via REQUEST_RESULT or `failAllPending` on disconnect, so they can't
+     * leak. Most requests should keep the default ceiling.
+     */
+    sendRequest(payload, opts) {
+        if (this.disposed) {
+            return Promise.reject(new NotConnectedError());
+        }
+        const requestId = makeRequestId();
+        const envelope = { payload, requestId };
+        const timeoutMs = opts?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        return new Promise((resolve, reject) => {
+            // Reject (and drop) the request if the host never sends a REQUEST_RESULT,
+            // so the promise can't hang forever. The REQUEST_RESULT / failAllPending
+            // paths clear this timer before settling. A non-positive timeout opts out
+            // (long-running requests rely on the host result / disconnect to settle).
+            const timer = timeoutMs > 0
+                ? setTimeout(() => {
+                    const pending = this.pendingRequests.get(requestId);
+                    if (!pending)
+                        return;
+                    this.pendingRequests.delete(requestId);
+                    pending.reject({
+                        code: MiniappErrorCode.ACTION_TIMEOUT,
+                        message: "Request timed out waiting for a response from the host",
+                    });
+                }, timeoutMs)
+                : undefined;
+            this.pendingRequests.set(requestId, {
+                requestId,
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            this.enqueueOrSend(serializeEnvelope(envelope));
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Event emitter — external API
+    // -------------------------------------------------------------------------
+    on(event, handler) {
+        this.emitter.on(event, handler);
+        return () => this.emitter.off(event, handler);
+    }
+    off(event, handler) {
+        this.emitter.off(event, handler);
+    }
+    /**
+     * Last-chance hook before the transport closes. Fires either when the
+     * phone notifies the session of an imminent disconnect (~50ms grace
+     * window before the socket is torn down) or when this session's
+     * `disconnect()` is called locally. Use it to flush final cleanup
+     * messages — e.g. `display.render([])` — synchronously. Async work
+     * started here will not complete before the socket closes.
+     */
+    onBeforeDisconnect(handler) {
+        return this.on("beforeDisconnect", handler);
+    }
+    onVisibilityChange(handler) {
+        return this.on("visibility", handler);
+    }
+    onCapabilitiesChange(handler) {
+        return this.on("capabilities", handler);
+    }
+    onColorSchemeChange(handler) {
+        return this.on("colorScheme", handler);
+    }
+    // -------------------------------------------------------------------------
+    // Internal — transport glue
+    // -------------------------------------------------------------------------
+    enqueueOrSend(raw) {
+        if (this.ready) {
+            try {
+                this.transport.send(raw);
+            }
+            catch (err) {
+                // If send fails post-ready, treat as transport error.
+                this.emitter.emit("error", err);
+            }
+            return;
+        }
+        this.outboundQueue.push(raw);
+    }
+    flushQueue() {
+        const queue = this.outboundQueue.splice(0);
+        for (const raw of queue) {
+            try {
+                this.transport.send(raw);
+            }
+            catch (err) {
+                this.emitter.emit("error", err);
+            }
+        }
+    }
+    handleIncoming(raw) {
+        const envelope = parseEnvelope(raw);
+        if (!envelope)
+            return;
+        const payload = envelope.payload;
+        const type = payload?.type;
+        switch (type) {
+            case MiniappResponseType.CONNECT_ACK: {
+                const ack = payload;
+                this.userId = ack.userId ?? "";
+                if (ack.packageName)
+                    this.packageName = ack.packageName;
+                this.capabilities = ack.capabilities ?? null;
+                if (ack.visibility)
+                    this.visibility = ack.visibility;
+                if (ack.colorScheme === "light" || ack.colorScheme === "dark") {
+                    this.colorScheme = ack.colorScheme;
+                }
+                if (ack.auth) {
+                    this.applyAuth(ack.auth);
+                    if (!this.userId)
+                        this.userId = ack.auth.mentraUserId;
+                }
+                // Populate the manifest-declared permission cache. Older runtimes
+                // that don't send `permissions` leave the all-false default in place
+                // — `hasPermission` getters will simply return false.
+                if (ack.permissions)
+                    this.applyPermissions(ack.permissions);
+                this.ready = true;
+                this.flushQueue();
+                this.emitter.emit("ready");
+                // Don't resolve request correlation here — CONNECT_ACK has no requestId.
+                return;
+            }
+            case MiniappResponseType.AUTH_UPDATE: {
+                const next = payload.auth;
+                if (next) {
+                    this.applyAuth(next);
+                    if (!this.userId)
+                        this.userId = next.mentraUserId;
+                }
+                return;
+            }
+            case MiniappResponseType.PERMISSIONS_UPDATE: {
+                const next = payload.permissions;
+                if (next)
+                    this.applyPermissions(next);
+                return;
+            }
+            case MiniappResponseType.SPEAKER_STATE: {
+                const state = payload.state;
+                if (!state)
+                    return;
+                const event = {
+                    state,
+                    errorCode: payload.errorCode,
+                    errorMessage: payload.errorMessage,
+                    durationMs: payload.durationMs,
+                };
+                this.speaker._applyState(event);
+                this.emitter.emit("speakerState", event);
+                return;
+            }
+            case MiniappRequestType.PING: {
+                // Phone → miniapp keepalive ping. Auto-reply with PONG.
+                const pong = { type: MiniappResponseType.PONG };
+                const env = {
+                    payload: pong,
+                    ...(envelope.requestId ? { requestId: envelope.requestId } : {}),
+                };
+                try {
+                    this.transport.send(serializeEnvelope(env));
+                }
+                catch {
+                    // Ignore; next ping will fail too and runtime will unregister.
+                }
+                return;
+            }
+            case MiniappResponseType.EVENT: {
+                const streamType = payload.streamType;
+                if (!streamType)
+                    return;
+                this.events._forwardEvent(streamType, payload.data);
+                return;
+            }
+            case MiniappResponseType.ACTION_CALL: {
+                // Another miniapp invoked one of our declared actions. Route to the
+                // registered handler (or buffer briefly for one to register). The SDK
+                // replies with an ACTION_RESULT request keyed by callId.
+                const callId = payload.callId;
+                const actionId = payload.actionId;
+                if (!callId || !actionId)
+                    return;
+                const params = payload.params ?? {};
+                const callerPackageName = payload.callerPackageName ?? "";
+                this.actions._deliver(callId, actionId, params, { callerPackageName });
+                return;
+            }
+            case MiniappResponseType.CAPABILITIES_UPDATE: {
+                const cap = payload.capabilities ?? null;
+                this.capabilities = cap;
+                this.emitter.emit("capabilities", cap);
+                return;
+            }
+            case MiniappResponseType.VISIBILITY_CHANGE: {
+                const next = payload.visibility;
+                if (next === "foreground" || next === "background") {
+                    this.visibility = next;
+                    this.emitter.emit("visibility", next);
+                }
+                return;
+            }
+            case MiniappResponseType.COLOR_SCHEME_CHANGE: {
+                const next = payload.colorScheme;
+                if (next === "light" || next === "dark") {
+                    this.colorScheme = next;
+                    this.emitter.emit("colorScheme", next);
+                }
+                return;
+            }
+            case MiniappResponseType.REQUEST_RESULT: {
+                const requestId = envelope.requestId;
+                if (!requestId)
+                    return;
+                const pending = this.pendingRequests.get(requestId);
+                if (!pending)
+                    return;
+                this.pendingRequests.delete(requestId);
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                if (payload.ok === false) {
+                    const err = payload.error ?? {
+                        code: MiniappErrorCode.INTERNAL,
+                        message: "Unknown error",
+                    };
+                    pending.reject(err);
+                }
+                else {
+                    pending.resolve(payload.data ?? null);
+                }
+                return;
+            }
+            case MiniappResponseType.WILL_DISCONNECT: {
+                const reason = payload.reason ?? "phone unregistering";
+                try {
+                    this.emitter.emit("beforeDisconnect", reason);
+                }
+                catch (err) {
+                    console.warn("[MiniappSession] beforeDisconnect handler threw:", err);
+                }
+                return;
+            }
+            case MiniappResponseType.ERROR: {
+                const err = new Error(payload.message ?? "MiniappSession error");
+                this.emitter.emit("error", err);
+                return;
+            }
+            default:
+                // Unknown type — drop silently. Forward-compat.
+                return;
+        }
+    }
+    handleTransportDisconnect(reason) {
+        this.ready = false;
+        this.failAllPending({ code: MiniappErrorCode.NOT_CONNECTED, message: `Transport disconnected: ${reason}` });
+        this.emitter.emit("disconnect", reason);
+    }
+    failAllPending(error) {
+        for (const pending of this.pendingRequests.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        // Auth waiters live outside pendingRequests — they're resolved by an
+        // AUTH_UPDATE push, not a correlated REQUEST_RESULT — so a transport drop,
+        // dispose, or CONNECT_ACK timeout must reject them here too. Otherwise an
+        // in-flight session.auth.getToken()/fetch() hangs until its 10s waiter
+        // timeout instead of failing fast with the disconnect error.
+        for (const waiter of Array.from(this.authWaiters)) {
+            clearTimeout(waiter.timer);
+            this.authWaiters.delete(waiter);
+            waiter.reject(new NotConnectedError(error.message));
+        }
+    }
+    authHasTtl(auth, minTtlMs) {
+        return auth.expiresAt - Date.now() > minTtlMs;
+    }
+    requestAuthRefresh(minTtlMs) {
+        if (this.authRefreshPromise)
+            return this.authRefreshPromise;
+        if (!this.ready || !this.transport.isOpen())
+            return Promise.resolve(null);
+        this.authRefreshPromise = this.sendRequest({
+            type: MiniappRequestType.AUTH_REFRESH,
+            minTtlMs,
+        })
+            .then((result) => {
+            const auth = result?.auth;
+            if (auth)
+                this.applyAuth(auth);
+            return auth ?? null;
+        })
+            .catch((err) => {
+            console.warn("[MiniappSession] auth refresh failed:", err);
+            return null;
+        })
+            .finally(() => {
+            this.authRefreshPromise = null;
+        });
+        return this.authRefreshPromise;
+    }
+    applyAuth(next) {
+        this.authState = { ...next };
+        for (const waiter of Array.from(this.authWaiters)) {
+            if (!this.authHasTtl(next, waiter.minTtlMs))
+                continue;
+            clearTimeout(waiter.timer);
+            this.authWaiters.delete(waiter);
+            waiter.resolve({ ...next });
+        }
+        this.emitter.emit("auth", { ...next });
+    }
+    /**
+     * Update the cached permission record. Idempotent: emits "permissions"
+     * only when the record actually changed. Sanitizes incoming objects to
+     * the v3 PermissionType union.
+     */
+    applyPermissions(next) {
+        let changed = false;
+        const updated = { ...this._permissions };
+        for (const k of ALL_PERMISSION_TYPES) {
+            const v = next[k] === true;
+            if (updated[k] !== v) {
+                updated[k] = v;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._permissions = updated;
+            this.emitter.emit("permissions", { ...updated });
+        }
+    }
+}
+/**
+ * Map a manifest UPPER_CASE permission name to the lowercase canonical key
+ * used by `session.permissions`. Returns null for unknown manifest keys.
+ *
+ * BACKGROUND_LOCATION + POST_NOTIFICATIONS map onto the same canonical keys
+ * as their non-suffixed counterparts (location / notifications) since
+ * `has()` is "do I have *any* form of this permission declared".
+ */
+function manifestKeyToCanonical(manifestKey) {
+    switch (manifestKey.toUpperCase()) {
+        case "MICROPHONE":
+            return "microphone";
+        case "CAMERA":
+            return "camera";
+        case "LOCATION":
+        case "BACKGROUND_LOCATION":
+            return "location";
+        case "READ_NOTIFICATIONS":
+        case "POST_NOTIFICATIONS":
+            return "notifications";
+        case "CALENDAR":
+            return "calendar";
+        default:
+            return null;
+    }
+}
+/** @internal — for the permissions module's onUpdate plumbing. */
+export function _allPermissionTypes() {
+    return ALL_PERMISSION_TYPES;
+}
+//# sourceMappingURL=session.js.map