☰

MPV Shim Local Connection

Allow Plex to connect to MPV Shim running on the same computer without a local Plex server.

  1. // ==UserScript==
  2. // @name     MPV Shim Local Connection
  3. // @version  2.3
  4. // @grant GM.xmlHttpRequest
  5. // @include  https://app.plex.tv/*
  6. // @connect  127.0.0.1
  7. // @description Allow Plex to connect to MPV Shim running on the same computer without a local Plex server.
  8. // @license  MIT; https://spdx.org/licenses/MIT.html#licenseText
  9. // @namespace https://greasyfork.org/users/456605
  10. // ==/UserScript==
  11.  
  12. function messageHandler(event) {
  13.     let message;
  14.     try {
  15.         message = JSON.parse(event.data);
  16.     } catch(_) {
  17.         return;
  18.     }
  19.     if (message.eventName != "gm_xhr_send") return;
  20.     let parsedURL = new URL(message.url);
  21.     parsedURL.host = "127.0.0.1:3000";
  22.     parsedURL.protocol = "http:";
  23.     GM.xmlHttpRequest({
  24.         method: 'GET',
  25.         url: parsedURL.toString(),
  26.         headers: {
  27.             "X-Plex-Client-Identifier": parsedURL.searchParams.get("X-Plex-Client-Identifier")
  28.         },
  29.         onload: function (result) {
  30.             window.postMessage(JSON.stringify({
  31.                 eventName: "gm_xhr_recv",
  32.                 response: result.responseText,
  33.                 headers: result.responseHeaders,
  34.                 id: message.id
  35.             }), "*");
  36.         }
  37.     });
  38. }
  39.  
  40. window.addEventListener("message", messageHandler, false);
  41.  
  42. function main () {
  43.     // From https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
  44.     function uuidv4() {
  45.         return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
  46.           (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
  47.         );
  48.     }
  49.     
  50.     let clientId = localStorage.getItem('gmpx_uuid');
  51.     if (!clientId) {
  52.         clientId = uuidv4();
  53.         localStorage.setItem('gmpx_uuid', clientId);
  54.     }
  55.   
  56.     let serverId = localStorage.getItem('gmpx_suuid');
  57.     if (!serverId) {
  58.         serverId = uuidv4();
  59.         localStorage.setItem('gmpx_suuid', serverId);
  60.     }
  61.  
  62.     // Yes I know this is disgusting. But apparently you can't cast to a server that isn't local.
  63.     // The Plex Web App doesn't even *try* to check for clients.
  64.     var inject = true;
  65.   
  66.     var fake_cast_server_resource = {
  67.       "name": "fake-cast-server",
  68.       "product": "Plex Media Server",
  69.       "productVersion": "1.18.9.2571-e106a8a91",
  70.       "platform": "Linux",
  71.       "platformVersion": "10 (buster)",
  72.       "device": "PC",
  73.       "clientIdentifier": serverId,
  74.       "createdAt": "2000-01-01T00:00:00Z",
  75.       "lastSeenAt": "2000-01-01T00:00:00Z",
  76.       "provides": "server",
  77.       "ownerId": null,
  78.       "sourceTitle": null,
  79.       "publicAddress": "0.0.0.0",
  80.       "accessToken": "AAAAAAAAAAAAAAAAAAAA",
  81.       "owned": false,
  82.       "home": false,
  83.       "synced": false,
  84.       "relay": false,
  85.       "presence": false,
  86.       "httpsRequired": false,
  87.       "publicAddressMatches": false,
  88.       "dnsRebindingProtection": false,
  89.       "natLoopbackSupported": true,
  90.       "connections": [
  91.         {
  92.           "protocol": "https",
  93.           "address": "127.0.0.1",
  94.           "port": 32400,
  95.           "uri": "https://fake.uri",
  96.           "local": true,
  97.           "relay": false,
  98.           "IPv6": false
  99.         }
  100.       ]
  101.     };
  102.  
  103.     var fake_cast_server_provider = {
  104.       "MediaContainer": {
  105.         "size": 1,
  106.         "allowCameraUpload": false,
  107.         "allowChannelAccess": false,
  108.         "allowMediaDeletion": false,
  109.         "allowSharing": false,
  110.         "allowSync": false,
  111.         "allowTuners": false,
  112.         "backgroundProcessing": false,
  113.         "certificate": true,
  114.         "companionProxy": true,
  115.         "countryCode": "usa",
  116.         "diagnostics": "",
  117.         "eventStream": false,
  118.         "friendlyName": "fake-cast-server",
  119.         "livetv": 7,
  120.         "machineIdentifier": serverId,
  121.         "myPlex": false,
  122.         "myPlexMappingState": "mapped",
  123.         "myPlexSigninState": "ok",
  124.         "myPlexSubscription": true,
  125.         "myPlexUsername": "admin@fake.uri",
  126.         "ownerFeatures": "",
  127.         "photoAutoTag": false,
  128.         "platform": "Linux",
  129.         "platformVersion": "10 (buster)",
  130.         "pluginHost": false,
  131.         "pushNotifications": false,
  132.         "readOnlyLibraries": false,
  133.         "streamingBrainABRVersion": 3,
  134.         "streamingBrainVersion": 2,
  135.         "sync": false,
  136.         "transcoderActiveVideoSessions": 0,
  137.         "transcoderAudio": false,
  138.         "transcoderLyrics": false,
  139.         "transcoderSubtitles": false,
  140.         "transcoderVideo": false,
  141.         "transcoderVideoBitrates": "64,96,208,320,720,1500,2000,3000,4000,8000,10000,12000,20000",
  142.         "transcoderVideoQualities": "0,1,2,3,4,5,6,7,8,9,10,11,12",
  143.         "transcoderVideoResolutions": "128,128,160,240,320,480,768,720,720,1080,1080,1080,1080",
  144.         "updatedAt": 946702800,
  145.         "updater": false,
  146.         "version": "1.18.9.2571-e106a8a91",
  147.         "voiceSearch": false,
  148.         "MediaProvider": []
  149.       }
  150.     };
  151.   
  152.     window.gmpx_eventHandlers = {};
  153.     window.gmpx_id = 0;
  154.     const parser = new DOMParser();
  155.     const serializer = new XMLSerializer();
  156.     function gmpx_messageHandler(event) {
  157.         let message;
  158.         try {
  159.             message = JSON.parse(event.data);
  160.         } catch(_) {
  161.             return;
  162.         }
  163.         if (message.eventName != "gm_xhr_recv") return;
  164.         window.gmpx_eventHandlers[message.id](message);
  165.         window.gmpx_eventHandlers[message.id] = undefined;
  166.     }
  167.     window.addEventListener("message", gmpx_messageHandler, false);
  168.     function intercept(url, responseText) {
  169.         if (url == "") return;
  170.         let parsedURL = new URL(url);
  171.         if (parsedURL.pathname == "/clients") {
  172.             const xml = parser.parseFromString(responseText, "text/xml");
  173.             const s = xml.createElement("Server")
  174.  
  175.             s.setAttribute("name", "local (direct)");
  176.             s.setAttribute("host", "127.0.0.1");
  177.             s.setAttribute("address", "127.0.0.1");
  178.             s.setAttribute("port", "3000");
  179.             s.setAttribute("machineIdentifier", clientId);
  180.             s.setAttribute("version", "1.0");
  181.             s.setAttribute("protocol", "plex");
  182.             s.setAttribute("product", "Plex MPV Shim");
  183.             s.setAttribute("deviceClass", "pc");
  184.             s.setAttribute("protocolVersion", "1");
  185.             s.setAttribute("protocolCapabilities", "timeline,playback,navigation,playqueues");
  186.  
  187.             xml.children[0].appendChild(s);
  188.             inject = false;
  189.             return serializer.serializeToString(xml);
  190.         } else if (parsedURL.pathname == "/api/v2/resources" && (parsedURL.hostname == "clients.plex.tv" || parsedURL.hostname == "plex.tv") && inject) {
  191.             const parsed = JSON.parse(responseText);
  192.             parsed.unshift(fake_cast_server_resource);
  193.             return JSON.stringify(parsed);
  194.         } else {
  195.             return responseText;
  196.         }
  197.     }
  198.  
  199.     // From https://stackoverflow.com/questions/26447335/
  200.     // Please note: This is very dirty in the way it works. Don't expect it to work perfectly in all areas.
  201.     (function() {
  202.         // create XMLHttpRequest proxy object
  203.         var oldXMLHttpRequest = XMLHttpRequest;
  204.         var oldWebSocket = WebSocket;
  205.       
  206.         WebSocket = function(url, extra) {
  207.             var self = this;
  208.             if (url.indexOf("fake.uri") >= 0) {
  209.                 self.override = true;
  210.                 var actual = {};
  211.             } else {
  212.                 var actual = new oldWebSocket(url, extra);
  213.             }
  214.             
  215.             // add all proxy getters/setters
  216.             ["binaryType", "bufferedAmount", "extensions", "onclose", "onerror",
  217.              "onmessage", "onopen", "protocol", "readyState", "url"].forEach(function(item) {
  218.                 Object.defineProperty(self, item, {
  219.                     get: function() { return actual[item];},
  220.                     set: function(val) { actual[item] = val;}
  221.                 });
  222.             });
  223.           
  224.             // add all pure proxy pass-through methods
  225.             ["close", "send"].forEach(function(item) {
  226.                 Object.defineProperty(self, item, {
  227.                     value: function() {
  228.                         if (self.override) { return; }
  229.                         return actual[item].apply(actual, arguments);
  230.                     }
  231.                 });
  232.             });
  233.         }
  234.         
  235.         WebSocket.CONNECTING = 0;
  236.         WebSocket.OPEN = 1;
  237.         WebSocket.CLOSING = 2;
  238.         WebSocket.CLOSED = 3;
  239.  
  240.         // define constructor for my proxy object
  241.         XMLHttpRequest = function() {
  242.             var actual = new oldXMLHttpRequest();
  243.             var self = this;
  244.             self.override = false;
  245.  
  246.             this.onreadystatechange = null;
  247.  
  248.             // this is the actual handler on the real XMLHttpRequest object
  249.             actual.onreadystatechange = function() {
  250.                 if (this.readyState == 4 && (actual.responseType == '' || actual.responseType == 'text')) {
  251.                     try {
  252.                         self._responseText = intercept(actual.responseURL, actual.responseText);
  253.                     } catch (err) {
  254.                         self._responseText = actual.responseText;
  255.                     }
  256.                 }
  257.                 if (self.onreadystatechange) {
  258.                     return self.onreadystatechange();
  259.                 }
  260.             };
  261.  
  262.             // add all proxy getters/setters
  263.             ["upload", "ontimeout, timeout", "withCredentials", "onerror", "onprogress"].forEach(function(item) {
  264.                 Object.defineProperty(self, item, {
  265.                     get: function() { return actual[item];},
  266.                     set: function(val) { actual[item] = val;}
  267.                 });
  268.             });
  269.  
  270.             // add all proxy getters/setters
  271.             ["response", "statusText", "status", "readyState", "responseURL", "responseType", "responseText"].forEach(function(item) {
  272.                 Object.defineProperty(self, item, {
  273.                     get: function() {
  274.                         if (self.hasOwnProperty("_" + item)) {
  275.                             return self["_" + item];
  276.                         } else {
  277.                             return actual[item];
  278.                         }
  279.                     },
  280.                     set: function(val) {actual[item] = val;}
  281.                 });
  282.             });
  283.  
  284.             // add all pure proxy pass-through methods
  285.             ["addEventListener", "abort", "getResponseHeader", "overrideMimeType", "setRequestHeader"].forEach(function(item) {
  286.                 Object.defineProperty(self, item, {
  287.                     value: function() {
  288.                         if (self.override) { return; }
  289.                         return actual[item].apply(actual, arguments);
  290.                     }
  291.                 });
  292.             });
  293.  
  294.             self.open = function() {
  295.                 if (arguments[0] == "GET") {
  296.                     const parsedURL = new URL(arguments[1]);
  297.                     if (parsedURL.searchParams.get("X-Plex-Target-Client-Identifier") == clientId) {
  298.                         const url = arguments[1];
  299.                         self.override = true;
  300.                         self._readyState = 1;
  301.                         self._send = function() {
  302.                             const id = window.gmpx_id++;
  303.                             self._responseURL = url;
  304.                             self._responseType = "";
  305.                             window.gmpx_eventHandlers[id] = function(result) {
  306.                                 self._readyState = 4;
  307.                                 self._status = 200;
  308.                                 self._statusText = "OK";
  309.                                 self._responseText = result.response;
  310.                                 self.headers = result.headers;
  311.                                 if (self.onreadystatechange) {
  312.                                     self.onreadystatechange();
  313.                                 }
  314.                                 if (self._onload) {
  315.                                     self._onload();
  316.                                 }
  317.                             };
  318.                             window.postMessage(JSON.stringify({
  319.                                 eventName: "gm_xhr_send",
  320.                                 url: url,
  321.                                 id: id
  322.                             }), "*");
  323.                         }
  324.                     } else if (parsedURL.hostname == "fake.uri") {
  325.                         const url = arguments[1];
  326.                         self.override = true;
  327.                         self.override2 = true;
  328.                         self._readyState = 1;
  329.                         self._send = function() {
  330.                             self._responseURL = url;
  331.                             self._responseType = "";
  332.                             self._status = 200;
  333.                             self._statusText = "OK";
  334.                             self._readyState = 4;
  335.                             
  336.                             self._responseText = "";
  337.                             if (parsedURL.pathname == "/clients") {
  338.                                 const xml = parser.parseFromString('<MediaContainer/>', 'text/xml');
  339.                                 const s = xml.createElement("Server");
  340.                                 s.setAttribute("name", "local (direct)");
  341.                                 s.setAttribute("host", "127.0.0.1");
  342.                                 s.setAttribute("address", "127.0.0.1");
  343.                                 s.setAttribute("port", "3000");
  344.                                 s.setAttribute("machineIdentifier", clientId);
  345.                                 s.setAttribute("version", "1.0");
  346.                                 s.setAttribute("protocol", "plex");
  347.                                 s.setAttribute("product", "Plex MPV Shim");
  348.                                 s.setAttribute("deviceClass", "pc");
  349.                                 s.setAttribute("protocolVersion", "1");
  350.                                 s.setAttribute("protocolCapabilities", "timeline,playback,navigation,playqueues");
  351.                                 xml.children[0].appendChild(s);
  352.                                 self._responseText = serializer.serializeToString(xml);
  353.                             } else if (parsedURL.pathname == "/neighborhood/devices") {
  354.                                 return "<MediaContainer size=\"0\"/>";
  355.                             } else if (parsedURL.pathname == "/media/providers") {
  356.                                 self._responseText = JSON.stringify(fake_cast_server_provider);
  357.                             } else if (parsedURL.pathname == "/player/proxy/poll") {
  358.                                 return;
  359.                             } else {
  360.                                  console.log("Unhandled URL: " + arguments[1]);
  361.                             }
  362.  
  363.                             if (self.onreadystatechange) {
  364.                                 self.onreadystatechange();
  365.                             }
  366.                             if (self._onload) {
  367.                                 self._onload();
  368.                             }
  369.                         }
  370.                     } else {
  371.                         return actual.open.apply(actual, arguments);
  372.                     }
  373.                 } else {
  374.                     return actual.open.apply(actual, arguments);
  375.                 }
  376.             }
  377.  
  378.             self.send = function() {
  379.                 if (self.override) {
  380.                     self._send();
  381.                 } else {
  382.                     return actual.send.apply(actual, arguments);
  383.                 }
  384.             }
  385.  
  386.             self.getAllResponseHeaders = function() {
  387.                 if (self.override2) {
  388.                     return "";
  389.                 } else if (self.override) {
  390.                     const headers = self.headers.split("\r\n");
  391.                     for (let i = 0; i < headers.length; i++) {
  392.                         if (headers[i].indexOf("x-plex-client-identifier") >= 0) {
  393.                             headers[i] = "x-plex-client-identifier: " + clientId;
  394.                         }
  395.                     }
  396.                     return headers.join("\r\n");
  397.                 } else {
  398.                     return actual.getAllResponseHeaders.apply(actual, arguments);
  399.                 }
  400.  
  401.             }
  402.  
  403.             Object.defineProperty(self, "responseXML", {
  404.                 get: function() {
  405.                     if (self.override) {
  406.                         return parser.parseFromString(self._responseText, "text/xml");
  407.                     } else {
  408.                         return actual[item];
  409.                     }
  410.                 }
  411.             });
  412.  
  413.             Object.defineProperty(self, "onload", {
  414.                 get: function() { if (self.override) return self._onload; return actual.onload;},
  415.                 set: function(val) { if (self.override) self._onload = val; else actual.onload = val;}
  416.             });
  417.         }
  418.     })();
  419. }
  420.  
  421. // From https://stackoverflow.com/questions/2303147/
  422. var script = document.createElement('script');
  423. script.appendChild(document.createTextNode('('+ main +')();'));
  424. (document.body || document.head || document.documentElement).appendChild(script);