@appstrata/protocol 0.1.0

package/dist/host/message-bridge.js

@@ -0,0 +1,360 @@
+/**
+ * MessageBridge - Host-side message protocol bridge.
+ *
+ * Bridges communication between the player and app via the message protocol.
+ * Handles the HELLO/READY/READY_ACK handshake and subsequent RPC/event communication.
+ *
+ * Key responsibilities:
+ * - Listen for HELLO messages from apps
+ * - Send READY messages with AppContext
+ * - Retry READY until READY_ACK received (if HELLO not received)
+ * - Handle REQUEST messages and send RESPONSE
+ * - Fire lifecycle EVENT messages
+ */
+import { createLogger, setHandlingLogRpc } from "@appstrata/core";
+const logger = createLogger("MessageBridge");
+import { isHelloMessage, isReadyAckMessage, isRequestMessage, appContextToWire, generateRequestId, } from "../messages.js";
+/**
+ * MessageBridge - Host-side protocol bridge.
+ *
+ * **Single-session:** one `MessageBridge` instance covers one App page load.
+ * Once the handshake completes (`receivedReadyAck = true`), the bridge enters
+ * the ACTIVE state and does not reset. When the App reloads, the old bridge
+ * must be destroyed and a new one created.
+ *
+ * Bridges the player to apps via the message protocol.
+ *
+ * Usage:
+ * ```typescript
+ * const bridge = new MessageBridge({
+ *   transport: createPostMessageTransport({ targetWindow: iframe.contentWindow!, targetOrigin: "*" }),
+ *   player: myPlayer,
+ *   getContext: async () => buildAppContext(),
+ * });
+ *
+ * // Start the handshake (sends READY)
+ * bridge.start();
+ *
+ * // Send lifecycle events
+ * bridge.fireShow();
+ * bridge.fireStart();
+ * ```
+ */
+export class MessageBridge {
+    constructor(config) {
+        this.receivedHello = false;
+        this.receivedReadyAck = false;
+        this.retryCount = 0;
+        this.started = false;
+        this.pendingEvents = [];
+        this.config = {
+            retryInterval: 1000,
+            maxRetries: 10,
+            ...config,
+        };
+        this.transport = config.transport;
+        // Install message listener
+        this.unsubscribeFromTransport = this.transport.onMessage((msg) => {
+            if (isHelloMessage(msg)) {
+                this.handleHello(msg);
+            }
+            else if (isReadyAckMessage(msg)) {
+                this.handleReadyAck(msg);
+            }
+            else if (isRequestMessage(msg)) {
+                this.handleRequest(msg);
+            }
+        });
+    }
+    /**
+     * Start the bridge (send initial READY message).
+     */
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        // avoid sending proactive READY if we've already received HELLO
+        // because we will already have sent READY in response to HELLO
+        if (!this.receivedHello) {
+            this.sendReady('proactive', true);
+        }
+    }
+    /**
+     * Handle HELLO message from app.
+     */
+    handleHello(message) {
+        logger.debug(`↓ HELLO received (requestId=${message.requestId}, timestamp=${message.timestamp})`);
+        this.receivedHello = true;
+        this.helloRequestId = message.requestId;
+        // Stop retrying if we were
+        this.cancelNextRetry();
+        // If the proactive READY was already acknowledged, the handshake is done.
+        // A late HELLO (arrived after READY_ACK) may trigger a second READY.
+        // TBD: whether the spec should allow this or not.
+        // if (this.receivedReadyAck) {
+        //   logger.debug("Ignoring late HELLO — handshake already completed via proactive READY");
+        //   return;
+        // }
+        // Send READY in response (will include requestId from HELLO)
+        this.sendReady('response to HELLO');
+    }
+    /**
+     * Handle READY_ACK message from app.
+     */
+    handleReadyAck(message) {
+        logger.debug(`↓ READY_ACK received (requestId=${message.requestId}, timestamp=${message.timestamp})`);
+        this.receivedReadyAck = true;
+        // Stop retrying
+        this.cancelNextRetry();
+        // Flush any events that were queued before handshake completed
+        this.flushPendingEvents();
+    }
+    /**
+     * Flush pending events that were queued before READY_ACK.
+     */
+    flushPendingEvents() {
+        for (const event of this.pendingEvents) {
+            this.transport.send(event);
+            logger.debug(`Flushed queued event: ${event.name}`);
+        }
+        this.pendingEvents = [];
+    }
+    /**
+     * Handle REQUEST message from app.
+     */
+    async handleRequest(message) {
+        // Spec §2.2: Hosts SHOULD ignore REQUESTs from an App that has not completed the handshake
+        if (!this.receivedReadyAck) {
+            logger.debug("Ignoring REQUEST before READY_ACK:", message.op);
+            return;
+        }
+        // Notification = no requestId => no RESPONSE (spec §4.4)
+        const isNotification = !message.requestId;
+        const isLogOp = message.op === "log";
+        if (isLogOp)
+            setHandlingLogRpc(true);
+        try {
+            logger.debug(`↓ REQUEST received: ${message.op} (requestId=${message.requestId ?? "(notification)"}, timestamp=${message.timestamp})`);
+            const result = await this.handlePlayerRequest(message.op, message.payload);
+            if (isNotification)
+                return;
+            const response = {
+                protocol: "appstrata-protocol",
+                version: "1.0",
+                type: "RESPONSE",
+                timestamp: Date.now(),
+                requestId: message.requestId,
+                op: message.op,
+                ok: true,
+                result,
+            };
+            this.transport.send(response);
+        }
+        catch (error) {
+            if (isNotification)
+                return;
+            const response = {
+                protocol: "appstrata-protocol",
+                version: "1.0",
+                type: "RESPONSE",
+                timestamp: Date.now(),
+                requestId: message.requestId,
+                op: message.op,
+                ok: false,
+                error: {
+                    code: "INTERNAL_ERROR",
+                    message: error instanceof Error ? error.message : String(error),
+                    details: error,
+                },
+            };
+            this.transport.send(response);
+        }
+        finally {
+            if (isLogOp)
+                setHandlingLogRpc(false);
+        }
+    }
+    /**
+     * Handle request by routing to player API.
+     */
+    async handlePlayerRequest(op, payload) {
+        const player = this.config.player;
+        const handlers = {
+            // Core operations
+            "notifyComplete": () => player.notifyComplete(),
+            "notifyEstimatedEnd": () => player.notifyEstimatedEnd(payload),
+            "notifyNoContent": () => player.notifyNoContent(payload),
+            // Storage operations
+            "storage.get": async () => {
+                this.requireCapability(player.storage, "Storage");
+                return { value: await player.storage.get(payload.key) };
+            },
+            "storage.set": async () => {
+                this.requireCapability(player.storage, "Storage");
+                await player.storage.set(payload.key, payload.value);
+            },
+            "storage.remove": async () => {
+                this.requireCapability(player.storage, "Storage");
+                await player.storage.remove(payload.key);
+            },
+            "storage.list": async () => {
+                this.requireCapability(player.storage, "Storage");
+                return { keys: await player.storage.list() };
+            },
+            "storage.clear": async () => {
+                this.requireCapability(player.storage, "Storage");
+                await player.storage.clear();
+            },
+            // Proxy operations
+            "proxy.fetch": async () => {
+                this.requireCapability(player.proxy, "Proxy");
+                const response = await player.proxy.fetch(payload);
+                // Convert ProxyResponse to ProxyResponseWire for serialization
+                const wireResponse = {
+                    ok: response.ok,
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                    body: await response.text(),
+                    cached: response.cached,
+                    stale: response.stale,
+                    cachedAt: response.cachedAt,
+                };
+                return wireResponse;
+            },
+            // Fire-and-forget: don't await so the _handlingLogRpc flag
+            // (cycle guard) is cleared before any async work in player.log().
+            "log": () => {
+                if (player.log) {
+                    void player.log(payload.level, payload.message, payload.data);
+                }
+            },
+        };
+        const handler = handlers[op];
+        if (!handler) {
+            throw new Error(`Unknown operation: ${op}`);
+        }
+        return await handler();
+    }
+    /**
+     * Helper to check capability availability.
+     */
+    requireCapability(capability, name) {
+        if (!capability) {
+            throw new Error(`${name} capability not available`);
+        }
+    }
+    /**
+     * Send latest AppContext as READY message to app.
+     *
+     * Awaits the AppContext to be available.
+     * If proactive is true, and HELLO arrives by the time the context is available,
+     * no READY is sent.
+     *
+     * @param reason - The phase at which the READY message is being sent. Only used for logging.
+     */
+    async sendReady(reason, proactive = false) {
+        const context = await this.config.getContext();
+        const contextWire = appContextToWire(context);
+        if (proactive && this.receivedHello) {
+            // HELLO arrived while we were waiting for the context
+            return;
+        }
+        const ready = {
+            protocol: "appstrata-protocol",
+            version: "1.0",
+            type: "READY",
+            timestamp: Date.now(),
+            context: contextWire,
+            requestId: this.helloRequestId ?? generateRequestId(),
+        };
+        logger.debug(`↑ Sending READY (${reason}) (requestId=${ready.requestId}, timestamp=${ready.timestamp})`);
+        this.transport.send(ready);
+        if (!this.receivedHello && !this.receivedReadyAck) {
+            this.scheduleNextRetry();
+        }
+    }
+    /**
+     * Schedule next retry for READY messages.
+     */
+    scheduleNextRetry() {
+        // Just an defensive check to avoid setting up overlapping retries and going over the max retries
+        if (this.retryTimer || this.retryCount >= this.config.maxRetries) {
+            return;
+        }
+        this.retryTimer = setTimeout(() => {
+            // Clear timer before calling sendReady() so that it can schedule the next retry
+            this.retryTimer = undefined;
+            this.retryCount++;
+            logger.debug(`Retrying READY (${this.retryCount}/${this.config.maxRetries})`);
+            if (this.retryCount < this.config.maxRetries) {
+                this.sendReady('retry');
+            }
+            else {
+                logger.debug("Max retries reached, giving up");
+            }
+        }, this.config.retryInterval);
+    }
+    /**
+     * Cancel the next retry for READY messages.
+     */
+    cancelNextRetry() {
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = undefined;
+        }
+    }
+    /**
+     * Send an EVENT message through the transport.
+     * If the handshake is not yet complete (READY_ACK not received), the event
+     * is queued and will be flushed when READY_ACK arrives.
+     */
+    sendEventMessage(name, payload) {
+        const message = {
+            protocol: "appstrata-protocol",
+            version: "1.0",
+            type: "EVENT",
+            timestamp: Date.now(),
+            name,
+            payload,
+        };
+        if (!this.receivedReadyAck) {
+            this.pendingEvents.push(message);
+            logger.debug(`Event queued (awaiting READY_ACK): ${name}`);
+            return;
+        }
+        this.transport.send(message);
+        logger.debug(`Event fired: ${name}`);
+    }
+    fireShow() {
+        this.sendEventMessage("show");
+    }
+    fireStart() {
+        this.sendEventMessage("start");
+    }
+    fireHide() {
+        this.sendEventMessage("hide");
+    }
+    fireStop() {
+        this.sendEventMessage("stop");
+    }
+    fireContextChange(context) {
+        this.sendEventMessage("contextChange", appContextToWire(context));
+    }
+    /**
+     * Cleanup.
+     *
+     * Unsubscribes from the transport but does NOT close it.
+     * The transport lifecycle is owned by whoever created it
+     * (e.g., the session manager), not by the bridge.
+     */
+    destroy() {
+        this.cancelNextRetry();
+        if (this.unsubscribeFromTransport) {
+            this.unsubscribeFromTransport();
+            this.unsubscribeFromTransport = undefined;
+        }
+        this.pendingEvents = [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AppStrata Protocol Package
+ *
+ * The messaging protocol implementation for AppStrata Digital Signage SDK.
+ * Contains message definitions, transport implementations, client (app-side) ProxyPlayer,
+ * and host (player-side) MessageBridge.
+ *
+ * @packageDocumentation
+ */
+export * from "./messages.js";
+export * from "./transport/index.js";
+export * from "./client/index.js";
+export * from "./host/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,eAAe,CAAC;AAG9B,cAAc,sBAAsB,CAAC;AAGrC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * AppStrata Protocol Package
+ *
+ * The messaging protocol implementation for AppStrata Digital Signage SDK.
+ * Contains message definitions, transport implementations, client (app-side) ProxyPlayer,
+ * and host (player-side) MessageBridge.
+ *
+ * @packageDocumentation
+ */
+// Messages
+export * from "./messages.js";
+// Transport
+export * from "./transport/index.js";
+// Client (app-side)
+export * from "./client/index.js";
+// Host (player-side)
+export * from "./host/index.js";

package/dist/messages.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Protocol message types from the AppStrata specification.
+ *
+ * Defines all message types used in the HELLO/READY/READY_ACK handshake
+ * and subsequent RPC and event communication.
+ */
+import type { AppContext, Resource } from "@appstrata/core";
+/**
+ * Protocol message - base structure for all messages.
+ * All protocol messages must include these fields.
+ */
+export interface ProtocolMessage {
+    /** Protocol identifier - must be "appstrata-protocol" */
+    protocol: "appstrata-protocol";
+    /** Protocol version - must be "1.0" */
+    version: "1.0";
+    /** Message type */
+    type: string;
+    /** Unix epoch milliseconds (Date.now()) at message construction time */
+    timestamp: number;
+    /** Allow additional properties */
+    [key: string]: unknown;
+}
+/**
+ * HELLO message (App → Host).
+ *
+ * Sent by app to announce readiness and establish session.
+ * App SHOULD send HELLO once per session after installing listeners.
+ */
+export interface HelloMessage extends ProtocolMessage {
+    type: "HELLO";
+    /** Request ID for handshake correlation (MUST be unique per HELLO) */
+    requestId: string;
+}
+/**
+ * AppContext in wire format.
+ *
+ * This is the wire protocol representation where capabilities are an array.
+ * The SDK converts this to AppContext with hasCapability() method.
+ */
+export interface AppContextWire {
+    instanceId?: string;
+    duration?: number;
+    config: Record<string, unknown>;
+    resources: Resource[];
+    mode: "signage" | "preview" | "development";
+    environment: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    device: {
+        id: string;
+        name?: string;
+        type?: string;
+        version?: string;
+        platformName?: string;
+        location?: [number, number];
+        locale: string;
+        timezone: string;
+        touchscreen?: boolean;
+    };
+    capabilities?: string[];
+}
+/**
+ * READY message (Host → App).
+ *
+ * Delivers complete AppContext to the app.
+ * Host MUST deliver READY at least once per session.
+ */
+export interface ReadyMessage extends ProtocolMessage {
+    type: "READY";
+    /** Complete app context */
+    context: AppContextWire;
+    /** Echoed from HELLO requestId if responding to HELLO; otherwise a fresh UUID generated by the Host. */
+    requestId: string;
+}
+/**
+ * READY_ACK message (App → Host).
+ *
+ * App acknowledges receipt of READY.
+ * App MUST always send READY_ACK upon receiving READY.
+ */
+export interface ReadyAckMessage extends ProtocolMessage {
+    type: "READY_ACK";
+    /** Echoed from the READY message's requestId */
+    requestId: string;
+}
+/**
+ * REQUEST message (App → Host).
+ *
+ * Used for capability operations (storage, proxy, etc.).
+ * NOT used for retrieving context (context is delivered via READY).
+ *
+ * When `requestId` is present, the Host MUST reply with a RESPONSE.
+ * When `requestId` is absent, the message is a **notification** (fire-and-forget)
+ * and the Host MUST NOT reply.
+ */
+export interface RequestMessage extends ProtocolMessage {
+    type: "REQUEST";
+    /** Unique request identifier. Absent for notifications (fire-and-forget). */
+    requestId?: string;
+    /** Operation name (e.g., "storage.get", "proxy.fetch") */
+    op: string;
+    /** Operation payload (operation-specific) */
+    payload?: unknown;
+}
+/**
+ * RESPONSE message (Host → App).
+ *
+ * Response to a REQUEST message.
+ */
+export interface ResponseMessage extends ProtocolMessage {
+    type: "RESPONSE";
+    /** Request ID from the original REQUEST */
+    requestId: string;
+    /** Operation name echoed from the original REQUEST */
+    op: string;
+    /** Whether the operation succeeded */
+    ok: boolean;
+    /** Result data (if ok is true) */
+    result?: unknown;
+    /** Error information (if ok is false) */
+    error?: {
+        /** Error code */
+        code: string;
+        /** Human-readable error message */
+        message?: string;
+        /** Additional error details */
+        details?: unknown;
+    };
+}
+/**
+ * EVENT message (Host → App).
+ *
+ * Used for lifecycle events and context changes.
+ */
+export interface EventMessage extends ProtocolMessage {
+    type: "EVENT";
+    /** Event name */
+    name: string;
+    /** Event payload (event-specific) */
+    payload?: unknown;
+}
+/**
+ * Type guard to check if data is a valid protocol message.
+ *
+ * Validates the base structure: protocol identifier, version, and type.
+ */
+export declare function isProtocolMessage(data: unknown): data is ProtocolMessage;
+/**
+ * Type guard for HELLO message.
+ */
+export declare function isHelloMessage(msg: ProtocolMessage): msg is HelloMessage;
+/**
+ * Type guard for READY message.
+ */
+export declare function isReadyMessage(msg: ProtocolMessage): msg is ReadyMessage;
+/**
+ * Type guard for READY_ACK message.
+ */
+export declare function isReadyAckMessage(msg: ProtocolMessage): msg is ReadyAckMessage;
+/**
+ * Type guard for REQUEST message.
+ */
+export declare function isRequestMessage(msg: ProtocolMessage): msg is RequestMessage;
+/**
+ * Type guard for RESPONSE message.
+ */
+export declare function isResponseMessage(msg: ProtocolMessage): msg is ResponseMessage;
+/**
+ * Type guard for EVENT message.
+ */
+export declare function isEventMessage(msg: ProtocolMessage): msg is EventMessage;
+/**
+ * Generate a unique request ID (UUID v4).
+ *
+ * @returns Unique request identifier
+ */
+export declare function generateRequestId(): string;
+/**
+ * Convert wire format context to AppContext.
+ *
+ * Adds the hasCapability() method to the context.
+ *
+ * @param wireContext - Context from wire protocol
+ * @returns AppContext with hasCapability method
+ */
+export declare function wireContextToAppContext(wireContext: AppContextWire): AppContext;
+/**
+ * Convert AppContext to wire format.
+ *
+ * Extracts capabilities array from hasCapability method.
+ *
+ * @param context - AppContext with hasCapability method
+ * @returns Wire format context with capabilities array
+ */
+export declare function appContextToWire(context: AppContext): AppContextWire;
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

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