@adventurelabs/scout-core 1.4.75 → 1.4.78

package/dist/helpers/cache.d.ts

@@ -1,4 +1,10 @@
 import { IHerdModule } from "../types/herd_module";
+export type JwtMintCacheKey = "client_abilities" | "pubsub";
+type CachedJwtMint = {
+    token: string;
+    iat: number;
+    exp: number;
+};
 export interface CacheMetadata {
     key: string;
     timestamp: number;
@@ -43,6 +49,9 @@ export declare class ScoutCache {
     private validateDatabaseSchema;
     setHerdModules(herdModules: IHerdModule[], ttlMs?: number, etag?: string): Promise<void>;
     getHerdModules(): Promise<CacheResult<IHerdModule[]>>;
+    setJwtMint<T extends CachedJwtMint>(key: JwtMintCacheKey, mint: T): Promise<void>;
+    getJwtMint<T extends CachedJwtMint>(key: JwtMintCacheKey): Promise<CacheResult<T>>;
+    clearJwtMint(key: JwtMintCacheKey): Promise<void>;
     clearHerdModules(): Promise<void>;
     invalidateHerdModules(): Promise<void>;
     getCacheStats(): Promise<CacheStats>;
@@ -60,3 +69,4 @@ export declare class ScoutCache {
     checkDatabaseHealth(): Promise<DatabaseHealth>;
 }
 export declare const scoutCache: ScoutCache;
+export {};

package/dist/helpers/cache.js

@@ -1,6 +1,7 @@
 const DB_NAME = "ScoutCache";
-const DB_VERSION = 6;
+const DB_VERSION = 8;
 const HERD_MODULES_STORE = "herd_modules";
+const JWT_MINTS_STORE = "jwt_mints";
 const CACHE_METADATA_STORE = "cache_metadata";
 // Default TTL: 24 hours (1 day)
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
@@ -56,6 +57,13 @@ export class ScoutCache {
                         unique: false,
                     });
                     console.log("[ScoutCache] Created herd_modules object store");
+                    const jwtMintsStore = db.createObjectStore(JWT_MINTS_STORE, {
+                        keyPath: "key",
+                    });
+                    jwtMintsStore.createIndex("timestamp", "timestamp", {
+                        unique: false,
+                    });
+                    console.log("[ScoutCache] Created jwt_mints object store");
                     // Create cache metadata store
                     const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
                         keyPath: "key",
@@ -78,14 +86,18 @@ export class ScoutCache {
         if (!this.db)
             return false;
         const hasHerdModulesStore = this.db.objectStoreNames.contains(HERD_MODULES_STORE);
+        const hasJwtMintsStore = this.db.objectStoreNames.contains(JWT_MINTS_STORE);
         const hasMetadataStore = this.db.objectStoreNames.contains(CACHE_METADATA_STORE);
         if (!hasHerdModulesStore) {
             console.error("[ScoutCache] Missing herd_modules object store");
         }
+        if (!hasJwtMintsStore) {
+            console.error("[ScoutCache] Missing jwt_mints object store");
+        }
         if (!hasMetadataStore) {
             console.error("[ScoutCache] Missing cache_metadata object store");
         }
-        return hasHerdModulesStore && hasMetadataStore;
+        return hasHerdModulesStore && hasJwtMintsStore && hasMetadataStore;
     }
     async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag) {
         await this.init();
@@ -190,6 +202,78 @@ export class ScoutCache {
             };
         });
     }
