@autional/shared 0.1.0-rc.34 → 0.1.0-rc.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autional/shared",
-  "version": "0.1.0-rc.34",
+  "version": "0.1.0-rc.36",
   "description": "Autional shared layer — API client, auth, types, hooks, utils",
   "license": "AGPL-3.0",
   "main": "./src/index.ts",

package/src/auth/__tests__/build-login-url.test.ts

@@ -182,38 +182,85 @@ describe('buildLoginUrl', () => {
 		});
 	});
 
-	describe('buildLogoutUrl（F-W5c 登出意图标记）', () => {
+	describe('buildLogoutUrl（TASK-LS-08 同源标准端点 + legacy 兜底）', () => {
 		const AUTH_CONFIG = {
 			VITE_PORTAL_CONFIG: {
 				auth: { host: 'auth', base: '' },
 			},
 		};
+		/** env 级 client_id（三级来源之二） */
+		const CID_CONFIG = {
+			...AUTH_CONFIG,
+			VITE_OAUTH_CLIENT_ID: 'cid-env',
+		};
 
-		it('门户域登出：auth 裸根 + redirect 回程 + logout=1', () => {
-			mockWindow('app.autional.com', 'https:', 'https://app.autional.com', AUTH_CONFIG);
+		beforeEach(() => {
+			// localStorage 桩按需设置；测试间清掉全局桩防跨用例泄漏（node 环境无真 localStorage）
+			vi.unstubAllGlobals();
+		});
+
+		it('门户域登出：同源标准端点 + client_id + post_logout_redirect_uri=<origin>/ + state=returnUrl', () => {
+			mockWindow('app.autional.com', 'https:', 'https://app.autional.com', CID_CONFIG);
 			const url = buildLogoutUrl('https://app.autional.com/demo/');
 			expect(url).toBe(
-				'https://auth.autional.com/?redirect=' +
-					encodeURIComponent('https://app.autional.com/demo/') +
-					'&logout=1',
+				'https://app.autional.com/oauth/api/v1/oauth/logout?client_id=cid-env&post_logout_redirect_uri=' +
+					encodeURIComponent('https://app.autional.com/') +
+					'&state=' +
+					encodeURIComponent('https://app.autional.com/demo/'),
 			);
 		});
 
-		it('auth 域租户页登出也走裸根：不经 /<slug>/login（那里 logout=1 被静默忽略）', () => {
-			mockWindow('auth.autional.local', 'https:', 'https://auth.autional.local', AUTH_CONFIG);
+		it('auth 域租户页登出同样走同源标准端点（不再裸根 / 不经 /<slug>/login）', () => {
+			mockWindow('auth.autional.local', 'https:', 'https://auth.autional.local', CID_CONFIG);
 			const url = buildLogoutUrl('https://auth.autional.local/acme-corp/dashboard');
 			expect(url).toBe(
-				'https://auth.autional.local/?redirect=' +
-					encodeURIComponent('https://auth.autional.local/acme-corp/dashboard') +
-					'&logout=1',
+				'https://auth.autional.local/oauth/api/v1/oauth/logout?client_id=cid-env&post_logout_redirect_uri=' +
+					encodeURIComponent('https://auth.autional.local/') +
+					'&state=' +
+					encodeURIComponent('https://auth.autional.local/acme-corp/dashboard'),
 			);
 			expect(url).not.toContain('/acme-corp/login');
 		});
 
-		it('无回程：auth 裸根 + logout=1', () => {
-			mockWindow('auth.autional.local', 'https:', 'https://auth.autional.local', AUTH_CONFIG);
+		it('无回程：仅 client_id + post_logout_redirect_uri，不产 state', () => {
+			mockWindow('app.autional.com', 'https:', 'https://app.autional.com', CID_CONFIG);
 			const url = buildLogoutUrl();
-			expect(url).toBe('https://auth.autional.local/?logout=1');
+			expect(url).toBe(
+				'https://app.autional.com/oauth/api/v1/oauth/logout?client_id=cid-env&post_logout_redirect_uri=' +
+					encodeURIComponent('https://app.autional.com/'),
+			);
+		});
+
+		describe('client_id 三级来源（会话持久化 → env → 空）', () => {
+			it('localStorage 会话值优先于 env', () => {
+				vi.stubGlobal('localStorage', { getItem: () => 'cid-session' });
+				mockWindow('app.autional.com', 'https:', 'https://app.autional.com', CID_CONFIG);
+				const url = buildLogoutUrl('https://app.autional.com/demo/');
+				expect(url).toContain('client_id=cid-session');
+				expect(url).not.toContain('cid-env');
+			});
+
+			it('localStorage 空 → env 兜底', () => {
+				vi.stubGlobal('localStorage', { getItem: () => null });
+				mockWindow('app.autional.com', 'https:', 'https://app.autional.com', CID_CONFIG);
+				expect(buildLogoutUrl()).toContain('client_id=cid-env');
+			});
+
+			it('双空 → legacy 兜底：auth 裸根 + redirect 回程 + logout=1', () => {
+				mockWindow('app.autional.com', 'https:', 'https://app.autional.com', AUTH_CONFIG);
+				const url = buildLogoutUrl('https://app.autional.com/demo/');
+				expect(url).toBe(
+					'https://auth.autional.com/?redirect=' +
+						encodeURIComponent('https://app.autional.com/demo/') +
+						'&logout=1',
+				);
+			});
+
+			it('双空 + 无回程 → legacy 裸根 + logout=1（现行为保持）', () => {
+				mockWindow('auth.autional.local', 'https:', 'https://auth.autional.local', AUTH_CONFIG);
+				const url = buildLogoutUrl();
+				expect(url).toBe('https://auth.autional.local/?logout=1');
+			});
 		});
 	});
 });

package/src/auth/roles.ts

@@ -8,6 +8,7 @@
  */
 
 import { getPortalUrl } from '../config';
+import { resolveClientIdForSession } from './oauth-client-id-store';
 
 /** auth-pages 的静态/受保护路由 — 首段不会是租户 slug */
 const AUTH_ROUTE_RESERVED = new Set([
@@ -20,6 +21,7 @@ const AUTH_ROUTE_RESERVED = new Set([
 	'privacy',
 	'error',
 	'logout',
+	'logout-confirm',
 	'passkey',
 	'reapply',
 	'mfa',
@@ -37,20 +39,41 @@ const AUTH_ROUTE_RESERVED = new Set([
 ]);
 
 /**
- * 登出回程 URL：auth 域**裸根**入口 + `logout=1` 显式登出意图标记。
+ * 登出 URL（TASK-LS-08）：同源标准端点（RP-Initiated Logout 无 hint 形态）优先，
+ * client_id 不可得时保持 legacy 形态。
  *
- * 刻意不复用 buildLoginUrl：其租户 slug 保留会把 auth 域页面的登出落到
- * `/<slug>/login`（登录页路由，不经入口路由），`logout=1` 在那里被静默忽略；
+ * 标准端点形态（ADR-12 同源直通）：`${origin}/oauth/api/v1/oauth/logout`
+ * - client_id：本部署的 OAuth 客户端（`resolveClientIdForSession` 三级来源：会话持久化
+ *   localStorage `oauth_client_id` → env），服务端据此做 post_logout_redirect_uri 注册面白名单校验；
+ * - post_logout_redirect_uri：本门户 origin 根（`<origin>/`，注册形态同 PlatformPortalRedirectURIs）；
+ * - state：returnUrl 的 URL-safe 编码（门户零行为驱动——服务端只原样回拼到回跳 URL，门户不解析）。
+ * 浏览器整页导航不带 Bearer → 服务端「无 hint 无会话浏览器」支 302 确认页承接；
+ * 用户确认后由确认页经 BFF（会话 cookie → Bearer）触达端点，走认证会话支并导航服务端 location。
+ *
+ * legacy 兜底（D2=A 兼容分支保留，EntryRouter 承接）：client_id 不可得 → auth 域**裸根**入口 +
+ * `logout=1` 显式登出意图标记。刻意不复用 buildLoginUrl：其租户 slug 保留会把 auth 域页面的
+ * 登出落到 `/<slug>/login`（登录页路由，不经入口路由），`logout=1` 在那里被静默忽略；
  * 带会话回程甚至会被登录页 checkAndRedirect 直接放行成静默重登（F-W5c）。
- * 裸根 = EntryRouter 唯一登出闸门：先终结 auth 域会话，再决定落点——
- * 回程能解析出真实租户 → 裸 `/<slug>/login`（不带回程参数：登出即"重新开始"，
- * 登录后走默认去向，去向选择权交还用户）；否则落 brand 裸根。
+ * 裸根 = EntryRouter 唯一登出闸门：先终结 auth 域会话，再决定落点——回程能解析出真实租户 →
+ * 裸 `/<slug>/login`；否则落 brand 裸根。
  */
 export function buildLogoutUrl(returnUrl?: string): string {
 	const base = getPortalUrl('auth');
-	if (!base) return '/';
-	const redirect = returnUrl ? `redirect=${encodeURIComponent(returnUrl)}&` : '';
-	return `${base}/?${redirect}logout=1`;
+	// legacy 兜底：现行为保持（auth 裸根 + logout=1 意图标记）
+	const legacy = (): string => {
+		if (!base) return '/';
+		const redirect = returnUrl ? `redirect=${encodeURIComponent(returnUrl)}&` : '';
+		return `${base}/?${redirect}logout=1`;
+	};
+
+	const clientId = resolveClientIdForSession();
+	if (!clientId || typeof window === 'undefined' || !window.location?.origin) return legacy();
+
+	const params = new URLSearchParams();
+	params.set('client_id', clientId);
+	params.set('post_logout_redirect_uri', `${window.location.origin}/`);
+	if (returnUrl) params.set('state', returnUrl);
+	return `${window.location.origin}/oauth/api/v1/oauth/logout?${params.toString()}`;
 }
 
 /**

package/src/auth/store.ts

@@ -201,7 +201,8 @@ export function loginWithTokens(
  *
  * redirectTo（U350）：显式落点（会话过期→auth /error、注销完成→/<slug>/login?account_deleted=true 等
  * 旗标页）——清理完成后整页前往。缺省仅清会话、不导航；注意与 useLogout 口径区分：该 hook 走
- * buildLogoutUrl 登出意图流（logout=1 交入口路由定落点），不得用于需要保留业务 query 旗标的目标。
+ * buildLogoutUrl 登出流（LS-08：同源标准端点；client_id 不可得时退 legacy logout=1 交入口路由），
+ * 不得用于需要保留业务 query 旗标的目标。
  */
 export async function logout(redirectTo?: string): Promise<void> {
 	const { AuthService } = await import('./service');

package/src/components/TenantIndexGuard.tsx

@@ -5,7 +5,8 @@
  * （不复制 4 份，违反 DRY）。
  *
  * - usePublicTenantSlugs: 调公开 tenants API（无认证端点），staleTime 5m 缓存，
- *   retry 1，任何失败返回空数组（放行语义由 TenantIndexGuard 处理）。
+ *   retry 1 + 8s 超时；失败上抛（不吞成空数组成功）——放行语义由消费方
+ *   （TenantIndexGuard / TenantRootRedirect）在失败态自行 fail-open（rc.35）。
  * - TenantIndexGuard: 租户 slug 白名单守卫（P0-2），防止未知 slug 被贪婪渲染为
  *   租户内容（index 首页与 /:slug/... 子路由通用）。404 页由各 portal 通过
  *   notFound prop 注入（shared 组件不能 import 具体 app 的 not-found/page）。
@@ -30,11 +31,20 @@ export interface PublicTenantInfo {
 	id?: string;
 }
 
+/** 公开租户名单请求超时（ms）。跨境链路（Vercel edge → 源站）实测新连接丢 ~45%，
+ * 失败连接 edge 端要 ~31s 才吐 502；正常成功 ≤2s，8s 留 4x 余量，失败快速交给 retry。
+ * （rc.35：此前无超时 + catch 吞错 → retry 死码、失败被当"空名单"成功。） */
+export const PUBLIC_TENANTS_FETCH_TIMEOUT_MS = 8000;
+
 /**
  * 公开租户列表（无认证端点，用于校验 URL slug 有效性）。
  * 从 end-user-portal App.tsx 原样抽取。
  * - staleTime 5m（plan §5 资源列：public tenants API 有缓存）
- * - retry 1；失败返回 []（白名单空数组放行，避免 API 挂掉时全站 404）
+ * - retry 1；非 2xx / 网络错 / 超时一律上抛（不吞成空数组成功）——
+ *   error 态不落缓存，下次调用自然重试
+ * - 消费方 fail-open：名单缺失（error 态 data=undefined 或空数组）→ 不拦截
+ *   （TenantIndexGuard 渲染 children；TenantRootRedirect 漏斗 brand；
+ *   resolveSlugAgainstList 信任传入 slug）
  *
  * ⚠️ 响应契约：tenant-service ListPublicTenants 返回 dto_base.ListResponse
  * （`{code, message, items, total, pagination, timestamp}`，items 才是数组）。
@@ -44,14 +54,18 @@ export function usePublicTenantSlugs() {
 	return useQuery<Array<PublicTenantInfo>>({
 		queryKey: ['public-tenants'],
 		queryFn: async () => {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), PUBLIC_TENANTS_FETCH_TIMEOUT_MS);
 			try {
-				const res = await fetch('/bff/tenant/api/v1/tenant/public/tenants');
-				if (!res.ok) return [];
+				const res = await fetch('/bff/tenant/api/v1/tenant/public/tenants', {
+					signal: controller.signal,
+				});
+				if (!res.ok) throw new Error(`public tenants API HTTP ${res.status}`);
 				const json = await res.json();
 				const list = json?.items ?? json?.data ?? json ?? [];
 				return Array.isArray(list) ? list : [];
-			} catch {
-				return [];
+			} finally {
+				clearTimeout(timer);
 			}
 		},
 		staleTime: 5 * 60 * 1000,

package/src/components/TenantRootRedirect.tsx

@@ -18,7 +18,11 @@ import { usePublicTenantSlugs } from './TenantIndexGuard';
  */
 export function TenantRootRedirect() {
 	const currentTenantId = useCurrentTenantId();
-	const { data: knownTenants, isSuccess: tenantsLoaded } = usePublicTenantSlugs();
+	const {
+		data: knownTenants,
+		isSuccess: tenantsLoaded,
+		isError: tenantsError,
+	} = usePublicTenantSlugs();
 
 	const slug = useMemo(() => {
 		if (!currentTenantId || !tenantsLoaded) return undefined;
@@ -35,7 +39,8 @@ export function TenantRootRedirect() {
 		}
 		// 有会话但公开名单尚未返回：等待（名单是 slug 唯一权威，不得抢跑漏斗 brand）。
 		// 无会话（currentTenantId 空）不受此闸，立即漏斗。
-		if (currentTenantId && !tenantsLoaded) return;
+		// 名单接口彻底失败（rc.35：重试耗尽后 error 态）不等待：按无匹配处理漏斗 brand，不卡死。
+		if (currentTenantId && !tenantsLoaded && !tenantsError) return;
 		const brand = getPortalUrl('brand');
 		// 门户不可派生（如经 IP 主机访问）：保持当前页，不导航（与 EntryRouter 同约定）
 		if (!brand) return;
@@ -43,7 +48,7 @@ export function TenantRootRedirect() {
 			window.location.origin + window.location.pathname,
 		)}`;
 		traceRedirect(target, { reason: 'funnel-brand' });
-	}, [slug, currentTenantId, tenantsLoaded]);
+	}, [slug, currentTenantId, tenantsLoaded, tenantsError]);
 
 	return null;
 }

package/src/components/__tests__/TenantIndexGuard.test.tsx

@@ -9,7 +9,9 @@ import { TenantIndexGuard, usePublicTenantSlugs } from '../TenantIndexGuard';
 function createQueryClient() {
 	return new QueryClient({
 		defaultOptions: {
-			queries: { retry: false, gcTime: Infinity },
+			// retryDelay 0：hook 内部 retry:1 覆盖 retry，但重试退避仍走 defaultOptions，
+			// 不设 0 时失败用例要白等默认 1s 退避
+			queries: { retry: false, retryDelay: 0, gcTime: Infinity },
 		},
 	});
 }
@@ -106,20 +108,34 @@ describe('usePublicTenantSlugs（响应契约解析）', () => {
 		await waitFor(() => expect(result).toEqual([{ id: '1', name: 'acme-corp' }]));
 	});
 
-	it('API 非 200 → 返回空数组（放行语义）', async () => {
+	it('API 非 200 → 上抛进入 error 态，不吞成空数组成功（rc.35）', async () => {
 		stubFetchNonOk();
-		let result: unknown[] | undefined;
+		let state: { isError: boolean; data: unknown[] | undefined } | undefined;
 		function Harness() {
 			const q = usePublicTenantSlugs();
-			result = q.data;
+			state = { isError: q.isError, data: q.data };
 			return null;
 		}
 		render(wrapper(<Harness />));
-		await waitFor(() => expect(result).toEqual([]));
+		await waitFor(() => expect(state?.isError).toBe(true));
+		expect(state?.data).toBeUndefined();
 	});
 
-	it('网络异常 → 返回空数组', async () => {
+	it('网络异常 → 上抛进入 error 态（retry 不再被吞错架空，rc.35）', async () => {
 		stubFetchReject();
+		let state: { isError: boolean; data: unknown[] | undefined } | undefined;
+		function Harness() {
+			const q = usePublicTenantSlugs();
+			state = { isError: q.isError, data: q.data };
+			return null;
+		}
+		render(wrapper(<Harness />));
+		await waitFor(() => expect(state?.isError).toBe(true));
+		expect(state?.data).toBeUndefined();
+	});
+
+	it('fetch 携带 AbortSignal（8s 超时接线，rc.35）', async () => {
+		stubFetch([{ id: '1', name: 'acme-corp' }]);
 		let result: unknown[] | undefined;
 		function Harness() {
 			const q = usePublicTenantSlugs();
@@ -127,7 +143,39 @@ describe('usePublicTenantSlugs（响应契约解析）', () => {
 			return null;
 		}
 		render(wrapper(<Harness />));
-		await waitFor(() => expect(result).toEqual([]));
+		await waitFor(() => expect(result).toEqual([{ id: '1', name: 'acme-corp' }]));
+		const fetchMock = fetch as unknown as ReturnType<typeof vi.fn>;
+		const init = fetchMock.mock.calls[0][1] as RequestInit;
+		expect(init.signal).toBeInstanceOf(AbortSignal);
+	});
+
+	it('超时 abort（AbortError）→ 上抛进入 error 态，不吞（rc.35）', async () => {
+		const signals: AbortSignal[] = [];
+		vi.stubGlobal(
+			'fetch',
+			vi.fn((_url: string, init?: RequestInit) => {
+				return new Promise((_resolve, reject) => {
+					signals.push(init!.signal!);
+					init!.signal!.addEventListener('abort', () =>
+						reject(new DOMException('The operation was aborted.', 'AbortError')),
+					);
+				});
+			}),
+		);
+		let isError = false;
+		function Harness() {
+			const q = usePublicTenantSlugs();
+			isError = q.isError;
+			return null;
+		}
+		render(wrapper(<Harness />));
+		// 模拟计时器到点 abort（计时器-到点→abort 是标准库行为，此处验 abort 错误的上抛路径）；
+		// hook retry:1 → 两跳都要 abort 才耗尽重试
+		await waitFor(() => expect(signals.length).toBeGreaterThan(0));
+		signals[0].dispatchEvent(new Event('abort'));
+		await waitFor(() => expect(signals.length).toBeGreaterThan(1));
+		signals[1].dispatchEvent(new Event('abort'));
+		await waitFor(() => expect(isError).toBe(true));
 	});
 
 	it('响应无 items/data 且非数组 → 返回空数组', async () => {
@@ -178,6 +226,14 @@ describe('TenantIndexGuard（P0-2 slug 白名单守卫）', () => {
 		await waitFor(() => expect(screen.getByTestId('children')).toBeInTheDocument());
 	});
 
+	it('名单接口失败（重试耗尽 error）→ fail-open 渲染 children，不白屏不 404（rc.35）', async () => {
+		stubFetchReject();
+		setPath('/any-slug');
+		render(wrapper(<TenantIndexGuard notFound={notFound}>{children}</TenantIndexGuard>));
+		await waitFor(() => expect(screen.getByTestId('children')).toBeInTheDocument());
+		expect(screen.queryByTestId('notfound')).toBeNull();
+	});
+
 	it('slug 有效 + 子路径（/acme-corp/terms）→ 渲染 children（回归：子路由此前被段数检查误杀）', async () => {
 		stubFetch([{ id: '1', name: 'acme-corp' }]);
 		setPath('/acme-corp/terms');

package/src/components/__tests__/TenantRootRedirect.test.tsx

@@ -34,7 +34,12 @@ import { getPortalUrl } from '../../config';
 function wrapper(children: ReactNode) {
 	return (
 		<QueryClientProvider
-			client={new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })}
+			client={
+				new QueryClient({
+					// retryDelay 0：hook 内部 retry:1 覆盖 retry，重试退避仍走 defaultOptions
+					defaultOptions: { queries: { retry: false, retryDelay: 0, gcTime: Infinity } },
+				})
+			}
 		>
 			{children}
 		</QueryClientProvider>
@@ -154,7 +159,7 @@ describe('TenantRootRedirect 裸根漏斗', () => {
 		expect(withoutRt(String(mockState.replace.mock.calls[0][0]))).toBe(withoutRt(expectedBrandFunnel()));
 	});
 
-	it('名单接口失败（返回空数组）→ 有会话按无匹配处理，漏斗 brand（不卡死）', async () => {
+	it('名单接口失败（error 态，rc.35 上抛）→ 有会话按无匹配处理，漏斗 brand（不卡死）', async () => {
 		mockState.currentTenantId = 't1';
 		vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')));