hiwork-core 0.0.18 → 0.0.21

package/README.md

@@ -136,6 +136,14 @@ ctx.inject(['hiworkFeatureCenter'], (scope) => {
 - [src/office-relay.ts](src/office-relay.ts)：文档中继的 host 侧服务（`hiworkOfficeRelay`）——
   跨 NAT 的在线编辑：插件把文档暂存到 DS 能访问的服务器侧（上传/轮询/取回/关闭），
   用户侧不再需要入向可达性；同样只在 Host 持 cookie、失败用稳定信封。
+- [src/identity.ts](src/identity.ts)：当前登录身份的只读 host 服务（`hiworkIdentity`）——
+  业务插件（hiwork-memory 的记忆隔离键等）经 `ctx.get('hiworkIdentity')` 取
+  `{ loggedIn, subject, username, displayName, employeeName, teamName }`；`subject` 是
+  账号名的 sha256 前 16 位（`u_` 前缀，**不含账号原文**），未登录回 `{ loggedIn: false }`。
+- [src/memory-config.ts](src/memory-config.ts)：记忆系统配置下发的只读 host 服务（`hiworkMemory`）——
+  hiwork-memory 经 `ctx.get('hiworkMemory').config()` 取网关下发的 `panelUrl` / `serviceId` /
+  `teamIds` / `apiKey`（网关 `GET /api/me/memory-config`；snake_case → camelCase 的转换只在 Host 做），
+  成功结果 5 分钟内存缓存、`force` 可绕过；凭据只在内存里活、不落盘、不进日志。
 - [src/default-model.ts](src/default-model.ts)：供给成功后校正 `agent-default-model`（默认模型落点）。
 - [src/client/login-gate.tsx](src/client/login-gate.tsx)：全屏登录门禁页。
 - [src/client/section.tsx](src/client/section.tsx)：设置页「AI Router 网关」卡片。

package/lib/client.js

@@ -3757,6 +3757,361 @@ var ManagedWorkbenchStore = class {
   }
 };
 
+// src/client/pms-todo.ts
+var PMS_TODO_CHANNEL = "/hiwork-pms-todo";
+var PmsTodoRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PmsTodoRpcError";
+  }
+};
+var GENERIC_FAILURE_MESSAGE4 = "PMS \u5F85\u529E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE4 = "PMS \u5F85\u529E\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002";
+var INTERNAL_CODE = "INTERNAL";
+function unwrapPmsTodoResult(value) {
+  if (typeof value !== "object" || value === null || !("ok" in value)) {
+    throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  }
+  const result = value;
+  if (result.ok === true) return result.value;
+  if (result.ok === false) {
+    const code = typeof result.error?.code === "string" ? result.error.code : INTERNAL_CODE;
+    const message = typeof result.error?.message === "string" && result.error.message.trim() !== "" ? result.error.message : GENERIC_FAILURE_MESSAGE4;
+    throw new PmsTodoRpcError(code, message);
+  }
+  throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+}
+function text5(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function countOr(value, fallback) {
+  return isFiniteCount(value) ? countOf(value) : fallback;
+}
+function toItem(value) {
+  if (!isRecord3(value)) return void 0;
+  const id = value["id"];
+  if (typeof id !== "number" || !Number.isSafeInteger(id)) return void 0;
+  const item = {
+    id,
+    title: text5(value["title"]) ?? "",
+    status: text5(value["status"]) ?? ""
+  };
+  const description = text5(value["description"]);
+  if (description !== void 0) item.description = description;
+  const category = text5(value["category"]);
+  if (category !== void 0) item.category = category;
+  const priority = text5(value["priority"]);
+  if (priority !== void 0) item.priority = priority;
+  const startDate = text5(value["startDate"]);
+  if (startDate !== void 0) item.startDate = startDate;
+  const dueDate = text5(value["dueDate"]);
+  if (dueDate !== void 0) item.dueDate = dueDate;
+  const completedTime = text5(value["completedTime"]);
+  if (completedTime !== void 0) item.completedTime = completedTime;
+  if (typeof value["isOverdue"] === "boolean") item.isOverdue = value["isOverdue"];
+  if (typeof value["isDueSoon"] === "boolean") item.isDueSoon = value["isDueSoon"];
+  return item;
+}
+function toStatus(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const username = text5(value["username"]);
+  const expiresAt = text5(value["expiresAt"]);
+  return {
+    configured: value["configured"] === true,
+    loggedIn: value["loggedIn"] === true,
+    ...username === void 0 ? {} : { username },
+    ...expiresAt === void 0 ? {} : { expiresAt }
+  };
+}
+function toToday(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const rawItems = value["items"];
+  if (!Array.isArray(rawItems)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const items = [];
+  for (const raw of rawItems) {
+    const item = toItem(raw);
+    if (item !== void 0) items.push(item);
+  }
+  return { items, fetchedAt: text5(value["fetchedAt"]) ?? "" };
+}
+function toStatistics(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  return {
+    total: countOf(value["total"]),
+    pending: countOf(value["pending"]),
+    completed: countOf(value["completed"]),
+    overdue: countOf(value["overdue"])
+  };
+}
+function toSetStatusResult(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const id = value["id"];
+  if (typeof id !== "number" || !Number.isSafeInteger(id)) {
+    throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  }
+  const status = value["status"];
+  if (status !== "PENDING" && status !== "COMPLETED") {
+    throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  }
+  const completedTime = text5(value["completedTime"]);
+  return { id, status, ...completedTime === void 0 ? {} : { completedTime } };
+}
+function isInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function toTaskItem(value) {
+  if (!isRecord3(value)) return void 0;
+  const id = value["id"];
+  if (!isInteger(id)) return void 0;
+  const numeric = (raw) => typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+  const item = {
+    id,
+    taskName: text5(value["taskName"]) ?? "",
+    description: text5(value["description"]) ?? "",
+    projectId: numeric(value["projectId"]),
+    projectName: text5(value["projectName"]) ?? "",
+    assigneeId: numeric(value["assigneeId"]),
+    assigneeName: text5(value["assigneeName"]) ?? "",
+    deadline: text5(value["deadline"]) ?? "",
+    status: numeric(value["status"]),
+    statusName: text5(value["statusName"]) ?? "",
+    priority: numeric(value["priority"]),
+    priorityName: text5(value["priorityName"]) ?? "",
+    taskType: text5(value["taskType"]) ?? "",
+    taskTypeName: text5(value["taskTypeName"]) ?? "",
+    auditStatus: numeric(value["auditStatus"]),
+    auditStatusName: text5(value["auditStatusName"]) ?? ""
+  };
+  const projectStageName = text5(value["projectStageName"]);
+  if (projectStageName !== void 0) item.projectStageName = projectStageName;
+  const requirementName = text5(value["requirementName"]);
+  if (requirementName !== void 0) item.requirementName = requirementName;
+  const moduleName = text5(value["moduleName"]);
+  if (moduleName !== void 0) item.moduleName = moduleName;
+  const estimatedHours = value["estimatedHours"];
+  if (typeof estimatedHours === "number" && Number.isFinite(estimatedHours)) item.estimatedHours = estimatedHours;
+  const actualHours = value["actualHours"];
+  if (typeof actualHours === "number" && Number.isFinite(actualHours)) item.actualHours = actualHours;
+  return item;
+}
+function toTaskList(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const rawItems = value["items"];
+  if (!Array.isArray(rawItems)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const items = [];
+  for (const raw of rawItems) {
+    const item = toTaskItem(raw);
+    if (item !== void 0) items.push(item);
+  }
+  const current = countOf(value["current"]);
+  return {
+    items,
+    total: countOr(value["total"], items.length),
+    current: isFiniteCount(value["current"]) ? current : 1,
+    size: countOr(value["size"], items.length)
+  };
+}
+function toTaskCompleteResult(value) {
+  if (!isRecord3(value)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  const id = value["id"];
+  const status = value["status"];
+  if (!isInteger(id) || !isInteger(status)) throw new PmsTodoRpcError(INTERNAL_CODE, INVALID_RESPONSE_MESSAGE4);
+  return { id, status };
+}
+var PmsTodoStore = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  current;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * 在飞请求**连同它所属的世代与端点**一起记账。
+   *
+   * 世代：`clear()`（登出 / 换账号）之后，账上那条是**上一个人**发起的，它的待办属于上一个人
+   * ——复用它等于让新账号看到上一个人的待办。端点：`today` 与 `statistics` 的返回值形状不同，
+   * 只有同一个端点的并发调用才允许合并。
+   */
+  inFlight;
+  /** 世代号：`clear()` 每调用一次 +1，用来作废它之前发起的在飞请求。 */
+  generation = 0;
+  /** 是否已经为「镜像还空着」的情况探过一次 `status`（避免每次同步读都发一次 RPC）。 */
+  statusProbed = false;
+  /**
+   * 本地镜像（同步）。从没同步过返回 `undefined`。
+   *
+   * ⚠️ 本方法有一次**惰性探测**：镜像还空着且从没探过时，它顺手发起一次 `status` 端点调用
+   * （结果到达后写镜像 + 通知订阅者）。理由——渲染是同步的，而「配没配凭据」只有主机知道；
+   * 没有这一步，`status` 端点就永远没有调用方，界面也只能靠一次失败的 `today()` 去反推。
+   * 因此调用方看到 `undefined` **不是**「未配置」，而是「还不知道」：必须订阅。
+   */
+  status() {
+    if (this.current === void 0 && !this.statusProbed) {
+      this.statusProbed = true;
+      void this.refreshStatus().catch(() => {
+      });
+    }
+    return this.current;
+  }
+  /**
+   * 显式去主机取一次状态并写镜像（`status()` 的异步入口）。
+   *
+   * 失败**不改镜像**（保留上一次已知状态），也**不在镜像里记错误**：错误属于这一次调用，
+   * 调用方（或下一次 `today()`）自己决定怎么展示。
+   */
+  async refreshStatus(signal) {
+    const { value, generation } = await this.call("status", "status", {}, toStatus, signal);
+    return this.adopt(value, generation);
+  }
+  /**
+   * 登录（凭据交给 Host；**本层不留存密码、不写任何缓存**）。
+   *
+   * 成功时把返回的状态写进镜像——登录是「身份刚变过」，镜像必须跟着变。
+   */
+  async login(input) {
+    const payload = { username: input.username, password: input.password };
+    if (input.remember !== void 0) payload["remember"] = input.remember;
+    const { value, generation } = await this.call("login", "login", payload, toStatus);
+    return this.adopt(value, generation);
+  }
+  /** 登出（Host 侧清凭据）；返回登出后的状态并写镜像。 */
+  async logout() {
+    const { value, generation } = await this.call("logout", "logout", {}, toStatus);
+    return this.adopt(value, generation);
+  }
+  /**
+   * 今日待办。
+   *
+   * 不做本地缓存（返回**刚拉到的**那一份）：待办的时效性就是它的全部价值，把上一次的结果当
+   * 「今日」交出去正是这个功能最容易犯的错；界面要离线态时自己留一份 + 标陈旧（spec §6）。
+   */
+  async today(signal) {
+    const { value } = await this.call("today", "today", {}, toToday, signal);
+    return value;
+  }
+  /** total / pending / completed / overdue 计数。 */
+  async statistics(signal) {
+    const { value } = await this.call("statistics", "statistics", {}, toStatistics, signal);
+    return value;
+  }
+  /**
+   * 勾完成 / 取消完成。
+   *
+   * 返回值里带服务端回声的 id / status（`PmsTodoFace.setStatus` 折成 `void`；面里不需要它，
+   * 但仓库保留着——回滚那一条待办时用它认人最稳）。
+   */
+  async setStatus(input) {
+    const { value } = await this.call("setStatus", "setStatus", { id: input.id, status: input.status }, toSetStatusResult);
+    return value;
+  }
+  /**
+   * **我的未完成项目任务**（spec §3 D7）：`myTasks` 端点的取数。
+   *
+   * 入参是**空对象**，没有 `userId`——「谁的任务」由 Host 从凭据记录里取（客户端连自己的
+   * PMS userId 都拿不到，这是 §3 D6 形状的一部分）。
+   *
+   * 与 `today` 同款：**不做本地缓存**（返回刚拉到的那一份），但**并发调用合并**（同一时刻问两遍
+   * 没有意义；世代判据同其他端点，换账号之后不复用）。
+   */
+  async myTasks(signal) {
+    const { value } = await this.call("myTasks", "myTasks", {}, toTaskList, signal);
+    return value;
+  }
+  /**
+   * **完成一条项目任务**（spec §3 D7）。
+   *
+   * 返回值里带服务端回声的 id / status（`PmsTodoFace.completeTask` 折成 `void`；仓库保留着
+   * ——回滚那一条任务时用它认人最稳）。缺权限时抛 `PmsTodoRpcError('FORBIDDEN')`。
+   *
+   * ⚠️ **刻意不走 {@link PmsTodoStore.call}**（即不参与并发合并）：`dedupe` 的键是**端点名**，
+   * 而这是带参数的命令——把它并进同一格会让「几乎同时完成 A 和 B」的第二次调用**复用第一次的
+   * 结果**，用户以为 B 完成了，其实请求根本没发出去。Host 侧的 `completeTask` 同样不合并
+   * （那里也注明「点了两次就是两次动作」）。
+   */
+  async completeTask(input) {
+    const raw = await this.rpc.call(PMS_TODO_CHANNEL, "completeTask", { id: input.id });
+    return toTaskCompleteResult(unwrapPmsTodoResult(raw));
+  }
+  /** 订阅镜像变化（右栏 tab 据此重渲染）。返回退订函数。 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 清空镜像（登出 / 换账号：状态是**按人**的，留着会串号），并**作废在飞的请求**。
+   *
+   * 只清镜像是不够的：清空那一刻正有一次拉取在飞时，那次拉取是**上一个人**发起的。所以世代
+   * +1：那之后的调用者一律不复用旧世代的那条，自己重新发一次 RPC。用世代号而**不是**把
+   * `inFlight` 直接抹成 undefined，理由与 `src/client/managed-workbench.ts` 的同名方法逐字相同
+   * （旧 promise 的 `finally` 会回头把新发起的那条记账清掉，两者互相踩）。
+   *
+   * 同时把 `statusProbed` 复位：新账号的镜像必须能再探一次，否则换账号后 `status()` 会一直
+   * 返回 `undefined` 且再也不去问主机。
+   */
+  clear() {
+    this.generation += 1;
+    this.current = void 0;
+    this.statusProbed = false;
+    this.emit();
+  }
+  /**
+   * 发一次 RPC、解开信封、过第二道形状校验。
+   *
+   * 返回值里带上**发起时的世代**：只有它等于当前世代时，调用方才写镜像（见 {@link adopt}）。
+   */
+  async call(key, endpoint, payload, parse, signal) {
+    return await this.dedupe(key, async (generation) => {
+      const raw = await this.rpc.call(PMS_TODO_CHANNEL, endpoint, payload, signal);
+      return { value: parse(unwrapPmsTodoResult(raw)), generation };
+    });
+  }
+  /**
+   * 并发合并：同一世代 + 同一端点撞在一起（面板挂载与手动刷新常常同拍）时共用一次请求，
+   * 且**共用同一个返回值**——两边对「这一次拉到了什么」的判断必须一致。
+   */
+  async dedupe(key, task) {
+    const inFlight = this.inFlight;
+    if (inFlight !== void 0 && inFlight.generation === this.generation && inFlight.key === key) {
+      return await inFlight.task;
+    }
+    const generation = this.generation;
+    const promise = task(generation);
+    this.inFlight = { generation, key, task: promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.inFlight?.task === promise) this.inFlight = void 0;
+    }
+  }
+  /**
+   * 采纳一份成功状态：写镜像 + 通知订阅者。
+   *
+   * 世代不符的那一份**不写镜像**（但仍原样返回给调用方）：它是 `clear()` 之前发起的请求，
+   * 属于上一个人。允许它写回等于「清空之后又被上一个人的状态占住」，而换账号时界面正好靠
+   * `status()` 判断该显示引导还是列表。
+   */
+  adopt(value, generation) {
+    if (generation !== this.generation) return value;
+    this.current = value;
+    this.emit();
+    return value;
+  }
+  emit() {
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+
 // src/client/index.ts
 var inject = ["slots", "locale", "remote", "remote.credentials", "settingsScope", "connection"];
 var INTERACTION_STYLE_ID = "hiwork-core-interaction-styles";
@@ -3797,6 +4152,7 @@ function apply(ctx) {
   const managedMcp = new ManagedMcpStore(connection.rpc);
   const managedSkills = new ManagedSkillsStore(connection.rpc);
   const managedWorkbench = new ManagedWorkbenchStore(connection.rpc);
+  const pmsTodo = new PmsTodoStore(connection.rpc);
   const appVersion = createAppVersion(connection.rpc);
   const pluginUpdates = createPluginUpdates(connection.rpc);
   ctx.slots.inject("settings.section", () => ctx.slots.register({
@@ -3818,6 +4174,7 @@ function apply(ctx) {
     managedMcp.clear();
     managedSkills.clear();
     managedWorkbench.clear();
+    pmsTodo.clear();
   }), "hiwork-core: \u7528\u91CF\u7F13\u5B58\u968F\u8D26\u53F7 / Key \u53D8\u5316\u6E05\u7A7A");
   ctx.effect(() => observeAboutNavIcon(), "hiwork-core: about nav icon");
   ctx.slots.inject("sidebar.brand.mark", () => ctx.slots.register({
@@ -3836,9 +4193,9 @@ function apply(ctx) {
   }, UserBadge));
   ctx.effect(() => mountLoginGate(scope, storeCredential), "hiwork-core: login gate");
   ctx.effect(() => observeHeroDecorations(document, dailyQuotes), "hiwork-core: hero decorations");
-  installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench);
+  installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench, pmsTodo);
 }
-function installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench) {
+function installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench, pmsTodo) {
   const featureRegistry = createFeatureRegistry();
   let center;
   const sessions = ctx.get("sessions");
@@ -3888,6 +4245,27 @@ function installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench)
       warm: async (signal) => await managedWorkbench.warm(signal),
       refresh: async (signal) => await managedWorkbench.refresh(signal),
       subscribe: (listener) => managedWorkbench.subscribe(listener)
+    },
+    // PMS 个人待办面：工作台域（hiwork-workbench）按这个成员判断「有没有这个能力」，老 core 上
+    // 它是 undefined，右栏 tab 降级成「请升级 HiWork 客户端」（spec §6 的降级矩阵第一行）。
+    // 七项与 spec §4.3 逐字对应；核心**只发端点调用**——凭据与 token 全在 Host（§3 D6）。
+    // `setStatus` 在面里折成 void（§4.3 冻结的形状），仓库返回值留给诊断与测试。
+    // `myTasks` / `completeTask` 是 §3 D7 追加的两项，**在面里也是可选成员**（旧 core 只有前七项，
+    // 消费方按 `face.pmsTodo.myTasks !== undefined` 判断，见 src/client/pms-todo.ts 的版本闸口）。
+    pmsTodo: {
+      status: () => pmsTodo.status(),
+      login: async (input) => await pmsTodo.login(input),
+      logout: async () => await pmsTodo.logout(),
+      today: async (signal) => await pmsTodo.today(signal),
+      statistics: async (signal) => await pmsTodo.statistics(signal),
+      setStatus: async (input) => {
+        await pmsTodo.setStatus(input);
+      },
+      myTasks: async (signal) => await pmsTodo.myTasks(signal),
+      completeTask: async (input) => {
+        await pmsTodo.completeTask(input);
+      },
+      subscribe: (listener) => pmsTodo.subscribe(listener)
     }
   };
   ctx.provide(HIWORK_FEATURE_CENTER_SERVICE, face);

package/lib/identity.js

@@ -0,0 +1,111 @@
+/**
+ * 当前登录身份的只读 host 服务（`hiworkIdentity`）。
+ *
+ * 背景：hiwork-core 已经把「谁登录了」完整地记在 `ai-router` 设置命名空间里
+ * （`username` / `displayName` / `keys`），但那是**本插件的私有状态段**——业务插件
+ * 要拿「当前登录员工」做数据隔离（hiwork-memory 的记忆隔离键、按人区分的本地
+ * 目录名等），既不该去解析别人的设置段，也不该把登录态复制一份自己维护。
+ * 本模块把那层读取收敛成一个稳定的小服务：消费方 `ctx.get('hiworkIdentity')`
+ * 拿到的是一份**只读视图**，登录态怎么变、什么时候变都由 Host 说了算。
+ *
+ * 设计要点（与宿主既有 RPC 服务同构，参照 `src/office-credentials.ts`）：
+ *  - **只读、同步、不抛异常**：`current()` 同步返回快照，未登录返回
+ *    `{ loggedIn: false }`，已登录但还没拉到 keys 时 `employeeName` / `teamName`
+ *    缺省而不是报错（首次登录的中间态、老网关不带这两个字段都会走到这里）；
+ *  - **绝不外泄账号原文进隔离键**：`subject = 'u_' + sha256(username) 的前 16 位 hex`。
+ *    subject 会进存储键 / 目录名，哈希保证它同一账号恒等（跨会话、跨设备稳定）、
+ *    不同账号几乎必然不同，同时不把企业账号明文写进磁盘或日志；
+ *    `username` 字段仍在视图里（界面要显示账号），但**不承担隔离键职责**；
+ *  - **不缓存、不订阅**：每次 `current()` 都读一次当前命名空间值，消费方不再需要
+ *    关心 Host 何时刷新过登录态；
+ *  - 服务经 `ctx.provide` 提供给同进程的其他插件，消费方用 `ctx.get` 探测
+ *    （老 core 上它是 undefined → 插件自行回退，不假设本服务存在）。
+ *
+ * 本模块不 import cordis 运行时：provide 走结构化的 {@link IdentityContext} 端口，
+ * 调用方（index.ts）传真实 ctx；单测直接伪造。
+ */
+import { createHash } from 'node:crypto';
+/** cordis 服务名（hiwork-memory 等消费方按此名 `ctx.get` 探测）。 */
+export const HIWORK_IDENTITY_SERVICE = 'hiworkIdentity';
+/** 视图字段名的语义名（供消费方日志 / 文档引用，避免各处硬编码字符串）。 */
+export const IDENTITY_SUBJECT_PREFIX = 'u_';
+/** 裁掉两侧空白；非字符串或空白串一律视同缺省。 */
+function textOrUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    return text === '' ? undefined : text;
+}
+/**
+ * 由登录账号派生稳定 subject：`u_` + `sha256(账号名).hex` 的前 16 位。
+ *
+ * 输入先裁掉两侧空白（与视图里的 `username` 同口径），因此 `' alice '` 与 `'alice'`
+ * 派生同一个 subject；大小写不折叠——账号名在网关侧就是区分大小写的。
+ * **本函数绝不返回账号名原文**：subject 会落进存储键 / 目录名，哈希是隔离键
+ * 既能稳定标识同一员工、又不外泄账号的那条界线。
+ */
+export function deriveSubject(username) {
+    const digest = createHash('sha256').update(username.trim(), 'utf8').digest('hex');
+    return `${IDENTITY_SUBJECT_PREFIX}${digest.slice(0, 16)}`;
+}
+/**
+ * 从 keys 里挑员工名 / 团队名：逐条取第一个非空值，两项**互不掩盖**
+ * （某把 Key 只带了 team_name，不会让另一把 Key 的 employee_name 被丢掉）。
+ * 同一账号的各把 Key 属于同一个人，命名相同的部分取值一致，因此不需要按 keyId 挑。
+ */
+function pickKeyNames(keys) {
+    let employeeName;
+    let teamName;
+    for (const key of keys ?? []) {
+        if (employeeName === undefined)
+            employeeName = textOrUndefined(key?.employee_name);
+        if (teamName === undefined)
+            teamName = textOrUndefined(key?.team_name);
+        if (employeeName !== undefined && teamName !== undefined)
+            break;
+    }
+    return {
+        ...(employeeName === undefined ? {} : { employeeName }),
+        ...(teamName === undefined ? {} : { teamName }),
+    };
+}
+/** 视图投影（无状态；未登录 / 读失败一律收敛为 `{ loggedIn: false }`）。 */
+class IdentityProvider {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    current() {
+        try {
+            const state = this.deps.current();
+            const username = textOrUndefined(state?.username);
+            // 未登录：只给 loggedIn，绝不带半份身份出去。
+            if (username === undefined)
+                return { loggedIn: false };
+            const displayName = textOrUndefined(state?.displayName);
+            const { employeeName, teamName } = pickKeyNames(state?.keys);
+            return {
+                loggedIn: true,
+                subject: deriveSubject(username),
+                username,
+                ...(displayName === undefined ? {} : { displayName }),
+                ...(employeeName === undefined ? {} : { employeeName }),
+                ...(teamName === undefined ? {} : { teamName }),
+            };
+        }
+        catch (error) {
+            // 只读服务不该把宿主的读失败变成消费方的异常：收敛成「未登录」并记一笔。
+            this.deps.log?.(`hiwork-core: 登录身份读取失败（${error instanceof Error ? error.name : typeof error}）`);
+            return { loggedIn: false };
+        }
+    }
+}
+/**
+ * 提供 host 侧服务 `hiworkIdentity`；返回 disposer（交给 `ctx.effect` 管理生命周期，
+ * 插件卸载时服务随 fiber 一并注销）。
+ */
+export function provideIdentity(ctx, deps) {
+    const service = new IdentityProvider(deps);
+    const dispose = ctx.provide(HIWORK_IDENTITY_SERVICE, service);
+    return typeof dispose === 'function' ? dispose : () => { };
+}