hiwork-core 0.0.1 → 0.0.3

package/README.md

@@ -54,9 +54,76 @@ pnpm test        # vitest
 
 客户端 bundle 由 `scripts/client-build.mjs` 用 esbuild 打成单文件：`@deepseek-ai/*` 与 react 走宿主模块表 external，品牌图片内联为 data URL。
 
+## Feature Center（扩展注册面）
+
+`hiwork-core` 的 client 半边提供 cordis 服务 `hiworkFeatureCenter`，把左侧 HiWork
+菜单与中央内容区做成可复用机制：业务插件（`hiwork-automation`、未来的
+`hiwork-knowledge`）只注册一个 feature，即可出现在菜单里并在中央区独立渲染，
+不需要再碰侧栏 DOM 或中央区状态机。
+
+```ts
+interface HiWorkFeature {
+  readonly id: string                        // 稳定 id，同时写入 data-hiwork-active-page
+  readonly label: () => string               // 函数形式，跟随语言切换
+  readonly icon?: string                     // 内联 SVG 字符串
+  readonly order?: number                    // 缺省 1000，按 order → id 稳定排序
+  readonly render: (context: FeatureRenderContext) => React.ReactNode
+}
+interface FeatureRenderContext {
+  readonly openNativeSession: (sessionId: string) => void  // 先退出 takeover，再交给宿主
+  readonly openNativeHome: () => void
+}
+interface HiWorkCoreClientFace {
+  readonly featureRegistry: FeatureRegistry  // register / list / activeId / open / openNative / subscribe
+  readonly openFeature: (id: string) => boolean
+  readonly openNativeSession: (sessionId: string) => void
+  readonly openNativeHome: () => void
+}
+```
+
+业务插件按服务名发现本面（**不** runtime-import 本包的值）：
+
+```ts
+ctx.inject(['hiworkFeatureCenter'], (scope) => {
+  const face = scope.get('hiworkFeatureCenter') as HiWorkCoreClientFace
+  ctx.effect(() => face.featureRegistry.register({
+    id: 'knowledge',
+    label: () => '知识库',
+    order: 30,
+    render: (context) => React.createElement(KnowledgeView, { openSession: context.openNativeSession }),
+  }), 'hiwork-knowledge: feature center')
+})
+```
+
+机制要点（实现见 [src/client/feature-registry.ts](src/client/feature-registry.ts) 与
+[src/client/feature-center.ts](src/client/feature-center.ts)）：
+
+- **侧栏菜单注入**：隐藏原生「新会话」按钮（保留 DOM 与 click handler，只加隐藏属性），
+  在同位置插入 HiWork 菜单；首项「新会话」直接代理原生按钮（图标克隆原生按钮的 SVG），
+  其余项按 order 排序。`icon` 是内联 SVG 字符串；缺省用兜底图标，保证侧栏折叠成
+  56px 图标栏时每个入口仍有可辨识图形（折叠态由宿主加在侧栏根上的 `*_collapsed`
+  类驱动纯 CSS：隐藏文字、图标放大到 18px，与原生控件同形）。
+  折叠态悬停 500ms 弹出提示气泡，黑底白字、圆角与字号逐项对齐框架 `ui-primitives`
+  的 `Tooltip`（`--dsw-alias-tooltip-bg`），取代浏览器自带的浅色 `title` 提示；
+  展开态文字已可见，与原生控件一致（`Tooltip disabled={wide}`）不出气泡。
+  找不到原生按钮时不抛错、不隐藏任何入口，菜单只列 feature（安全降级）。
+- **中央区 takeover**：挂一个 `[data-hiwork-feature-root]` React root，用
+  `html[data-hiwork-active-page]` 上的纯 CSS 规则隐藏原生会话子树（保持挂载、保留状态）；
+  点击任意原生会话行或调用 `openNativeSession` 时，先卸载 root、移除属性恢复原生内容，
+  再交给宿主。切换 feature 先卸载旧 root，任意时刻只有一个业务页面。
+  takeover root 自带 `background: var(--dsw-alias-bg-base)`——与原生会话根同一个主题变量，
+  否则会透出框架灰底、与侧栏同色而不是原生页面的底色。
+- **自愈与清理**：`MutationObserver` + 有界重试处理延迟挂载、语言切换与壳重建；
+  render 抛错由错误边界捕获并恢复原生会话区；注入节点带实例令牌，HMR/重复 apply
+  不会出现两份菜单，旧实例的 dispose 也不会删掉新实例的节点。
+- **Host 纯度**：全部 DOM 逻辑只在 `src/client/**`，Host build 不引用 `document`。
+
 ## 目录结构
 
 - [src/index.ts](src/index.ts)：宿主入口，登录编排、凭据写入与依赖接口。
+- [src/client/feature-registry.ts](src/client/feature-registry.ts)：扩展注册表（排序、校验、活动页）。
+- [src/client/feature-center.ts](src/client/feature-center.ts)：侧栏菜单注入 + 中央区 takeover。
+- [src/client/contracts.ts](src/client/contracts.ts)：业务插件可见的 client 面与服务名。
 - [src/orchestration.ts](src/orchestration.ts)：登录后模型供给编排（拉 Key、写路由、热重载）。
 - [src/client/login-gate.tsx](src/client/login-gate.tsx)：全屏登录门禁页。
 - [src/client/section.tsx](src/client/section.tsx)：设置页「AI Router 网关」卡片。

