fix: control panel cache policy (#901)

* fix: control panel cache policy

* chore: temp logs

* fix: registry

* fix: evault filtering

Author: coodos

infrastructure/control-panel/src/lib/services/evaultService.ts

@@ -30,6 +30,7 @@ export class EVaultService {
 		return freshData;
 	}
 
+
 	/**
 	 * Get cache status information
 	 */

infrastructure/control-panel/src/lib/services/registry.ts

@@ -19,7 +19,7 @@ export class RegistryService {
 	private baseUrl: string;
 
 	constructor() {
-		this.baseUrl = env.PUBLIC_REGISTRY_URL || 'https://registry.staging.metastate.foundation';
+		this.baseUrl = env.PUBLIC_REGISTRY_URL || 'https://registry.w3ds.metastate.foundation';
 	}
 
 	async getEVaults(): Promise<RegistryVault[]> {

infrastructure/control-panel/src/routes/+page.svelte

@@ -278,7 +278,11 @@
 			isLoading = true;
 			error = null;
 			console.log('🔍 Fetching eVaults...');
-			const data = await EVaultService.getEVaults();
+			let data = await EVaultService.forceRefresh();
+			if (!Array.isArray(data) || data.length === 0) {
+				// Fallback to cache only if fresh load returns empty/invalid.
+				data = await EVaultService.getEVaults();
+			}
 			console.log('📦 Data received:', data);
 			console.log('📊 Data type:', typeof data);
 			console.log('📊 Is array:', Array.isArray(data));

infrastructure/control-panel/src/routes/api/evaults/+server.ts

@@ -41,16 +41,20 @@ function firstNonEmptyString(...values: unknown[]): string | null {
 async function fetchFirstParsedByOntology(
 	vault: RegistryVault,
 	ontologyId: string,
-	token: string
+	token?: string
 ): Promise<Record<string, unknown> | null> {
-	try {
+	const tryRequest = async (withAuth: boolean): Promise<Record<string, unknown> | null> => {
+		const headers: Record<string, string> = {
+			'Content-Type': 'application/json',
+			'X-ENAME': vault.ename
+		};
+		if (withAuth && token) {
+			headers.Authorization = `Bearer ${token}`;
+		}
+
 		const response = await fetch(`${vault.uri}/graphql`, {
 			method: 'POST',
-			headers: {
-				'Content-Type': 'application/json',
-				'X-ENAME': vault.ename,
-				Authorization: `Bearer ${token}`
-			},
+			headers,
 			body: JSON.stringify({
 				query: META_ENVELOPES_QUERY,
 				variables: {
@@ -66,21 +70,38 @@ async function fetchFirstParsedByOntology(
 		}
 
 		const payload = await response.json();
+		if (Array.isArray(payload?.errors) && payload.errors.length > 0) {
+			return null;
+		}
 		const parsed = payload?.data?.metaEnvelopes?.edges?.[0]?.node?.parsed;
 
 		if (!parsed || typeof parsed !== 'object') {
 			return null;
 		}
 
 		return parsed as Record<string, unknown>;
+	};
+
+	try {
+		// Try with token first (preferred), then fallback to X-ENAME-only.
+		const withAuth = await tryRequest(Boolean(token));
+		if (withAuth) {
+			return withAuth;
+		}
+
+		if (token) {
+			return await tryRequest(false);
+		}
+
+		return null;
 	} catch {
 		return null;
 	}
 }
 
 async function resolveVaultIdentity(
 	vault: RegistryVault,
-	token: string
+	token?: string
 ): Promise<{ name: string; type: 'user' | 'group' }> {
 	const defaultName = firstNonEmptyString(vault.ename, vault.evault, 'Unknown') || 'Unknown';
 
@@ -99,7 +120,15 @@ async function resolveVaultIdentity(
 		return {
 			type: 'group',
 			name:
-				firstNonEmptyString(groupManifest.name, groupManifest.eName, vault.ename, vault.evault) ||
+				firstNonEmptyString(
+					groupManifest.name,
+					groupManifest.displayName,
+					groupManifest.title,
+					groupManifest.eName,
+					groupManifest.ename,
+					vault.ename,
+					vault.evault
+				) ||
 				defaultName
 		};
 	}
@@ -136,7 +165,12 @@ async function requestPlatformToken(platform: string): Promise<string> {
 export const GET: RequestHandler = async ({ url }) => {
 	try {
 		const platform = env.PUBLIC_CONTROL_PANEL_URL || url.origin;
-		const token = await requestPlatformToken(platform);
+		let token: string | undefined;
+		try {
+			token = await requestPlatformToken(platform);
+		} catch (tokenError) {
+			console.warn('Falling back to X-ENAME-only eVault queries:', tokenError);
+		}
 
 		// Fetch all evaults from registry
 		const registryVaults = await registryService.getEVaults();
@@ -149,32 +183,26 @@ export const GET: RequestHandler = async ({ url }) => {
 
 				const identity = await resolveVaultIdentity(vault, token);
 
-				// Check health status by attempting to fetch from URI
-				let status = 'Unknown';
-				try {
-					const healthResponse = await fetch(`${vault.uri}/health`, {
-						signal: AbortSignal.timeout(2000) // 2 second timeout
-					});
-					status = healthResponse.ok ? 'Active' : 'Inactive';
-				} catch {
-					status = 'Inactive';
-				}
-
 				return {
 					id: evaultId,
 					name: identity.name,
 					type: identity.type,
 					ename: vault.ename,
 					uri: vault.uri,
 					evault: vault.evault,
-					status: status,
+					status: 'Unknown',
 					serviceUrl: vault.uri
 				};
 			})
 		);
 
-		console.log(`Total eVaults found: ${evaults.length}`);
-		return json({ evaults });
+		// Filter out platform-owned user profiles (e.g. "File Manager Platform").
+		const filteredEVaults = evaults.filter(
+			(vault) => !(vault.type === 'user' && /platform$/i.test(vault.name.trim()))
+		);
+
+		console.log(`Total eVaults found: ${filteredEVaults.length}`);
+		return json({ evaults: filteredEVaults });
 	} catch (error) {
 		console.error('Error fetching eVaults:', error);
 		return json({ error: 'Failed to fetch eVaults', evaults: [] }, { status: 500 });