@oj-module/cli 0.2.50 → 0.2.53

package/templates/src/_platform/api/_shared/service/domain/users.ts

@@ -59,13 +59,30 @@ function assertNotSelf(actorId: number, targetUid: number): void {
 		fail(400, "cannot operate on yourself");
 }
 
-/** AC1-8：成员资格（superadmin/admin 分配）仅 superadmin 可动。 */
+/**
+ * AC1-8（已修订）：成员资格提权守卫——按**被授予的角色**分层，不再一刀切。
+ *
+ *   · `superadmin` —— 仍严格只许 superadmin 授。它是**平台级**角色：握着它就能进
+ *     /system/wecom 那类跨租户页面（listApps 列出**所有企业**的档案），一旦租户内可授
+ *     即为跨租户越权，故这条不因下面的修订而放宽。
+ *   · `admin` —— 允许本租户内握有 `admin` 或 `superadmin` 的人任命。
+ *     判定与写入两侧都被租户作用域约束：`rolesOf()` 读 sys_user_role 走请求租户注入，
+ *     下面的写入同样带 tenant_id，所以租户管理员只能影响**自己租户**，不会越到别家。
+ *     动机：企业租户是隐式具象化的，平台 superadmin 因租户隔离查不到企业租户的用户
+ *     （实测 404），若 admin 任命也只许 superadmin，企业租户就永远配不出管理员。
+ *   · 其余角色（editor/viewer 等）—— 不校验，保持原行为。
+ */
 async function assertMembershipAllowed(actorId: number, nextRoles: string[]): Promise<void> {
 	if (!nextRoles.includes("superadmin") && !nextRoles.includes("admin"))
 		return;
 	const actorRoles = await rolesOf(Number(actorId));
-	if (!actorRoles.includes("superadmin"))
-		fail(403, "membership management requires superadmin");
+	const isSuper = actorRoles.includes("superadmin");
+	// 提权到平台级：只许 superadmin
+	if (nextRoles.includes("superadmin") && !isSuper)
+		fail(403, "granting superadmin requires superadmin");
+	// 任命本租户管理员：本租户的 admin 或 superadmin 均可
+	if (nextRoles.includes("admin") && !isSuper && !actorRoles.includes("admin"))
+		fail(403, "membership management requires admin or superadmin");
 }
 
 export async function listUsers(): Promise<UserRow[]> {
@@ -206,11 +223,30 @@ export async function updateUserRoles(actorId: number, targetUid: number, roles:
 			await t.table("sys_user_role").insert({ user_id: targetUid, role_name: role }).run();
 	});
 	invalidateUser(Number(targetUid));
+	// 提权类变更（牵涉 admin / superadmin）单列严重级：任命管理员＝把该租户的最高权限交出去，
+	// 不该和「勾了个 editor」落在同一噪声水平上。收回也算——撤销提权同样是安全事件。
+	const touchesPrivilege = (r: string) => r === "admin" || r === "superadmin";
+	const elevated = next.some(touchesPrivilege) || [...beforeSet].some(touchesPrivilege);
 	await recordOp({
 		action: "user.roles.update",
 		module: "framework",
 		target: await usernameOf(Number(targetUid)),
-		detail: { added: next.filter(r => !beforeSet.has(r)), removed: [...beforeSet].filter(r => !next.includes(r)) },
+		detail: {
+			added: next.filter(r => !beforeSet.has(r)),
+			removed: [...beforeSet].filter(r => !next.includes(r)),
+			// —— 租户维度 ——
+			// 每个租户都有自己的管理员，且**用户名撞车**（都叫 admin）：只记 username 分不清
+			// 「哪个租户的 admin 任命了谁」。sys_oplog.tenant_id 虽由请求租户注入，但那是隐式列，
+			// 显式落一份 + 双方 uid，审计才能直接按租户筛、也能定位到具体两个账号。
+			tenant: http.tenantId ?? "",
+			actorUid: Number(actorId),
+			targetUid: Number(targetUid),
+			// 便于直接筛出「任命/撤销管理员」这类高价值条目，不必去解析 added/removed
+			elevated,
+		},
+		// 4=warning（与「重设租户管理员口令」同级）：提权变更按安全事件留痕；
+		// 普通角色变更（editor/viewer）保持默认 6=info，避免审计被噪声淹没。
+		level: elevated ? 4 : 6,
 	});
 }
 