package/lib/ai-router-client.js

@@ -1,3 +1,4 @@
+import { PKG_VERSION } from "./version.js";
 /** 网关错误：携带稳定 code，供编排层映射。 */
 export class GatewayError extends Error {
     code;
@@ -69,7 +70,7 @@ export class AiRouterClient {
         }
     }
     async request(path, opts) {
-        const headers = { 'user-agent': 'hiwork-core/0.1.14' };
+        const headers = { 'user-agent': `hiwork-core/${PKG_VERSION}` };
         if (opts.body !== undefined)
             headers['content-type'] = 'application/json';
         if (opts.sessionCookie !== undefined)

package/lib/client.js

@@ -2270,6 +2270,510 @@ function mountLoginGate(scope, storeCredential) {
   };
 }
 
+// src/client/feature-registry.ts
+var DEFAULT_FEATURE_ORDER = 1e3;
+function compareFeatures(left, right) {
+  const leftOrder = left.order ?? DEFAULT_FEATURE_ORDER;
+  const rightOrder = right.order ?? DEFAULT_FEATURE_ORDER;
+  if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+  if (left.id === right.id) return 0;
+  return left.id < right.id ? -1 : 1;
+}
+function createFeatureRegistry() {
+  const features = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let activeId = null;
+  const notify = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        console.error("hiwork feature center subscriber failed:", error);
+      }
+    }
+  };
+  return {
+    register(feature) {
+      const id = feature.id.trim();
+      if (id === "") throw new Error("hiwork feature id must not be blank");
+      if (features.has(id)) throw new Error(`hiwork feature "${id}" is already registered`);
+      const entry = { ...feature, id };
+      features.set(id, entry);
+      notify();
+      let disposed = false;
+      return () => {
+        if (disposed) return;
+        disposed = true;
+        if (features.get(id) !== entry) return;
+        features.delete(id);
+        if (activeId === id) activeId = null;
+        notify();
+      };
+    },
+    list() {
+      return [...features.values()].sort(compareFeatures);
+    },
+    activeId() {
+      return activeId;
+    },
+    open(id) {
+      if (!features.has(id)) return false;
+      if (activeId === id) return true;
+      activeId = id;
+      notify();
+      return true;
+    },
+    openNative() {
+      if (activeId === null) return;
+      activeId = null;
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/client/feature-center.ts
+var import_react5 = require("react");
+var import_client2 = require("react-dom/client");
+var SIDEBAR_SELECTOR = '[data-pane="sidebar"], [class*="sidebarCol"]';
+var CONVERSATION_SELECTOR = '[data-pane="conversation"], [class*="centerCol"]';
+var REGION_SELECTOR = '[class*="regionArea"]';
+var NEW_SESSION_SELECTOR = [
+  'button[data-testid="new-session"]',
+  'button[data-action="new-session"]',
+  'button[class*="newSession"]'
+].join(", ");
+var MENU_ATTRIBUTE = "data-hiwork-feature-menu";
+var MENU_ITEM_ATTRIBUTE = "data-hiwork-feature-menu-item";
+var MENU_ICON_ATTRIBUTE = "data-hiwork-feature-menu-icon";
+var MENU_LABEL_ATTRIBUTE = "data-hiwork-feature-menu-label";
+var TOOLTIP_ATTRIBUTE = "data-hiwork-feature-tooltip";
+var TOOLTIP_VISIBLE_ATTRIBUTE = "data-hiwork-feature-tooltip-visible";
+var NATIVE_HIDDEN_ATTRIBUTE = "data-hiwork-native-new-session";
+var FEATURE_ROOT_ATTRIBUTE = "data-hiwork-feature-root";
+var OWNER_ATTRIBUTE = "data-hiwork-owner";
+var ACTIVE_PAGE_ATTRIBUTE = "data-hiwork-active-page";
+var NATIVE_MENU_ITEM_ID = "__native_new_session__";
+var DEFAULT_NEW_SESSION_LABEL = "\u65B0\u4F1A\u8BDD";
+var STYLE_ELEMENT_ID = "hiwork-feature-center-styles";
+var TOOLTIP_DELAY_MS = 500;
+var TOOLTIP_GAP_PX = 8;
+var DEFAULT_NEW_SESSION_ICON = '<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><path d="M8 3.4v9.2M3.4 8h9.2" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>';
+var DEFAULT_FEATURE_ICON = '<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><rect x="2.75" y="2.75" width="10.5" height="10.5" rx="3" stroke="currentColor" stroke-width="1.5"/><circle cx="8" cy="8" r="1.4" fill="currentColor"/></svg>';
+var SESSION_ROW_SELECTOR = [
+  '[class*="sessionRow"]',
+  '[class*="projectRow"]',
+  '[class*="searchResultRow"]',
+  '[class*="searchResultWorkspace"]',
+  '[class*="newSession"]'
+].join(", ");
+var featureCenterCss = [
+  `[${NATIVE_HIDDEN_ATTRIBUTE}="hidden"] { display: none !important; }`,
+  `[${MENU_ATTRIBUTE}] { display: flex; flex-direction: column; gap: 2px; margin: 0 2px 8px; }`,
+  `[${MENU_ITEM_ATTRIBUTE}] { display: flex; align-items: center; gap: 8px; width: 100%; box-sizing: border-box; padding: 8px 10px; border: 0; border-radius: 10px; background: transparent; color: var(--dsw-alias-label-primary, #0f1115); font-size: 14px; line-height: 22px; text-align: left; cursor: pointer; }`,
+  `[${MENU_ITEM_ATTRIBUTE}]:hover { background: var(--dsw-alias-interactive-bg-hover, rgba(15, 17, 21, 0.06)); }`,
+  `[${MENU_ITEM_ATTRIBUTE}][data-hiwork-feature-active="true"] { background: var(--dsw-alias-interactive-bg-active, rgba(15, 17, 21, 0.1)); }`,
+  `[${MENU_ICON_ATTRIBUTE}] { display: inline-flex; flex: none; width: 16px; height: 16px; }`,
+  `[${MENU_ICON_ATTRIBUTE}] > svg { display: block; width: 16px; height: 16px; }`,
+  // 侧栏折叠：宿主在侧栏根元素上加 `*_collapsed`（rc.1 为 hHd-Xa_collapsed），
+  // 原生控件此时只显示图标；注入菜单必须同形，否则文字会在 56px 宽栏里竖排。
+  `[class*="sidebarCol"] [class*="collapsed"] [${MENU_ATTRIBUTE}] { margin: 0 4px 8px; }`,
+  `[class*="sidebarCol"] [class*="collapsed"] [${MENU_LABEL_ATTRIBUTE}] { display: none; }`,
+  `[class*="sidebarCol"] [class*="collapsed"] [${MENU_ITEM_ATTRIBUTE}] { justify-content: center; padding: 8px 0; }`,
+  `[class*="sidebarCol"] [class*="collapsed"] [${MENU_ICON_ATTRIBUTE}], [class*="sidebarCol"] [class*="collapsed"] [${MENU_ICON_ATTRIBUTE}] > svg { width: 18px; height: 18px; }`,
+  // 折叠态提示气泡：几何与配色逐项对齐框架 `ui-primitives` 的 `Tooltip.module.css`
+  // （黑底白字、3px 7px 内边距、8px 圆角、13/20 字号、150ms 淡入、最大半屏宽）。
+  `[${TOOLTIP_ATTRIBUTE}] { position: fixed; z-index: 100; display: none; width: max-content; max-width: 50vw; padding: 3px 7px; border-radius: 8px; background: var(--dsw-alias-tooltip-bg, #2c2c2e); color: var(--dsw-static-neutral-bluish-00, #fff); font-size: 13px; line-height: 20px; white-space: pre-line; overflow-wrap: break-word; pointer-events: none; transform: translateY(-50%); }`,
+  `[${TOOLTIP_ATTRIBUTE}][${TOOLTIP_VISIBLE_ATTRIBUTE}="true"] { display: block; animation: hiwork-feature-tooltip-in 150ms var(--ds-ease-in-out, ease); }`,
+  `@keyframes hiwork-feature-tooltip-in { from { opacity: 0; } }`,
+  `@media (prefers-reduced-motion: reduce) { [${TOOLTIP_ATTRIBUTE}][${TOOLTIP_VISIBLE_ATTRIBUTE}="true"] { animation: none; } }`,
+  // 与原生会话根同一背景（`background: var(--dsw-alias-bg-base)`）；不显式上色的话
+  // takeover 区会透出框架灰底，和侧栏同色而不是原生页面的白色/深色。
+  `[${FEATURE_ROOT_ATTRIBUTE}] { display: flex; flex-direction: column; flex: 1; min-width: 0; min-height: 0; overflow: hidden; background: var(--dsw-alias-bg-base, #fff); }`,
+  `html[${ACTIVE_PAGE_ATTRIBUTE}] [data-pane="conversation"] > *:not([${FEATURE_ROOT_ATTRIBUTE}]), html[${ACTIVE_PAGE_ATTRIBUTE}] [class*="centerCol"] > *:not([${FEATURE_ROOT_ATTRIBUTE}]) { display: none !important; }`
+].join("\n");
+var FeatureErrorBoundary = class extends import_react5.Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(error, _info) {
+    this.props.onError(error);
+  }
+  render() {
+    return this.state.failed ? null : this.props.children ?? null;
+  }
+};
+var ownerCounter = 0;
+var activeOwner = null;
+function sidebarRoot() {
+  const column = document.querySelector(SIDEBAR_SELECTOR);
+  if (column === null) return void 0;
+  const logoOwner = column.querySelector('[class*="logoRow"]')?.parentElement;
+  return logoOwner ?? column.firstElementChild ?? void 0;
+}
+function nativeNewSessionButton(root) {
+  const matched = root.querySelector(NEW_SESSION_SELECTOR);
+  if (matched !== null) return matched;
+  for (const child of Array.from(root.children)) {
+    if (child.tagName === "BUTTON") return child;
+  }
+  return void 0;
+}
+function conversationContainer() {
+  return document.querySelector(CONVERSATION_SELECTOR) ?? void 0;
+}
+function isCollapsedRail(item) {
+  const host = item.closest('[class*="collapsed"]');
+  if (host === null) return false;
+  const column = item.closest(SIDEBAR_SELECTOR);
+  return column === null || column.contains(host);
+}
+function mountFeatureCenter(options) {
+  const { registry } = options;
+  const interval = options.retryIntervalMs ?? 200;
+  const budget = options.retryBudgetMs ?? 1e4;
+  const maxRetries = Math.max(1, Math.floor(budget / Math.max(1, interval)));
+  const owner = `hiwork-core-${++ownerCounter}`;
+  if (typeof document === "undefined") {
+    return { dispose: () => void 0, openNativeHome: () => void 0 };
+  }
+  const isActiveOwner = () => activeOwner === owner;
+  for (const stale of Array.from(document.querySelectorAll(`[${MENU_ATTRIBUTE}], [${FEATURE_ROOT_ATTRIBUTE}], [${TOOLTIP_ATTRIBUTE}], #${STYLE_ELEMENT_ID}`))) {
+    stale.remove();
+  }
+  for (const hidden of Array.from(document.querySelectorAll(`[${NATIVE_HIDDEN_ATTRIBUTE}]`))) {
+    hidden.removeAttribute(NATIVE_HIDDEN_ATTRIBUTE);
+  }
+  document.documentElement.removeAttribute(ACTIVE_PAGE_ATTRIBUTE);
+  activeOwner = owner;
+  const style = document.createElement("style");
+  style.id = STYLE_ELEMENT_ID;
+  style.setAttribute(OWNER_ATTRIBUTE, owner);
+  style.textContent = featureCenterCss;
+  document.head.appendChild(style);
+  let menuElement;
+  let menuSignature = "";
+  let root;
+  let container;
+  let mountedId = null;
+  let retryTimer;
+  let retries = 0;
+  let disposed = false;
+  let tooltipElement;
+  let tooltipTimer;
+  let tooltipItem;
+  const hideTooltip = () => {
+    if (tooltipTimer !== void 0) {
+      clearTimeout(tooltipTimer);
+      tooltipTimer = void 0;
+    }
+    tooltipItem = void 0;
+    tooltipElement?.removeAttribute(TOOLTIP_VISIBLE_ATTRIBUTE);
+  };
+  const ensureTooltip = () => {
+    let element = tooltipElement;
+    if (element === void 0) {
+      element = document.createElement("div");
+      element.setAttribute(TOOLTIP_ATTRIBUTE, "");
+      element.setAttribute(OWNER_ATTRIBUTE, owner);
+      element.setAttribute("role", "tooltip");
+      document.body.appendChild(element);
+      tooltipElement = element;
+    }
+    return element;
+  };
+  const placeTooltip = (item, element) => {
+    const rect = item.getBoundingClientRect();
+    const width = element.offsetWidth;
+    const overflowRight = rect.right + TOOLTIP_GAP_PX + width > window.innerWidth;
+    const left = overflowRight ? rect.left - TOOLTIP_GAP_PX - width : rect.right + TOOLTIP_GAP_PX;
+    element.style.left = `${Math.max(0, left)}px`;
+    element.style.top = `${rect.top + rect.height / 2}px`;
+  };
+  const showTooltip = (item, label) => {
+    const element = ensureTooltip();
+    element.textContent = label;
+    element.setAttribute(TOOLTIP_VISIBLE_ATTRIBUTE, "true");
+    tooltipItem = item;
+    placeTooltip(item, element);
+  };
+  const bindTooltip = (item, label) => {
+    item.addEventListener("pointerenter", () => {
+      hideTooltip();
+      tooltipTimer = setTimeout(() => {
+        tooltipTimer = void 0;
+        if (disposed || !item.isConnected || !isCollapsedRail(item)) return;
+        showTooltip(item, label);
+      }, TOOLTIP_DELAY_MS);
+    });
+    item.addEventListener("pointerleave", () => {
+      if (tooltipItem === item || tooltipTimer !== void 0) hideTooltip();
+    });
+  };
+  document.addEventListener("scroll", hideTooltip, true);
+  const clearTakeover = () => {
+    const reactRoot = root;
+    root = void 0;
+    mountedId = null;
+    if (reactRoot !== void 0) {
+      try {
+        reactRoot.unmount();
+      } catch (error) {
+        console.warn("hiwork feature center: unmount failed", error);
+      }
+    }
+    const element = container;
+    container = void 0;
+    if (element !== void 0 && element.getAttribute(OWNER_ATTRIBUTE) === owner) element.remove();
+    if (isActiveOwner()) document.documentElement.removeAttribute(ACTIVE_PAGE_ATTRIBUTE);
+  };
+  const onRenderError = (error) => {
+    console.warn("hiwork feature render failed:", error);
+    const failedId = mountedId;
+    queueMicrotask(() => {
+      if (disposed) return;
+      if (registry.activeId() === failedId) registry.openNative();
+      else if (mountedId === failedId) clearTakeover();
+    });
+  };
+  const renderContext = {
+    openNativeSession: (sessionId) => {
+      registry.openNative();
+      options.openNativeSession(sessionId);
+    },
+    openNativeHome: () => {
+      registry.openNative();
+      clickNativeNewSession();
+    }
+  };
+  function clickNativeNewSession() {
+    const root_ = sidebarRoot();
+    const button = root_ === void 0 ? void 0 : nativeNewSessionButton(root_);
+    button?.click();
+  }
+  const onMenuClick = (event) => {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const item = target.closest(`[${MENU_ITEM_ATTRIBUTE}]`);
+    if (item === null || !(menuElement?.contains(item) ?? false)) return;
+    hideTooltip();
+    const id = item.getAttribute(MENU_ITEM_ATTRIBUTE);
+    if (id === null) return;
+    if (id === NATIVE_MENU_ITEM_ID) {
+      renderContext.openNativeHome();
+      return;
+    }
+    registry.open(id);
+  };
+  const createMenuItem = (id, label, icon, active) => {
+    const item = document.createElement("button");
+    item.type = "button";
+    item.setAttribute(MENU_ITEM_ATTRIBUTE, id);
+    if (active) item.setAttribute("data-hiwork-feature-active", "true");
+    item.setAttribute("aria-label", label);
+    bindTooltip(item, label);
+    const iconSpan = document.createElement("span");
+    iconSpan.setAttribute(MENU_ICON_ATTRIBUTE, "");
+    iconSpan.innerHTML = icon;
+    item.append(iconSpan);
+    const labelSpan = document.createElement("span");
+    labelSpan.setAttribute(MENU_LABEL_ATTRIBUTE, "");
+    labelSpan.textContent = label;
+    item.append(labelSpan);
+    return item;
+  };
+  const nativeIcon = (native) => {
+    const svg = native?.querySelector("svg");
+    return svg === null || svg === void 0 ? DEFAULT_NEW_SESSION_ICON : svg.outerHTML;
+  };
+  const rebuildMenuItems = () => {
+    const element = menuElement;
+    if (element === void 0) return;
+    const active = registry.activeId();
+    const features = registry.list();
+    const sidebar = sidebarRoot();
+    const native = sidebar === void 0 ? void 0 : nativeNewSessionButton(sidebar);
+    const newSessionLabel = options.newSessionLabel?.() ?? DEFAULT_NEW_SESSION_LABEL;
+    const signature = [
+      native === void 0 ? "no-native" : `native:${nativeIcon(native)}`,
+      newSessionLabel,
+      active ?? "",
+      ...features.map((item) => `${item.id}:${item.order ?? ""}:${item.label()}:${item.icon ?? ""}`)
+    ].join("|");
+    if (signature === menuSignature) return;
+    menuSignature = signature;
+    hideTooltip();
+    const items = [];
+    if (native !== void 0) items.push(createMenuItem(NATIVE_MENU_ITEM_ID, newSessionLabel, nativeIcon(native), false));
+    for (const item of features) {
+      items.push(createMenuItem(item.id, item.label(), item.icon ?? DEFAULT_FEATURE_ICON, item.id === active));
+    }
+    element.replaceChildren(...items);
+  };
+  const ensureMenu = (sidebar, native) => {
+    let element = menuElement;
+    if (element === void 0) {
+      element = document.createElement("div");
+      element.setAttribute(MENU_ATTRIBUTE, "");
+      element.setAttribute(OWNER_ATTRIBUTE, owner);
+      element.setAttribute("role", "navigation");
+      element.addEventListener("click", onMenuClick);
+      menuElement = element;
+      menuSignature = "";
+    }
+    if (element.parentElement !== sidebar) {
+      const region = sidebar.querySelector(REGION_SELECTOR);
+      if (native !== void 0 && native.parentElement === sidebar) sidebar.insertBefore(element, native.nextElementSibling);
+      else if (region !== null && region.parentElement === sidebar) sidebar.insertBefore(element, region);
+      else sidebar.appendChild(element);
+    }
+    rebuildMenuItems();
+  };
+  const dedupe = (selector) => {
+    for (const node of Array.from(document.querySelectorAll(selector))) {
+      if (node.getAttribute(OWNER_ATTRIBUTE) !== owner) node.remove();
+    }
+  };
+  const syncMenu = () => {
+    dedupe(`[${MENU_ATTRIBUTE}]`);
+    const sidebar = sidebarRoot();
+    if (sidebar === void 0) return;
+    const native = nativeNewSessionButton(sidebar);
+    if (native !== void 0) native.setAttribute(NATIVE_HIDDEN_ATTRIBUTE, "hidden");
+    ensureMenu(sidebar, native);
+  };
+  const syncTakeover = () => {
+    dedupe(`[${FEATURE_ROOT_ATTRIBUTE}]`);
+    const activeId = registry.activeId();
+    if (activeId === null) {
+      clearTakeover();
+      return;
+    }
+    const target = registry.list().find((item) => item.id === activeId);
+    if (target === void 0) {
+      clearTakeover();
+      return;
+    }
+    const host = conversationContainer();
+    if (host === void 0) {
+      clearTakeover();
+      return;
+    }
+    if (container !== void 0 && container.isConnected && container.parentElement === host && mountedId === activeId) return;
+    clearTakeover();
+    const element = document.createElement("div");
+    element.setAttribute(FEATURE_ROOT_ATTRIBUTE, "");
+    element.setAttribute(OWNER_ATTRIBUTE, owner);
+    element.dataset.hiworkFeatureId = activeId;
+    host.appendChild(element);
+    document.documentElement.setAttribute(ACTIVE_PAGE_ATTRIBUTE, activeId);
+    container = element;
+    mountedId = activeId;
+    const reactRoot = (0, import_client2.createRoot)(element);
+    root = reactRoot;
+    try {
+      reactRoot.render((0, import_react5.createElement)(FeatureErrorBoundary, { onError: onRenderError }, target.render(renderContext)));
+    } catch (error) {
+      onRenderError(error);
+    }
+  };
+  const pending = () => {
+    const sidebar = sidebarRoot();
+    if (sidebar === void 0) return true;
+    if (menuElement === void 0 || !sidebar.contains(menuElement)) return true;
+    if (registry.activeId() === null) return false;
+    const host = conversationContainer();
+    if (host === void 0) return true;
+    return container === void 0 || !host.contains(container);
+  };
+  const scheduleRetry = () => {
+    if (disposed || retryTimer !== void 0 || retries >= maxRetries) return;
+    retryTimer = setTimeout(() => {
+      retryTimer = void 0;
+      retries += 1;
+      sync();
+      if (pending()) scheduleRetry();
+    }, interval);
+  };
+  const onDocumentClickCapture = (event) => {
+    if (registry.activeId() === null) return;
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    if (target.closest(`[${FEATURE_ROOT_ATTRIBUTE}]`) !== null) return;
+    if (target.closest(`[${MENU_ATTRIBUTE}]`) !== null) return;
+    if (target.closest(SESSION_ROW_SELECTOR) === null) return;
+    registry.openNative();
+  };
+  const unsubscribeRegistry = registry.subscribe(() => {
+    sync();
+  });
+  let unsubscribeLocale;
+  if (options.subscribeLocale !== void 0) {
+    try {
+      unsubscribeLocale = options.subscribeLocale(() => {
+        menuSignature = "";
+        rebuildMenuItems();
+      });
+    } catch (error) {
+      console.warn("hiwork feature center: locale subscription unavailable", error);
+    }
+  }
+  const observer = new MutationObserver(() => {
+    sync();
+  });
+  observer.observe(document.body, { childList: true, subtree: true });
+  document.addEventListener("click", onDocumentClickCapture, true);
+  const sync = () => {
+    if (disposed || !isActiveOwner()) return;
+    syncMenu();
+    syncTakeover();
+    if (pending()) scheduleRetry();
+  };
+  sync();
+  return {
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      observer.disconnect();
+      if (retryTimer !== void 0) clearTimeout(retryTimer);
+      retryTimer = void 0;
+      unsubscribeRegistry();
+      unsubscribeLocale?.();
+      document.removeEventListener("click", onDocumentClickCapture, true);
+      document.removeEventListener("scroll", hideTooltip, true);
+      hideTooltip();
+      const tooltip = tooltipElement;
+      tooltipElement = void 0;
+      if (tooltip !== void 0 && tooltip.getAttribute(OWNER_ATTRIBUTE) === owner) tooltip.remove();
+      clearTakeover();
+      const element = menuElement;
+      menuElement = void 0;
+      if (element !== void 0) {
+        element.removeEventListener("click", onMenuClick);
+        if (element.getAttribute(OWNER_ATTRIBUTE) === owner) element.remove();
+      }
+      if (!isActiveOwner()) return;
+      activeOwner = null;
+      for (const hidden of Array.from(document.querySelectorAll(`[${NATIVE_HIDDEN_ATTRIBUTE}]`))) {
+        hidden.removeAttribute(NATIVE_HIDDEN_ATTRIBUTE);
+      }
+      if (style.getAttribute(OWNER_ATTRIBUTE) === owner) style.remove();
+    },
+    openNativeHome: () => {
+      renderContext.openNativeHome();
+    }
+  };
+}
+
+// src/client/contracts.ts
+var HIWORK_FEATURE_CENTER_SERVICE = "hiworkFeatureCenter";
+
 // src/client/index.ts
 var inject = ["slots", "locale", "remote", "remote.credentials", "settingsScope"];
 var INTERACTION_STYLE_ID = "hiwork-core-interaction-styles";
