feat: Preliminary Support for Viper-backed OAuth in Sonos

dljsjr · dljsjr · commit 3e52f1a9a5a6 · 2025-04-15T18:01:25.000-05:00
diff --git a/drivers/SmartThings/sonos/src/api/cmd_handlers.lua b/drivers/SmartThings/sonos/src/api/cmd_handlers.lua
@@ -24,6 +24,14 @@ local function _do_send_to_group(driver, device, payload)
   local household_id, group_id = driver.sonos:get_group_for_device(device)
   payload[1].householdId = household_id
   payload[1].groupId = group_id
+  local maybe_token, err = driver:get_oauth_token()
+  if err then
+    log.warn(string.format("notice: get_oauth_token -> %s", err))
+  end
+
+  if maybe_token then
+    payload[1].authorization = string.format("Bearer %s", maybe_token.access_token)
+  end
 
   _do_send(device, payload)
 end
@@ -32,7 +40,14 @@ local function _do_send_to_self(driver, device, payload)
   local household_id, player_id = driver.sonos:get_player_for_device(device)
   payload[1].householdId = household_id
   payload[1].playerId = player_id
+  local maybe_token, err = driver:get_oauth_token()
+  if err then
+    log.warn(string.format("notice: get_oauth_token -> %s", err))
+  end
 
+  if maybe_token then
+    payload[1].authorization = string.format("Bearer %s", maybe_token.access_token)
+  end
   _do_send(device, payload)
 end
 
diff --git a/drivers/SmartThings/sonos/src/api/rest.lua b/drivers/SmartThings/sonos/src/api/rest.lua
@@ -72,21 +72,43 @@ local SonosRestApi = {}
 --- Query a Sonos Group IP address for individual player info
 --- @param ip string the IP address of the player
 --- @param port integer the port number of the player
+--- @param access_token string? the OAuth Access Token
 --- @return SonosDiscoveryInfo|nil
 --- @return string|nil error
-function SonosRestApi.get_player_info(ip, port)
+function SonosRestApi.get_player_info(ip, port, access_token)
   local url = "https://" .. ip .. ":" .. port .. "/api/v1/players/local/info"
-  return process_rest_response(RestClient.one_shot_get(url, HEADERS))
+  local headers = {}
+  for k,v in pairs(HEADERS) do
+    headers[k] = v
+  end
+  if type(access_token) == "string" then
+    headers['Authorization'] = string.format("Bearer %s", access_token)
+  end
+  return process_rest_response(RestClient.one_shot_get(url, headers))
 end
 
-function SonosRestApi.get_groups_info(ip, port, household)
+function SonosRestApi.get_groups_info(ip, port, household, access_token)
   local url = string.format("https://%s:%s/api/v1/households/%s/groups", ip, port, household)
-  return process_rest_response(RestClient.one_shot_get(url, HEADERS))
+  local headers = {}
+  for k,v in pairs(HEADERS) do
+    headers[k] = v
+  end
+  if type(access_token) == "string" then
+    headers['Authorization'] = string.format("Bearer %s", access_token)
+  end
+  return process_rest_response(RestClient.one_shot_get(url, headers))
 end
 
-function SonosRestApi.get_favorites(ip, port, household)
+function SonosRestApi.get_favorites(ip, port, household, access_token)
   local url = string.format("https://%s:%s/api/v1/households/%s/favorites", ip, port, household)
-  return process_rest_response(RestClient.one_shot_get(url, HEADERS))
+  local headers = {}
+  for k,v in pairs(HEADERS) do
+    headers[k] = v
+  end
+  if type(access_token) == "string" then
+    headers['Authorization'] = string.format("Bearer %s", access_token)
+  end
+  return process_rest_response(RestClient.one_shot_get(url, headers))
 end
 
 return SonosRestApi
diff --git a/drivers/SmartThings/sonos/src/api/sonos_connection.lua b/drivers/SmartThings/sonos/src/api/sonos_connection.lua
@@ -40,16 +40,26 @@ local favorites_version = ""
 ---@param sonos_conn SonosConnection
 ---@param namespaces string[]
 ---@param command "subscribe"|"unsubscribe"