package/templates/src/auth/api/_shared/wecom/admin.ts

@@ -13,6 +13,7 @@ import type { WecomConfig, WecomCorpConfig, WecomKind } from "./config";
 import type { WecomStoreDeps } from "./store";
 import { invalidateAllUsers } from "#/_platform/_shared/service/infra/access";
 import { assertProviderConfig, eventUrlOf } from "./config";
+import { provisionTenantAdmin } from "./tenant-admin";
 import { corpScope, revokeTenantSessions, saveProfile, tenantOfCorp } from "./store";
 
 export interface WecomAdminDeps {
@@ -194,6 +195,9 @@ export async function connectCorp(cfg: WecomCorpConfig, client: WecomClient, dep
 		}).run();
 		await client.invalidateCorpToken(cfg.corpId, old);
 	}
+	// 租户具象化：给这个企业配一个本租户的管理员（admin，非 superadmin），否则
+	// 该租户里只有 JIT 出来的员工号，没人能做组织架构同步、也没人能在租户内授权。
+	await provisionTenantAdmin(cfg.corpId);
 	invalidateAllUsers();
 	return { corpId: cfg.corpId, agentId: cfg.agentId, departments: depts.length, members };
 }

package/templates/src/auth/api/_shared/wecom/client.ts

@@ -518,11 +518,18 @@ export function createWecomClient(deps: WecomClientDeps) {
 				await invalidateCorpToken(corpId, agentId);
 				continue;
 			}
-			if (errcode !== 0)
+			if (errcode !== 0) {
+				// 部署侧错误（IP 白名单 / 限流）不是用户凭据问题：按 502 抛，避免被统一成 401 把排查带偏
+				log.warn("wecom getuserinfo rejected", "errcode", String(errcode), "errmsg", String(res.errmsg ?? ""));
+				if (errcode === 60020 || errcode === 45009)
+					throw upstream(`企微 auth/getuserinfo 失败：errcode=${errcode} ${String(res.errmsg ?? "")}`.trim());
 				rejectCode();
+			}
 			const userid = res.userid == null ? "" : String(res.userid);
-			if (!userid)
+			if (!userid) {
+				log.warn("wecom getuserinfo no userid", "keys", Object.keys(res).join(","));
 				rejectCode(); // 非企业成员（外部联系人）时企微只给 openid，不认作本应用用户
+			}
 			return userid;
 		}
 		throw upstream("企微 token 反复失效（40001/42001）");

package/templates/src/auth/api/_shared/wecom/events.ts

@@ -21,6 +21,7 @@ import { invalidateAllUsers } from "#/_platform/_shared/service/infra/access";
 import { recordOp } from "#/_platform/_shared/service/infra/audit";
 import { handleContactChange } from "./contacts";
 import { callbackFields, field, requireField } from "./payload";
+import { provisionTenantAdmin } from "./tenant-admin";
 import { corpScope, ensureTenant, findCorpAuth, getSuiteTicket, putSuiteTicket, revokeTenantSessions, saveProfile, setAuthMode, setProfileStatus, tenantOfCorp } from "./store";
 
 /** suite_ticket 官方有效期 30 分钟（10 分钟推一次）；本地按 30 分钟作废，宁可拒一次也不拿过期票打企微 */
@@ -117,6 +118,8 @@ async function applyAuthCode(authCode: string, state: string | null, deps: Suite
 		// secret 可能已轮换：旧 token 必须立刻作废，否则下一个登录会带着失效 token 打 userinfo
 		await client.invalidateCorpToken(granted.corpId, agentId);
 	}
+	// 租户具象化：代开发企业授权成功即配一个本租户管理员（尽力而为，绝不拖垮 1 秒回调窗口）
+	await provisionTenantAdmin(granted.corpId);
 	await auditAuth("wecom.auth.apply", granted.corpId, { agentIds: granted.agentIds, env });
 	return { corpId: granted.corpId, agentIds: granted.agentIds };
 }

package/templates/src/auth/api/_shared/wecom/tenant-admin.ts