@@ -2304,10 +2808,12 @@ function apply(ctx) {
   }, AboutSection));
   ctx.effect(() => observeAboutNavIcon(), "hiwork-core: about nav icon");
   ctx.slots.inject("sidebar.brand.mark", () => ctx.slots.register({
-    name: "sidebar.brand.mark"
+    name: "sidebar.brand.mark",
+    priority: -1
   }, BrandMark));
   ctx.slots.inject("sidebar.brand.name", () => ctx.slots.register({
-    name: "sidebar.brand.name"
+    name: "sidebar.brand.name",
+    priority: -1
   }, BrandName));
   ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
     name: "sidebar.footer.action",
@@ -2316,5 +2822,42 @@ function apply(ctx) {
   }, UserBadge));
   ctx.effect(() => mountLoginGate(scope, storeCredential), "hiwork-core: login gate");
   ctx.effect(() => observeHeroDecorations(), "hiwork-core: hero decorations");
+  installFeatureCenter(ctx);
+}
+function installFeatureCenter(ctx) {
+  const featureRegistry = createFeatureRegistry();
+  let center;
+  const sessions = ctx.get("sessions");
+  const locale = ctx.get("locale");
+  const face = {
+    featureRegistry,
+    openFeature: (id) => featureRegistry.open(id),
+    // 顺序固定：先退出 takeover 恢复原生会话区，再交给宿主导航。
+    openNativeSession: (sessionId) => {
+      featureRegistry.openNative();
+      sessions?.open(sessionId);
+    },
+    openNativeHome: () => {
+      if (center !== void 0) {
+        center.openNativeHome();
+        return;
+      }
+      featureRegistry.openNative();
+    }
+  };
+  ctx.provide(HIWORK_FEATURE_CENTER_SERVICE, face);
+  ctx.effect(() => {
+    center = mountFeatureCenter({
+      registry: featureRegistry,
+      openNativeSession: (sessionId) => {
+        sessions?.open(sessionId);
+      },
+      ...locale === void 0 ? {} : { subscribeLocale: (listener) => locale.subscribe(listener) }
+    });
+    return () => {
+      center?.dispose();
+      center = void 0;
+    };
+  }, "hiwork-core: feature center");
 }
 return module.exports; } });

