@warren-bank/fx_cast_bridge 0.3.1

package/js/config.json

@@ -0,0 +1,4 @@
+{
+    "applicationName": "fx_cast_bridge",
+    "applicationVersion": "0.3.1"
+}

package/js/src/bridge/components/airplay/auth.js

@@ -0,0 +1,251 @@
+"use strict";
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (
+                  !desc ||
+                  ("get" in desc
+                      ? !m.__esModule
+                      : desc.writable || desc.configurable)
+              ) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      }
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __setModuleDefault =
+    (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+              Object.defineProperty(o, "default", {
+                  enumerable: true,
+                  value: v
+              });
+          }
+        : function (o, v) {
+              o["default"] = v;
+          });
+var __importStar =
+    (this && this.__importStar) ||
+    (function () {
+        var ownKeys = function (o) {
+            ownKeys =
+                Object.getOwnPropertyNames ||
+                function (o) {
+                    var ar = [];
+                    for (var k in o)
+                        if (Object.prototype.hasOwnProperty.call(o, k))
+                            ar[ar.length] = k;
+                    return ar;
+                };
+            return ownKeys(o);
+        };
+        return function (mod) {
+            if (mod && mod.__esModule) return mod;
+            var result = {};
+            if (mod != null)
+                for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                    if (k[i] !== "default") __createBinding(result, mod, k[i]);
+            __setModuleDefault(result, mod);
+            return result;
+        };
+    })();
+var __awaiter =
+    (this && this.__awaiter) ||
+    function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+            return value instanceof P
+                ? value
+                : new P(function (resolve) {
+                      resolve(value);
+                  });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) {
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function rejected(value) {
+                try {
+                    step(generator["throw"](value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function step(result) {
+                result.done
+                    ? resolve(result.value)
+                    : adopt(result.value).then(fulfilled, rejected);
+            }
+            step(
+                (generator = generator.apply(thisArg, _arguments || [])).next()
+            );
+        });
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirPlayAuth = exports.AirPlayAuthCredentials = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fast_srp_hap_1 = __importDefault(require("fast-srp-hap"));
+const node_fetch_1 = __importStar(require("node-fetch"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const bplist_1 = __importDefault(require("./bplist"));
+const AIRPLAY_PORT = 7000;
+const MIMETYPE_BPLIST = "application/x-apple-binary-plist";
+class AirPlayAuthCredentials {
+    constructor(clientId, clientSk, clientPk) {
+        if (clientId && clientSk && clientPk) {
+            this.clientId = clientId;
+            this.clientSk = clientSk;
+            this.clientPk = clientPk;
+        } else {
+            const keyPair = tweetnacl_1.default.sign.keyPair();
+            this.clientId = crypto_1.default.randomBytes(8).toString("hex");
+            this.clientSk = keyPair.secretKey.slice(0, 32);
+            this.clientPk = keyPair.publicKey;
+        }
+    }
+}
+exports.AirPlayAuthCredentials = AirPlayAuthCredentials;
+class AirPlayAuth {
+    constructor(address, credentials) {
+        this.address = address;
+        this.credentials = credentials;
+        this.baseUrl = new URL(`http://${this.address}:${AIRPLAY_PORT}`);
+    }
+    beginPairing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendPostRequest("/pair-pin-start");
+        });
+    }
+    finishPairing(pin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pk: serverPk, salt: serverSalt } =
+                yield this.pairSetupPin1();
+            const srpParams = fast_srp_hap_1.default.params[2048];
+            srpParams.hash = "sha1";
+            const srpClient = new fast_srp_hap_1.default.Client(
+                srpParams,
+                serverSalt,
+                Buffer.from(this.credentials.clientId),
+                Buffer.from(pin),
+                Buffer.from(this.credentials.clientSk)
+            );
+            srpClient.setB(serverPk);
+            yield this.pairSetupPin2(
+                srpClient.computeA(),
+                srpClient.computeM1()
+            );
+            yield this.pairSetupPin3(srpClient.computeK());
+        });
+    }
+    pairSetupPin1() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [response] = yield this.sendPostRequestBplist(
+                "/pair-setup-pin",
+                {
+                    method: "pin",
+                    user: this.credentials.clientId
+                }
+            );
+            return response;
+        });
+    }
+    pairSetupPin2(pk, proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [response] = yield this.sendPostRequestBplist(
+                "/pair-setup-pin",
+                {
+                    pk,
+                    proof
+                }
+            );
+            return response;
+        });
+    }
+    pairSetupPin3(sharedSecretHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aesKey = crypto_1.default
+                .createHash("sha512")
+                .update("Pair-Setup-AES-Key")
+                .update(sharedSecretHash)
+                .digest()
+                .slice(0, 16);
+            const aesIv = crypto_1.default
+                .createHash("sha512")
+                .update("Pair-Setup-AES-IV")
+                .update(sharedSecretHash)
+                .digest()
+                .slice(0, 16);
+            aesIv[15]++;
+            const cipher = crypto_1.default.createCipheriv(
+                "aes-128-gcm",
+                aesKey,
+                aesIv
+            );
+            const epk = cipher.update(this.credentials.clientPk);
+            cipher.final();
+            const authTag = cipher.getAuthTag();
+            const [response] = yield this.sendPostRequestBplist(
+                "/pair-setup-pin",
+                {
+                    epk,
+                    authTag
+                }
+            );
+            return response;
+        });
+    }
+    sendPostRequest(path, contentType, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestUrl = new URL(path, this.baseUrl);
+            const requestHeaders = new node_fetch_1.Headers({
+                "User-Agent": "AirPlay/320.20"
+            });
+            if (data && contentType) {
+                requestHeaders.append("Content-Type", contentType);
+            }
+            const response = yield (0, node_fetch_1.default)(requestUrl.href, {
+                method: "POST",
+                headers: requestHeaders,
+                body: data
+            });
+            if (!response.ok) {
+                throw new Error(`AirPlay request error: ${response.status}`);
+            }
+            return yield response.buffer();
+        });
+    }
+    sendPostRequestBplist(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestBody = data
+                ? bplist_1.default.create(data)
+                : undefined;
+            const response = yield this.sendPostRequest(
+                path,
+                MIMETYPE_BPLIST,
+                requestBody
+            );
+            return bplist_1.default.parse.parseBuffer(response);
+        });
+    }
+}
+exports.AirPlayAuth = AirPlayAuth;

