STAR: JWT refresh (client-only), refresh token storage, quest/inventory fixes

dellams · dellams · commit 84f06a045d53 · 2026-03-16T00:23:18.000-05:00
- Client: in-memory JWT auto-renew after manual beam-in; 401 retry with refresh, clear token on refresh fail
- Client: SetRefreshToken/GetCurrentRefreshToken + native exports for games to persist refresh_token
- Client: throttle 'no cached quest' log spam; inventory logging for diagnostics
- ODOOM: persist refresh_token in oasisstar.json; pass to client on restore; always call star_api_refresh_quest_cache_in_background (remove ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND guards) so tracker and quest list load
- No flow/callback changes to games; master remains stable

Made-with: Cursor
diff --git a/OASIS Omniverse/ODOOM/uzdoom_star_integration.cpp b/OASIS Omniverse/ODOOM/uzdoom_star_integration.cpp
@@ -1371,9 +1371,7 @@ static void ODOOM_OnAuthDone(void* user_data) {
 				}
 			}
 			/* Start loading quest list so tracker title/objective show without opening popup (ODOOM_RefreshQuestCVars will use cache when ready). */
-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND
 			star_api_refresh_quest_cache_in_background();
-#endif
 			ODOOM_RefreshQuestCVars();  /* push once immediately in case cache already has data */
 		}
 		/* Persist session to oasisstar.json immediately so we stay logged in after restart (or if game crashes before exit). */
@@ -1921,11 +1919,7 @@ void ODOOM_InventoryInputCaptureFrame(void)
 		static int s_quest_popup_was_open = 0;
 		static int s_quest_refresh_frames = 0;
 		if (questPopupOpen && !s_quest_popup_was_open) {
-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND
 			star_api_refresh_quest_cache_in_background();
-#else
-			/* Without new API: do not invalidate – show existing cache and let 60-frame refresh update when fetch completes. */
-#endif
 			ODOOM_RefreshQuestCVars();  /* push current cache to CVars so list shows immediately */
 			s_quest_refresh_frames = 0; /* do not run 60-frame refresh this frame */
 		}
@@ -1977,9 +1971,8 @@ void ODOOM_InventoryInputCaptureFrame(void)
 							oidVar->SetGenericRep(u, CVAR_String);
 						}
 					}
-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND
+					star_api_invalidate_quest_cache();
 					star_api_refresh_quest_cache_in_background();