@@ -0,0 +1,194 @@
+// 租户管理员：给每个企业租户（tenant_id = corp_id）配一个**本租户内**的管理员账号。
+//
+// 为什么必须有这一层：
+//   企业租户是企微登录时才由 `ensureTenant()` 隐式具象化的，里面只有 JIT 建出来的
+//   `wecom:<userid>` 员工号，**一个管理员都没有**——于是没人能进 /system/departments
+//   做组织架构同步、也没人能在该租户内授权。平台 superadmin 虽然在 /system/wecom
+//   上看得到所有企业，但管不了租户内的组织/成员/角色（详见下面「越权」一段）。
+//
+// 为什么是 `admin` 而不是 `superadmin`：
+//   `superadmin` 在本系统是**跨租户**的框架级角色——/system/wecom 每个端点都过
+//   `assertSuperAdmin()`，而它列出的 listApps() 是**所有企业**的档案。只要某租户里
+//   有人握着 superadmin，他带自己租户的头访问该页就能看到别家企业的档案，属跨租户
+//   越权。所以：superadmin = 平台级、只留在 default 租户（运维纪律）；
+//   admin = 租户级、每租户一个（本文件负责开的就是这个）。
+//
+// ─────────────────────────────────────────────────────────────────────────────
+// 【db.asSystem 例外说明 —— 全仓唯一，不得复制】
+//
+// 本文件是全代码库**唯一**使用 `db.asSystem()` 的地方。
+//
+// 为什么必须用它：superadmin 的请求自带 `default` 租户头，而 `db.asTenant` 是
+// 「请求级、只能设一次，且要求当时还没有租户」。也就是说平台侧**没有任何正常通道**
+// 能往企业租户里写 users / sys_user_role。而「给新租户配管理员」是平台开通动作，
+// 不是业务写——正是逃生通道的用途（global.d.ts 原文："use db.asSystem() for system tasks"）。
+//
+// 框架红线：同一段注释紧接着写「业务 handler 不得使用」。所以这里是**有意识且被审计
+// 的单一例外**，代价与边界必须写清楚：
+//   · 范围：只在本文件，只服务「开通 / 重设租户管理员」这一件事；
+//   · 写操作必须显式带上 tenant_id 条件（asSystem 绕过自动注入，漏了就是跨租户脏写）；
+//   · 每个入口都在 admin/api.ts 走 recordOp 留痕（开通 level 2、改密 level 4）；
+//   · **不得在本文件之外任何地方复制 db.asSystem()**。
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** 租户管理员的固定账号名（每租户各一个，互不冲突——users 唯一键含 tenant_id） */
+export const TENANT_ADMIN_USERNAME = "admin";
+/** 授予的角色：租户级日常管理（组织/成员/角色/同步），**不是**跨租户的 superadmin */
+const TENANT_ADMIN_ROLE = "admin";
+
+export interface TenantAdminState {
+	/** 租户（= 企业 ID） */
+	corpId: string
+	/** 管理员账号名 */
+	username: string
+	/** 该租户是否已有一个握着 admin 角色的账号 */
+	exists: boolean
+	/** 是否处于「须改密」状态（开通后恒为 true，直到本人改过一次） */
+	mustChange: boolean
+}
+
+/**
+ * 随机初始口令：**任何人都不知道**（bcrypt 单向，也不落库、不打日志）。
+ *
+ * 这不是缺陷而是设计：开通时不需要有人知道口令；平台侧要接管时走
+ * `setTenantAdminPassword()` **自己设一个已知的**——他输入的那个他本来就知道，
+ * 于是「口令需要被传递」这个问题被消掉了，全系统没有任何口令以可逆形式静态存储。
+ */
+function randomPassword(): string {
+	// randomHex 产出 [0-9a-f]，长度 20 > 口令最小长度 6，且数字字母混合
+	return crypto.randomHex(10);
+}
+
+/** 跨租户读：指定租户下的管理员行（asSystem 例外，见文件头） */
+async function adminRow(tenantId: string): Promise<{ id: number, must_change: number } | null> {
+	const rows = await db.asSystem().table("users")
+		.select(["id", "must_change"])
+		.where({
+			and: [
+				{ field: "tenant_id", op: "eq", value: tenantId },
+				{ field: "username", op: "eq", value: TENANT_ADMIN_USERNAME },
+			],
+		})
+		.all() as Array<{ id: number, must_change: number | null }>;
+	if (!rows.length)
+		return null;
+	return { id: Number(rows[0]!.id), must_change: Number(rows[0]!.must_change ?? 0) };
+}
+
+/** 跨租户读：该用户在本租户是否握着 admin 角色（账号存在 ≠ 有角色，可能被收回过） */
+async function hasAdminRole(tenantId: string, uid: number): Promise<boolean> {
+	const roles = await db.asSystem().table("sys_user_role")
+		.select(["role_name"])
+		.where({
+			and: [
+				{ field: "tenant_id", op: "eq", value: tenantId },
+				{ field: "user_id", op: "eq", value: uid },
+			],
+		})
+		.all() as Array<{ role_name: string }>;
+	return roles.some(r => String(r.role_name) === TENANT_ADMIN_ROLE);
+}
+
+/** 查看某租户的管理员状态（幂等、只读；不存在不建） */
+export async function tenantAdminState(tenantId: string): Promise<TenantAdminState> {
+	const row = await adminRow(tenantId);
+	if (!row)
+		return { corpId: tenantId, username: TENANT_ADMIN_USERNAME, exists: false, mustChange: false };
+	return {
+		corpId: tenantId,
+		username: TENANT_ADMIN_USERNAME,
+		exists: await hasAdminRole(tenantId, row.id),
+		mustChange: row.must_change === 1,
+	};
+}
+
+/**
+ * 开通租户管理员（幂等）：没有就建，有就只确认角色还在。
+ *
+ * 只做两件事：建 `admin` 账号（随机口令 + 强制改密）、授予本租户的 `admin` 角色。
+ * 重复调用安全——这正是「验证并接入可以反复点」的前提。
+ */
+export async function ensureTenantAdmin(tenantId: string): Promise<{ created: boolean }> {
+	let row = await adminRow(tenantId);
+
+	if (!row) {
+		// 与 ensureWecomUser 同形状：只填业务关心的列，其余走列默认值
+		await db.asSystem().table("users").insert({
+			tenant_id: tenantId,
+			username: TENANT_ADMIN_USERNAME,
+			display_name: "租户管理员",
+			password_hash: await bcrypt.hash(randomPassword()),
+			avatar_base64: "",
+			source: "local",
+			must_change: 1,
+			is_forbidden: 0,
+			activated: 1,
+		}).run();
+		// 回查拿 id：预查与插入之间有竞态（并发开通），回查是唯一可靠的取 id 方式
+		row = await adminRow(tenantId);
+	}
+	if (!row)
+		throw Object.assign(new Error("租户管理员建档失败"), { status: 500 });
+
+	if (!await hasAdminRole(tenantId, row.id)) {
+		await db.asSystem().table("sys_user_role").insert({
+			user_id: row.id,
+			role_name: TENANT_ADMIN_ROLE,
+			tenant_id: tenantId,
+		}).run();
+		return { created: true };
+	}
+	return { created: false };
+}
+
+/**
+ * 开通租户管理员（**尽力而为**）：开不通只告警，绝不打断调用方。
+ *
+ * 为什么调用方不能因为它失败：
+ *   · create_auth 有约 1 秒响应窗口（超时企业管理员看到「应用安装失败」），而 bcrypt
+ *     是 CPU 密集操作，不该让它有机会拖垮回调；
+ *   · connectCorp 走到这里时档案**已经落库**，抛错只会让界面显示「接入失败」而实际已接入。
+ *
+ * 补开通道：superadmin 随时可走「重设租户管理员口令」入口，该入口内部会先
+ * `ensureTenantAdmin()`，所以一次开通失败不会留下没有管理员的死租户。
+ */
+export async function provisionTenantAdmin(tenantId: string): Promise<void> {
+	try {
+		const r = await ensureTenantAdmin(tenantId);
+		log.info("wecom tenant admin provisioned", "corpId", tenantId, "created", r.created);
+	}
+	catch (e) {
+		log.warn("wecom tenant admin provision skipped", "corpId", tenantId, "reason", (e as Error).message);
+	}
+}
+
+/**
+ * 重设租户管理员口令（平台 superadmin 专用入口）。
+ *
+ * 口令**不存储**：superadmin 自己输入新口令 → 他知道 → 告知租户管理员。
+ * 落库的只有 bcrypt，且置 must_change=1（首次登录必须改），并级联吊销该用户的
+ * refresh token，避免旧会话继续有效。
+ */
+export async function setTenantAdminPassword(tenantId: string, password: string): Promise<TenantAdminState> {
+	// 先确保账号与角色都在：允许「还没人登录过」的租户被平台直接接管
+	await ensureTenantAdmin(tenantId);
+	const row = await adminRow(tenantId);
+	if (!row)
+		throw Object.assign(new Error("租户管理员建档失败"), { status: 500 });
+
+	await db.asSystem().table("users")
+		.update({ password_hash: await bcrypt.hash(password), must_change: 1 })
+		.where({
+			and: [
+				{ field: "tenant_id", op: "eq", value: tenantId },
+				{ field: "username", op: "eq", value: TENANT_ADMIN_USERNAME },
+			],
+		})
+		.run();
+
+	// 改密后旧会话必须失效。跨租户删 refresh 走带 tenant_id 条件的裸 SQL
+	// （先例见 store.ts::revokeTenantSessions：守卫是 check-on-miss，带了租户条件即放行）
+	await db.exec("DELETE FROM sys_refresh_token WHERE tenant_id = ? AND user_id = ?", [tenantId, row.id]);
+
+	return await tenantAdminState(tenantId);
+}