package/js/src/bridge/components/airplay/bplist.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+const bplist_creator_1 = __importDefault(require("bplist-creator"));
+const bplist_parser_1 = __importDefault(require("bplist-parser"));
+exports.default = {
+    create: bplist_creator_1.default,
+    parse: bplist_parser_1.default
+};

package/js/src/bridge/components/cast/Session.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (
+                  !desc ||
+                  ("get" in desc
+                      ? !m.__esModule
+                      : desc.writable || desc.configurable)
+              ) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      }
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __setModuleDefault =
+    (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+              Object.defineProperty(o, "default", {
+                  enumerable: true,
+                  value: v
+              });
+          }
+        : function (o, v) {
+              o["default"] = v;
+          });
+var __importStar =
+    (this && this.__importStar) ||
+    (function () {
+        var ownKeys = function (o) {
+            ownKeys =
+                Object.getOwnPropertyNames ||
+                function (o) {
+                    var ar = [];
+                    for (var k in o)
+                        if (Object.prototype.hasOwnProperty.call(o, k))
+                            ar[ar.length] = k;
+                    return ar;
+                };
+            return ownKeys(o);
+        };
+        return function (mod) {
+            if (mod && mod.__esModule) return mod;
+            var result = {};
+            if (mod != null)
+                for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                    if (k[i] !== "default") __createBinding(result, mod, k[i]);
+            __setModuleDefault(result, mod);
+            return result;
+        };
+    })();
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importStar(require("./client"));
+class Session extends client_1.default {
+    establishAppConnection(transportId) {
+        this.transportConnection = this.createChannel(
+            client_1.NS_CONNECTION,
+            this.sourceId,
+            transportId
+        );
+        this.transportHeartbeat = this.createChannel(
+            client_1.NS_HEARTBEAT,
+            this.sourceId,
+            transportId
+        );
+        this.transportConnection.send({ type: "CONNECT" });
+    }
+    sendMessage(namespace, message) {
+        let channel = this.namespaceChannelMap.get(namespace);
+        if (!channel) {
+            channel = this.createChannel(
+                namespace,
+                this.sourceId,
+                this.transportId
+            );
+            channel.on("message", messageData => {
+                if (!this.sessionId) {
+                    return;
+                }
+                messageData = JSON.stringify(messageData);
+                this.messaging.sendMessage({
+                    subject: "cast:sessionMessageReceived",
+                    data: {
+                        sessionId: this.sessionId,
+                        namespace,
+                        messageData
+                    }
+                });
+            });
+            this.namespaceChannelMap.set(namespace, channel);
+        }
+        channel.send(message);
+    }
+    constructor(appId, receiverDevice, messaging, onSessionCreated) {
+        super();
+        this.appId = appId;
+        this.receiverDevice = receiverDevice;
+        this.messaging = messaging;
+        this.onSessionCreated = onSessionCreated;
+        this.namespaceChannelMap = new Map();
+        this.onReceiverMessage = message => {
+            var _a, _b;
+            switch (message.type) {
+                case "RECEIVER_STATUS": {
+                    const { status } = message;
+                    const application =
+                        (_a = status.applications) === null || _a === void 0
+                            ? void 0
+                            : _a.find(app => app.appId === this.appId);
+                    if (!this.sessionId) {
+                        if (message.requestId !== this.launchRequestId) {
+                            break;
+                        }
+                        if (application) {
+                            this.sessionId = application.sessionId;
+                            this.transportId = application.transportId;
+                            this.establishAppConnection(this.transportId);
+                            (_b = this.onSessionCreated) === null ||
+                            _b === void 0
+                                ? void 0
+                                : _b.call(this, this.sessionId);
+                            this.messaging.sendMessage({
+                                subject: "main:castSessionCreated",
+                                data: {
+                                    sessionId: this.sessionId,
+                                    statusText: application.statusText,
+                                    namespaces: application.namespaces,
+                                    volume: status.volume,
+                                    appId: application.appId,
+                                    displayName: application.displayName,
+                                    receiverId: this.receiverDevice.id,
+                                    receiverFriendlyName:
+                                        this.receiverDevice.friendlyName,
+                                    transportId: this.sessionId,
+                                    senderApps: [],
+                                    appImages: []
+                                }
+                            });
+                        }
+                        break;
+                    }
+                    if (!application) {
+                        this.client.close();
+                        break;
+                    }
+                    this.messaging.sendMessage({
+                        subject: "main:castSessionUpdated",
+                        data: {
+                            sessionId: this.sessionId,
+                            statusText: application.statusText,
+                            namespaces: application.namespaces,
+                            volume: message.status.volume
+                        }
+                    });
+                    break;
+                }
+                case "LAUNCH_ERROR": {
+                    console.error(`err: LAUNCH_ERROR, ${message.reason}`);
+                    this.client.close();
+                    break;
+                }
+            }
+        };
+        super
+            .connect(receiverDevice.host, {
+                port: receiverDevice.port,
+                onHeartbeat: () => {
+                    if (this.transportHeartbeat) {
+                        this.transportHeartbeat.send({ type: "PING" });
+                    }
+                },
+                onReceiverMessage: message => {
+                    this.onReceiverMessage(message);
+                }
+            })
+            .then(() => {
+                this.launchRequestId = this.sendReceiverMessage({
+                    type: "LAUNCH",
+                    appId: this.appId
+                });
+            });
+        this.client.on("close", () => {
+            if (this.sessionId) {
+                messaging.sendMessage({
+                    subject: "cast:sessionStopped",
+                    data: { sessionId: this.sessionId }
+                });
+            }
+        });
+    }
+}
+exports.default = Session;

