@warren-bank/fx_cast_bridge 0.3.1

package/js/src/daemon.js

@@ -0,0 +1,181 @@
+"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.init = init;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const bridge = __importStar(require("./bridge"));
+const chalk_1 = __importDefault(require("chalk"));
+const ws_1 = __importDefault(require("ws"));
+const messaging_1 = require("./bridge/messaging");
+process.on("SIGTERM", () =>
+    __awaiter(void 0, void 0, void 0, function* () {
+        process.exit(1);
+    })
+);
+function init(opts) {
+    const server = !opts.secure
+        ? http_1.default.createServer()
+        : https_1.default.createServer({
+              key: opts.key,
+              cert: opts.cert
+          });
+    const wss = new ws_1.default.Server({ noServer: true });
+    wss.on("connection", socket => {
+        bridge.run(new messaging_1.WebsocketMessenger(socket));
+    });
+    function authenticate(req) {
+        if (!opts.password) return true;
+        const password = new URL(
+            req.url,
+            `http://${req.headers.host}`
+        ).searchParams.get("password");
+        return password === opts.password;
+    }
+    server.on("upgrade", (req, socket, head) => {
+        var _a;
+        if (
+            ((_a = req.headers.origin) === null || _a === void 0
+                ? void 0
+                : _a.startsWith("moz-extension://")) &&
+            authenticate(req)
+        ) {
+            wss.handleUpgrade(req, socket, head, ws => {
+                wss.emit("connection", ws, req);
+            });
+            return;
+        }
+        socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+        socket.destroy();
+    });
+    server.on("request", (req, res) => {
+        if ("origin" in req.headers) {
+            req.destroy();
+            return;
+        }
+        res.writeHead(authenticate(req) ? 200 : 401);
+        res.end();
+    });
+    if (
+        opts.host !== "localhost" &&
+        opts.host !== "127.0.0.1" &&
+        !opts.secure
+    ) {
+        process.stdout.write(
+            chalk_1.default.red(
+                "WARNING: A non-local host is set, but secure connections are not enabled!\n"
+            )
+        );
+    }
+    process.stdout.write(
+        `Starting WebSocket server at ${opts.secure ? "wss" : "ws"}://${opts.host.includes(":") ? `[${opts.host}]` : opts.host}:${opts.port}... `
+    );
+    server.listen({ port: opts.port, host: opts.host }, () => {
+        process.stdout.write("Done!\n");
+    });
+    server.on("error", err => {
+        console.error("Failed!");
+        console.error(err.message);
+    });
+}

package/js/src/main.js

@@ -0,0 +1,236 @@
+#! /usr/bin/env node
+
+"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 });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yargs_1 = __importDefault(require("yargs"));
+const config_json_1 = require("../config.json");
+const messaging_1 = require("./bridge/messaging");
+const argv = (0, yargs_1.default)()
+    .scriptName(config_json_1.applicationName)
+    .usage("$0 [args]")
+    .help()
+    .alias("help", "h")
+    .version(`v${config_json_1.applicationVersion}`)
+    .alias("version", "v")
+    .config("config", parseConfig)
+    .option("daemon", {
+        alias: "d",
+        describe: `Launch in daemon mode. This starts a WebSocket server that \
+the extension can be configured to connect to under bridge options.`,
+        type: "boolean",
+        default: true
+    })
+    .option("host", {
+        alias: "n",
+        describe: `Host for daemon WebSocket server. This must match the host \
+set in the extension options.`,
+        default: "localhost"
+    })
+    .option("port", {
+        alias: "p",
+        describe: `Port number for daemon WebSocket server. This must match \
+the port set in the extension options.`,
+        default: 9556
+    })
+    .option("password", {
+        alias: "P",
+        describe: `Set an optional password for the daemon WebSocket server. \
+This must match the password set in the extension options.
+Note: If using this option it is highly recommended that you enable secure \
+connections to avoid leaking plaintext passwords!`,
+        type: "string"
+    })
+    .option("secure", {
+        alias: "s",
+        describe: `Use a secure HTTPS server for WebSocket connections. \
+Requires key/cert file options to be specified.`,
+        type: "boolean",
+        default: false
+    })
+    .option("key-file", {
+        alias: "k",
+        describe: `Path to the private key PEM file to use for the \
+HTTPS server.`,
+        type: "string"
+    })
+    .option("cert-file", {
+        alias: "c",
+        describe: `Path to the certificate PEM file to use for the \
+HTTPS server.`,
+        type: "string"
+    })
+    .check(argv => {
+        if (!argv.daemon) {
+            argv.daemon = true;
+        }
+        if (argv.port < 1025 || argv.port > 65535) {
+            throw new Error("Invalid port specified!");
+        }
+        if (argv.secure) {
+            if (!argv["key-file"] || !argv["cert-file"]) {
+                throw new Error("Missing required key/cert files.");
+            }
+            if (
+                !fs_1.default.existsSync(argv["key-file"]) ||
+                !fs_1.default.existsSync(argv["cert-file"])
+            ) {
+                throw new Error("Specified key/cert files do not exist.");
+            }
+        }
+        return true;
+    })
+    .parseSync(process.argv);
+function parseConfig(configPath) {
+    let config;
+    try {
+        config = JSON.parse(
+            fs_1.default.readFileSync(configPath, { encoding: "utf-8" })
+        );
+    } catch (err) {
+        throw new Error(`Failed to parse config file!`);
+    }
+    const configDirName = path_1.default.dirname(configPath);
+    if (typeof config["key-file"] === "string") {
+        config["key-file"] = path_1.default.resolve(
+            configDirName,
+            config["key-file"]
+        );
+    }
+    if (typeof config["cert-file"] === "string") {
+        config["cert-file"] = path_1.default.resolve(
+            configDirName,
+            config["cert-file"]
+        );
+    }
+    return config;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (argv.daemon) {
+            const daemon = yield Promise.resolve().then(() =>
+                __importStar(require("./daemon"))
+            );
+            const daemonOpts = {
+                host: argv.host,
+                port: argv.port,
+                password: argv.password
+            };
+            if (argv.secure) {
+                daemonOpts.secure = true;
+                daemonOpts.key = fs_1.default.readFileSync(argv.keyFile);
+                daemonOpts.cert = fs_1.default.readFileSync(argv.certFile);
+            }
+            daemon.init(daemonOpts);
+        } else {
+            const bridge = yield Promise.resolve().then(() =>
+                __importStar(require("./bridge"))
+            );
+            bridge.run(new messaging_1.StdioMessenger());
+        }
+    });
+}
+main();

