;
@@ -20,37 +25,24 @@ type UpdatePackageParams = {
// --- cache updaters (single place that knows the cache shapes) ---
const removeAppFromList = (appId: number) => {
- queryClient.setQueryData(
- appKeys.list(),
- (old?: { data?: App[] } | undefined) => ({
- data: old?.data?.filter((i) => i.id !== appId) ?? [],
- }),
- );
-};
-
-const addAppToList = (app: { id: number; name: string; platform: string }) => {
- queryClient.setQueryData(
- appKeys.list(),
- (old?: { data?: App[] } | undefined) => ({
- data: [...(old?.data || []), app],
- }),
+ queryClient.setQueryData(appKeys.list(), (old?: { data?: App[] }) =>
+ removeAppFromListCache(old, appId),
);
+ queryClient.removeQueries({ queryKey: appKeys.detail(appId), exact: true });
};
const applyAppUpdate = (appId: number, params: UpdateAppParams) => {
- queryClient.setQueryData(appKeys.detail(appId), (old: App | undefined) => ({
- ...old,
- ...params,
- }));
- queryClient.setQueryData(
- appKeys.list(),
- (old?: { data?: App[] } | undefined) => ({
- data:
- old?.data?.map((i) => (i.id === appId ? { ...i, ...params } : i)) ?? [],
- }),
+ queryClient.setQueryData(appKeys.detail(appId), (old: App | undefined) =>
+ updateAppDetailCache(old, params),
+ );
+ queryClient.setQueryData(appKeys.list(), (old?: { data?: App[] }) =>
+ updateAppInListCache(old, appId, params),
);
};
+const revalidateAppList = () =>
+ queryClient.invalidateQueries({ queryKey: appKeys.list() });
+
const applyPackageUpdate = (
appId: number,
packageId: number,
@@ -147,7 +139,9 @@ const removeBindingFromList = (appId: number, bindingId: number) => {
export const createApp = async (params: { name: string; platform: string }) => {
const id = await api.createApp(params);
- addAppToList({ ...params, id });
+ // The create endpoint returns only an id. Refetch the canonical entity list
+ // instead of inserting an object without appKey/status into a fresh cache.
+ await revalidateAppList();
return id;
};
@@ -156,7 +150,10 @@ export const createApp = async (params: { name: string; platform: string }) => {
export const useDeleteApp = () =>
useMutation({
mutationFn: (appId: number) => api.deleteApp(appId),
- onSuccess: (_data, appId) => removeAppFromList(appId),
+ onSuccess: async (_data, appId) => {
+ removeAppFromList(appId);
+ await revalidateAppList();
+ },
});
export const useUpdateApp = () =>
@@ -168,7 +165,13 @@ export const useUpdateApp = () =>
appId: number;
params: UpdateAppParams;
}) => api.updateApp(appId, params),
- onSuccess: (_data, { appId, params }) => applyAppUpdate(appId, params),
+ onSuccess: async (_data, { appId, params }) => {
+ applyAppUpdate(appId, params);
+ await Promise.all([
+ revalidateAppList(),
+ queryClient.invalidateQueries({ queryKey: appKeys.detail(appId) }),
+ ]);
+ },
});
export const useUpdatePackage = () =>
diff --git a/src/utils/charts.test.ts b/src/utils/charts.test.ts
index 70a4c750..7e8d2489 100644
--- a/src/utils/charts.test.ts
+++ b/src/utils/charts.test.ts
@@ -37,7 +37,7 @@ describe('buildTimeSeriesLineConfig', () => {
).toBe('classicDark');
});
- test('formats the x axis with the requested time format', () => {
+ test('formats the x axis and tooltip with their requested time formats', () => {
const local = dayjs(data[0]!.time);
const config = buildTimeSeriesLineConfig({
data,
@@ -52,6 +52,7 @@ describe('buildTimeSeriesLineConfig', () => {
isDark: false,
height: 1,
axisTimeFormat: 'HH:mm',
+ tooltipTimeFormat: 'MM/DD',
});
expect(short.axis.x.labelFormatter(data[0]!.time)).toBe(
local.format('HH:mm'),
@@ -59,6 +60,7 @@ describe('buildTimeSeriesLineConfig', () => {
// 无法解析的刻度原样返回
expect(config.axis.x.labelFormatter('not a date')).toBe('not a date');
expect(config.tooltip.title(data[0]!)).toBe(local.format('MM/DD HH:mm'));
+ expect(short.tooltip.title(data[0]!)).toBe(local.format('MM/DD'));
});
test('wires titles, tooltip formatter and color domain', () => {
diff --git a/src/utils/charts.ts b/src/utils/charts.ts
index a13e803c..736febcf 100644
--- a/src/utils/charts.ts
+++ b/src/utils/charts.ts
@@ -24,6 +24,8 @@ export interface TimeSeriesLineOptions {
yTitle?: string;
/** x 轴刻度的时间格式，默认 'MM/DD HH:mm'；节点面板只看当天用 'HH:mm'。 */
axisTimeFormat?: string;
+ /** tooltip 标题的时间格式，默认 'MM/DD HH:mm'；日级图可只显示日期。 */
+ tooltipTimeFormat?: string;
/** tooltip 单项的值文本；不传则交给 G2 默认渲染。 */
formatTooltipValue?: (point: P) => string;
/** 多条线同时命中时合并到一个 tooltip，默认开启。 */
@@ -38,7 +40,7 @@ export interface TimeSeriesLineOptions
{
}
const DEFAULT_AXIS_TIME_FORMAT = 'MM/DD HH:mm';
-const TOOLTIP_TIME_FORMAT = 'MM/DD HH:mm';
+const DEFAULT_TOOLTIP_TIME_FORMAT = 'MM/DD HH:mm';
/**
* 各指标页共用的时间序列折线图配置：主题跟随暗色模式、x 轴按时间格式化、
@@ -51,6 +53,7 @@ export function buildTimeSeriesLineConfig
({
xTitle,
yTitle,
axisTimeFormat = DEFAULT_AXIS_TIME_FORMAT,
+ tooltipTimeFormat = DEFAULT_TOOLTIP_TIME_FORMAT,
formatTooltipValue,
sharedTooltip = true,
colorDomain,
@@ -79,7 +82,7 @@ export function buildTimeSeriesLineConfig
({
y: yTitle === undefined ? {} : { title: yTitle },
},
tooltip: {
- title: (point: P) => dayjs(point.time).format(TOOLTIP_TIME_FORMAT),
+ title: (point: P) => dayjs(point.time).format(tooltipTimeFormat),
...(formatTooltipValue
? {
items: [
diff --git a/src/utils/chunk-recovery.test.ts b/src/utils/chunk-recovery.test.ts
new file mode 100644
index 00000000..8035ce11
--- /dev/null
+++ b/src/utils/chunk-recovery.test.ts
@@ -0,0 +1,10 @@
+import { describe, expect, test } from 'bun:test';
+import { shouldReloadChunkError } from './chunk-recovery';
+
+describe('shouldReloadChunkError', () => {
+ test('allows one reload for each UI build', () => {
+ expect(shouldReloadChunkError(null, '2026.8.31-a')).toBe(true);
+ expect(shouldReloadChunkError('2026.8.31-a', '2026.8.31-a')).toBe(false);
+ expect(shouldReloadChunkError('2026.8.31-a', '2026.9.1-b')).toBe(true);
+ });
+});
diff --git a/src/utils/chunk-recovery.ts b/src/utils/chunk-recovery.ts
new file mode 100644
index 00000000..74d8cc22
--- /dev/null
+++ b/src/utils/chunk-recovery.ts
@@ -0,0 +1,11 @@
+export const CHUNK_ERROR_RELOAD_KEY = 'pushy_chunk_error_reload_attempted';
+
+/**
+ * Retry a stale chunk once per UI build. A later deployment has a different
+ * build id and therefore gets its own recovery attempt even if the previous
+ * marker is still present in the tab's session storage.
+ */
+export const shouldReloadChunkError = (
+ attemptedVersion: string | null,
+ currentVersion: string,
+) => attemptedVersion !== currentVersion;
diff --git a/src/utils/endpoint.test.ts b/src/utils/endpoint.test.ts
new file mode 100644
index 00000000..31114ae6
--- /dev/null
+++ b/src/utils/endpoint.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import { isEndpointSelectionUnchanged, normalizeEndpointUrl } from './endpoint';
+
+describe('normalizeEndpointUrl', () => {
+ test('canonicalizes HTTPS endpoints and preserves an API path', () => {
+ expect(normalizeEndpointUrl(' https://example.com/api/ ')).toBe(
+ 'https://example.com/api',
+ );
+ expect(normalizeEndpointUrl('https://example.com/')).toBe(
+ 'https://example.com',
+ );
+ });
+
+ test('allows plain HTTP only for local development hosts', () => {
+ expect(normalizeEndpointUrl('http://localhost:9000/api')).toBe(
+ 'http://localhost:9000/api',
+ );
+ expect(normalizeEndpointUrl('http://127.0.0.1:9000')).toBe(
+ 'http://127.0.0.1:9000',
+ );
+ expect(normalizeEndpointUrl('http://example.com/api')).toBeNull();
+ });
+
+ test('rejects embedded credentials, query strings, fragments and non-http URLs', () => {
+ expect(
+ normalizeEndpointUrl('https://user:pass@example.com/api'),
+ ).toBeNull();
+ expect(normalizeEndpointUrl('https://example.com/api?token=1')).toBeNull();
+ expect(normalizeEndpointUrl('https://example.com/api#section')).toBeNull();
+ expect(normalizeEndpointUrl('ftp://example.com/api')).toBeNull();
+ expect(normalizeEndpointUrl('not a url')).toBeNull();
+ });
+});
+
+describe('isEndpointSelectionUnchanged', () => {
+ test('treats the existing default and the same canonical endpoint as unchanged', () => {
+ expect(isEndpointSelectionUnchanged(null, null)).toBe(true);
+ expect(
+ isEndpointSelectionUnchanged(
+ 'https://example.com/api/',
+ 'https://example.com/api',
+ ),
+ ).toBe(true);
+ });
+
+ test('requires reset for an invalid non-null endpoint left by an older release', () => {
+ expect(isEndpointSelectionUnchanged('http://api.example.com', null)).toBe(
+ false,
+ );
+ expect(isEndpointSelectionUnchanged('not a url', null)).toBe(false);
+ });
+
+ test('detects real changes between default and custom endpoints', () => {
+ expect(isEndpointSelectionUnchanged(null, 'https://example.com/api')).toBe(
+ false,
+ );
+ expect(isEndpointSelectionUnchanged('https://example.com/api', null)).toBe(
+ false,
+ );
+ });
+});
diff --git a/src/utils/endpoint.ts b/src/utils/endpoint.ts
index 4410769b..2db8b6ef 100644
--- a/src/utils/endpoint.ts
+++ b/src/utils/endpoint.ts
@@ -2,8 +2,61 @@ import { useEffect, useState } from 'react';
import { safeStorage } from '@/utils/storage';
const CUSTOM_BASE_URL_STORAGE_KEY = 'pushy_custom_base_url';
+const LOCAL_HOSTNAMES = new Set([
+ 'localhost',
+ '127.0.0.1',
+ '0.0.0.0',
+ '::1',
+ '[::1]',
+]);
export const customBaseUrlChangeEvent = 'pushy-custom-base-url-change';
+/**
+ * Canonicalize a custom API base URL and reject values that would either be
+ * blocked as mixed content or conceal credentials/query data in the endpoint.
+ * Plain HTTP remains available for local development only.
+ */
+export function normalizeEndpointUrl(value: string): string | null {
+ try {
+ const url = new URL(value.trim());
+ const isLocal = LOCAL_HOSTNAMES.has(url.hostname);
+ const protocolAllowed =
+ url.protocol === 'https:' || (url.protocol === 'http:' && isLocal);
+ if (
+ !protocolAllowed ||
+ url.username ||
+ url.password ||
+ url.search ||
+ url.hash
+ ) {
+ return null;
+ }
+
+ const pathname = url.pathname.replace(/\/+$/, '');
+ return `${url.origin}${pathname}`;
+ } catch {
+ return null;
+ }
+}
+
+/**
+ * Compare a normalized endpoint choice with the persisted selection. An
+ * invalid, non-null legacy value is deliberately not equal to the default
+ * selection so resetting still removes it from storage and clears old state.
+ */
+export function isEndpointSelectionUnchanged(
+ currentCustomUrl: string | null,
+ nextUrl: string | null,
+): boolean {
+ if (nextUrl === null) {
+ return currentCustomUrl === null;
+ }
+ return (
+ currentCustomUrl !== null &&
+ normalizeEndpointUrl(currentCustomUrl) === nextUrl
+ );
+}
+
export function getCustomBaseUrl(): string | null {
if (typeof window === 'undefined') {
return null;
@@ -62,18 +115,22 @@ export function useCustomBaseUrl(): string | null {
}
export async function testEndpointStatus(baseUrl: string): Promise {
+ const normalizedUrl = normalizeEndpointUrl(baseUrl);
+ if (!normalizedUrl) {
+ return false;
+ }
+
+ const controller = new AbortController();
+ const timeoutId = setTimeout(() => controller.abort(), 5000);
try {
- const cleanUrl = baseUrl.trim().replace(/\/$/, '');
- const testUrl = `${cleanUrl}/status`;
- const controller = new AbortController();
- const timeoutId = setTimeout(() => controller.abort(), 5000);
- const response = await fetch(testUrl, {
+ const response = await fetch(`${normalizedUrl}/status`, {
method: 'GET',
signal: controller.signal,
});
- clearTimeout(timeoutId);
return response.ok;
} catch {
return false;
+ } finally {
+ clearTimeout(timeoutId);
}
}
diff --git a/src/utils/service-worker-retirement.test.ts b/src/utils/service-worker-retirement.test.ts
new file mode 100644
index 00000000..138a44b9
--- /dev/null
+++ b/src/utils/service-worker-retirement.test.ts
@@ -0,0 +1,117 @@
+import { describe, expect, mock, test } from 'bun:test';
+import {
+ isLegacyPushyRegistration,
+ LEGACY_PUSHY_CACHE_PREFIX,
+ retireLegacyPwaState,
+} from './service-worker-retirement';
+
+const PAGE_ORIGIN = 'https://admin.example.com';
+
+describe('isLegacyPushyRegistration', () => {
+ test('matches the retired root worker through any registration slot', () => {
+ const unregister = mock(async () => true);
+
+ expect(
+ isLegacyPushyRegistration(
+ {
+ active: { scriptURL: `${PAGE_ORIGIN}/sw.js` },
+ unregister,
+ },
+ PAGE_ORIGIN,
+ ),
+ ).toBe(true);
+ expect(
+ isLegacyPushyRegistration(
+ {
+ waiting: { scriptURL: `${PAGE_ORIGIN}/sw.js?build=old` },
+ unregister,
+ },
+ PAGE_ORIGIN,
+ ),
+ ).toBe(true);
+ });
+
+ test('rejects unrelated paths, origins and unknown registrations', () => {
+ const unregister = mock(async () => true);
+
+ expect(
+ isLegacyPushyRegistration(
+ {
+ active: { scriptURL: `${PAGE_ORIGIN}/other-sw.js` },
+ unregister,
+ },
+ PAGE_ORIGIN,
+ ),
+ ).toBe(false);
+ expect(
+ isLegacyPushyRegistration(
+ {
+ active: { scriptURL: 'https://other.example.com/sw.js' },
+ unregister,
+ },
+ PAGE_ORIGIN,
+ ),
+ ).toBe(false);
+ expect(isLegacyPushyRegistration({ unregister }, PAGE_ORIGIN)).toBe(false);
+ });
+});
+
+describe('retireLegacyPwaState', () => {
+ test('unregisters only the legacy worker and deletes only pushy-admin caches', async () => {
+ const unregisterLegacy = mock(async () => true);
+ const unregisterUnrelated = mock(async () => true);
+ const deleteCache = mock(async () => true);
+
+ await retireLegacyPwaState({
+ pageOrigin: PAGE_ORIGIN,
+ serviceWorker: {
+ getRegistrations: async () => [
+ {
+ active: { scriptURL: `${PAGE_ORIGIN}/sw.js` },
+ unregister: unregisterLegacy,
+ },
+ {
+ active: { scriptURL: `${PAGE_ORIGIN}/other-sw.js` },
+ unregister: unregisterUnrelated,
+ },
+ ],
+ },
+ cacheStorage: {
+ keys: async () => [
+ `${LEGACY_PUSHY_CACHE_PREFIX}v2`,
+ 'unrelated-cache',
+ `${LEGACY_PUSHY_CACHE_PREFIX}v3`,
+ ],
+ delete: deleteCache,
+ },
+ });
+
+ expect(unregisterLegacy).toHaveBeenCalledTimes(1);
+ expect(unregisterUnrelated).not.toHaveBeenCalled();
+ expect(deleteCache).toHaveBeenCalledTimes(2);
+ expect(deleteCache).toHaveBeenCalledWith('pushy-admin-v2');
+ expect(deleteCache).toHaveBeenCalledWith('pushy-admin-v3');
+ expect(deleteCache).not.toHaveBeenCalledWith('unrelated-cache');
+ });
+
+ test('keeps cleaning other state when one operation fails', async () => {
+ const deleteCache = mock(async () => true);
+
+ await expect(
+ retireLegacyPwaState({
+ pageOrigin: PAGE_ORIGIN,
+ serviceWorker: {
+ getRegistrations: async () => {
+ throw new Error('registration lookup failed');
+ },
+ },
+ cacheStorage: {
+ keys: async () => ['pushy-admin-v2'],
+ delete: deleteCache,
+ },
+ }),
+ ).resolves.toBeUndefined();
+
+ expect(deleteCache).toHaveBeenCalledWith('pushy-admin-v2');
+ });
+});
diff --git a/src/utils/service-worker-retirement.ts b/src/utils/service-worker-retirement.ts
new file mode 100644
index 00000000..6ea5e63e
--- /dev/null
+++ b/src/utils/service-worker-retirement.ts
@@ -0,0 +1,119 @@
+export const LEGACY_PUSHY_CACHE_PREFIX = 'pushy-admin-';
+
+interface ServiceWorkerLike {
+ scriptURL: string;
+}
+
+interface ServiceWorkerRegistrationLike {
+ active?: ServiceWorkerLike | null;
+ installing?: ServiceWorkerLike | null;
+ waiting?: ServiceWorkerLike | null;
+ unregister: () => Promise;
+}
+
+interface ServiceWorkerContainerLike {
+ getRegistrations: () => Promise;
+}
+
+interface CacheStorageLike {
+ delete: (cacheName: string) => Promise;
+ keys: () => Promise;
+}
+
+const getServiceWorkerContainer = ():
+ | ServiceWorkerContainerLike
+ | undefined => {
+ if (typeof navigator === 'undefined' || !('serviceWorker' in navigator)) {
+ return undefined;
+ }
+ return navigator.serviceWorker;
+};
+
+const getCacheStorage = (): CacheStorageLike | undefined =>
+ typeof caches === 'undefined' ? undefined : caches;
+
+const getPageOrigin = (): string | undefined =>
+ typeof window === 'undefined' ? undefined : window.location.origin;
+
+/**
+ * Identify the retired root-level Pushy worker without touching registrations
+ * owned by another application that happens to share the same origin.
+ */
+export function isLegacyPushyRegistration(
+ registration: ServiceWorkerRegistrationLike,
+ pageOrigin: string | undefined,
+): boolean {
+ if (!pageOrigin) {
+ return false;
+ }
+
+ let normalizedOrigin: string;
+ try {
+ normalizedOrigin = new URL(pageOrigin).origin;
+ } catch {
+ return false;
+ }
+
+ return [registration.active, registration.waiting, registration.installing]
+ .filter((worker): worker is ServiceWorkerLike => Boolean(worker?.scriptURL))
+ .some((worker) => {
+ try {
+ const scriptUrl = new URL(worker.scriptURL, normalizedOrigin);
+ return (
+ scriptUrl.origin === normalizedOrigin &&
+ scriptUrl.pathname === '/sw.js'
+ );
+ } catch {
+ return false;
+ }
+ });
+}
+
+/**
+ * Remove registrations and runtime caches left by the retired PWA layer.
+ * Every branch is best-effort so a browser implementation error cannot block
+ * the management console from starting.
+ */
+export async function retireLegacyPwaState({
+ serviceWorker = getServiceWorkerContainer(),
+ cacheStorage = getCacheStorage(),
+ pageOrigin = getPageOrigin(),
+}: {
+ serviceWorker?: ServiceWorkerContainerLike;
+ cacheStorage?: CacheStorageLike;
+ pageOrigin?: string;
+} = {}): Promise {
+ const cleanupTasks: Promise[] = [];
+
+ if (serviceWorker) {
+ cleanupTasks.push(
+ serviceWorker
+ .getRegistrations()
+ .then((registrations) =>
+ Promise.allSettled(
+ registrations
+ .filter((registration) =>
+ isLegacyPushyRegistration(registration, pageOrigin),
+ )
+ .map((registration) => registration.unregister()),
+ ),
+ ),
+ );
+ }
+
+ if (cacheStorage) {
+ cleanupTasks.push(
+ cacheStorage
+ .keys()
+ .then((keys) =>
+ Promise.allSettled(
+ keys
+ .filter((key) => key.startsWith(LEGACY_PUSHY_CACHE_PREFIX))
+ .map((key) => cacheStorage.delete(key)),
+ ),
+ ),
+ );
+ }
+
+ await Promise.allSettled(cleanupTasks);
+}