@zhin.js/host-http 1.1.0 → 1.1.1

package/README.md

@@ -54,3 +54,8 @@ http:
 The legacy Koa `@zhin.js/host-router` stack and the `@zhin.js/host-api` management-plane plugin have
 been removed; the management-plane REST/RPC/SSE is now assembled by `@zhin.js/cli` (Console Host) on
 top of this package — no Host plugins need to be installed or enabled.
+
+Extended Console RPC uses `src/console-rpc-extended/index.ts` as its module boundary. The dispatcher
+only maps protocol method names to schedule, inbox, login, Endpoint-management, and Workroom control
+handlers. Shared request parsing and generation-leased Endpoint execution live behind internal helper
+ports, so adding one RPC domain does not enlarge the central dispatcher or couple unrelated domains.

package/lib/console-plugin-rpc.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeConsoleRpcContext, RuntimeConsoleRpcMessage, RuntimeConsoleRpcReply } from './console-rpc.js';
+/** Dispatches the plugin-management slice; undefined means the type belongs elsewhere. */
+export declare function dispatchPluginConsoleRpc(type: string, message: RuntimeConsoleRpcMessage, ctx: RuntimeConsoleRpcContext): Promise<RuntimeConsoleRpcReply | undefined>;

package/lib/console-plugin-rpc.js