package/js/src/transforms.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncodeTransform =
+    exports.DecodeTransform =
+    exports.ResponseTransform =
+        void 0;
+const stream_1 = require("stream");
+class ResponseTransform extends stream_1.Transform {
+    constructor(_handler) {
+        super({
+            readableObjectMode: true,
+            writableObjectMode: true
+        });
+        this._handler = _handler;
+    }
+    _transform(chunk, _encoding, callback) {
+        Promise.resolve(this._handler(chunk)).then(res => {
+            if (res) {
+                callback(null, res);
+            } else {
+                callback(null);
+            }
+        });
+    }
+}
+exports.ResponseTransform = ResponseTransform;
+class DecodeTransform extends stream_1.Transform {
+    constructor() {
+        super({
+            readableObjectMode: true
+        });
+        this._messageBuffer = Buffer.alloc(0);
+    }
+    _transform(chunk, _encoding, callback) {
+        this._messageBuffer = Buffer.concat([this._messageBuffer, chunk]);
+        for (;;) {
+            if (this._messageLength === undefined) {
+                if (this._messageBuffer.length >= 4) {
+                    this._messageLength = this._messageBuffer.readUInt32LE(0);
+                    this._messageBuffer = this._messageBuffer.slice(4);
+                    continue;
+                }
+            } else {
+                if (this._messageBuffer.length >= this._messageLength) {
+                    const message = JSON.parse(
+                        this._messageBuffer
+                            .slice(0, this._messageLength)
+                            .toString()
+                    );
+                    this.push(message);
+                    this._messageBuffer = this._messageBuffer.slice(
+                        this._messageLength
+                    );
+                    this._messageLength = undefined;
+                    continue;
+                }
+            }
+            callback();
+            break;
+        }
+    }
+}
+exports.DecodeTransform = DecodeTransform;
+class EncodeTransform extends stream_1.Transform {
+    constructor() {
+        super({
+            writableObjectMode: true
+        });
+    }
+    _transform(chunk, _encoding, callback) {
+        const messageLength = Buffer.alloc(4);
+        const message = Buffer.from(JSON.stringify(chunk));
+        messageLength.writeUInt32LE(message.length, 0);
+        callback(null, Buffer.concat([messageLength, message]));
+    }
+}
+exports.EncodeTransform = EncodeTransform;

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@warren-bank/fx_cast_bridge",
+    "version": "0.3.1",
+    "description": "fx_cast companion application (bridge)",
+    "license": "MIT",
+    "type": "commonjs",
+    "files": [
+        "js/"
+    ],
+    "bin": {
+        "fx_cast_bridge": "./js/src/main.js"
+    },
+    "scripts": {
+        "start": "node ./js/src/main.js"
+    },
+    "dependencies": {
+        "bplist-creator": "^0.1.0",
+        "bplist-parser": "^0.3.1",
+        "castv2": "^0.1.10",
+        "chalk": "^4.1.2",
+        "fast-srp-hap": "^2.0.4",
+        "mime-types": "^2.1.35",
+        "node-dns-sd": "^1.0.1",
+        "node-fetch": "^3.2.10",
+        "tweetnacl": "^1.0.3",
+        "ws": "^8.5.0",
+        "yargs": "^17.5.1"
+    },
+    "devDependencies": {
+        "@types/mdns": "^0.0.34",
+        "@types/mime-types": "^2.1.1",
+        "@types/minimist": "^1.2.2",
+        "@types/node": "^17.0.26",
+        "@types/node-fetch": "^2.6.1",
+        "@types/ws": "^8.5.3",
+        "@types/yargs": "^17.0.11",
+        "fs-extra": "^10.1.0",
+        "mustache": "^4.2.0",
+        "tiny-typed-emitter": "^2.1.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/warren-bank/fork-node-fx_cast_bridge"
+    },
+    "keywords": [
+        "fx_cast",
+        "bridge",
+        "firefox",
+        "chromecast"
+    ]
+}