package/js/src/bridge/components/cast/client.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NS_RECEIVER = exports.NS_HEARTBEAT = exports.NS_CONNECTION = void 0;
+const castv2_1 = require("castv2");
+exports.NS_CONNECTION = "urn:x-cast:com.google.cast.tp.connection";
+exports.NS_HEARTBEAT = "urn:x-cast:com.google.cast.tp.heartbeat";
+exports.NS_RECEIVER = "urn:x-cast:com.google.cast.receiver";
+const DEFAULT_PORT = 8009;
+const HEARTBEAT_INTERVAL_MS = 5000;
+class CastClient {
+    constructor(sourceId = "sender-0", destinationId = "receiver-0") {
+        this.sourceId = sourceId;
+        this.destinationId = destinationId;
+        this.client = new castv2_1.Client();
+        this.receiverRequestId = Math.floor(Math.random() * 1e6);
+    }
+    createChannel(
+        namespace,
+        sourceId = this.sourceId,
+        destinationId = this.destinationId
+    ) {
+        return this.client.createChannel(
+            sourceId,
+            destinationId,
+            namespace,
+            "JSON"
+        );
+    }
+    sendReceiverMessage(message) {
+        if (!this.receiverChannel) return;
+        const requestId = this.receiverRequestId++;
+        this.receiverChannel.send(
+            Object.assign(Object.assign({}, message), { requestId })
+        );
+        return requestId;
+    }
+    connect(host, options) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.client.on("error", reject);
+            this.client.on("close", () => {
+                if (this.heartbeatChannel && this.heartbeatIntervalId) {
+                    clearInterval(this.heartbeatIntervalId);
+                }
+            });
+            this.client.connect(
+                {
+                    host,
+                    port:
+                        (_a =
+                            options === null || options === void 0
+                                ? void 0
+                                : options.port) !== null && _a !== void 0
+                            ? _a
+                            : DEFAULT_PORT
+                },
+                () => {
+                    this.connectionChannel = this.createChannel(
+                        exports.NS_CONNECTION
+                    );
+                    this.heartbeatChannel = this.createChannel(
+                        exports.NS_HEARTBEAT
+                    );
+                    this.receiverChannel = this.createChannel(
+                        exports.NS_RECEIVER
+                    );
+                    this.receiverChannel.on("message", message => {
+                        var _a;
+                        (_a =
+                            options === null || options === void 0
+                                ? void 0
+                                : options.onReceiverMessage) === null ||
+                        _a === void 0
+                            ? void 0
+                            : _a.call(options, message);
+                    });
+                    this.connectionChannel.send({ type: "CONNECT" });
+                    this.heartbeatChannel.send({ type: "PING" });
+                    this.heartbeatIntervalId = setInterval(() => {
+                        var _a, _b;
+                        (_a = this.heartbeatChannel) === null || _a === void 0
+                            ? void 0
+                            : _a.send({ type: "PING" });
+                        (_b =
+                            options === null || options === void 0
+                                ? void 0
+                                : options.onHeartbeat) === null || _b === void 0
+                            ? void 0
+                            : _b.call(options);
+                    }, HEARTBEAT_INTERVAL_MS);
+                    resolve();
+                }
+            );
+        });
+    }
+    disconnect() {
+        var _a;
+        if (this.heartbeatIntervalId) {
+            clearInterval(this.heartbeatIntervalId);
+        }
+        (_a = this.connectionChannel) === null || _a === void 0
+            ? void 0
+            : _a.send({ type: "CLOSE" });
+        this.client.close();
+    }
+}
+exports.default = CastClient;

package/js/src/bridge/components/cast/discovery.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+const mdns_1 = __importDefault(require("../../lib/mdns"));
+class Discovery {
+    constructor(opts) {
+        this.browser = mdns_1.default.createBrowser(
+            "googlecast",
+            function hasServiceChanged(a, b) {
+                const txtFields = ['id', 'fn', 'md', 'ca'];
+                for (const key of txtFields) {
+                    if (a.txtRecord[key] !== b.txtRecord[key]) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        );
+        this.browser.on("serviceUp", service => {
+            if (!service.txtRecord || !service.name) return;
+            const record = service.txtRecord;
+            const device = {
+                id: record.id,
+                friendlyName: record.fn,
+                modelName: record.md,
+                capabilities: parseInt(record.ca),
+                host: service.address,
+                port: service.port
+            };
+            opts.onDeviceFound(device);
+        });
+        this.browser.on("serviceDown", service => {
+            if (!service.txtRecord || !service.name) return;
+            const record = service.txtRecord;
+            opts.onDeviceDown(record.id);
+        });
+    }
+    start() {
+        this.browser.start();
+    }
+    stop() {
+        this.browser.stop();
+    }
+}
+exports.default = Discovery;