package/lib/index.js

@@ -3136,6 +3136,9 @@ function isUnloading(ctx) {
   return state === FIBER_UNLOADING || state === FIBER_DISPOSED;
 }
 
+// src/version.ts
+var PKG_VERSION = false ? "dev" : "0.0.3";
+
 // src/ai-router-client.ts
 var GatewayError = class extends Error {
   constructor(code, message, status) {
@@ -3190,7 +3193,7 @@ var AiRouterClient = class {
     }
   }
   async request(path, opts) {
-    const headers = { "user-agent": "hiwork-core/0.1.14" };
+    const headers = { "user-agent": `hiwork-core/${PKG_VERSION}` };
     if (opts.body !== void 0) headers["content-type"] = "application/json";
     if (opts.sessionCookie !== void 0) headers["cookie"] = opts.sessionCookie;
     const init = {

package/lib/types/client/contracts.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `hiwork-core` 对业务插件公开的 client 面。
+ *
+ * 业务插件（`hiwork-automation`、未来的 `hiwork-knowledge` …）不在运行时 import
+ * 本包的值——DSH 的 client 模块表要求「feature 插件不 runtime-import 另一个
+ * feature 插件」。它们改为通过 cordis 服务发现本面：
+ *
+ * ```ts
+ * ctx.inject(['hiworkFeatureCenter'], (scope) => {
+ *   const face = scope.get('hiworkFeatureCenter') as HiWorkCoreClientFace
+ *   ctx.effect(() => face.featureRegistry.register({ ... }), 'my-plugin: feature')
+ * })
+ * ```
+ *
+ * 本文件同时是服务名的唯一来源（{@link HIWORK_FEATURE_CENTER_SERVICE}），
+ * 避免两侧字符串漂移。
+ *
+ * 这里**不做** `declare module '@deepseek-ai/cordis'` 的 Context 合并：实测它会让
+ * `tsconfig.client-build.json`（只包含 src/client）丢掉 cordis 内部的 `ctx.effect`
+ * 声明合并，导致 client 声明构建失败。业务插件在自己的结构契约里声明同名的可选成员
+ * 即可（见 `hiwork-automation` 的 `contracts.ts`），运行期只按服务名读取。
+ */
+import type { FeatureRegistry } from './feature-registry.ts';
+/** cordis 服务名：`hiwork-core` 的 client 半边提供，业务插件按名注入。 */
+export declare const HIWORK_FEATURE_CENTER_SERVICE = "hiworkFeatureCenter";
+/**
+ * 业务插件能看到的全部能力。
+ *
+ * 只暴露注册与导航：菜单、中央区 takeover、原生按钮代理都由 `hiwork-core` 自己
+ * 实现，业务插件不需要（也不应该）触碰 DOM。
+ */
+export interface HiWorkCoreClientFace {
+    /** 扩展注册表：注册/注销 feature，读取当前活动页。 */
+    readonly featureRegistry: FeatureRegistry;
+    /** 打开一个已注册 feature 的中央页；未注册返回 false。 */
+    readonly openFeature: (id: string) => boolean;
+    /** 打开原生会话：先退出 takeover，再交给宿主会话导航。 */
+    readonly openNativeSession: (sessionId: string) => void;
+    /** 回到原生「新会话」首页：先退出 takeover，再触发原生新会话动作。 */
+    readonly openNativeHome: () => void;
+}

package/lib/types/client/feature-center.d.ts

@@ -0,0 +1,38 @@
+import type { FeatureRegistry } from './feature-registry.ts';
+/** 中央区 takeover 的活动页标记（纯 CSS 隐藏原生内容的开关）。 */
+export declare const ACTIVE_PAGE_ATTRIBUTE = "data-hiwork-active-page";
+/**
+ * Feature Center 的全局样式。
+ *
+ * 隐藏原生会话内容用的是 `html[data-hiwork-active-page]` 上的纯 CSS 规则：移除属性
+ * 即完全恢复，不会留下任何内联 `display:none`。隐藏原生按钮同理走属性规则。
+ */
+export declare const featureCenterCss: string;
+/** 中央区适配器配置。 */
+export interface FeatureCenterOptions {
+    /** hiwork-core 的扩展注册表。 */
+    readonly registry: FeatureRegistry;
+    /** 宿主会话导航（`ctx.sessions.open`）。 */
+    readonly openNativeSession: (sessionId: string) => void;
+    /** 「新会话」菜单文案；缺省「新会话」。 */
+    readonly newSessionLabel?: () => string;
+    /** 语言变化源（`ctx.locale.subscribe`）；变化时重建菜单文案。 */
+    readonly subscribeLocale?: (listener: () => void) => () => void;
+    /** 未就绪时的重试间隔（毫秒），缺省 200。 */
+    readonly retryIntervalMs?: number;
+    /** 未就绪时的重试总预算（毫秒），缺省 10_000；预算耗尽后只靠 observer 自愈。 */
+    readonly retryBudgetMs?: number;
+}
+/** 中央区适配器句柄。 */
+export interface FeatureCenterHandle {
+    /** 断开 observer、卸载 takeover、移除菜单与样式、恢复原生按钮可见性；可重复调用。 */
+    dispose(): void;
+    /** 回到原生「新会话」首页：先退出 takeover，再触发原生按钮动作。 */
+    openNativeHome(): void;
+}
+/**
+ * 挂载 Feature Center：注入侧栏菜单并管理中央区 takeover。
+ * @param options - 注册表、宿主导航与重试预算。
+ * @returns 句柄；`dispose()` 恢复原生 DOM。
+ */
+export declare function mountFeatureCenter(options: FeatureCenterOptions): FeatureCenterHandle;

package/lib/types/client/feature-registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * HiWork Feature Center 的扩展注册表（浏览器半边，无 DOM 依赖）。
+ *
+ * 业务插件（`hiwork-automation`、未来的 `hiwork-knowledge` …）通过
+ * `featureRegistry.register(feature)` 贡献一个中央页入口；`hiwork-core` 的侧栏菜单
+ * 与中央区 takeover 只读这份注册表，不持有任何业务状态。
+ *
+ * 契约要点：
+ *  - `id` 必须非空且全局唯一，重复注册抛错（fail loud，不静默覆盖）；
+ *  - `register` 返回幂等 disposer，可重复调用；
+ *  - `list()` 按 `order`（缺省 {@link DEFAULT_FEATURE_ORDER}）再按 `id` 稳定排序；
+ *  - `open` / `openNative` 只在可观察状态真的变化时通知订阅者。
+ */
+import type { ReactNode } from 'react';
+/** 缺省排序权重：未声明 `order` 的 feature 排在声明了正权重之后、按 id 稳定。 */
+export declare const DEFAULT_FEATURE_ORDER = 1000;
+/**
+ * 业务插件渲染中央页时拿到的上下文。
+ *
+ * 只提供导航能力，registry 不向插件暴露任务/知识库等业务状态：业务状态仍由插件
+ * 自己的 runtime 持有。
+ */
+export interface FeatureRenderContext {
+    /** 打开一条原生 DSH 会话；调用前会先退出 takeover 并恢复原生会话区。 */
+    readonly openNativeSession: (sessionId: string) => void;
+    /** 回到原生「新会话」首页；调用前会先退出 takeover。 */
+    readonly openNativeHome: () => void;
+}
+/** 一个可注册的 HiWork 扩展入口。 */
+export interface HiWorkFeature {
+    /** 稳定 id，同时作为菜单项与 `data-hiwork-active-page` 的值。 */
+    readonly id: string;
+    /** 菜单文案；函数形式以便语言切换后重新求值。 */
+    readonly label: () => string;
+    /** 可选图标标记（内联 SVG 字符串），由侧栏适配器渲染。 */
+    readonly icon?: string;
+    /** 菜单排序权重，越小越靠前；缺省 {@link DEFAULT_FEATURE_ORDER}。 */
+    readonly order?: number;
+    /** 渲染中央页内容；抛错由中央区适配器捕获并恢复原生会话区。 */
+    readonly render: (context: FeatureRenderContext) => ReactNode;
+}
+/** 扩展注册表。 */
+export interface FeatureRegistry {
+    /** 注册一个 feature；返回幂等 disposer。id 为空或重复时抛错。 */
+    register(feature: HiWorkFeature): () => void;
+    /** 当前已注册 feature 的稳定排序快照。 */
+    list(): readonly HiWorkFeature[];
+    /** 当前打开的 feature id；未打开扩展时为 `null`。 */
+    activeId(): string | null;
+    /** 打开指定 feature；不存在返回 false，已打开时返回 true 但不重复通知。 */
+    open(id: string): boolean;
+    /** 退出扩展、回到原生会话区；未打开扩展时是 no-op。 */
+    openNative(): void;
+    /** 订阅注册/注销/活动页变化；返回退订函数。 */
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * 创建一份独立的注册表。每次 `apply()` 只创建一份，随插件 fiber 一起释放。
+ * @returns 扩展注册表。
+ */
+export declare function createFeatureRegistry(): FeatureRegistry;

package/lib/types/client/index.d.ts

@@ -1,4 +1,6 @@
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
+export type { FeatureRenderContext, FeatureRegistry, HiWorkFeature } from './feature-registry.ts';
+export type { HiWorkCoreClientFace } from './contracts.ts';
 /** 浏览器插件契约（dsh client module system）。connection 随 IApiClient 移除后不再依赖。 */
 export declare const inject: string[];
 /** 挂载网关模型设置 section（一级 tab）与未登录弹窗。 */

package/lib/types/version.d.ts

@@ -0,0 +1 @@
+export declare const PKG_VERSION: string;

package/lib/version.js

@@ -0,0 +1 @@
+export const PKG_VERSION = typeof __PKG_VERSION__ === 'undefined' ? 'dev' : __PKG_VERSION__;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hiwork-core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "description": "HiWork 企业统一登录与模型自动供给插件（ai-router 网关登录，Web 表单，无 CLI 认证）",
   "license": "UNLICENSED",