-local _update_subscriptions_helper = function(sonos_conn, householdId, playerId, groupId, namespaces, command)
+local _update_subscriptions_helper = function(sonos_conn, householdId, playerId, groupId, namespaces,
+                                              command)
   for _, namespace in ipairs(namespaces) do
+    local wss_msg_header = {
+      namespace = namespace,
+      command = command,
+      householdId = householdId,
+      groupId = groupId,
+      playerId = playerId
+    }
+    local maybe_token, err = sonos_conn.driver:get_oauth_token()
+    if err then
+      log.warn(string.format("notice: get_oauth_token -> %s", err))
+    end
+
+    if maybe_token then
+      wss_msg_header.authorization = string.format("Bearer %s", maybe_token.access_token)
+    end
     local payload_table = {
-      {
-        namespace = namespace,
-        command = command,
-        householdId = householdId,
-        groupId = groupId,
-        playerId = playerId
-      },
+      wss_msg_header,
       {}
     }
     local payload = json.encode(payload_table)
@@ -82,7 +92,8 @@ end
 ---@param self_player_id PlayerId
 local function _open_coordinator_socket(sonos_conn, household_id, self_player_id)
   log.debug("Open coordinator socket for: " .. sonos_conn.device.label)
-  local _, coordinator_id, err = sonos_conn.driver.sonos:get_coordinator_for_device(sonos_conn.device)
+  local _, coordinator_id, err = sonos_conn.driver.sonos:get_coordinator_for_device(sonos_conn
+    .device)
   if err ~= nil then
     log.error(
       string.format(
@@ -95,14 +106,16 @@ local function _open_coordinator_socket(sonos_conn, household_id, self_player_id
   if coordinator_id ~= self_player_id then
     local household = sonos_conn.driver.sonos:get_household(household_id)
     if household == nil then
-      log.error(string.format("Cannot open coordinator socket, houshold doesn't exist: %s", household_id))
+      log.error(string.format("Cannot open coordinator socket, houshold doesn't exist: %s",
+        household_id))
       return
     end
 
     local coordinator = household.players[coordinator_id]
     if coordinator == nil then
       log.error(st_utils.stringify_table(
-        {household = sonos_conn.driver.sonos:get_household(household_id)}, string.format("Coordinator doesn't exist for player: %s", sonos_conn.device.label), false
+        { household = sonos_conn.driver.sonos:get_household(household_id) },
+        string.format("Coordinator doesn't exist for player: %s", sonos_conn.device.label), false
       ))
       return
     end
@@ -155,11 +168,26 @@ end
 ---@param sonos_conn SonosConnection
 local function _spawn_reconnect_task(sonos_conn)
   log.debug("Spawning reconnect task for ", sonos_conn.device.label)
+  local token_receive_handle, err = sonos_conn.driver:get_oauth_token_receive_handle()
+  if not token_receive_handle then
+    log.warn(string.format("error creating oauth token receive handle for respawn task: %s", err))
+  end
   cosock.spawn(function()
     local backoff = backoff_builder(60, 1, 0.1)
     while not sonos_conn:is_running() do
-      local start_success = sonos_conn:start()
-      if start_success then return end
+      if sonos_conn.driver.waiting_for_token and token_receive_handle then
+        local token, channel_error = token_receive_handle:receive()
+        if not token then
+          log.warn(string.format("Error requesting token: %s", channel_error))
+          local _, get_token_err = sonos_conn.driver:get_oauth_token()
+          if get_token_err then
+            log.warn(string.format("notice: get_oauth_token -> %s", get_token_err))
+          end
+        end
+      else
+        local start_success = sonos_conn:start()
+        if start_success then return end
+      end
       cosock.socket.sleep(backoff())
     end
   end, string.format("%s Reconnect Task", sonos_conn.device.label))
@@ -171,7 +199,8 @@ end
 --- @return SonosConnection
 function SonosConnection.new(driver, device)
   log.debug(string.format("Creating new SonosConnection for %s", device.label))
-  local self = setmetatable({ driver = driver, device = device, _listener_uuids = {}, _initialized = false },
+  local self = setmetatable(
+    { driver = driver, device = device, _listener_uuids = {}, _initialized = false },
     SonosConnection)
 
   -- capture the label here in case something goes wonky like a callback being fired after a
@@ -185,14 +214,16 @@ function SonosConnection.new(driver, device)
       local success = table.remove(json_result, 1)
       if not success then
         log.error(st_utils.stringify_table(
-          {response_body = msg.data, json = json_result}, "Couldn't decode JSON in WebSocket callback:", false
+          { response_body = msg.data, json = json_result },
+          "Couldn't decode JSON in WebSocket callback:", false
         ))
         return
       end
       local header, body = table.unpack(table.unpack(json_result))
       if header.type == "groups" then
         log.trace(string.format("Groups type message for %s", device_name))
-        local household_id, current_coordinator = self.driver.sonos:get_coordinator_for_device(self.device)
+        local household_id, current_coordinator = self.driver.sonos:get_coordinator_for_device(self
+          .device)
         local _, player_id = self.driver.sonos:get_player_for_device(self.device)
         self.driver.sonos:update_household_info(header.householdId, body, self.device)
         local _, updated_coordinator = self.driver.sonos:get_coordinator_for_device(self.device)
@@ -225,8 +256,9 @@ function SonosConnection.new(driver, device)
           local household = self.driver.sonos:get_household(header.householdId)
           if household == nil or household.groups == nil then
             log.error(st_utils.stringify_table(
-              {response_body = msg.data, household = household or header.householdId},
-              "Received groupVolume message for non-existent household or household groups dont exist", false
+              { response_body = msg.data, household = household or header.householdId },
+              "Received groupVolume message for non-existent household or household groups dont exist",
+              false
             ))
             return
           end
@@ -246,8 +278,9 @@ function SonosConnection.new(driver, device)
         local household = self.driver.sonos:get_household(header.householdId)
         if household == nil or household.groups == nil then
           log.error(st_utils.stringify_table(
-            {response_body = msg.data, household = household or header.householdId},
-            "Received playbackStatus message for non-existent household or household groups dont exist", false
+            { response_body = msg.data, household = household or header.householdId },
+            "Received playbackStatus message for non-existent household or household groups dont exist",
+            false
           ))
           return
         end
@@ -266,8 +299,9 @@ function SonosConnection.new(driver, device)
         local household = self.driver.sonos:get_household(header.householdId)
         if household == nil or household.groups == nil then
           log.error(st_utils.stringify_table(
-            {response_body = msg.data, household = household or header.householdId},
-            "Received metadataStatus message for non-existent household or household groups dont exist", false
+            { response_body = msg.data, household = household or header.householdId },
+            "Received metadataStatus message for non-existent household or household groups dont exist",
+            false
           ))
           return
         end
@@ -289,19 +323,21 @@ function SonosConnection.new(driver, device)
           local household = self.driver.sonos:get_household(header.householdId) or { groups = {} }
 
           for group_id, group in pairs(household.groups) do
-            local coordinator_id = self.driver.sonos:get_coordinator_for_group(header.householdId, group_id)
+            local coordinator_id = self.driver.sonos:get_coordinator_for_group(header.householdId,
+              group_id)
             local coordinator_player = household.players[coordinator_id]
             if coordinator_player == nil then
               log.error(st_utils.stringify_table(
-                {household = household, coordinator_id = coordinator_id}, "Received message for non-existent coordinator player", false
+                { household = household, coordinator_id = coordinator_id },
+                "Received message for non-existent coordinator player", false
               ))
               return
             end
 
             local url_ip = lb_utils.force_url_table(coordinator_player.websocketUrl).host
 
             local favorites_response, err, _ =
-            SonosRestApi.get_favorites(url_ip, SonosApi.DEFAULT_SONOS_PORT, header.householdId)
+                SonosRestApi.get_favorites(url_ip, SonosApi.DEFAULT_SONOS_PORT, header.householdId)
 
             if err or not favorites_response then
               log.error("Error querying for favorites: " .. err)
@@ -310,7 +346,10 @@ function SonosConnection.new(driver, device)
               for _, favorite in ipairs(favorites_response.items or {}) do
                 local new_item = { id = favorite.id, name = favorite.name }
                 if favorite.imageUrl then new_item.imageUrl = favorite.imageUrl end
-                if favorite.service and favorite.service.name then new_item.mediaSource = favorite.service.name end
+                if favorite.service and favorite.service.name then
+                  new_item.mediaSource = favorite
+                      .service.name
+                end
                 table.insert(new_favorites, new_item)
               end
               self.driver.sonos:update_household_favorites(header.householdId, new_favorites)
@@ -329,11 +368,14 @@ function SonosConnection.new(driver, device)
         end
       end
     else
-      log.warn(string.format("WebSocket Message for %s did not have a data payload: %s", device_name, st_utils.stringify_table(msg)))
+      log.warn(string.format("WebSocket Message for %s did not have a data payload: %s", device_name,
+        st_utils.stringify_table(msg)))
     end
   end
 
   self.on_error = function(uuid, err)
+    -- TODO: Implement a call to `getToken` here on certain failures, once I actually
+    -- know what an auth failure over websocket is going to look like.
     log.error(err or ("unknown websocket error for " .. (self.device.label or "unknown device")))
   end
 
@@ -351,8 +393,9 @@ end
 function SonosConnection:is_running()
   local self_running = self:self_running()
   local coord_running = self:coordinator_running()
-  log.debug(string.format("%s all connections running? %s", self.device.label, st_utils.stringify_table({coordinator = self_running, mine = self_running})))
-  return  self_running and coord_running
+  log.debug(string.format("%s all connections running? %s", self.device.label,
+    st_utils.stringify_table({ coordinator = self_running, mine = self_running })))
+  return self_running and coord_running
 end
 
 --- Whether or not the connection has a live websocket connection
@@ -425,7 +468,27 @@ function SonosConnection:start()
     _open_coordinator_socket(self, household_id, player_id)
   end
 
-  self:refresh_subscriptions()
+
+  local reply_tx, reply_rx = cosock.channel.new()
+
+  self:refresh_subscriptions(reply_tx)
+
+  local reply = reply_rx:receive()
+  log.info(st_utils.stringify_table(reply, "reply from subscription attempt", true))
+  -- TODO handle logic to abort connection if the refresh is refused
+  -- once we know what a forbidden/unauthorized error will look like.
+  local connection_successful = true
+  if not connection_successful then
+    if not self.driver.waiting_for_token then
+      local err = self.driver:get_oauth_token()
+      if err then
+        log.warn(string.format("notice: get_oauth_token -> %s", err))
+      end
+      self.driver.waiting_for_token = true
+      self.on_close()
+    end
+    return false
+  end
   local coordinator_id = self.driver.sonos:get_coordinator_for_player(household_id, player_id)
   if Router.is_connected(player_id) and Router.is_connected(coordinator_id) then
     self.device:online()
diff --git a/drivers/SmartThings/sonos/src/api/sonos_websocket_router.lua b/drivers/SmartThings/sonos/src/api/sonos_websocket_router.lua
@@ -107,7 +107,10 @@ cosock.spawn(function()
               end
 
               log.trace(string.format("Sending message over websocket for target %s", target))
-              wss:send(Message.new(Message.TEXT, msg.body))
+              local response = table.pack(wss:send(Message.new(Message.TEXT, msg.body)))
+              if msg.header.reply_tx then
+                msg.header.reply_tx:send(response)
+              end
             end
           elseif msg.type and msg.data and recv.id then -- websocket message received
             log.trace(string.format("Received WebSocket message, fanning out to listeners"))
@@ -229,9 +232,9 @@ function SonosWebSocketRouter.open_socket_for_player(player_id, wss_url)
   end
 end
 
-function SonosWebSocketRouter.send_message_to_player(target, json_payload)
+function SonosWebSocketRouter.send_message_to_player(target, json_payload, reply_tx)
   local websocket_message = {
-    header = { type = "WebSocket", target = target },
+    header = { type = "WebSocket", target = target, reply_tx = reply_tx},
     body = json_payload
   }
 
diff --git a/drivers/SmartThings/sonos/src/init.lua b/drivers/SmartThings/sonos/src/init.lua
diff --git a/drivers/SmartThings/sonos/src/types.lua b/drivers/SmartThings/sonos/src/types.lua