-#endif
 					ODOOM_RefreshQuestCVars();
 				}
 			} else {
diff --git a/OASIS Omniverse/STARAPIClient/StarApiClient.cs b/OASIS Omniverse/STARAPIClient/StarApiClient.cs
@@ -472,8 +472,6 @@ public async Task<OASISResult<bool>> RestoreSessionAsync(CancellationToken cance
         /* Invoke the same "profile loaded" operation callback that refresh_avatar_profile uses, so the game runs beamed-in logic: tracker, XP, quest cache, etc. */
         StarApiExports.InvokeOperationCallback(StarApiResultCode.Success, StarApiExports.StarApiOpProfileLoaded);
         StarApiExports.StarApiLogFileOnly("[Auth] RestoreSession: success, profile loaded (operation callback invoked)");
-        /* Start proactive JWT refresh so token is renewed before expiry (same as after manual beam-in). */
-        ScheduleBackgroundTokenRefresh();
         return Success(true, StarApiResultCode.Success, "Session restored.");
     }
 
@@ -724,19 +722,26 @@ public Task<OASISResult<bool>> QueueHasItemAsync(string itemName, CancellationTo
     public async Task<OASISResult<List<StarItem>>> GetInventoryAsync(CancellationToken cancellationToken = default)
     {
         if (!IsInitialized())
+        {
+            StarApiExports.StarApiLogFileOnly("[Inventory] GetInventoryAsync: not initialized");
             return FailAndCallback<List<StarItem>>("Client is not initialized.", StarApiResultCode.NotInitialized);
+        }
 
         Task<OASISResult<List<StarItem>>>? task;
         lock (_inventoryCacheLock)
         {
             if (_cachedInventory is not null)
             {
                 var merged = MergeLocalPendingIntoInventory(_cachedInventory);
+                StarApiExports.StarApiLogFileOnly($"[Inventory] GetInventoryAsync: returning cache count={merged.Count}");
                 InvokeCallback(StarApiResultCode.Success);
                 return Success(merged, StarApiResultCode.Success, $"Loaded {merged.Count} item(s) (cached + pending).");
             }
             if (_inventoryFetchTask is null)
+            {
+                StarApiExports.StarApiLogFileOnly("[Inventory] GetInventoryAsync: cache miss, starting FetchInventoryOnceAsync");
                 _inventoryFetchTask = FetchInventoryOnceAsync();
+            }
             task = _inventoryFetchTask;
         }
 
@@ -759,8 +764,10 @@ public async Task<OASISResult<List<StarItem>>> GetInventoryAsync(CancellationTok
         if (result.Result is not null)
         {
             var merged = MergeLocalPendingIntoInventory(result.Result);
+            StarApiExports.StarApiLogFileOnly($"[Inventory] GetInventoryAsync: fetch completed count={merged.Count}");
             return Success(merged, StarApiResultCode.Success, result.Message ?? $"Loaded {merged.Count} item(s).");
         }
+        StarApiExports.StarApiLogFileOnly($"[Inventory] GetInventoryAsync: fetch failed IsError={result.IsError} Message={result.Message ?? "(null)"}");
         return result;
     }
 
@@ -817,9 +824,11 @@ private List<StarItem> MergeLocalPendingIntoInventory(List<StarItem> apiList)
 
     private async Task<OASISResult<List<StarItem>>> FetchInventoryOnceAsync()
     {
+        StarApiExports.StarApiLogFileOnly("[Inventory] FetchInventoryOnceAsync: ensuring avatar id");
         var avatarIdResult = await EnsureAvatarIdAsync(CancellationToken.None).ConfigureAwait(false);
         if (avatarIdResult.IsError || string.IsNullOrWhiteSpace(avatarIdResult.Result))
         {
+            StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: no avatar id Message={avatarIdResult.Message ?? "(null)"}");
             return new OASISResult<List<StarItem>>
             {
                 IsError = true,
@@ -829,27 +838,38 @@ private async Task<OASISResult<List<StarItem>>> FetchInventoryOnceAsync()
             };
         }
 
+        var url = $"{_baseApiUrl}/api/avatar/inventory";
+        StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: GET {url}");
         try
         {
-            var response = await SendRawAsync(HttpMethod.Get, $"{_baseApiUrl}/api/avatar/inventory", null, CancellationToken.None).ConfigureAwait(false);
+            var response = await SendRawAsync(HttpMethod.Get, url, null, CancellationToken.None).ConfigureAwait(false);
             if (response.IsError && ParseCode(response.ErrorCode, StarApiResultCode.ApiError) == StarApiResultCode.Network)
             {
+                StarApiExports.StarApiLogFileOnly("[Inventory] FetchInventoryOnceAsync: first attempt failed (network), retrying once");
                 await Task.Delay(200, CancellationToken.None).ConfigureAwait(false);
-                response = await SendRawAsync(HttpMethod.Get, $"{_baseApiUrl}/api/avatar/inventory", null, CancellationToken.None).ConfigureAwait(false);
+                response = await SendRawAsync(HttpMethod.Get, url, null, CancellationToken.None).ConfigureAwait(false);
             }
             if (response.IsError)
+            {
+                StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: GET failed Message={response.Message ?? "(null)"}");
                 return FailAndCallback<List<StarItem>>(response.Message, ParseCode(response.ErrorCode, StarApiResultCode.ApiError), response.Exception);
+            }
 
             var parseResult = ParseEnvelopeOrPayload(response.Result, out var resultElement, out var parseErrorCode, out var parseErrorMessage);
             if (!parseResult)
+            {
+                StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: parse failed {parseErrorMessage ?? "(null)"}");
                 return FailAndCallback<List<StarItem>>(parseErrorMessage, parseErrorCode);
+            }
 
             var mapped = ParseInventoryItems(resultElement);
+            StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: GET OK parsed count={mapped?.Count ?? 0}");
             InvokeCallback(StarApiResultCode.Success);
             return Success(mapped, StarApiResultCode.Success, $"Loaded {mapped.Count} item(s).");
         }
         catch (Exception ex)
         {
+            StarApiExports.StarApiLogFileOnly($"[Inventory] FetchInventoryOnceAsync: exception {ex.Message}");
             return FailAndCallback<List<StarItem>>($"Failed to load inventory: {ex.Message}", StarApiResultCode.Network, ex);
         }
     }
@@ -859,6 +879,7 @@ public void InvalidateInventoryCache()
     {
         lock (_inventoryCacheLock)
         {
+            StarApiExports.StarApiLogFileOnly("[Inventory] InvalidateInventoryCache: clearing cache");
             _cachedInventory = null;
             _inventoryFetchTask = null;
         }
@@ -5249,6 +5270,7 @@ public static unsafe class StarApiExports
     private static volatile int _starDebug;
     private static int StarApiGetQuestsStringLastLoggedToCopy = -1;
     private static bool _topLevelQuestsLastLoggedLoading;
+    private static long _lastNoCachedQuestLogTicks;
 
     /// <summary>Whether STAR debug logging is on (games set via star_api_set_debug). When true, quest API and other requests log URI and response to file and console.</summary>
     internal static bool GetStarDebug() => _starDebug != 0;
@@ -5488,18 +5510,24 @@ public static int StarApiGetInventory(star_item_list_t** itemList)
 
         var client = GetClient();
         if (client is null)
+        {
+            try { StarApiExports.StarApiLogFileOnly("[Inventory] star_api_get_inventory: no client"); } catch { }
             return (int)SetErrorAndReturn("Client is not initialized.", StarApiResultCode.NotInitialized, StarApiOpGetInventory);
+        }
 
+        try { StarApiExports.StarApiLogFileOnly("[Inventory] star_api_get_inventory: calling GetInventoryAsync (blocking)"); } catch { }
         var result = client.GetInventoryAsync().GetAwaiter().GetResult();
         var resultCode = ExtractCode(result);
         if (result.IsError || result.Result is null)
         {
+            try { StarApiExports.StarApiLogFileOnly($"[Inventory] star_api_get_inventory: failed IsError={result.IsError} Message={result.Message ?? "(null)"} Count={result.Result?.Count ?? -1}"); } catch { }
             SetError(result.Message ?? "Failed to load inventory.");
             InvokeOperationCallback(resultCode, StarApiOpGetInventory);
             return (int)resultCode;
         }
 
         var count = (nuint)result.Result.Count;
+        try { StarApiExports.StarApiLogFileOnly($"[Inventory] star_api_get_inventory: success count={count}"); } catch { }
         var listPtr = (star_item_list_t*)NativeMemory.Alloc((nuint)1, (nuint)sizeof(star_item_list_t));
         if (listPtr is null)
             return (int)SetErrorAndReturn("Memory allocation failed for item list.", StarApiResultCode.InitFailed, StarApiOpGetInventory);
@@ -6043,8 +6071,13 @@ public static int StarApiGetActiveQuestId(sbyte* buf, nuint bufSize)
         var id = client.GetCachedActiveQuestId();
         if (!id.HasValue || id.Value == Guid.Empty)
         {
-            try { StarApiExports.StarApiLogFileOnly("[Quest] star_api_get_active_quest_id: no cached value"); } catch { }
-            if (StarApiExports.GetStarDebug()) try { StarApiExports.StarApiLog("[Quest] get_active_quest_id: no cached quest (API may not return AvatarDetail.ActiveQuestId)"); } catch { }
+            var now = Environment.TickCount64;
+            if (now - Volatile.Read(ref _lastNoCachedQuestLogTicks) > 3000)
+            {
+                Volatile.Write(ref _lastNoCachedQuestLogTicks, now);
+                try { StarApiExports.StarApiLogFileOnly("[Quest] star_api_get_active_quest_id: no cached value (throttled)"); } catch { }
+                if (StarApiExports.GetStarDebug()) try { StarApiExports.StarApiLog("[Quest] get_active_quest_id: no cached quest (API may not return AvatarDetail.ActiveQuestId)"); } catch { }
+            }
             buf[0] = 0; return 0;
         }
         try { StarApiExports.StarApiLog($"[Quest] star_api_get_active_quest_id: returning {id}"); } catch { }
@@ -6066,8 +6099,13 @@ public static int StarApiGetActiveObjectiveId(sbyte* buf, nuint bufSize)
         var id = client.GetCachedActiveObjectiveId();
         if (!id.HasValue || id.Value == Guid.Empty)
         {
-            try { StarApiExports.StarApiLogFileOnly("[Quest] star_api_get_active_objective_id: no cached value"); } catch { }
-            if (StarApiExports.GetStarDebug()) try { StarApiExports.StarApiLog("[Quest] get_active_objective_id: no cached objective (API may not return AvatarDetail.ActiveObjectiveId)"); } catch { }
+            var now = Environment.TickCount64;
+            if (now - Volatile.Read(ref _lastNoCachedQuestLogTicks) > 3000)
+            {
+                Volatile.Write(ref _lastNoCachedQuestLogTicks, now);
+                try { StarApiExports.StarApiLogFileOnly("[Quest] star_api_get_active_objective_id: no cached value (throttled)"); } catch { }
+                if (StarApiExports.GetStarDebug()) try { StarApiExports.StarApiLog("[Quest] get_active_objective_id: no cached objective (API may not return AvatarDetail.ActiveObjectiveId)"); } catch { }
+            }
             buf[0] = 0; return 0;
         }
         try { StarApiExports.StarApiLog($"[Quest] star_api_get_active_objective_id: returning {id}"); } catch { }

Original file line number	Diff line number	Diff line change
`@@ -1371,9 +1371,7 @@ static void ODOOM_OnAuthDone(void* user_data) {`
`1371`	`1371`	`}`
`1372`	`1372`	`}`
`1373`	`1373`	`/* Start loading quest list so tracker title/objective show without opening popup (ODOOM_RefreshQuestCVars will use cache when ready). */`
`1374`		`-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND`
`1375`	`1374`	`star_api_refresh_quest_cache_in_background();`
`1376`		`-#endif`
`1377`	`1375`	`ODOOM_RefreshQuestCVars(); /* push once immediately in case cache already has data */`
`1378`	`1376`	`}`
`1379`	`1377`	`/* Persist session to oasisstar.json immediately so we stay logged in after restart (or if game crashes before exit). */`
`@@ -1921,11 +1919,7 @@ void ODOOM_InventoryInputCaptureFrame(void)`
`1921`	`1919`	`static int s_quest_popup_was_open = 0;`
`1922`	`1920`	`static int s_quest_refresh_frames = 0;`
`1923`	`1921`	`if (questPopupOpen && !s_quest_popup_was_open) {`
`1924`		`-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND`
`1925`	`1922`	`star_api_refresh_quest_cache_in_background();`
`1926`		`-#else`
`1927`		`- /* Without new API: do not invalidate – show existing cache and let 60-frame refresh update when fetch completes. */`
`1928`		`-#endif`
`1929`	`1923`	`ODOOM_RefreshQuestCVars(); /* push current cache to CVars so list shows immediately */`
`1930`	`1924`	`s_quest_refresh_frames = 0; /* do not run 60-frame refresh this frame */`
`1931`	`1925`	`}`
`@@ -1977,9 +1971,8 @@ void ODOOM_InventoryInputCaptureFrame(void)`
`1977`	`1971`	`oidVar->SetGenericRep(u, CVAR_String);`
`1978`	`1972`	`}`
`1979`	`1973`	`}`
`1980`		`-#ifdef ODOOM_STAR_API_HAS_REFRESH_QUEST_BACKGROUND`
	`1974`	`+ star_api_invalidate_quest_cache();`
`1981`	`1975`	`star_api_refresh_quest_cache_in_background();`
`1982`		`-#endif`
`1983`	`1976`	`ODOOM_RefreshQuestCVars();`
`1984`	`1977`	`}`
`1985`	`1978`	`} else {`