@eluvio/elv-client-js 4.0.77 → 4.0.79

package/dist/src/client/LiveStream.js

@@ -341,7 +341,7 @@ var StreamGenerateOffering = /*#__PURE__*/function () {
  */
 exports.StreamStatus = /*#__PURE__*/function () {
   var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
-    var name, _ref5$stopLro, stopLro, _ref5$showParams, showParams, conf, status, libraryId, mainMeta, fabURI, edgeWriteToken, edgeMeta, recordings, sequence, period, tlro, sinceLastFinalize, recording_period, insertions, i, insertionTimeSinceEpoch, state, lroStatus, playout_urls, objectId, playout_options, hls_clear_enabled, hls_aes128_enabled, hls_sample_aes_enabled, networkInfo, token, embed_net, embed_url;
+    var name, _ref5$stopLro, stopLro, _ref5$showParams, showParams, conf, status, libraryId, mainMeta, fabURI, _edgeWriteToken, edgeMeta, recordings, sequence, period, tlro, sinceLastFinalize, recording_period, insertions, i, insertionTimeSinceEpoch, state, lroStatus, playout_urls, objectId, playout_options, hls_clear_enabled, hls_aes128_enabled, hls_sample_aes_enabled, networkInfo, token, embed_net, embed_url;
     return _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -372,29 +372,30 @@ exports.StreamStatus = /*#__PURE__*/function () {
           });
         case 13:
           mainMeta = _context3.sent;
+          status.reference_url = mainMeta.live_recording_config.reference_url;
           if (!(mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined)) {
-            _context3.next = 17;
+            _context3.next = 18;
             break;
           }
           status.state = "unconfigured";
           return _context3.abrupt("return", status);
-        case 17:
+        case 18:
           if (!(mainMeta.live_recording == undefined || mainMeta.live_recording.fabric_config == undefined || mainMeta.live_recording.playout_config == undefined || mainMeta.live_recording.recording_config == undefined)) {
-            _context3.next = 20;
+            _context3.next = 21;
             break;
           }
           status.state = "uninitialized";
           return _context3.abrupt("return", status);
-        case 20:
+        case 21:
           fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
           if (!(fabURI === undefined)) {
-            _context3.next = 25;
+            _context3.next = 26;
             break;
           }
           console.log("bad fabric config - missing ingress node API");
           status.state = "uninitialized";
           return _context3.abrupt("return", status);
-        case 25:
+        case 26:
           // Support both hostname and URL ingress_node_api
           if (!fabURI.startsWith("http")) {
             // Assume https
@@ -402,39 +403,39 @@ exports.StreamStatus = /*#__PURE__*/function () {
           }
           status.fabric_api = fabURI;
           status.url = mainMeta.live_recording.recording_config.recording_params.origin_url;
-          edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
-          if (!(edgeWriteToken == undefined)) {
-            _context3.next = 32;
+          _edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          if (_edgeWriteToken) {
+            _context3.next = 33;
             break;
           }
           status.state = "inactive";
           return _context3.abrupt("return", status);
-        case 32:
+        case 33:
           this.RecordWriteToken({
-            writeToken: edgeWriteToken,
+            writeToken: _edgeWriteToken,
             fabricNodeUrl: fabURI
           });
-          status.edge_write_token = edgeWriteToken;
-          status.stream_id = edgeWriteToken; // By convention the stream ID is its write token
-          _context3.next = 37;
+          status.edge_write_token = _edgeWriteToken;
+          status.stream_id = _edgeWriteToken; // By convention the stream ID is its write token
+          _context3.next = 38;
           return this.ContentObjectMetadata({
             libraryId: libraryId,
             objectId: conf.objectId,
-            writeToken: edgeWriteToken,
+            writeToken: _edgeWriteToken,
             select: ["live_recording"]
           });
-        case 37:
+        case 38:
           edgeMeta = _context3.sent;
           status.edge_meta_size = JSON.stringify(edgeMeta).length;
 
           // If a stream has never been started return state 'inactive'
           if (!(edgeMeta.live_recording === undefined || edgeMeta.live_recording.recordings === undefined || edgeMeta.live_recording.recordings.recording_sequence === undefined)) {
-            _context3.next = 42;
+            _context3.next = 43;
             break;
           }
           status.state = "stopped";
           return _context3.abrupt("return", status);
-        case 42:
+        case 43:
           recordings = edgeMeta.live_recording.recordings;
           status.recording_period_sequence = recordings.recording_sequence;
           sequence = recordings.recording_sequence;
@@ -453,14 +454,14 @@ exports.StreamStatus = /*#__PURE__*/function () {
             video_since_last_finalize_sec: sinceLastFinalize
           };
           status.recording_period = recording_period;
-          _context3.next = 53;
+          _context3.next = 54;
           return this.FabricUrl({
             libraryId: libraryId,
             objectId: conf.objectId,
-            writeToken: edgeWriteToken,
+            writeToken: _edgeWriteToken,
             call: "live/status/" + tlro
           });
-        case 53:
+        case 54:
           status.lro_status_url = _context3.sent;
           status.insertions = [];
           if (edgeMeta.live_recording.playout_config.interleaves != undefined && edgeMeta.live_recording.playout_config.interleaves[sequence] != undefined) {
@@ -480,27 +481,27 @@ exports.StreamStatus = /*#__PURE__*/function () {
           }
           state = "stopped";
           lroStatus = "";
-          _context3.prev = 59;
+          _context3.prev = 60;
           _context3.t0 = this.utils;
-          _context3.next = 63;
+          _context3.next = 64;
           return HttpClient.Fetch(status.lro_status_url);
-        case 63:
+        case 64:
           _context3.t1 = _context3.sent;
-          _context3.next = 66;
+          _context3.next = 67;
           return _context3.t0.ResponseToJson.call(_context3.t0, _context3.t1);
-        case 66:
+        case 67:
           lroStatus = _context3.sent;
           state = lroStatus.state;
-          _context3.next = 76;
+          _context3.next = 77;
           break;
-        case 70:
-          _context3.prev = 70;
-          _context3.t2 = _context3["catch"](59);
+        case 71:
+          _context3.prev = 71;
+          _context3.t2 = _context3["catch"](60);
           console.log("LRO Status (failed): ", _context3.t2.response.statusCode);
           status.state = "stopped";
           status.error = _context3.t2.response;
           return _context3.abrupt("return", status);
-        case 76:
+        case 77:
           // Convert LRO 'state' to desired 'state'
           if (state === "running" && period.video_finalized_parts_info.last_finalization_time === 0) {
             state = "starting";
@@ -511,98 +512,98 @@ exports.StreamStatus = /*#__PURE__*/function () {
           }
           status.state = state;
           if (!((state === "running" || state === "stalled" || state === "starting") && stopLro)) {
-            _context3.next = 97;
+            _context3.next = 98;
             break;
           }
-          _context3.next = 81;
+          _context3.next = 82;
           return this.FabricUrl({
             libraryId: libraryId,
             objectId: conf.objectId,
-            writeToken: edgeWriteToken,
+            writeToken: _edgeWriteToken,
             call: "live/stop/" + tlro
           });
-        case 81:
+        case 82:
           lroStopUrl = _context3.sent;
-          _context3.prev = 82;
+          _context3.prev = 83;
           _context3.t3 = this.utils;
-          _context3.next = 86;
+          _context3.next = 87;
           return HttpClient.Fetch(lroStopUrl);
-        case 86:
+        case 87:
           _context3.t4 = _context3.sent;
-          _context3.next = 89;
+          _context3.next = 90;
           return _context3.t3.ResponseToJson.call(_context3.t3, _context3.t4);
-        case 89:
+        case 90:
           console.log("LRO Stop: ", lroStatus.body);
-          _context3.next = 95;
+          _context3.next = 96;
           break;
-        case 92:
-          _context3.prev = 92;
-          _context3.t5 = _context3["catch"](82);
+        case 93:
+          _context3.prev = 93;
+          _context3.t5 = _context3["catch"](83);
           console.log("LRO Stop (failed): ", _context3.t5.response.statusCode);
-        case 95:
+        case 96:
           state = "stopped";
           status.state = state;
-        case 97:
+        case 98:
           if (!(state === "running")) {
-            _context3.next = 129;
+            _context3.next = 130;
             break;
           }
           playout_urls = {};
           objectId = conf.objectId;
-          _context3.next = 102;
+          _context3.next = 103;
           return this.PlayoutOptions({
             objectId: objectId,
             linkPath: "public/asset_metadata/sources/default"
           });
-        case 102:
+        case 103:
           playout_options = _context3.sent;
           hls_clear_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods.clear !== undefined;
           if (!hls_clear_enabled) {
-            _context3.next = 108;
+            _context3.next = 109;
             break;
           }
-          _context3.next = 107;
+          _context3.next = 108;
           return this.FabricUrl({
             libraryId: libraryId,
             objectId: objectId,
             rep: "playout/default/hls-clear/playlist.m3u8"
           });
-        case 107:
-          playout_urls.hls_clear = _context3.sent;
         case 108:
+          playout_urls.hls_clear = _context3.sent;
+        case 109:
           hls_aes128_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["aes-128"] !== undefined;
           if (!hls_aes128_enabled) {
-            _context3.next = 113;
+            _context3.next = 114;
             break;
           }
-          _context3.next = 112;
+          _context3.next = 113;
           return this.FabricUrl({
             libraryId: libraryId,
             objectId: objectId,
             rep: "playout/default/hls-aes128/playlist.m3u8"
           });
-        case 112:
-          playout_urls.hls_aes128 = _context3.sent;
         case 113:
+          playout_urls.hls_aes128 = _context3.sent;
+        case 114:
           hls_sample_aes_enabled = playout_options && playout_options.hls && playout_options.hls.playoutMethods && playout_options.hls.playoutMethods["sample-aes"] !== undefined;
           if (!hls_sample_aes_enabled) {
-            _context3.next = 118;
+            _context3.next = 119;
             break;
           }
-          _context3.next = 117;
+          _context3.next = 118;
           return this.FabricUrl({
             libraryId: libraryId,
             objectId: objectId,
             rep: "playout/default/hls-sample-aes/playlist.m3u8"
           });
-        case 117:
-          playout_urls.hls_sample_aes = _context3.sent;
         case 118:
-          _context3.next = 120;
+          playout_urls.hls_sample_aes = _context3.sent;
+        case 119:
+          _context3.next = 121;
           return this.NetworkInfo();
-        case 120:
+        case 121:
           networkInfo = _context3.sent;
-          _context3.next = 123;
+          _context3.next = 124;
           return this.authClient.AuthorizationToken({
             libraryId: libraryId,
             objectId: objectId,
@@ -610,7 +611,7 @@ exports.StreamStatus = /*#__PURE__*/function () {
             noCache: true,
             noAuth: true
           });
-        case 123:
+        case 124:
           token = _context3.sent;
           embed_net = "main";
           if (networkInfo.name.includes("demo")) {
@@ -619,20 +620,20 @@ exports.StreamStatus = /*#__PURE__*/function () {
           embed_url = "https://embed.v3.contentfabric.io/?net=".concat(embed_net, "&p&ct=h&oid=").concat(conf.objectId, "&mt=lv&ath=").concat(token);
           playout_urls.embed_url = embed_url;
           status.playout_urls = playout_urls;
-        case 129:
-          _context3.next = 134;
+        case 130:
+          _context3.next = 135;
           break;
-        case 131:
-          _context3.prev = 131;
+        case 132:
+          _context3.prev = 132;
           _context3.t6 = _context3["catch"](5);
           console.error(_context3.t6);
-        case 134:
-          return _context3.abrupt("return", status);
         case 135:
+          return _context3.abrupt("return", status);
+        case 136:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, this, [[5, 131], [59, 70], [82, 92]]);
+    }, _callee3, this, [[5, 132], [60, 71], [83, 93]]);
   }));
   return function (_x3) {
     return _ref6.apply(this, arguments);
@@ -801,31 +802,29 @@ exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
         case 0:
           name = _ref9.name, op = _ref9.op;
           _context5.prev = 1;
-          console.log("Stream ", op, ": ", name);
-          _context5.next = 5;
+          _context5.next = 4;
           return this.StreamStatus({
             name: name
           });
-        case 5:
+        case 4:
           status = _context5.sent;
           if (!(status.state != "stopped")) {
-            _context5.next = 10;
+            _context5.next = 9;
             break;
           }
           if (!(op === "start")) {
-            _context5.next = 10;
+            _context5.next = 9;
             break;
           }
           status.error = "Unable to start stream - state: " + status.state;
           return _context5.abrupt("return", status);
-        case 10:
+        case 9:
           if (!(status.state == "running" || status.state == "starting" || status.state == "stalled")) {
-            _context5.next = 33;
+            _context5.next = 31;
             break;
           }
-          console.log("STOPPING");
-          _context5.prev = 12;
-          _context5.next = 15;
+          _context5.prev = 10;
+          _context5.next = 13;
           return this.CallBitcodeMethod({
             libraryId: status.library_id,
             objectId: status.object_id,
@@ -833,50 +832,50 @@ exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
             method: "/live/stop/" + status.tlro,
             constant: false
           });
-        case 15:
-          _context5.next = 19;
+        case 13:
+          _context5.next = 17;
           break;
+        case 15:
+          _context5.prev = 15;
+          _context5.t0 = _context5["catch"](10);
         case 17:
-          _context5.prev = 17;
-          _context5.t0 = _context5["catch"](12);
-        case 19:
           // Wait until LRO is terminated
           _tries = 10;
-        case 20:
+        case 18:
           if (!(status.state != "stopped" && _tries-- > 0)) {
-            _context5.next = 29;
+            _context5.next = 27;
             break;
           }
           console.log("Wait to terminate - ", status.state);
-          _context5.next = 24;
+          _context5.next = 22;
           return Sleep(1000);
-        case 24:
-          _context5.next = 26;
+        case 22:
+          _context5.next = 24;
           return this.StreamStatus({
             name: name
           });
-        case 26:
+        case 24:
           status = _context5.sent;
-          _context5.next = 20;
+          _context5.next = 18;
           break;
-        case 29:
+        case 27:
           console.log("Status after stop - ", status.state);
           if (!(_tries <= 0)) {
-            _context5.next = 33;
+            _context5.next = 31;
             break;
           }
           console.log("Failed to stop");
           return _context5.abrupt("return", status);
-        case 33:
+        case 31:
           if (!(op === "stop")) {
-            _context5.next = 35;
+            _context5.next = 33;
             break;
           }
           return _context5.abrupt("return", status);
-        case 35:
+        case 33:
           console.log("STARTING", "edge_write_token", status.edge_write_token);
-          _context5.prev = 36;
-          _context5.next = 39;
+          _context5.prev = 34;
+          _context5.next = 37;
           return this.CallBitcodeMethod({
             libraryId: status.library_id,
             objectId: status.object_id,
@@ -884,49 +883,49 @@ exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
             method: "/live/start",
             constant: false
           });
-        case 39:
-          _context5.next = 45;
+        case 37:
+          _context5.next = 43;
           break;
-        case 41:
-          _context5.prev = 41;
-          _context5.t1 = _context5["catch"](36);
+        case 39:
+          _context5.prev = 39;
+          _context5.t1 = _context5["catch"](34);
           console.log("LRO Start (failed): ", _context5.t1);
           return _context5.abrupt("return", {
             state: status.state,
             error: "LRO start failed - must create a stream first"
           });
-        case 45:
+        case 43:
           // Wait until LRO is 'starting'
           tries = 10;
-        case 46:
+        case 44:
           if (!(status.state != "starting" && tries-- > 0)) {
-            _context5.next = 55;
+            _context5.next = 53;
             break;
           }
           console.log("Wait to start - ", status.state);
-          _context5.next = 50;
+          _context5.next = 48;
           return Sleep(1000);
-        case 50:
-          _context5.next = 52;
+        case 48:
+          _context5.next = 50;
           return this.StreamStatus({
             name: name
           });
-        case 52:
+        case 50:
           status = _context5.sent;
-          _context5.next = 46;
+          _context5.next = 44;
           break;
-        case 55:
+        case 53:
           console.log("Status after restart - ", status.state);
           return _context5.abrupt("return", status);
-        case 59:
-          _context5.prev = 59;
+        case 57:
+          _context5.prev = 57;
           _context5.t2 = _context5["catch"](1);
           console.error(_context5.t2);
-        case 62:
+        case 60:
         case "end":
           return _context5.stop();
       }
-    }, _callee5, this, [[1, 59], [12, 17], [36, 41]]);
+    }, _callee5, this, [[1, 57], [10, 15], [34, 39]]);
   }));
   return function (_x5) {
     return _ref10.apply(this, arguments);
@@ -934,8 +933,7 @@ exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
 }();
 
 /**
- * Stop the live stream session and close the edge write token.
- * Not implemented fully
+ * Close the edge write token and make the stream object inactive.
  *
  * @methodGroup Live Stream
  * @namedParams
@@ -945,13 +943,13 @@ exports.StreamStartOrStopOrReset = /*#__PURE__*/function () {
  */
 exports.StreamStopSession = /*#__PURE__*/function () {
   var _ref12 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref11) {
-    var name, conf, objectId, libraryId, mainMeta, fabURI, edgeWriteToken, edgeMeta, status, tries, fin;
+    var name, conf, objectId, libraryId, mainMeta, fabURI, metaEdgeWriteToken, streamMetadata, status, _yield$this$EditConte, writeToken, newState, stopTime, finalizeMetadata, fin;
     return _regeneratorRuntime.wrap(function _callee6$(_context6) {
       while (1) switch (_context6.prev = _context6.next) {
         case 0:
           name = _ref11.name;
           _context6.prev = 1;
-          console.log("TERMINATE: ", name);
+          this.Log("Terminating stream session for: ".concat(name));
           _context6.next = 5;
           return this.LoadConf({
             name: name
@@ -980,121 +978,108 @@ exports.StreamStopSession = /*#__PURE__*/function () {
           this.SetNodes({
             fabricURIs: [fabURI]
           });
-          edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
-          if (!(edgeWriteToken === undefined || edgeWriteToken === "")) {
+          metaEdgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+          if (metaEdgeWriteToken) {
             _context6.next = 19;
             break;
           }
           return _context6.abrupt("return", {
             state: "inactive",
-            error: "no active streams - must create a stream first"
+            error: "The stream is not active"
           });
         case 19:
-          _context6.next = 21;
+          _context6.prev = 19;
+          _context6.next = 22;
           return this.ContentObjectMetadata({
             libraryId: libraryId,
             objectId: objectId,
-            writeToken: edgeWriteToken
+            writeToken: metaEdgeWriteToken
           });
-        case 21:
-          edgeMeta = _context6.sent;
-          _context6.next = 24;
+        case 22:
+          streamMetadata = _context6.sent;
+          _context6.next = 25;
           return this.StreamStatus({
             name: name
           });
-        case 24:
+        case 25:
           status = _context6.sent;
-          if (!(status.state != "terminated")) {
-            _context6.next = 48;
+          if (!(status.state !== "stopped")) {
+            _context6.next = 28;
             break;
           }
-          console.log("STOPPING");
-          _context6.prev = 27;
+          return _context6.abrupt("return", {
+            state: status.state,
+            error: "The stream must be stopped before terminating"
+          });
+        case 28:
           _context6.next = 30;
-          return this.CallBitcodeMethod({
-            libraryId: status.library_id,
-            objectId: status.object_id,
-            writeToken: status.edge_write_token,
-            method: "/live/stop/" + status.tlro,
-            constant: false
+          return this.DeleteWriteToken({
+            libraryId: libraryId,
+            writeToken: metaEdgeWriteToken
           });
         case 30:
-          _context6.next = 34;
+          _context6.next = 35;
           break;
         case 32:
           _context6.prev = 32;
-          _context6.t0 = _context6["catch"](27);
-        case 34:
-          // Wait until LRO is terminated
-          tries = 10;
+          _context6.t0 = _context6["catch"](19);
+          this.Log("Unable to retrieve metadata for edge write token ".concat(edgeWriteToken));
         case 35:
-          if (!(status.state != "stopped" && tries-- > 0)) {
-            _context6.next = 44;
-            break;
-          }
-          console.log("Wait to terminate - ", status.state);
-          _context6.next = 39;
-          return Sleep(1000);
-        case 39:
-          _context6.next = 41;
-          return this.StreamStatus({
-            name: name
+          _context6.next = 37;
+          return this.EditContentObject({
+            libraryId: libraryId,
+            objectId: objectId
           });
-        case 41:
-          status = _context6.sent;
-          _context6.next = 35;
-          break;
-        case 44:
-          console.log("Status after stop - ", status.state);
-          if (!(tries <= 0)) {
-            _context6.next = 48;
-            break;
-          }
-          console.log("Failed to stop");
-          return _context6.abrupt("return", status);
-        case 48:
-          // Set stop time
-          edgeMeta.recording_stop_time = Math.floor(new Date().getTime() / 1000);
-          console.log("recording_start_time: ", edgeMeta.recording_start_time);
-          console.log("recording_stop_time:  ", edgeMeta.recording_stop_time);
-          edgeMeta.live_recording.status = {
-            state: "terminated",
-            recording_stop_time: edgeMeta.recording_stop_time
+        case 37:
+          _yield$this$EditConte = _context6.sent;
+          writeToken = _yield$this$EditConte.writeToken;
+          // Set stop time and inactive state
+          newState = "inactive";
+          stopTime = Math.floor(new Date().getTime() / 1000);
+          finalizeMetadata = {
+            live_recording: {
+              status: {
+                edge_write_token: "",
+                state: newState,
+                recording_stop_time: stopTime
+              },
+              fabric_config: {
+                edge_write_token: ""
+              }
+            },
+            recording_stop_time: stopTime
           };
-          edgeMeta.live_recording.fabric_config.edge_write_token = "";
-          _context6.next = 55;
-          return this.ReplaceMetadata({
+          _context6.next = 44;
+          return this.MergeMetadata({
             libraryId: libraryId,
             objectId: objectId,
-            writeToken: edgeWriteToken,
-            metadata: edgeMeta
+            writeToken: writeToken,
+            metadata: finalizeMetadata
           });
-        case 55:
-          _context6.next = 57;
+        case 44:
+          _context6.next = 46;
           return this.FinalizeContentObject({
             libraryId: libraryId,
             objectId: objectId,
-            writeToken: edgeWriteToken,
-            commitMessage: "Finalize live stream - stop time " + edgeMeta.recording_stop_time,
-            publish: false // Don't publish this version because it is not currently useful
+            writeToken: writeToken,
+            commitMessage: "Deactivate live stream - stop time ".concat(stopTime)
           });
-        case 57:
+        case 46:
           fin = _context6.sent;
           return _context6.abrupt("return", {
             fin: fin,
             name: name,
-            edge_write_token: edgeWriteToken,
-            state: "terminated"
+            state: newState
           });
-        case 61:
-          _context6.prev = 61;
+        case 50:
+          _context6.prev = 50;
           _context6.t1 = _context6["catch"](1);
           console.error(_context6.t1);
-        case 64:
+        case 53:
         case "end":
           return _context6.stop();
       }
-    }, _callee6, this, [[1, 61], [27, 32]]);
+    }, _callee6, this, [[1, 50], [19, 32]]);
   }));
   return function (_x6) {
     return _ref12.apply(this, arguments);
@@ -1662,24 +1647,25 @@ exports.StreamConfig = /*#__PURE__*/function () {
           mainMeta = _context11.sent;
           userConfig = mainMeta.live_recording_config;
           status.user_config = userConfig;
+          console.log("userConfig", userConfig);
 
           // Get node URI from user config
-          hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").split(":")[0];
+          hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").replace("srt://", "").split(":")[0];
           streamUrl = new URL(userConfig.url);
           console.log("Retrieving nodes...");
-          _context11.next = 20;
+          _context11.next = 21;
           return this.SpaceNodes({
             matchEndpoint: hostName
           });
-        case 20:
+        case 21:
           nodes = _context11.sent;
           if (!(nodes.length < 1)) {
-            _context11.next = 24;
+            _context11.next = 25;
             break;
           }
           status.error = "No node matching stream URL " + streamUrl.href;
           return _context11.abrupt("return", status);
-        case 24:
+        case 25:
           node = nodes[0];
           status.node = node;
           endpoint = node.endpoints[0];
@@ -1693,17 +1679,17 @@ exports.StreamConfig = /*#__PURE__*/function () {
           timeoutId = setTimeout(function () {
             controller.abort();
           }, 60 * 1000); // milliseconds
-          _context11.prev = 31;
-          _context11.next = 34;
+          _context11.prev = 32;
+          _context11.next = 35;
           return this.Rep({
             libraryId: libraryId,
             objectId: conf.objectId,
             rep: "probe"
           });
-        case 34:
+        case 35:
           probeUrl = _context11.sent;
           _context11.t0 = this.utils;
-          _context11.next = 38;
+          _context11.next = 39;
           return HttpClient.Fetch(probeUrl, {
             body: JSON.stringify({
               "filename": streamUrl.href,
@@ -1712,35 +1698,34 @@ exports.StreamConfig = /*#__PURE__*/function () {
             method: "POST",
             signal: controller.signal
           });
-        case 38:
+        case 39:
           _context11.t1 = _context11.sent;
-          _context11.next = 41;
+          _context11.next = 42;
           return _context11.t0.ResponseToJson.call(_context11.t0, _context11.t1);
-        case 41:
+        case 42:
           probe = _context11.sent;
           if (probe) {
             clearTimeout(timeoutId);
           }
           if (!probe.errors) {
-            _context11.next = 45;
+            _context11.next = 46;
             break;
           }
           throw probe.errors[0];
-        case 45:
-          _context11.next = 54;
+        case 46:
+          _context11.next = 55;
           break;
-        case 47:
-          _context11.prev = 47;
-          _context11.t2 = _context11["catch"](31);
+        case 48:
+          _context11.prev = 48;
+          _context11.t2 = _context11["catch"](32);
           if (!(_context11.t2.code === "ETIMEDOUT")) {
-            _context11.next = 53;
+            _context11.next = 54;
             break;
           }
           throw "Stream probe time out - make sure the stream source is available";
-        case 53:
-          throw _context11.t2;
         case 54:
-          console.log("PROBE", probe);
+          throw _context11.t2;
+        case 55:
           probe.format.filename = streamUrl.href;
 
           // Create live recording config
@@ -1773,31 +1758,199 @@ exports.StreamConfig = /*#__PURE__*/function () {
           });
         case 66:
           _context11.next = 68;
-          return this.ReplaceMetadata({
-            libraryId: libraryId,
-            objectId: conf.objectId,
-            writeToken: writeToken,
-            metadataSubtree: "probe",
-            metadata: probe
-          });
-        case 68:
-          _context11.next = 70;
           return this.FinalizeContentObject({
             libraryId: libraryId,
             objectId: conf.objectId,
             writeToken: writeToken,
             commitMessage: "Apply live stream configuration"
           });
-        case 70:
+        case 68:
           status.fin = _context11.sent;
           return _context11.abrupt("return", status);
-        case 72:
+        case 70:
         case "end":
           return _context11.stop();
       }
-    }, _callee11, this, [[31, 47]]);
+    }, _callee11, this, [[32, 48]]);
   }));
   return function (_x11) {
     return _ref22.apply(this, arguments);
   };
-}();
+}();
+
+/**
+ * List the pre-allocated URLs for a site
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} - ID of the live stream site object
+ *
+ * @return {Promise<Object>} - The list of stream URLs
+ */
+exports.StreamListUrls = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+  var _this = this;
+  var _ref24,
+    siteId,
+    STATUS_MAP,
+    tenantContractId,
+    streamMetadata,
+    activeUrlMap,
+    streamUrlStatus,
+    streamUrls,
+    _args13 = arguments;
+  return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+    while (1) switch (_context13.prev = _context13.next) {
+      case 0:
+        _ref24 = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : {}, siteId = _ref24.siteId;
+        _context13.prev = 1;
+        STATUS_MAP = {
+          UNCONFIGURED: "unconfigured",
+          UNINITIALIZED: "uninitialized",
+          INACTIVE: "inactive",
+          STOPPED: "stopped",
+          STARTING: "starting",
+          RUNNING: "running",
+          STALLED: "stalled"
+        };
+        if (siteId) {
+          _context13.next = 12;
+          break;
+        }
+        _context13.next = 6;
+        return this.userProfileClient.TenantContractId();
+      case 6:
+        tenantContractId = _context13.sent;
+        if (tenantContractId) {
+          _context13.next = 9;
+          break;
+        }
+        throw Error("No tenant contract ID configured");
+      case 9:
+        _context13.next = 11;
+        return this.ContentObjectMetadata({
+          libraryId: tenantContractId.replace("iten", "ilib"),
+          objectId: tenantContractId.replace("iten", "iq__"),
+          metadataSubtree: "public/sites/live_streams"
+        });
+      case 11:
+        siteId = _context13.sent;
+      case 12:
+        _context13.t0 = this;
+        _context13.next = 15;
+        return this.ContentObjectLibraryId({
+          objectId: siteId
+        });
+      case 15:
+        _context13.t1 = _context13.sent;
+        _context13.t2 = siteId;
+        _context13.t3 = {
+          libraryId: _context13.t1,
+          objectId: _context13.t2,
+          metadataSubtree: "public/asset_metadata/live_streams",
+          resolveLinks: true,
+          resolveIgnoreErrors: true
+        };
+        _context13.next = 20;
+        return _context13.t0.ContentObjectMetadata.call(_context13.t0, _context13.t3);
+      case 20:
+        streamMetadata = _context13.sent;
+        activeUrlMap = {};
+        _context13.next = 24;
+        return this.utils.LimitedMap(10, Object.keys(streamMetadata || {}), /*#__PURE__*/function () {
+          var _ref25 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(slug) {
+            var stream, versionHash, objectId, libraryId, status, streamMeta, url, isActive;
+            return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+              while (1) switch (_context12.prev = _context12.next) {
+                case 0:
+                  stream = streamMetadata[slug];
+                  if (stream && stream.sources && stream.sources["default"] && stream.sources["default"]["."] && stream.sources["default"]["."].container || ((stream["/"] || "").match(/^\/?qfab\/([\w]+)\/?.+/) || [])[1]) {
+                    versionHash = stream.sources["default"]["."].container || ((stream["/"] || "").match(/^\/?qfab\/([\w]+)\/?.+/) || [])[1];
+                  }
+                  if (!versionHash) {
+                    _context12.next = 16;
+                    break;
+                  }
+                  objectId = _this.utils.DecodeVersionHash(versionHash).objectId;
+                  _context12.next = 6;
+                  return _this.ContentObjectLibraryId({
+                    objectId: objectId
+                  });
+                case 6:
+                  libraryId = _context12.sent;
+                  _context12.next = 9;
+                  return _this.StreamStatus({
+                    name: objectId
+                  });
+                case 9:
+                  status = _context12.sent;
+                  _context12.next = 12;
+                  return _this.ContentObjectMetadata({
+                    objectId: objectId,
+                    libraryId: libraryId,
+                    select: ["live_recording_config/reference_url",
+                    // live_recording_config/url is the old path
+                    "live_recording_config/url"]
+                  });
+                case 12:
+                  streamMeta = _context12.sent;
+                  url = streamMeta.live_recording_config.reference_url || streamMeta.live_recording_config.url;
+                  isActive = [STATUS_MAP.STARTING, STATUS_MAP.RUNNING, STATUS_MAP.STALLED, STATUS_MAP.STOPPED].includes(status.state);
+                  if (url && isActive) {
+                    activeUrlMap[url] = true;
+                  }
+                case 16:
+                case "end":
+                  return _context12.stop();
+              }
+            }, _callee12);
+          }));
+          return function (_x12) {
+            return _ref25.apply(this, arguments);
+          };
+        }());
+      case 24:
+        streamUrlStatus = {};
+        _context13.t4 = this;
+        _context13.next = 28;
+        return this.ContentObjectLibraryId({
+          objectId: siteId
+        });
+      case 28:
+        _context13.t5 = _context13.sent;
+        _context13.t6 = siteId;
+        _context13.t7 = {
+          libraryId: _context13.t5,
+          objectId: _context13.t6,
+          metadataSubtree: "/live_stream_urls",
+          resolveLinks: true,
+          resolveIgnoreErrors: true
+        };
+        _context13.next = 33;
+        return _context13.t4.ContentObjectMetadata.call(_context13.t4, _context13.t7);
+      case 33:
+        streamUrls = _context13.sent;
+        if (streamUrls) {
+          _context13.next = 36;
+          break;
+        }
+        throw Error("No pre-allocated URLs configured");
+      case 36:
+        Object.keys(streamUrls || {}).forEach(function (protocol) {
+          streamUrlStatus[protocol] = streamUrls[protocol].map(function (url) {
+            return {
+              url: url,
+              active: activeUrlMap[url] || false
+            };
+          });
+        });
+        return _context13.abrupt("return", streamUrlStatus);
+      case 40:
+        _context13.prev = 40;
+        _context13.t8 = _context13["catch"](1);
+        console.error(_context13.t8);
+      case 43:
+      case "end":
+        return _context13.stop();
+    }
+  }, _callee13, this, [[1, 40]]);
+}));