@@ -0,0 +1,130 @@
+import { PLUGIN_RPC } from '@zhin.js/console-protocol';
+/** Dispatches the plugin-management slice; undefined means the type belongs elsewhere. */
+export async function dispatchPluginConsoleRpc(type, message, ctx) {
+    const requestId = message.requestId;
+    try {
+        switch (type) {
+            case PLUGIN_RPC.SET_ENABLED: {
+                const instanceKey = stringField(message, 'instanceKey');
+                const enabled = message.enabled;
+                if (!instanceKey || typeof enabled !== 'boolean') {
+                    return { requestId, error: 'instanceKey and boolean enabled are required' };
+                }
+                if (!ctx.setPluginEnabled) {
+                    return { requestId, error: 'Plugin lifecycle management is not configured' };
+                }
+                const lifecycle = await ctx.setPluginEnabled(instanceKey, enabled);
+                ctx.publishEvent?.('plugin:lifecycle-updated', { instanceKey, enabled });
+                if (ctx.requestRestart) {
+                    setTimeout(() => void Promise.resolve(ctx.requestRestart?.()).catch(() => undefined), 500);
+                }
+                return {
+                    requestId,
+                    data: {
+                        success: true,
+                        instanceKey,
+                        enabled,
+                        disabled: lifecycle.disabled,
+                        restartRequired: true,
+                        message: `${instanceKey} 已${enabled ? '启用' : '停用'}，Host 正在重启`,
+                    },
+                };
+            }
+            case PLUGIN_RPC.PLAN_INSTALL: {
+                const packageName = stringField(message, 'packageName');
+                if (!packageName)
+                    return { requestId, error: 'packageName is required' };
+                if (!ctx.pluginManagement)
+                    return { requestId, error: 'Plugin management is not configured' };
+                return { requestId, data: await ctx.pluginManagement.planInstall(packageName) };
+            }
+            case PLUGIN_RPC.INSTALL: {
+                const packageName = stringField(message, 'packageName');
+                if (!packageName)
+                    return { requestId, error: 'packageName is required' };
+                if (!ctx.pluginManagement?.install) {
+                    return { requestId, error: 'Plugin installation is not configured' };
+                }
+                const result = await ctx.pluginManagement.install(packageName, optionalString(message.expectedRevision));
+                ctx.publishEvent?.('plugin:installed', { packageName, restartRequired: result.restartRequired });
+                return { requestId, data: { success: true, ...result } };
+            }
+            case PLUGIN_RPC.PLAN_UNINSTALL: {
+                const packageName = stringField(message, 'packageName');
+                if (!packageName)
+                    return { requestId, error: 'packageName is required' };
+                if (!ctx.pluginManagement?.planUninstall) {
+                    return { requestId, error: 'Plugin uninstall planning is not configured' };
+                }
+                return { requestId, data: await ctx.pluginManagement.planUninstall(packageName) };
+            }
+            case PLUGIN_RPC.UNINSTALL: {
+                const packageName = stringField(message, 'packageName');
+                if (!packageName || stringField(message, 'confirmation') !== packageName) {
+                    return { requestId, error: 'confirmation must exactly match packageName' };
+                }
+                if (!ctx.pluginManagement?.uninstall) {
+                    return { requestId, error: 'Plugin uninstall is not configured' };
+                }
+                const result = await ctx.pluginManagement.uninstall(packageName, optionalString(message.expectedRevision));
+                ctx.publishEvent?.('plugin:uninstalled', { packageName, restartRequired: result.restartRequired });
+                return { requestId, data: { success: true, ...result } };
+            }
+            case PLUGIN_RPC.PLAN_UPDATE: {
+                const packageName = stringField(message, 'packageName');
+                const targetVersion = stringField(message, 'targetVersion');
+                if (!packageName || !targetVersion) {
+                    return { requestId, error: 'packageName and targetVersion are required' };
+                }
+                if (!ctx.pluginManagement?.planUpdate) {
+                    return { requestId, error: 'Plugin update planning is not configured' };
+                }
+                return { requestId, data: await ctx.pluginManagement.planUpdate(packageName, targetVersion) };
+            }
+            case PLUGIN_RPC.UPDATE: {
+                const packageName = stringField(message, 'packageName');
+                const targetVersion = stringField(message, 'targetVersion');
+                if (!packageName || !targetVersion) {
+                    return { requestId, error: 'packageName and targetVersion are required' };
+                }
+                if (!ctx.pluginManagement?.update)
+                    return { requestId, error: 'Plugin update is not configured' };
+                const result = await ctx.pluginManagement.update(packageName, targetVersion, optionalString(message.expectedRevision));
+                ctx.publishEvent?.('plugin:updated', {
+                    packageName,
+                    version: result.installedVersion,
+                    restartRequired: result.restartRequired,
+                });
+                return { requestId, data: { success: true, ...result } };
+            }
+            case PLUGIN_RPC.VALIDATE_CONFIG: {
+                const pluginName = stringField(message, 'pluginName');
+                if (!pluginName)
+                    return { requestId, error: 'pluginName is required' };
+                if (!ctx.validatePluginConfig)
+                    return { requestId, error: 'Config validation is not configured' };
+                return { requestId, data: await ctx.validatePluginConfig(pluginName, message.data) };
+            }
+            case PLUGIN_RPC.DIAGNOSE: {
+                const pluginName = stringField(message, 'pluginName');
+                if (!pluginName)
+                    return { requestId, error: 'pluginName is required' };
+                if (!ctx.diagnosePlugin)
+                    return { requestId, error: 'Plugin diagnostics are not configured' };
+                return { requestId, data: await ctx.diagnosePlugin(pluginName) };
+            }
+            default:
+                return undefined;
+        }
+    }
+    catch (error) {
+        return { requestId, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function stringField(message, key) {
+    const value = message[key];
+    return typeof value === 'string' ? value.trim() : '';
+}
+function optionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}

package/lib/console-rest-pages.d.ts

@@ -29,7 +29,7 @@ export interface ConsoleRestCtx {
     /** Distinguishes a real IM conversation with no Agent turn from a typo key. */
     readonly isKnownConversationSession?: (sessionKey: string) => boolean | undefined | Promise<boolean | undefined>;
 }
-/** 内省数据门面 — 由 basic/cli 用 agent 包 collectIntrospection* 装配。 */
+/** 内省数据门面 — 由 composition root 从当前 Runtime snapshot 装配。 */
 export interface ConsoleAgentIntrospection {
     commands?(): readonly unknown[];
     middlewares?(): readonly unknown[];

package/lib/console-rest-pages.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { HttpBodyError, readJsonBody } from './json-body.js';
+import { MarketplaceRegistry } from './marketplace-registry.js';
 const INTROSPECTION_PAGE_SIZES = {
     commands: 25,
     middlewares: 30,
@@ -11,7 +12,6 @@ const INTROSPECTION_PAGE_SIZES = {
     bindings: 30,
     mcp: 30,
 };
-let pluginsCache = null;
 const PLUGINS_CACHE_TTL = 5 * 60 * 1000;
 /**
  * 注册 Console 页面 REST 路由。返回注销函数（注销全部已注册路由）。
@@ -175,20 +175,11 @@ function registerLogsRoutes(route, base, ctx) {
 // marketplace（legacy marketplace-rest-api.ts；plugins.json + npmmirror）
 // ---------------------------------------------------------------------------
 function registerMarketplaceRoutes(route, base, ctx, fetchFn, pluginRegistryUrl, npmRegistryUrl) {
-    const fetchPluginRegistry = async () => {
-        if (pluginsCache && Date.now() - pluginsCache.ts < PLUGINS_CACHE_TTL) {
-            return pluginsCache.data;
-        }
-        const resp = await fetchFn(pluginRegistryUrl, {
-            signal: AbortSignal.timeout(30_000),
-        });
-        if (!resp.ok)
-            throw new Error(`plugins.json fetch failed: ${resp.status}`);
-        const json = (await resp.json());
-        const list = json.plugins || [];
-        pluginsCache = { data: list, ts: Date.now() };
-        return list;
-    };
+    const registry = new MarketplaceRegistry({
+        fetchFn,
+        url: pluginRegistryUrl,
+        ttlMs: PLUGINS_CACHE_TTL,
+    });
     route('GET', '/pub/marketplace/search', async (_request, response, url) => {
         const q = url.searchParams.get('q') ?? url.searchParams.get('keyword') ?? '';
         const pageNum = Math.max(1, parseInt(url.searchParams.get('page') ?? '1', 10) || 1);
@@ -197,7 +188,7 @@ function registerMarketplaceRoutes(route, base, ctx, fetchFn, pluginRegistryUrl,
         const official = url.searchParams.get('official') ?? undefined;
         const searchKeyword = q.trim().toLowerCase();
         try {
-            const allPlugins = (await fetchPluginRegistry());
+            const allPlugins = (await registry.list());
             let plugins = allPlugins.map((p) => ({
                 name: p.name,
                 displayName: p.displayName || '',
@@ -259,8 +250,8 @@ function registerMarketplaceRoutes(route, base, ctx, fetchFn, pluginRegistryUrl,
         try {
             let cachedDownloads = { weekly: 0, monthly: 0 };
             try {
-                const registry = (await fetchPluginRegistry());
-                const cached = registry.find((p) => p.name === pkgName);
+                const registryPlugins = (await registry.list());
+                const cached = registryPlugins.find((p) => p.name === pkgName);
                 if (cached?.downloads && typeof cached.downloads === 'object') {
                     cachedDownloads = cached.downloads;
                 }
@@ -379,7 +370,7 @@ async function listInstalledPluginPackages(projectRoot) {
     }));
 }
 // ---------------------------------------------------------------------------
-// introspection（legacy introspection-rest-api.ts；分页形状对齐 IntrospectionJsonResponse）
+// Runtime snapshot introspection
 // ---------------------------------------------------------------------------
 function registerIntrospectionRoutes(route, base, ctx, options) {
     const collectors = [
@@ -822,7 +813,7 @@ function parseSessionAction(pathname, prefix, action) {
     return { sessionKey: decodePathParam(rawKey) };
 }
 // ---------------------------------------------------------------------------
-// 内部分页 / 过滤（语义对齐 agent 包 introspection-pagination.ts）
+// 内部分页 / 过滤
 // ---------------------------------------------------------------------------
 function paginateItems(all, page, pageSize) {
     const total = all.length;

package/lib/{console-rpc-extended.d.ts → console-rpc-extended/contracts.d.ts}

@@ -1,21 +1,3 @@
-/**
- * Extended Console RPC: cron/schedule + endpoint social/inbox surface.
- *
- * 挂在 `dispatchRuntimeConsoleRpc`（console-rpc.ts）之后的第二级 dispatch：
- * 返回 `undefined` 表示不识别该 type，由调用方继续走默认分支；
- * 识别后返回 `{ data }` 或 `{ error }`（requestId 由调用方补齐）。
- *
- * 数据源约定（只读真实数据源，不做内存假数据）：
- * - cron：`ctx.scheduleHost`（Plugin Runtime ScheduleHost，仅 register/list，
- *   无持久化引擎，故 cron:add/remove/pause/resume 报"未接线"）。
- * - request.list：优先 `management.listRequests()`（live endpoint）；否则回退
- *   unified_inbox_request。审批始终走 approveRequest/rejectRequest。
- * - inbox（历史）：`ctx.databaseHost.models`（unified_inbox_message/request/notice，
- *   表不存在或查询失败 → 空数组 + inboxEnabled:false；requestConsumed/noticeConsumed
- *   按行 id update consumed=1，表/model 缺失时报"未接线"）。
- * - 社交/群管：`ctx.withEndpointManagement` 在固定 generation lease 内
- *   消费 `management` 语义端口；平台 SDK 字段归一化由 Adapter 负责。
- */
 export interface ConsoleRpcExtendedCtx {
     /** full scope 才允许写操作；demo scope 只放行只读 RPC。 */
     fullScope: boolean;
@@ -134,7 +116,28 @@ export type ExtendedRpcResult = {
 } | {
     error: string;
 };
-interface EndpointManagementPort {
+export interface ScheduleJobRow {
+    id: string;
+    cron: string;
+    description?: string;
+}
+export interface InboxSelection {
+    where(query: Record<string, unknown>): InboxSelection;
+    /** 可选：DB 侧排序下推（wrapModel 链具备该能力，轻量 fake 可缺失）。 */
+    orderBy?(field: string, direction?: 'ASC' | 'DESC'): InboxSelection;
+    /** 可选：DB 侧 limit 下推。 */
+    limit?(count: number): InboxSelection;
+    /** 可选：DB 侧 offset 下推。 */
+    offset?(count: number): InboxSelection;
+    then<TResult1 = Record<string, unknown>[], TResult2 = never>(onfulfilled?: ((value: Record<string, unknown>[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+}
+export interface InboxModel {
+    select(): InboxSelection;
+    update?(patch: Record<string, unknown>): {
+        where(query: Record<string, unknown>): Promise<unknown> | unknown;
+    };
+}
+export interface EndpointManagementPort {
     listFriends?(): Promise<readonly {
         user_id: number | string;
         nickname: string;
@@ -172,5 +175,3 @@ interface EndpointManagementPort {
     setGroupAdmin?(groupId: string, userId: string, enabled: boolean): Promise<void>;
     deleteFriend?(userId: string): Promise<void>;
 }
-export declare function dispatchExtendedConsoleRpc(type: string, data: Record<string, unknown> | undefined, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult | undefined>;
-export {};

package/lib/console-rpc-extended/contracts.js

@@ -0,0 +1,4 @@
+const CRON_NOT_WIRED = '持久化调度未接线：当前 Plugin Runtime ScheduleHost 仅支持插件注册的内存任务（list），' +
+    '不支持 add/remove/pause/resume（需要 @zhin.js/agent 持久化调度引擎）';
+const CONSUMED_NOT_WIRED = '收件箱已读标记未接线：unified_inbox_request/notice 表未注册或 DatabaseHost 未启动';
+export {};

package/lib/console-rpc-extended/dispatcher.d.ts

@@ -0,0 +1,2 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare function dispatchExtendedConsoleRpc(type: string, data: Record<string, unknown> | undefined, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult | undefined>;

package/lib/console-rpc-extended/dispatcher.js

@@ -0,0 +1,92 @@
+import { assertDemoConsoleRpcAllowed } from '@zhin.js/console-protocol';
+import { addCron, listSchedule, mutateCron } from './schedule-rpc.js';
+import { actOnRequest, listInbox, listInboxMessages, listPendingRequests, listRecentInboxMessages, mapNoticeRow, mapRequestRow, markInboxConsumed, TABLE_NOTICE, TABLE_REQUEST, } from './inbox-rpc.js';
+import { cancelLogin, listLoginPending, submitLogin } from './login-rpc.js';
+import { deleteFriend, groupWriteOp, listChannels, listFriends, listGroupMembers, listGroups, } from './endpoint-rpc.js';
+import { mutateWorkroomKnowledge, mutateWorkroomProfile } from './workroom-rpc.js';
+export async function dispatchExtendedConsoleRpc(type, data, ctx) {
+    const d = data ?? {};
+    if (!ctx.fullScope) {
+        const denied = assertDemoConsoleRpcAllowed(type);
+        if (denied)
+            return { error: denied };
+    }
+    switch (type) {
+        case 'schedule:list':
+        case 'cron:list':
+            return listSchedule(ctx);
+        case 'cron:add':
+            return addCron(d, ctx);
+        case 'cron:remove':
+        case 'cron:pause':
+        case 'cron:resume':
+            return mutateCron(type, d, ctx);
+        case 'request.list':
+            return listPendingRequests(d, ctx);
+        case 'inbox.requests':
+            return listInbox(d, ctx, TABLE_REQUEST, 'requests', mapRequestRow);
+        case 'inbox.notices':
+            return listInbox(d, ctx, TABLE_NOTICE, 'notices', mapNoticeRow);
+        case 'inbox.messages':
+            return listInboxMessages(d, ctx);
+        case 'inbox.recent':
+            return listRecentInboxMessages(d, ctx);
+        case 'request.approve':
+        case 'request.reject':
+            return actOnRequest(type, d, ctx);
+        case 'login.list':
+            return listLoginPending(ctx);
+        case 'login.submit':
+            return submitLogin(d, ctx);
+        case 'login.cancel':
+            return cancelLogin(d, ctx);
+        case 'request.consumed':
+            return markInboxConsumed(d, ctx, TABLE_REQUEST);
+        case 'notice.consumed':
+            return markInboxConsumed(d, ctx, TABLE_NOTICE);
+        case 'endpoint.friends':
+            return listFriends(d, ctx);
+        case 'endpoint.groups':
+            return listGroups(d, ctx);
+        case 'endpoint.channels':
+            return listChannels(d, ctx);
+        case 'endpoint.group_members':
+            return listGroupMembers(d, ctx);
+        case 'endpoint.group_kick':
+            return groupWriteOp(d, ctx, {
+                method: 'kickGroupMember',
+                buildArgs: (gid, uid) => [gid, uid],
+                requireUser: true,
+                unsupported: '踢出群成员',
+            });
+        case 'endpoint.group_mute':
+            return groupWriteOp(d, ctx, {
+                method: 'muteGroupMember',
+                buildArgs: (gid, uid, extra) => [gid, uid, extra.duration ?? 600],
+                requireUser: true,
+                unsupported: '禁言群成员',
+            });
+        case 'endpoint.group_admin':
+            return groupWriteOp(d, ctx, {
+                method: 'setGroupAdmin',
+                buildArgs: (gid, uid, extra) => [gid, uid, extra.enable !== false],
+                requireUser: true,
+                unsupported: '设置群管理员',
+            });
+        case 'endpoint.delete_friend':
+            return deleteFriend(d, ctx);
+        case 'workroom.profile.status':
+        case 'workroom.profile.bootstrap':
+        case 'workroom.profile.pack.publish':
+        case 'workroom.profile.publish':
+        case 'workroom.profile.rollback':
+        case 'workroom.profile.policy.publish':
+            return mutateWorkroomProfile(type, d, ctx);
+        case 'workroom.knowledge.get':
+        case 'workroom.knowledge.publish':
+        case 'workroom.knowledge.rollback':
+            return mutateWorkroomKnowledge(type, d, ctx);
+        default:
+            return undefined;
+    }
+}

package/lib/console-rpc-extended/endpoint-rpc.d.ts

@@ -0,0 +1,24 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare function listFriends(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function listGroups(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function listChannels(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function listGroupMembers(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+interface GroupWriteSpec {
+    method: 'kickGroupMember' | 'muteGroupMember' | 'setGroupAdmin';
+    buildArgs(groupId: string, userId: string, extra: {
+        duration?: number;
+        enable?: boolean;
+    }): unknown[];
+    requireUser: boolean;
+    /** 中文操作名，用于"该平台不支持 xxx"。 */
+    unsupported: string;
+}
+export declare function groupWriteOp(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx, spec: GroupWriteSpec): Promise<ExtendedRpcResult>;
+export declare function deleteFriend(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function normalizeParent(raw: unknown): {
+    type: 'group' | 'guild';
+    id: string;
+    name?: string;
+} | undefined;
+export declare function channelFromStoredRow(row: Record<string, unknown>): Record<string, unknown>;
+export {};

package/lib/console-rpc-extended/endpoint-rpc.js

@@ -0,0 +1,137 @@
+import { strField, withLiveEndpoint } from './rpc-values.js';
+export async function listFriends(d, ctx) {
+    const endpoint = requireEndpointAddress(d);
+    if ('error' in endpoint)
+        return endpoint;
+    return withLiveEndpoint(ctx, endpoint.adapter, endpoint.endpointKey, async (management) => {
+        if (management.listFriends) {
+            const friends = [...await management.listFriends()];
+            return { data: { friends, count: friends.length } };
+        }
+        return { error: `当前适配器（${endpoint.adapter}）不支持好友列表` };
+    });
+}
+export async function listGroups(d, ctx) {
+    const endpoint = requireEndpointAddress(d);
+    if ('error' in endpoint)
+        return endpoint;
+    return withLiveEndpoint(ctx, endpoint.adapter, endpoint.endpointKey, async (management) => {
+        if (management.listGroups) {
+            const groups = [...await management.listGroups()];
+            return { data: { groups, count: groups.length } };
+        }
+        return { error: `当前适配器（${endpoint.adapter}）不支持群列表` };
+    });
+}
+export async function listChannels(d, ctx) {
+    const endpoint = requireEndpointAddress(d);
+    if ('error' in endpoint)
+        return endpoint;
+    return withLiveEndpoint(ctx, endpoint.adapter, endpoint.endpointKey, async (management) => {
+        if (management.listChannels) {
+            const channels = [...await management.listChannels()];
+            return { data: { channels, count: channels.length } };
+        }
+        return { error: `当前适配器（${endpoint.adapter}）不支持频道列表` };
+    });
+}
+export async function listGroupMembers(d, ctx) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    const groupId = strField(d, 'groupId');
+    if (!adapter || !endpointKey || !groupId) {
+        return { error: 'adapter, endpointKey, and groupId are required' };
+    }
+    return withLiveEndpoint(ctx, adapter, endpointKey, async (management) => {
+        const method = management.listGroupMembers;
+        if (!method) {
+            return { error: `当前适配器（${adapter}）不支持群成员列表` };
+        }
+        const members = [...await method(groupId)];
+        return { data: { members, count: members.length } };
+    });
+}
+export async function groupWriteOp(d, ctx, spec) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    const groupId = strField(d, 'groupId');
+    const userId = strField(d, 'userId');
+    if (!adapter || !endpointKey || !groupId) {
+        return { error: 'adapter, endpointKey, and groupId are required' };
+    }
+    if (spec.requireUser && !userId) {
+        return { error: 'userId is required' };
+    }
+    return withLiveEndpoint(ctx, adapter, endpointKey, async (management) => {
+        const method = management[spec.method];
+        if (!method) {
+            return { error: `当前适配器（${adapter}）不支持${spec.unsupported}` };
+        }
+        const durationRaw = d.duration;
+        const enableRaw = d.enable;
+        const args = spec.buildArgs(groupId, userId, {
+            duration: typeof durationRaw === 'number' && Number.isFinite(durationRaw)
+                ? durationRaw
+                : undefined,
+            enable: typeof enableRaw === 'boolean' ? enableRaw : undefined,
+        });
+        await method.call(management, ...args);
+        return { data: { success: true } };
+    });
+}
+export async function deleteFriend(d, ctx) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    const userId = strField(d, 'userId');
+    if (!adapter || !endpointKey || !userId) {
+        return { error: 'adapter, endpointKey, and userId are required' };
+    }
+    return withLiveEndpoint(ctx, adapter, endpointKey, async (management) => {
+        const method = management.deleteFriend;
+        if (!method) {
+            return { error: '当前适配器暂不支持删除好友' };
+        }
+        await method(userId);
+        return { data: { success: true } };
+    });
+}
+// ---------------------------------------------------------------- helpers
+function requireEndpointAddress(d) {
+    const adapter = strField(d, 'adapter');
+    const endpointKey = strField(d, 'endpointKey');
+    if (!adapter || !endpointKey)
+        return { error: 'adapter and endpointKey are required' };
+    return { adapter, endpointKey };
+}
+export function normalizeParent(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const parent = raw;
+    const id = typeof parent.id === 'string' && parent.id.trim() ? parent.id.trim() : undefined;
+    if (!id)
+        return undefined;
+    let type;
+    if (parent.type === 'group' || parent.type === 'guild')
+        type = parent.type;
+    else if (parent.type === 'channel')
+        type = 'guild';
+    if (!type)
+        return undefined;
+    const name = typeof parent.name === 'string' && parent.name.trim() ? parent.name.trim() : undefined;
+    return name ? { type, id, name } : { type, id };
+}
+export function channelFromStoredRow(row) {
+    const parent = parentFromStoredRow(row);
+    return {
+        id: String(row.channel_id ?? ''),
+        type: String(row.channel_type ?? ''),
+        ...(row.channel_name != null ? { name: String(row.channel_name) } : {}),
+        ...(parent ? { parent } : {}),
+    };
+}
+function parentFromStoredRow(row) {
+    return normalizeParent({
+        type: row.channel_parent_type,
+        id: row.channel_parent_id,
+    });
+}

package/lib/console-rpc-extended/inbox-rpc.d.ts

@@ -0,0 +1,23 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+export declare const TABLE_MESSAGE = "unified_inbox_message";
+export declare const TABLE_REQUEST = "unified_inbox_request";
+export declare const TABLE_NOTICE = "unified_inbox_notice";
+export declare function listInbox(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx, table: string, key: 'requests' | 'notices', mapRow: (row: Record<string, unknown>) => Record<string, unknown>): Promise<ExtendedRpcResult>;
+/** request.list —— 优先 live EndpointManagement.listRequests；否则回退 unified_inbox_request。 */
+export declare function listPendingRequests(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function listInboxMessages(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+/**
+ * Cross-endpoint recent inbox used by paired Mobile Console clients.
+ * Unlike endpoint-detail `inbox.messages`, every row carries its complete
+ * routable address so selecting a conversation can safely call
+ * `endpoint.send_message` through the Device Protocol write allowlist.
+ */
+export declare function listRecentInboxMessages(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;
+export declare function mapRequestRow(row: Record<string, unknown>): Record<string, unknown>;
+export declare function mapNoticeRow(row: Record<string, unknown>): Record<string, unknown>;
+/**
+ * request.consumed / notice.consumed —— 按行 id 置 consumed=1。
+ * 表未注册（或 model 无 update）时保持"未接线"报错。
+ */
+export declare function markInboxConsumed(d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx, table: string): Promise<ExtendedRpcResult>;
+export declare function actOnRequest(type: 'request.approve' | 'request.reject', d: Record<string, unknown>, ctx: ConsoleRpcExtendedCtx): Promise<ExtendedRpcResult>;