package/templates/src/auth/api/wecom/admin/tenant-admin/api.ts

@@ -0,0 +1,41 @@
+// GET /api/auth/wecom/admin/tenant-admin?corpId= —— 查某企业的租户管理员状态。
+//
+// 权限：仅 superadmin。这是**跨租户**的平台级视图（查的是别家企业的管理员有没有开通），
+// 与同目录其它端点一致。只读，不存在也不建——建号由开通流程与 password 端点负责。
+import { assertSuperAdmin } from "#/_platform/_shared/service/infra/access";
+import { respond } from "#/_platform/_shared/respond";
+import { tenantAdminState } from "../../../_shared/wecom/tenant-admin";
+
+async function get() {
+	await respond(async () => {
+		await assertSuperAdmin();
+		const corpId = String(((http.query ?? {}) as Record<string, unknown>).corpId ?? "").trim();
+		if (!corpId)
+			throw Object.assign(new Error("缺少企业代码"), { status: 400 });
+		return tenantAdminState(corpId);
+	});
+}
+
+get.schema = {
+	query: {
+		type: "object",
+		required: ["corpId"],
+		properties: { corpId: { type: "string", minLength: 1 } },
+	},
+};
+
+get.response = {
+	type: "object",
+	required: ["corpId", "username", "exists", "mustChange"],
+	properties: {
+		corpId: { type: "string" },
+		// 固定账号名：每租户各一个（users 唯一键含 tenant_id，互不影响）
+		username: { type: "string" },
+		// 该租户是否已有一个握着 admin 角色的账号
+		exists: { type: "boolean" },
+		// 是否须改密（开通后恒 true，直到本人改过一次）
+		mustChange: { type: "boolean" },
+	},
+};
+
+export default { get };