+    async setJwtMint(key, mint) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([JWT_MINTS_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            transaction.objectStore(JWT_MINTS_STORE).put({
+                key,
+                data: mint,
+                timestamp: Date.now(),
+                dbVersion: DB_VERSION,
+            });
+        });
+    }
+    async getJwtMint(key) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([JWT_MINTS_STORE], "readonly");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            const request = transaction.objectStore(JWT_MINTS_STORE).get(key);
+            request.onsuccess = () => {
+                const entry = request.result;
+                if (!entry?.data?.token ||
+                    entry.dbVersion !== DB_VERSION ||
+                    !entry.timestamp) {
+                    this.stats.misses++;
+                    resolve({ data: null, isStale: true, age: 0, metadata: null });
+                    return;
+                }
+                const now = Date.now();
+                const age = now - entry.timestamp;
+                const isStale = entry.data.exp <= Math.floor(now / 1000);
+                this.stats.hits++;
+                resolve({
+                    data: entry.data,
+                    isStale,
+                    age,
+                    metadata: {
+                        key,
+                        timestamp: entry.timestamp,
+                        ttl: Math.max((entry.data.exp - entry.data.iat) * 1000, 0),
+                        version: "1.0.0",
+                        dbVersion: DB_VERSION,
+                    },
+                });
+            };
+        });
+    }
+    async clearJwtMint(key) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        if (!this.validateDatabaseSchema()) {
+            throw new Error("Database schema validation failed - required object stores not found");
+        }
+        const transaction = this.db.transaction([JWT_MINTS_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            transaction.objectStore(JWT_MINTS_STORE).delete(key);
+        });
+    }
     async clearHerdModules() {
         await this.init();
         if (!this.db)

package/dist/helpers/client_abilities_token.d.ts

@@ -4,5 +4,4 @@ import { IClientAbilitiesJwtPublicKeyEntry, IClientAbilitiesTokenMint } from "..
 import { IWebResponseCompatible } from "../types/requests";
 export declare function mint_client_abilities_token(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IClientAbilitiesTokenMint>>;
 export declare function get_client_abilities_jwt_public_keys(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IClientAbilitiesJwtPublicKeyEntry[]>>;
-/** Cryptographic check only; returns the same mint envelope from the edge. */
 export declare function verify_client_abilities_token(mint: IClientAbilitiesTokenMint, publicKeys: IClientAbilitiesJwtPublicKeyEntry[]): Promise<IClientAbilitiesTokenMint>;

package/dist/helpers/client_abilities_token.js

@@ -32,7 +32,6 @@ export async function get_client_abilities_jwt_public_keys(client) {
     }
     return IWebResponse.success(keys).to_compatible();
 }
-/** Cryptographic check only; returns the same mint envelope from the edge. */
 export async function verify_client_abilities_token(mint, publicKeys) {
     if (publicKeys.length === 0) {
         throw new Error("no client abilities JWT public keys configured");

package/dist/helpers/herd_modules_equal.d.ts

@@ -0,0 +1,2 @@
+import { IHerdModule } from "../types/herd_module";
+export declare function herdModulesSemanticallyEqual(current: IHerdModule[], incoming: IHerdModule[]): boolean;

package/dist/helpers/herd_modules_equal.js

@@ -0,0 +1,28 @@
+import { dequal } from "dequal";
+function withoutFetchTimestamp({ timestamp_last_refreshed: _timestamp, ...module }) {
+    return module;
+}
+export function herdModulesSemanticallyEqual(current, incoming) {
+    if (current === incoming) {
+        return true;
+    }
+    if (current.length !== incoming.length) {
+        return false;
+    }
+    if (current.length === 0) {
+        return true;
+    }
+    const currentByHerdId = new Map(current.map((module) => [
+        String(module.herd.id),
+        withoutFetchTimestamp(module),
+    ]));
+    for (const incomingModule of incoming) {
+        const herdId = String(incomingModule.herd.id);
+        const existing = currentByHerdId.get(herdId);
+        if (!existing ||
+            !dequal(existing, withoutFetchTimestamp(incomingModule))) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/helpers/pubsub_token.d.ts

@@ -1,5 +1,7 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-import { IPubsubTokenMint } from "../types/pubsub_token";
+import { IPubsubJwtPublicKeyEntry, IPubsubTokenMint } from "../types/pubsub_token";
 import { IWebResponseCompatible } from "../types/requests";
 export declare function mint_pubsub_token(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IPubsubTokenMint>>;
+export declare function get_pubsub_jwt_public_keys(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IPubsubJwtPublicKeyEntry[]>>;
+export declare function verify_pubsub_token(mint: IPubsubTokenMint, publicKeys: IPubsubJwtPublicKeyEntry[]): Promise<IPubsubTokenMint>;

package/dist/helpers/pubsub_token.js

@@ -1,3 +1,4 @@
+import * as jose from "jose";
 import { IWebResponse } from "../types/requests";
 export async function mint_pubsub_token(client) {
     const { data, error } = await client.functions.invoke("mint-pubsub-token", {
@@ -12,3 +13,43 @@ export async function mint_pubsub_token(client) {
     }
     return IWebResponse.success(mint).to_compatible();
 }
+export async function get_pubsub_jwt_public_keys(client) {
+    const { data, error } = await client.rpc("get_pubsub_jwt_public_keys");
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    const entries = Array.isArray(data) ? data : [];
+    const keys = [];
+    for (const row of entries) {
+        if (row &&
+            typeof row === "object" &&
+            "kid" in row &&
+            "jwk" in row &&
+            typeof row.kid === "string" &&
+            row.jwk &&
+            typeof row.jwk === "object") {
+            keys.push({ kid: row.kid, jwk: row.jwk });
+        }
+    }
+    return IWebResponse.success(keys).to_compatible();
+}
+export async function verify_pubsub_token(mint, publicKeys) {
+    if (publicKeys.length === 0) {
+        throw new Error("no pubsub JWT public keys configured");
+    }
+    const header = jose.decodeProtectedHeader(mint.token);
+    const kid = header.kid;
+    if (!kid || typeof kid !== "string") {
+        throw new Error("pubsub JWT missing kid");
+    }
+    const entry = publicKeys.find((k) => k.kid === kid);
+    if (!entry) {
+        throw new Error(`unknown pubsub JWT kid: ${kid}`);
+    }
+    const alg = typeof entry.jwk.alg === "string" && entry.jwk.alg
+        ? entry.jwk.alg
+        : header.alg ?? "ES256";
+    const verifyKey = await jose.importJWK(entry.jwk, alg);
+    await jose.jwtVerify(mint.token, verifyKey, { algorithms: [alg] });
+    return mint;
+}

package/dist/helpers/versions_software.d.ts

@@ -7,4 +7,3 @@ export declare function get_versions_software_by_system(client: SupabaseClient<D
 export declare function create_version_software(client: SupabaseClient<Database>, newVersionSoftware: VersionsSoftwareInsert): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function update_version_software(client: SupabaseClient<Database>, version_id: number, updatedVersionSoftware: Partial<VersionsSoftwareInsert>): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function delete_version_software(client: SupabaseClient<Database>, version_id: number): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
-export declare function get_versions_software_by_created_by(client: SupabaseClient<Database>, user_id: string): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;

package/dist/helpers/versions_software.js

@@ -75,17 +75,3 @@ export async function delete_version_software(client, version_id) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function get_versions_software_by_created_by(client, user_id) {
-    const { data, error } = await client
-        .from("versions_software")
-        .select("*")
-        .eq("created_by", user_id)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No software versions found for user").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}

package/dist/helpers/versions_software_server.d.ts

@@ -3,4 +3,3 @@ import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_versions_software(client?: SupabaseClient): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
 export declare function server_get_versions_software_by_system(system: string, client?: SupabaseClient): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
-export declare function server_get_versions_software_by_created_by(user_id: string, client?: SupabaseClient): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;

package/dist/helpers/versions_software_server.js

@@ -53,19 +53,3 @@ export async function server_get_versions_software_by_system(system, client) {
     const withUrls = await attachBuildArtifactUrls(data, client);
     return IWebResponse.success(withUrls).to_compatible();
 }
-export async function server_get_versions_software_by_created_by(user_id, client) {
-    const supabase = client || (await newServerClient());
-    const { data, error } = await supabase
-        .from("versions_software")
-        .select("*")
-        .eq("created_by", user_id)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No software versions found for user").to_compatible();
-    }
-    const withUrls = await attachBuildArtifactUrls(data, client);
-    return IWebResponse.success(withUrls).to_compatible();
-}

package/dist/hooks/useScoutRefresh.js

@@ -1,6 +1,5 @@
-import { useEffect, useCallback, useRef, useMemo } from "react";
+import { useEffect, useCallback, useRef, useMemo, startTransition } from "react";
 import { useAppDispatch } from "../store/hooks";
-import { useStore } from "react-redux";
 import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setUser, setDataSource, setDataSourceInfo, } from "../store/scout";
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
@@ -8,6 +7,11 @@ import { scoutCache } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 import { EnumWebResponse } from "../types/requests";
 import { createBrowserClient } from "@supabase/ssr";
+function dispatchInTransition(dispatch, action) {
+    startTransition(() => {
+        dispatch(action);
+    });
+}
 /**
  * Hook for refreshing scout data with detailed timing measurements and cache-first loading
  *
@@ -38,7 +42,6 @@ export function useScoutRefresh(options = {}) {
     onlineRefetchMinIntervalMs = 15 * 1000, // 15 seconds
      } = options;
     const dispatch = useAppDispatch();
-    const store = useStore();
     const refreshInProgressRef = useRef(false);
     const lastQueryAtRef = useRef(0);
     const supabase = useMemo(() => {
@@ -98,7 +101,7 @@ export function useScoutRefresh(options = {}) {
                     const totalMs = Date.now() - startTotal;
                     timingRefs.current.userApiDuration = totalMs;
                     dispatch(setUserApiDuration(totalMs));
-                    dispatch(setUser(data.user));
+                    dispatchInTransition(dispatch, setUser(data.user));
                     return data.user;
                 }
                 catch (e) {
@@ -116,7 +119,7 @@ export function useScoutRefresh(options = {}) {
                         const totalMs = Date.now() - startTotal;
                         timingRefs.current.userApiDuration = totalMs;
                         dispatch(setUserApiDuration(totalMs));
-                        dispatch(setUser(data.user));
+                        dispatchInTransition(dispatch, setUser(data.user));
                         return data.user;
                     }
                 }
@@ -155,7 +158,7 @@ export function useScoutRefresh(options = {}) {
                         }));
                         // Update the store with cached data
                         console.log(`[useScoutRefresh] Updating store with cached herd modules`);
-                        dispatch(setHerdModules(cachedHerdModules));
+                        dispatchInTransition(dispatch, setHerdModules(cachedHerdModules));
                         dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                         // If cache is fresh, we still background fetch but don't wait (only when online)
                         if (!cacheResult.isStale) {
@@ -204,7 +207,7 @@ export function useScoutRefresh(options = {}) {
                                             }
                                             // Update store with fresh data from background request
                                             console.log(`[useScoutRefresh] Updating store with background herd modules`);
-                                            dispatch(setHerdModules(backgroundHerdModulesResult.data));
+                                            dispatchInTransition(dispatch, setHerdModules(backgroundHerdModulesResult.data));
                                             // Update data source to DATABASE
                                             dispatch(setDataSource(EnumDataSource.DATABASE));
                                             dispatch(setDataSourceInfo({
@@ -245,7 +248,7 @@ export function useScoutRefresh(options = {}) {
                         source: EnumDataSource.CACHE,
                         timestamp: Date.now(),
                     }));
-                    dispatch(setHerdModules(cachedHerdModules));
+                    dispatchInTransition(dispatch, setHerdModules(cachedHerdModules));
                     dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                 }
                 else {
@@ -327,11 +330,11 @@ export function useScoutRefresh(options = {}) {
                     await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
-            // Step 4: Conditionally update store with fresh data, skip timestamp-only changes
+            // Step 4: Update store with fresh data (reducer skips no-op updates)
             const dataProcessingStartTime = Date.now();
             // Update store with new data
             console.log(`[useScoutRefresh] Updating store with fresh herd modules`);
-            dispatch(setHerdModules(compatible_new_herd_modules));
+            dispatchInTransition(dispatch, setHerdModules(compatible_new_herd_modules));
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
             const dataProcessingDuration = Date.now() - dataProcessingStartTime;
             timingRefs.current.dataProcessingDuration = dataProcessingDuration;
@@ -367,7 +370,6 @@ export function useScoutRefresh(options = {}) {
         }
     }, [
         dispatch,
-        store,
         supabase,
         onRefreshComplete,
         cacheFirst,

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from "./types/events";
 export * from "./types/connectivity";
 export * from "./types/pubsub_token";
 export * from "./types/client_abilities_token";
+export * from "./types/jwt_mint";
 export * from "./helpers/analysis_usage";
 export * from "./helpers/artifacts";
 export * from "./helpers/auth";

package/dist/index.js

@@ -14,6 +14,7 @@ export * from "./types/events";
 export * from "./types/connectivity";
 export * from "./types/pubsub_token";
 export * from "./types/client_abilities_token";
+export * from "./types/jwt_mint";
 // Helpers
 export * from "./helpers/analysis_usage";
 export * from "./helpers/artifacts";

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -3,30 +3,31 @@ import { type ReactNode } from "react";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
 import { IClientAbilitiesTokenMint } from "../types/client_abilities_token";
+import { IPubsubTokenMint } from "../types/pubsub_token";
+import { EnumJwtMintStatus } from "../types/jwt_mint";
 export interface ClientAbilitiesMintState {
-    /** Set only after jose verification against DB pubkeys. */
     mint: IClientAbilitiesTokenMint | null;
-    isLoading: boolean;
+    status: EnumJwtMintStatus;
     error: string | null;
     refreshMint: () => Promise<void>;
 }
 export interface ScoutRefreshAbilityParams {
-    /** Mint and verify a client abilities JWT. Default: `true`. */
     mintClientAbilitiesToken?: boolean;
-    /**
-     * Expected JWT lifetime in seconds (default 1 hour).
-     * Align with edge `CLIENT_ABILITIES_TOKEN_TTL_SEC`; used to schedule re-mint
-     * (falls back when `exp` is missing; otherwise uses `exp` from the mint).
-     */
+    mintPubsubToken?: boolean;
     clientAbilitiesTokenTtlSec?: number;
-    /** Re-mint this many seconds before expiry (default 120). */
+    pubsubTokenTtlSec?: number;
     refreshBeforeExpirySec?: number;
-    /** Ms to cache pubkey RPC results (default 10 min). */
     publicKeysCacheTtlMs?: number;
 }
+export interface PubsubTokenMintState {
+    mint: IPubsubTokenMint | null;
+    status: EnumJwtMintStatus;
+    error: string | null;
+    refreshMint: () => Promise<void>;
+}
 export declare function useSupabase(): SupabaseClient<Database>;
-/** Verified client abilities JWT (minted on a schedule by ScoutRefreshProvider). */
 export declare function useClientAbilitiesMint(): ClientAbilitiesMintState;
+export declare function usePubsubTokenMint(): PubsubTokenMintState;
 export interface ScoutRefreshProviderProps extends UseScoutRefreshOptions {
     children: ReactNode;
     abilityParams?: ScoutRefreshAbilityParams;