hiwork-core 0.0.11 → 0.0.17

package/lib/workbench-bridge.js

@@ -0,0 +1,447 @@
+/**
+ * `/hiwork-workbench` loopback RPC 的 Host 实现：管理员登记并分配给当前账号的**工作台应用清单**。
+ *
+ * 契约见 spec `docs/superpowers/specs/2026-09-17-hiwork-workbench-design.md` §4.1（清单 JSON）与
+ * §4.5（Host 面）。本文件是 `src/managed-skills.ts` 同一副骨架的**第三条链**，也是三条里最短的一条：
+ * 工作台 M0 只做「看得到货架」，因此
+ *  - 端点只有两个：`snapshot`（你现在有什么）/ `refresh`（现在去拉一次）。**没有 `package` 那一档**
+ *    （清单里没有大字节，一条 GET 全量下发）；
+ *  - **M1 的四个端点（`submit` / `poll` / `cancel` / `materialize`）刻意不在本文件里**：它们要动
+ *    工作区落盘与上传字节，属于任务运行时的范围（plan T5 的「M0 的边界」）。别为了「一次写完」
+ *    顺手加上——那会把 M0 的验收面撑成 M1。
+ *
+ * 与 MCP / 技能逐字同款的三条铁律：
+ *  - **网关会话 cookie 绝不离开 Host**：cookie 只在 `resolveSession()` 内部出现，客户端拿到的是
+ *    清单（经 loopback RPC 过去，里面没有任何令牌）；
+ *  - **拉清单失败绝不清空上一次成功的清单**：失败返回「保留旧值 + 标注失败原因」，于是断网时
+ *    界面还能显示上次成功缓存 + 「可能不是最新」（spec §10 的离线那一行）；
+ *  - **`snapshot` 可能陈旧、只有 `refresh` 的成功返回值可作真相**：下架 / 撤销分配后卡片消失
+ *    只能基于 `refresh` 的返回值判定（spec §4.5）。
+ *
+ * 与技能清单不同的一处：**远端会回 404**（网关没配置工作台时那条路由压根没注册，spec §10），
+ * 它被映射成 `WORKBENCH_DISABLED` 而非「网关不可达」——这是可展示的功能状态，不是故障。
+ *
+ * 演进纪律（spec §4.1）：**未知字段忽略；未知 `executor.kind` / `inputs[].type` 原样透传**。
+ * 本文件的规范化只做「形状兜底 + 已知字段改名（`icon` → `iconUrl`）」，绝不按白名单过滤语义
+ * ——老客户端遇到新 kind 由客户端置灰 + 提示升级（spec D2），Host 不替它做丢弃决策。
+ *
+ * 本模块不 import cordis 运行时，只依赖结构化的 {@link WorkbenchRpcDeps} 端口，便于单测直接伪造。
+ */
+import { GatewayError, } from "./ai-router-client.js";
+/** RPC 频道；必须与 client 半边 `src/client/managed-workbench.ts` 的 `MANAGED_WORKBENCH_CHANNEL` 一致（由测试锁定）。 */
+export const WORKBENCH_RPC_CHANNEL = '/hiwork-workbench';
+/**
+ * 端点白名单：M0 只有「拿清单」这一件事的两个入口。
+ *
+ * `snapshot` 是「你现在有什么」（有缓存就直接给，冷启动才拉一次），`refresh` 是「现在去拉一次」。
+ * 分两个端点的理由与 MCP / 技能同款：同步策略（启动 / 超 TTL / 手动刷新）由消费方自己定，
+ * Host 不该替它决定什么时候必须联网。
+ *
+ * ⚠️ `submit` / `poll` / `cancel` / `materialize` 属 M1（spec §4.5），**不许提前登记**：
+ * 白名单是客户端可用的能力边界，多一项就等于先发布了一个没有实现的承诺。
+ */
+export const WORKBENCH_RPC_ENDPOINTS = ['snapshot', 'refresh'];
+/**
+ * Host 侧后台预热间隔：30 分钟（与 MCP / 技能两份同量级）。
+ * 它**不是**权威节奏——只为让客户端首次 `snapshot` 不必等一次网络往返。
+ */
+export const WORKBENCH_REFRESH_INTERVAL_MS = 30 * 60_000;
+/** 请求侧错误（只有 `bad-request`：未知端点 / 非法 payload）。 */
+export class WorkbenchRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkbenchRequestError';
+    }
+}
+/** 通用失败文案：不暴露任何网关细节。 */
+export const WORKBENCH_GENERIC_FAILURE_MESSAGE = '工作台应用清单暂时无法获取，请稍后重试';
+/** 未登录 / 会话失效的统一文案（与用量、每日一句、MCP / 技能清单几个频道同口径）。 */
+export const WORKBENCH_SESSION_EXPIRED_MESSAGE = '登录状态已过期，请重新登录';
+/** 本部署未启用工作台（网关 404）的文案：spec §10 的降级矩阵里这一行要给人可行动的提示。 */
+export const WORKBENCH_DISABLED_MESSAGE = '本部署未启用工作台，请联系管理员';
+/** 工作台未启用时的稳定 code（与网关客户端的映射一致，消费方按它走降级文案）。 */
+export const WORKBENCH_DISABLED_CODE = 'WORKBENCH_DISABLED';
+/**
+ * 各稳定错误码的用户可见文案（网关 message 含实现细节时用它兜底）。
+ * 只列本频道**真会收到**的 code：工作台 M0 没有「应用已下架」那一档——下架的表现是
+ * 「这次清单里没有这条」，不是一条错误（spec §10）。
+ */
+const WORKBENCH_MESSAGE_FALLBACK = {
+    SESSION_EXPIRED: WORKBENCH_SESSION_EXPIRED_MESSAGE,
+    GATEWAY_UNREACHABLE: WORKBENCH_GENERIC_FAILURE_MESSAGE,
+    [WORKBENCH_DISABLED_CODE]: WORKBENCH_DISABLED_MESSAGE,
+};
+/**
+ * 网关 message 消毒（与 `usage-rpc.ts` 的 `displayGatewayMessage` 同实现，MCP / 技能那两半逐字同款）：
+ * 含 baseURL / HTTP 状态码 / URL 的原始消息一律换成稳定文案，其余（网关自己写好的中文业务文案）
+ * 原样保留。code 不受影响，始终原样透传。
+ */
+export function displayWorkbenchMessage(code, message) {
+    const text = typeof message === 'string' ? message.trim() : '';
+    if (text === '')
+        return WORKBENCH_MESSAGE_FALLBACK[code] ?? WORKBENCH_GENERIC_FAILURE_MESSAGE;
+    const leaksImplementationDetail = /https?:\/\//i.test(text)
+        || /\bHTTP\s*\d{3}\b/i.test(text)
+        || /\bbaseURL\b/i.test(text);
+    if (leaksImplementationDetail)
+        return WORKBENCH_MESSAGE_FALLBACK[code] ?? WORKBENCH_GENERIC_FAILURE_MESSAGE;
+    return text;
+}
+/**
+ * payload 校验：两个端点都**只放行空对象**（M0 没有任何入参）。
+ *
+ * 与技能清单的空入参分支逐字同款：出现任何字段都是客户端实现缺陷，直接 `bad-request`
+ * ——一个 `{ code: 'pdf-to-word' }` 被静默忽略，会让调用方以为「按 code 过滤」生效了。
+ */
+export function parseWorkbenchPayload(endpoint, raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new WorkbenchRequestError('bad-request', '工作台清单请求参数不合法。');
+    }
+    const record = raw;
+    const keys = Object.keys(record);
+    const first = keys[0];
+    if (first !== undefined) {
+        throw new WorkbenchRequestError('bad-request', `工作台清单请求包含未知字段 '${first}'。`);
+    }
+    // endpoint 已在调用方过白名单；这里保留参数是为了类型上与其它频道的 parse* 同形。
+    void endpoint;
+    return {};
+}
+/** 是否为白名单端点。 */
+export function isWorkbenchRpcEndpoint(endpoint) {
+    return WORKBENCH_RPC_ENDPOINTS.includes(endpoint);
+}
+/** 非空字符串或 undefined（清单里一个字段坏了不该让整条清单失败）。 */
+function textOrUndefined(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+/** 宽松的记录判定（数组与 null 都不算）。 */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** 字符串数组（非字符串项丢弃；这是形状兜底，不是语义白名单）。 */
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && item.trim() !== '');
+}
+/**
+ * 执行器规范化：**唯一要求是 `kind` 存在且是非空字符串**。
+ *
+ * 三个刻意的选择：
+ *  - 认不认识的 kind 都照发（`kind` 是开放集合，spec §4.1 的演进纪律；老客户端遇到新 kind
+ *    自己置灰 + 提示升级，见 spec D2）；
+ *  - 未知键**原样保留**（`submitPath` / `limits` / 未来的 `target` 都在这里过去）；
+ *  - 非字符串的 `mode` 丢掉而不是透传：契约面声明的就是 `mode?: string`，留一个数字进去
+ *    等于让消费方拿到一个自己类型没声明过的值。
+ */
+function normalizeExecutor(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const kind = textOrUndefined(raw['kind']);
+    if (kind === undefined)
+        return undefined;
+    const executor = { ...raw, kind };
+    const mode = textOrUndefined(raw['mode']);
+    if (mode === undefined)
+        delete executor.mode;
+    else
+        executor.mode = mode;
+    return executor;
+}
+/**
+ * 输入项规范化：**缺 `key` 的整条丢掉**（没有 key 就没有表单绑定的坐标），其余全部兜底。
+ *
+ * `type` 不认识的照样发出去（spec §4.1：未知 type → 该应用置灰，不是整页崩）；`accept` /
+ * `options` / `default` 这些**只对某些 type 有意义**的键靠 `...raw` 原样带走。
+ */
+function normalizeInput(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const key = textOrUndefined(raw['key']);
+    if (key === undefined)
+        return undefined;
+    return {
+        ...raw,
+        key,
+        type: textOrUndefined(raw['type']) ?? '',
+        label: textOrUndefined(raw['label']) ?? key,
+        required: raw['required'] === true,
+    };
+}
+/**
+ * 输出项规范化：与输入项同款，但只有 `key` / `type` 两个契约字段
+ * （产物怎么命名由网关侧决定，客户端不参与）。
+ */
+function normalizeOutput(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const key = textOrUndefined(raw['key']);
+    if (key === undefined)
+        return undefined;
+    return { ...raw, key, type: textOrUndefined(raw['type']) ?? '' };
+}
+/**
+ * 把网关响应里的一条应用规范化成 {@link WorkbenchAppView}。
+ *
+ * **只在两种情况下丢条目**：不是对象，或缺了 `code` / `executor.kind`
+ * ——前者是卡片与路径的唯一坐标，后者是「这条能不能跑」的唯一判据（少了它连「置灰 + 提示升级」
+ * 都渲染不出来）。丢弃时记一条日志，因为服务端数据问题的证据在 Host 侧，客户端看不到网关响应。
+ *
+ * **其余一律兜底而不丢**：`displayName` 缺省回 `code`、`summary` / `tags` / `effects` 缺省为空。
+ * 这与「未知 kind 透传」是同一条纪律的两面：Host 不做语义过滤，只保证形状可用。
+ */
+function normalizeApp(raw, log) {
+    if (!isRecord(raw))
+        return undefined;
+    const code = textOrUndefined(raw['code']);
+    const executor = normalizeExecutor(raw['executor']);
+    if (code === undefined || executor === undefined) {
+        log?.('hiwork-core: 工作台清单里有一条结构不完整的应用（缺 code 或 executor.kind），已跳过');
+        return undefined;
+    }
+    const iconUrl = textOrUndefined(raw['icon']);
+    const category = isRecord(raw['category']) ? raw['category'] : undefined;
+    const inputs = [];
+    for (const item of Array.isArray(raw['inputs']) ? raw['inputs'] : []) {
+        const normalized = normalizeInput(item);
+        if (normalized !== undefined)
+            inputs.push(normalized);
+    }
+    const outputs = [];
+    for (const item of Array.isArray(raw['outputs']) ? raw['outputs'] : []) {
+        const normalized = normalizeOutput(item);
+        if (normalized !== undefined)
+            outputs.push(normalized);
+    }
+    const revision = raw['revision'];
+    return {
+        code,
+        displayName: textOrUndefined(raw['displayName']) ?? code,
+        summary: textOrUndefined(raw['summary']) ?? '',
+        // `exactOptionalPropertyTypes` 下不许显式写 undefined，用条件展开。
+        ...(iconUrl === undefined ? {} : { iconUrl }),
+        category: {
+            code: textOrUndefined(category?.['code']) ?? '',
+            name: textOrUndefined(category?.['name']) ?? '',
+        },
+        tags: stringArray(raw['tags']),
+        featured: raw['featured'] === true,
+        revision: typeof revision === 'number' && Number.isFinite(revision) ? revision : 0,
+        executor,
+        inputs,
+        outputs,
+        effects: stringArray(raw['effects']),
+    };
+}
+/** 任意异常 → 可展示的失败（网关 code 透传，message 消毒；其余收敛为通用失败）。 */
+function failureOf(error) {
+    if (error instanceof WorkbenchRequestError)
+        return { code: error.code, message: error.message, details: {} };
+    if (error instanceof GatewayError) {
+        return { code: error.code, message: displayWorkbenchMessage(error.code, error.message), details: {} };
+    }
+    return { code: 'internal', message: WORKBENCH_GENERIC_FAILURE_MESSAGE, details: {} };
+}
+/** 会话 cookie 规范化：空串与 undefined 同义（都是「当前没有会话」），与 `resolveSession` 的口径一致。 */
+function normalizeSession(sessionCookie) {
+    return sessionCookie === undefined || sessionCookie === '' ? undefined : sessionCookie;
+}
+/** 取消判定（用函数包一层，避免 TS 把属性窄化固化到 `await` 之后）。 */
+function isAborted(signal) {
+    return signal?.aborted === true;
+}
+/**
+ * 清单缓存：**只有成功响应才覆写**，失败只记原因；且缓存**按会话绑定**（见 {@link WorkbenchStore.bindSession}）。
+ *
+ * 「成功」的判据里含**响应形状**：200 但响应不是「带数组 `apps` 的对象」按**取数失败**处理
+ * （见 {@link WorkbenchStore.fetchOnce}）——那种响应是中间层给的，不是服务端说「你没有应用」，
+ * 读成空清单会让货架在反代维护页面前清空，用户以为管理员把应用全撤了（spec §10 的离线态本意
+ * 是「显示上次成功缓存 + 可能不是最新」，不是「什么都不显示」）。
+ *
+ * 进程内的（不落盘）是有意的：清单是「服务端此刻认什么」的投影，跨重启的旧清单没有价值
+ * ——重启后消费方会立刻 `warm()` 一次，拿到新的比拿到旧的更安全。
+ */
+export class WorkbenchStore {
+    deps;
+    now;
+    cached;
+    lastError;
+    /** 产生 `cached` 的那个会话 cookie（只在内存里）。会话绑定的全部依据就是它。 */
+    cachedSession;
+    /**
+     * 在飞请求连同它所用的会话一起记账：并发合并**只允许发生在同一会话内**。
+     * 合并跨会话等于把 A 那次拉取的结果交给 B（登出 / 换账号后货架会显示上一个人的应用）。
+     */
+    inFlight;
+    constructor(deps, now = () => Date.now()) {
+        this.deps = deps;
+        this.now = now;
+    }
+    /**
+     * 当前缓存（同步读，不发请求）。从没成功过返回 undefined；
+     * 最近一次失败会以 `stale + lastError` 标注在上一次成功的结果上。
+     *
+     * ⚠️ **本方法不做会话绑定**——它是 spec §4.5 冻结的同步读，而当前会话只能异步解析（见
+     * {@link peekForCurrentSession}），同步函数里根本判不了「这份缓存还算不算我的」。
+     * 所以模块内唯一的正确用法是：先 `await store.peekForCurrentSession()`，再（或由它内部）`peek()`。
+     * 直接调 `peek()` 只适合诊断与测试断言内存状态。
+     */
+    peek() {
+        if (this.cached === undefined)
+            return undefined;
+        return this.lastError === undefined
+            ? this.cached
+            : { ...this.cached, stale: true, lastError: this.lastError };
+    }
+    /**
+     * 「当前会话下的缓存」= 解析当前会话 → 剪枝 → {@link peek}。
+     *
+     * 与 `src/managed-skills.ts` 的同名方法逐字同款：`peek()` 是 spec §4.5 冻结的**同步**接口，而
+     * 「当前是谁」只有 `deps.resolveSession()` 异步拿得到，于是分工只能是「async 的一侧先绑会话，
+     * sync 的 `peek()` 再读」。端点实现必须走它、不许绕过。
+     */
+    async peekForCurrentSession() {
+        this.bindSession(normalizeSession(await this.deps.resolveSession()));
+        return this.peek();
+    }
+    /**
+     * 会话绑定：缓存只属于产生它的那个会话；当前会话不是它（含**当前没有会话**）→ 立刻丢弃。
+     *
+     * 与技能清单那半逐字同款（那里写了为什么**不许**为了「两半对齐」改回 MCP 的写法）：
+     * 绑会话**自带**——不依赖任何调用方、不依赖谁记得清缓存，登出后（当前会话为空）与换账号后
+     * 都不会再吐出上一个人的清单。`clear()` 也没有任何调用方（端点白名单够不到 Host 内存），
+     * 把安全不变量挂在一个没人调的钩子上正是已经失败过一次的做法。
+     *
+     * 它也**不**触碰「失败不覆写缓存」那条铁律：剪枝的触发条件是**会话变了**，不是「这一次拉取
+     * 失败了」。失败路径仍然原样保留本会话上一次成功的清单（`stale + lastError`）。
+     */
+    bindSession(current) {
+        if (current === this.cachedSession)
+            return;
+        this.cached = undefined;
+        this.cachedSession = undefined;
+        // 失败记录也是**按会话的**：换了人（或登出）之后，上一个人的 lastError 与这一份都不该
+        // 继续挂在账上——否则新的 `snapshot` 会把别人的失败当作自己的「最近一次失败」展示。
+        this.lastError = undefined;
+    }
+    /**
+     * 去网关拉一次清单并更新缓存。失败时抛异常，且**本会话的缓存原样保留**。
+     *
+     * 并发调用合并成一次请求：后台预热与消费方的手动刷新撞在一起时不必打两遍网关。
+     * 合并**只在同一会话内**——两个会话合并到一起，就等于把 A 的结果发给 B。
+     */
+    async load() {
+        const session = normalizeSession(await this.deps.resolveSession());
+        const inFlight = this.inFlight;
+        if (inFlight !== undefined && inFlight.session === session)
+            return await inFlight.task;
+        const task = this.fetchOnce(session);
+        this.inFlight = { session, task };
+        try {
+            return await task;
+        }
+        finally {
+            // 只有自己那次还在账上才清：更晚发起的（另一个会话的）请求不该被这一笔收尾抹掉。
+            if (this.inFlight?.task === task)
+                this.inFlight = undefined;
+        }
+    }
+    /**
+     * 清空内存清单（登出 / 换账号调用）。
+     *
+     * ⚠️ **当前没有任何调用方**：这是 spec §4.5 冻结要求提供的接口（与技能清单那半同款），而它的
+     * 用途已经被**会话绑定**覆盖——缓存按会话剪枝，登出 / 换账号后再也吐不出上一个人的清单。
+     * 保留它是为了不改冻结接口；真要删得先改 spec §4.5。冻结接口里的成员不要悄悄删掉。
+     */
+    clear() {
+        this.cached = undefined;
+        this.lastError = undefined;
+        this.cachedSession = undefined;
+    }
+    async fetchOnce(sessionCookie) {
+        try {
+            if (sessionCookie === undefined) {
+                throw new GatewayError('SESSION_EXPIRED', WORKBENCH_SESSION_EXPIRED_MESSAGE);
+            }
+            const gateway = this.deps.gateway();
+            if (gateway === undefined) {
+                throw new GatewayError('GATEWAY_UNREACHABLE', '网关地址未配置，请先在「网关模型」里完成登录');
+            }
+            const view = await gateway.getMyWorkbenchApps(sessionCookie);
+            // 200 + 能解析的 JSON，但**不是「带数组 apps 的对象」**⇒ 按取数失败处理，绝不
+            // 当成「成功拉到的空清单」。这类响应只可能来自夹在中间的层（反代维护页 / SSO 门户 /
+            // 任何在 200 上回自己那份 JSON 的东西）——服务端这条端点的 200 形状是冻结契约（spec §4.1）。
+            // 读成空清单的后果是货架在故障期间被清空，用户据此以为管理员把应用全下架了。
+            if (!isRecord(view) || !Array.isArray(view.apps)) {
+                this.deps.log?.('hiwork-core: 工作台清单响应不是带 apps 数组的对象（可能的中间层），按取数失败处理');
+                throw new GatewayError('GATEWAY_UNREACHABLE', WORKBENCH_GENERIC_FAILURE_MESSAGE);
+            }
+            const apps = [];
+            for (const item of view.apps) {
+                const normalized = normalizeApp(item, this.deps.log);
+                if (normalized !== undefined)
+                    apps.push(normalized);
+            }
+            const snapshot = {
+                revision: typeof view.revision === 'number' && Number.isFinite(view.revision) ? view.revision : 0,
+                fetchedAt: new Date(this.now()).toISOString(),
+                apps,
+                stale: false,
+            };
+            // 成功才覆写，并**连同产生它的会话**一起记账：会话绑定（bindSession）之后要靠这一行。
+            // 迟到的写回（旧会话的请求在换账号之后才返回）不构成漏洞：它只会把 cachedSession 记回旧
+            // 会话，而任何一次读取都要先过 bindSession——不匹配就当场丢弃，永远到不了调用方手里。
+            this.cached = snapshot;
+            this.cachedSession = sessionCookie;
+            this.lastError = undefined;
+            return snapshot;
+        }
+        catch (error) {
+            this.lastError = failureOf(error);
+            throw error;
+        }
+    }
+}
+/**
+ * 处理一次端点调用：返回 DSH Connection 的结果信封，**永不抛异常**。
+ * 导出以便单测直接驱动（无需伪造 `ctx.connection`）。
+ */
+export async function handleWorkbenchEndpoint(endpoint, rawPayload, deps, store, signal) {
+    try {
+        if (isAborted(signal))
+            return failure('cancelled', '工作台清单请求已取消。');
+        if (!isWorkbenchRpcEndpoint(endpoint)) {
+            throw new WorkbenchRequestError('bad-request', `未知的工作台清单端点 '${endpoint}'`);
+        }
+        parseWorkbenchPayload(endpoint, rawPayload);
+        // snapshot：有缓存就直接给（可能是 stale），冷启动才走一次网络。
+        // 注意这里**没有**直接用 `store.peek()`：spec §4.5 的 `peek()` 是同步读、拿不到当前会话，
+        // 而缓存必须按会话绑定（登出 / 换账号后不许再吐出上一个人的清单），所以走 async 前置
+        // `peekForCurrentSession()`——它先解析当前 cookie 做一次同步剪枝，再返回缓存。两个端点都走它，
+        // 于是 `refresh` 也会顺手剪掉已经不匹配的缓存（拉失败时也不会留着别人的旧清单）。
+        const cached = await store.peekForCurrentSession();
+        if (endpoint === 'snapshot' && cached !== undefined)
+            return { ok: true, value: cached };
+        return { ok: true, value: await store.load() };
+    }
+    catch (error) {
+        deps.log?.(`hiwork-core: 工作台清单 RPC '${endpoint}' 失败（${error instanceof Error ? error.name : typeof error}）`);
+        return { ok: false, error: failureOf(error) };
+    }
+}
+function failure(code, message) {
+    return { ok: false, error: { code, message, details: {} } };
+}
+/**
+ * 注册 `/hiwork-workbench` 频道，返回异步 disposer（交给 `ctx.effect` 管理生命周期）。
+ */
+export function registerWorkbenchRpc(ctx, deps, store) {
+    const handler = (endpoint, payload, signal) => handleWorkbenchEndpoint(endpoint, payload, deps, store, signal);
+    const remove = ctx.connection.rpc.handle(WORKBENCH_RPC_CHANNEL, handler, { authority: 'loopback' });
+    return async () => { await remove(); };
+}

package/package.json

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