package/templates/src/auth/api/wecom/admin/tenant-admin/password/api.ts

@@ -0,0 +1,66 @@
+// POST /api/auth/wecom/admin/tenant-admin/password —— 重设某企业的租户管理员口令。
+//
+// 权限：仅 superadmin（跨租户的平台级动作）。
+//
+// 为什么做成「superadmin 自己输入新口令」而不是「系统生成后回显」：
+//   口令只以 bcrypt 落库，**没有任何可逆存储**，所以系统无法回显一个已存在的口令。
+//   让 superadmin 自己输入，他知道这个值 → 直接告知租户管理员即可。代价为零，
+//   收益是全系统不存在静态可读的口令副本。
+//
+// 副作用（都是必需的）：
+//   · must_change = 1 —— 管理员首次登录必须改掉这个临时口令；
+//   · 级联删 refresh —— 改密后旧会话立即失效，避免旧 token 继续可用。
+import { assertSuperAdmin } from "#/_platform/_shared/service/infra/access";
+import { recordOp } from "#/_platform/_shared/service/infra/audit";
+import { respond } from "#/_platform/_shared/respond";
+import { setTenantAdminPassword } from "../../../../_shared/wecom/tenant-admin";
+
+async function post() {
+	await respond(async () => {
+		await assertSuperAdmin();
+		const body = (http.body ?? {}) as { corpId?: unknown, password?: unknown };
+		const corpId = String(body.corpId ?? "").trim();
+		const password = String(body.password ?? "");
+		if (!corpId)
+			throw Object.assign(new Error("缺少企业代码"), { status: 400 });
+		// 与 users/password 同下限（6 位）：太短的口令在交接环节泄露风险更高
+		if (password.length < 6)
+			throw Object.assign(new Error("口令至少 6 位"), { status: 400 });
+
+		const state = await setTenantAdminPassword(corpId, password);
+		await recordOp({
+			action: "wecom.admin.tenant_admin_password",
+			module: "auth",
+			target: corpId,
+			// 不记口令本身（连脱敏都不记）：审计只要能回答「谁在何时给哪个企业重设过」
+			detail: { username: state.username },
+			// 重设他人管理员口令＝接管该租户的最高权限，按安全事件留痕
+			level: 4,
+		});
+		return state;
+	});
+}
+
+post.schema = {
+	body: {
+		type: "object",
+		required: ["corpId", "password"],
+		properties: {
+			corpId: { type: "string", minLength: 1 },
+			password: { type: "string", minLength: 6 },
+		},
+	},
+};
+
+post.response = {
+	type: "object",
+	required: ["corpId", "username", "exists", "mustChange"],
+	properties: {
+		corpId: { type: "string" },
+		username: { type: "string" },
+		exists: { type: "boolean" },
+		mustChange: { type: "boolean" },
+	},
+};
+
+export default { post };

package/templates/src/login/web/pages/login.tsx

@@ -54,12 +54,19 @@ export default function LoginPage() {
 	const login = useAuthStore(s => s.login);
 	const [error, setError] = useState<string>();
 	const [loading, setLoading] = useState(false);
+	const [known, setKnown] = useState(false);
+	const inWecom = typeof navigator !== "undefined" && /wxwork/i.test(navigator.userAgent);
 	const [methods, setMethods] = useState<LoginMethod[]>(["local"]);
 	const [active, setActive] = useState<LoginMethod>("local");
 	// 企业代码入口默认收起：单租户部署（绝大多数）保持今天的登录页外观，
 	// 只有服务商/客户带 `?tenant=` 或手工展开时才需要填。
-	// 例外：持久化租户不是部署默认值时必须展开——租户头是**隐式**跟着请求走的
+	// 例外一：持久化租户不是部署默认值时必须展开——租户头是**隐式**跟着请求走的
 	// （runtime 每请求注入），藏起来等于让上一次的租户无声地把这次登录带走。
+	// 例外二：**开了企业微信登录就默认展开**（见下方 effect）——企微租户的键是 corp_id，
+	//   一旦有企业接入，「登录哪个租户」就是真问题：平台管理员在 default，而各企业的
+	//   管理员在各自的 corp 租户里，收起等于让运维找不到切租户的入口。
+	//   判据用「wecom 是否在登录方式里」而不是去数租户：匿名请求没有租户上下文，
+	//   统计租户要动用 db.asSystem（全仓仅 tenant-admin.ts 一处，不为此破例）。
 	const [showTenant, setShowTenant] = useState(() => useTenantStore.getState().tenant !== DEFAULT_TENANT);
 	// 表单里的企业代码：带上 persisted 值（URL `?tenant=` 已先落到 store），用户看得见才改得动
 	const [tenant] = useState(() => {
@@ -77,18 +84,31 @@ export default function LoginPage() {
 	// 企微 302 落地参数：只在首次渲染解析一次（ticket 一次性，解析结果必须稳定）
 	const [landing] = useState(() => parseWecomLanding(search));
 	const exchangedRef = useRef(false);
+	// 仅「认证中 / 已失败」两态：企微内、回跳落地、或 ?corp 深链即进入认证态，
+	// 直接展示「认证中」，不渲染登录表单；只有认证失败（换票失败 / 企微方式不可用）才回落表单。
+	const [phase, setPhase] = useState<"auth" | "form">(
+		inWecom || landing || urlCorp ? "auth" : "form",
+	);
 
 	useEffect(() => {
 		fetchLoginMethods()
 			.then((r) => {
-				const m = r.methods.filter(isKnownMethod);
+				setKnown(true);
+				// 先按 string[] 看一眼：runtime 的返回类型把 wecom 排除在外，而这里恰恰要认它
+				const raw: string[] = r.methods;
+				const m = raw.filter(isKnownMethod);
 				if (!m.length)
 					return;
 				setMethods(m);
+				// 有企微登录 ⇒ 有企业租户（租户键 = corp_id）⇒ 默认展开企业代码，
+				// 否则平台/企业两类管理员没法切换登录目标（用户仍可点「收起」手动折叠）。
+				if (raw.includes("wecom"))
+					setShowTenant(true);
 				if (!m.includes("local"))
 					setActive(m[0]);
 			})
 			.catch(() => {
+				setKnown(true);
 				// 发现失败时回落单表单（local），不阻断登录。
 			});
 	}, []);
@@ -110,6 +130,7 @@ export default function LoginPage() {
 			}
 			catch (e) {
 				setError(e instanceof Error ? e.message : String(e));
+				setPhase("form");
 				setLoading(false);
 			}
 		})();
@@ -121,13 +142,16 @@ export default function LoginPage() {
 	useEffect(() => {
 		const c = new URLSearchParams(search).get("corp")?.trim() ?? "";
 		// 企微内（wxwork UA）从「应用主页」点开即自动发起授权；带 ?corp= 的深链同样自动发起。
-		const inWecom = typeof navigator !== "undefined" && /wxwork/i.test(navigator.userAgent);
 		if ((!c && !inWecom) || landing || autoFiredRef.current)
 			return;
-		if (new URLSearchParams(search).get("error"))
+		if (new URLSearchParams(search).get("error")) {
+			setPhase("form");
 			return;
-		if (!methods.includes("wecom"))
+		}
+		if (known && !methods.includes("wecom")) {
+			setPhase("form");
 			return;
+		}
 		autoFiredRef.current = true;
 		window.location.assign(`${resolveApiBase()}${wecomAuthorizePath(corp, agent)}`);
 	}, [landing, methods, search, corp, agent]);
@@ -245,6 +269,18 @@ export default function LoginPage() {
 		return form(m);
 	}
 
+	// 认证态：只展示「认证中」，不渲染任何登录表单（满足「只有登录失败才出现 login」）
+	if (phase === "auth") {
+		return (
+			<>
+				<Typography.Title level={3}>
+					{t("login:page.title")}
+				</Typography.Title>
+				<Alert style={{ marginBottom: 16 }} type="info" message={t("login:method.wecom.exchanging")} showIcon />
+			</>
+		);
+	}
+
 	return (
 		<>
 			<Typography.Title level={3}>
@@ -253,26 +289,20 @@ export default function LoginPage() {
 			<Typography.Paragraph type="secondary">
 				{t("login:page.subtitle")}
 			</Typography.Paragraph>
-			{landing && loading && (
-				<Alert style={{ marginBottom: 16 }} type="info" message={t("login:method.wecom.exchanging")} showIcon />
-			)}
 			{error && <Alert style={{ marginBottom: 16 }} type="error" message={error} showIcon />}
-			{/* 换票期间不渲染 tab：避免用户在跳转前又点一次登录 */}
-			{landing && loading
-				? null
-				: showTabs
-					? (
-						<Tabs
-							activeKey={active}
-							onChange={key => setActive(key as LoginMethod)}
-							items={methods.map(m => ({
-								key: m,
-								label: t(`login:method.${m}`),
-								children: panelOf(m),
-							}))}
-						/>
-					)
-					: panelOf(methods[0] ?? "local")}
+			{showTabs
+				? (
+					<Tabs
+						activeKey={active}
+						onChange={key => setActive(key as LoginMethod)}
+						items={methods.map(m => ({
+							key: m,
+							label: t(`login:method.${m}`),
+							children: panelOf(m),
+						}))}
+					/>
+				)
+				: panelOf(methods[0] ?? "local")}
 		</>
 	);
 }

package/templates/src/system/api/settings/api.ts

@@ -1,7 +1,7 @@
 import { respond } from "#/_platform/_shared/respond";
 import { listSettings, updateSetting } from "#/_platform/_shared/service/domain/settings";
 // /api/system/settings —— 系统设置（PRD §4.3）：GET 按组列出（secret 掩码），PUT 写值（写审计）。
-import { assertSystemAdmin } from "#/_platform/_shared/service/infra/access";
+import { assertSuperAdmin } from "#/_platform/_shared/service/infra/access";
 
 const settingItemSchema = {
 	type: "object",
@@ -23,7 +23,7 @@ const settingItemSchema = {
 
 async function get() {
 	await respond(async () => {
-		await assertSystemAdmin();
+		await assertSuperAdmin();
 		return listSettings();
 	});
 }
@@ -41,7 +41,7 @@ get.response = {
 
 async function put() {
 	await respond(async () => {
-		await assertSystemAdmin();
+		await assertSuperAdmin();
 		const body = http.body || {};
 		return updateSetting(Number(http.user?.id), String(body.key ?? ""), String(body.value ?? ""));
 	});

package/templates/src/system/web/entry.ts

@@ -54,9 +54,10 @@ const routes: AppRouteRecordRaw[] = [
 				handle: { title: "system:menu.oplog" },
 			},
 			{
+				// 站点设置（证书/站点级开关）：仅超管可见可访问
 				path: "/system/settings",
 				Component: Settings,
-				handle: { title: "system:menu.settings" },
+				handle: { title: "system:menu.settings", roles: ["superadmin"] },
 			},
 			{
 				path: "/system/login-methods",
@@ -64,11 +65,10 @@ const routes: AppRouteRecordRaw[] = [
 				handle: { title: "system:menu.loginMethods" },
 			},
 			{
-				// 企微代开发后台（服务商运营面）：页面内再判一次 superadmin（路由级不做角色门禁，
-				// 与 users/roles 页同策略——403 面板比路由消失更容易解释）
+				// 企微代开发后台（服务商运营面）：仅超管可见（路由级 roles + 页面内二次判定）
 				path: "/system/wecom",
 				Component: WecomAdmin,
-				handle: { title: "system:menu.wecom" },
+				handle: { title: "system:menu.wecom", roles: ["superadmin"] },
 			},
 		],
 	},

package/templates/src/system/web/locales/en-US.json

@@ -228,6 +228,20 @@
 			"connectConfirm": "Connect checks: whether the app Secret can fetch a token, whether contacts are readable, and whether any member is visible. Re-run it whenever the Corporation ID / AgentId changed or the Secret was rotated.",
 			"connectOk": "Connected: {{depts}} departments visible, {{members}} members in the sample department",
 			"connectHint": "After rotating the app Secret you must click \"Verify and connect\" again, otherwise every call fails with 40001. How many people get synced depends on the app's visible scope — set it to the whole company for a full sync."
+		},
+		"tenantAdmin": {
+			"title": "Tenant administrators",
+			"hint": "Each enterprise tenant (tenant key = corp ID) gets an admin account automatically on provisioning, used to manage that tenant's org chart, members and roles. It is a tenant-level admin and cannot see other enterprises. The initial password is random and known to no one — to take over, reset a password you know here, hand it to the tenant admin, and they will be forced to change it on first login.",
+			"username": "Admin account",
+			"state": "State",
+			"exists": "Provisioned",
+			"missing": "Not provisioned",
+			"action": "Action",
+			"reset": "Reset password",
+			"resetTitle": "Reset tenant admin password",
+			"resetHint": "This resets the tenant admin password of enterprise {{corpId}}. Choose the new password yourself and deliver it out-of-band — only a bcrypt hash is stored, so no existing password can ever be shown. The admin must change it on first login, and their existing sessions are revoked immediately.",
+			"resetPlaceholder": "New password (at least 6 chars)",
+			"resetOk": "Tenant admin password reset"
 		}
 	},
 	"err": {