@zhin.js/host-http 1.0.1 → 1.0.2

package/lib/console-rpc-extended.js

@@ -9,90 +9,82 @@
  * - cron：`ctx.scheduleHost`（Plugin Runtime ScheduleHost，仅 register/list，
  *   无持久化引擎，故 cron:add/remove/pause/resume 报"未接线"）。
  * - inbox：`ctx.databaseHost.models`（unified_inbox_message/request/notice 三张表，
- *   表不存在或查询失败 → 空数组 + inboxEnabled:false）。
- * - 社交/群管：`ctx.resolveEndpoint` 拿 live endpoint 实例，
- *   实例上探测到对应方法才调用，否则报"该平台不支持"。
+ *   表不存在或查询失败 → 空数组 + inboxEnabled:false；requestConsumed/noticeConsumed
+ *   按行 id update consumed=1，表/model 缺失时报"未接线"）。
+ * - 社交/群管：`ctx.resolveEndpoint` 拿 live endpoint 实例，只消费其
+ *   `management` 语义端口；平台 SDK 兼容与字段归一化由 Adapter 负责。
  */
-/** 新 Runtime 统一收件箱表名（与 packages/im/zhin/src/setup/register-inbox.ts 一致）。 */
+/** 新 Runtime 统一收件箱表名（SSOT：@zhin.js/plugin-runtime inbox.js）。 */
+import { assertDemoConsoleRpcAllowed, normalizeConsoleRpcType, } from '@zhin.js/console-protocol';
 const TABLE_MESSAGE = 'unified_inbox_message';
 const TABLE_REQUEST = 'unified_inbox_request';
 const TABLE_NOTICE = 'unified_inbox_notice';
-/** demo scope 只读放行清单之外的写操作 type。 */
-const WRITE_TYPES = new Set([
-    'cron:add',
-    'cron:remove',
-    'cron:pause',
-    'cron:resume',
-    'endpoint:requestApprove',
-    'endpoint:requestReject',
-    'endpoint:requestConsumed',
-    'endpoint:noticeConsumed',
-    'endpoint:groupKick',
-    'endpoint:groupMute',
-    'endpoint:groupAdmin',
-    'endpoint:deleteFriend',
-]);
 const CRON_NOT_WIRED = '持久化调度未接线：当前 Plugin Runtime ScheduleHost 仅支持插件注册的内存任务（list），' +
     '不支持 add/remove/pause/resume（需要 @zhin.js/agent 持久化调度引擎）';
-const CONSUMED_NOT_WIRED = '收件箱已读标记未接线：新 Runtime 尚未提供 request/notice 的 consumed 写路径';
+const CONSUMED_NOT_WIRED = '收件箱已读标记未接线：unified_inbox_request/notice 表未注册或 DatabaseHost 未启动';
 export async function dispatchExtendedConsoleRpc(type, data, ctx) {
     const d = data ?? {};
-    if (WRITE_TYPES.has(type) && !ctx.fullScope) {
-        return { error: `Demo scope: RPC "${type}" is forbidden` };
+    type = normalizeConsoleRpcType(type);
+    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 { error: CRON_NOT_WIRED };
-        case 'endpoint:requests':
+            return mutateCron(type, d, ctx);
+        case 'request.list':
             return listPendingRequests(d, ctx);
-        case 'endpoint:inboxRequests':
+        case 'inbox.requests':
             return listInbox(d, ctx, TABLE_REQUEST, 'requests', mapRequestRow);
-        case 'endpoint:inboxNotices':
+        case 'inbox.notices':
             return listInbox(d, ctx, TABLE_NOTICE, 'notices', mapNoticeRow);
-        case 'endpoint:inboxMessages':
+        case 'inbox.messages':
             return listInboxMessages(d, ctx);
-        case 'endpoint:requestApprove':
-        case 'endpoint:requestReject':
+        case 'request.approve':
+        case 'request.reject':
             return actOnRequest(type, d, ctx);
-        case 'endpoint:requestConsumed':
-        case 'endpoint:noticeConsumed':
-            return { error: CONSUMED_NOT_WIRED };
-        case 'endpoint:friends':
+        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':
+        case 'endpoint.groups':
             return listGroups(d, ctx);
-        case 'endpoint:channels':
+        case 'endpoint.channels':
             return listChannels(d, ctx);
-        case 'endpoint:groupMembers':
+        case 'endpoint.group_members':
             return listGroupMembers(d, ctx);
-        case 'endpoint:groupKick':
+        case 'endpoint.group_kick':
             return groupWriteOp(d, ctx, {
-                methods: ['removeMember', 'kickMember', 'setGroupKick'],
+                method: 'kickGroupMember',
                 buildArgs: (gid, uid) => [gid, uid],
                 requireUser: true,
                 unsupported: '踢出群成员',
             });
-        case 'endpoint:groupMute':
+        case 'endpoint.group_mute':
             return groupWriteOp(d, ctx, {
-                methods: ['muteMember', 'setGroupBan', 'banMember'],
+                method: 'muteGroupMember',
                 buildArgs: (gid, uid, extra) => [gid, uid, extra.duration ?? 600],
                 requireUser: true,
                 unsupported: '禁言群成员',
             });
-        case 'endpoint:groupAdmin':
+        case 'endpoint.group_admin':
             return groupWriteOp(d, ctx, {
-                methods: ['setModerator', 'setGroupAdmin', 'setAdmin'],
+                method: 'setGroupAdmin',
                 buildArgs: (gid, uid, extra) => [gid, uid, extra.enable !== false],
                 requireUser: true,
                 unsupported: '设置群管理员',
             });
-        case 'endpoint:deleteFriend':
+        case 'endpoint.delete_friend':
             return deleteFriend(d, ctx);
         default:
             return undefined;
@@ -114,9 +106,91 @@ function listSchedule(ctx) {
             id: job.id,
             cron: job.cron,
             ...(typeof job.description === 'string' ? { description: job.description } : {}),
+            // console cron 页渲染字段（由 schedule host 提供时透传）
+            expression: job.expression ?? job.cron,
+            running: job.running ?? true,
+            ...(job.plugin ? { plugin: job.plugin } : {}),
+            ...(job.nextExecution
+                ? { nextExecution: job.nextExecution } : {}),
         }));
-        // persistent 引擎未接入新 Runtime，返回空数组保持 legacy 形状。
-        return { data: { memory, persistent: [] } };
+        return listPersistentJobs(ctx).then((persistent) => ({ data: { memory, persistent } }));
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+/** 持久化任务（Agent Host ScheduleJobEngine）→ 前端 PersistentCron 形状。 */
+async function listPersistentJobs(ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return [];
+    try {
+        const jobs = await engine.listJobs();
+        return jobs.map((job) => ({
+            id: job.id,
+            label: job.label ?? job.id,
+            cronExpression: job.schedule?.cron ?? '',
+            prompt: job.action?.prompt ?? '',
+            enabled: job.enabled !== false,
+            source: job.source ?? 'manual',
+            createdAt: job.createdAt,
+            nextExecution: job.state?.nextRunAtMs,
+            ...(job.notify?.target
+                ? { context: { target: job.notify.target } } : {}),
+            lastExecutedAt: job.state?.lastExecutedAt,
+            lastStatus: job.state?.lastStatus,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function addCron(d, ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return { error: CRON_NOT_WIRED };
+    const cronExpression = String(d.cronExpression ?? '').trim();
+    const prompt = String(d.prompt ?? '').trim();
+    if (!cronExpression)
+        return { error: 'cronExpression is required' };
+    if (!prompt)
+        return { error: 'prompt is required' };
+    const label = typeof d.label === 'string' && d.label.trim() ? d.label.trim() : undefined;
+    const context = (d.context ?? {});
+    const target = context.target ?? context.channel;
+    const job = {
+        id: `console-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`,
+        ...(label ? { label } : {}),
+        enabled: true,
+        schedule: { kind: 'solar', cron: cronExpression },
+        action: { kind: 'agent', prompt },
+        notify: target
+            ? { channel: 'im', target }
+            : { channel: 'silent' },
+        source: 'manual',
+    };
+    try {
+        const created = await engine.addJob(job);
+        return { data: { job: created, success: true } };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+async function mutateCron(type, d, ctx) {
+    const engine = ctx.resolveScheduleEngine?.();
+    if (!engine)
+        return { error: CRON_NOT_WIRED };
+    const id = String(d.id ?? '').trim();
+    if (!id)
+        return { error: 'id is required' };
+    try {
+        const ok = type === 'cron:remove'
+            ? await engine.removeJob(id)
+            : type === 'cron:pause'
+                ? await engine.pauseJob(id)
+                : await engine.resumeJob(id);
+        return ok ? { data: { success: true } } : { error: `任务不存在: ${id}` };
     }
     catch (error) {
         return { error: errorMessage(error) };
@@ -160,7 +234,7 @@ async function listInbox(d, ctx, table, key, mapRow) {
         .map(mapRow);
     return { data: { [key]: sorted, inboxEnabled: enabled } };
 }
-/** endpoint:requests —— 未处理的好友/群请求（unified_inbox_request 中 resolved=0）。 */
+/** request.list —— 未处理的好友/群请求（unified_inbox_request 中 resolved=0）。 */
 async function listPendingRequests(d, ctx) {
     const adapter = strField(d, '$adapter', 'adapter');
     const endpointId = strField(d, '$endpoint', 'endpointId', 'endpoint');
@@ -218,56 +292,105 @@ async function listInboxMessages(d, ctx) {
     return { data: { messages, inboxEnabled: enabled } };
 }
 function mapRequestRow(row) {
+    const actorId = row.actor_id;
+    const actorName = row.actor_name ?? undefined;
+    const sceneId = row.scene_id;
+    const sceneType = row.scene_type ?? undefined;
     return {
         id: row.id,
         platform_request_id: row.platform_request_id,
+        // console endpoint-detail 期望的 camelCase/扁平别名（SSE 推送路径同款形状）
+        platformRequestId: row.platform_request_id,
         type: row.type,
-        scene_type: row.scene_type ?? undefined,
-        scene_id: row.scene_id,
+        scene_type: sceneType,
+        scene_id: sceneId,
+        channel_id: sceneId,
+        channel_type: sceneType,
+        channel: { id: sceneId, type: sceneType },
         sub_type: row.sub_type ?? undefined,
-        actor: { id: row.actor_id, name: row.actor_name ?? undefined },
+        actor: { id: actorId, name: actorName },
+        sender: { id: actorId, name: actorName },
+        sender_id: actorId,
+        sender_name: actorName,
         comment: row.comment ?? undefined,
         created_at: row.created_at,
+        timestamp: row.created_at,
         resolved: row.resolved,
         resolved_at: row.resolved_at ?? undefined,
     };
 }
 function mapNoticeRow(row) {
+    const actorId = row.actor_id ?? undefined;
+    const actorName = row.actor_name ?? undefined;
+    const sceneId = row.scene_id;
+    const sceneType = row.scene_type ?? undefined;
     return {
         id: row.id,
         platform_notice_id: row.platform_notice_id,
         type: row.type,
-        scene_type: row.scene_type ?? undefined,
-        scene_id: row.scene_id,
+        scene_type: sceneType,
+        scene_id: sceneId,
+        channel_id: sceneId,
+        channel_type: sceneType,
         sub_type: row.sub_type ?? undefined,
-        actor_id: row.actor_id ?? undefined,
-        actor_name: row.actor_name ?? undefined,
+        actor_id: actorId,
+        actor_name: actorName,
+        // console endpoint-detail 期望的操作人字段别名
+        operator_id: actorId,
+        operator_name: actorName,
         target_id: row.target_id ?? undefined,
         target_name: row.target_name ?? undefined,
         payload: row.payload,
         created_at: row.created_at,
+        timestamp: row.created_at,
     };
 }
+// ---------------------------------------------------------------- consumed 标记
+/**
+ * request.consumed / notice.consumed —— 按行 id 置 consumed=1。
+ * 表未注册（或 model 无 update）时保持"未接线"报错。
+ */
+async function markInboxConsumed(d, ctx, table) {
+    const ids = numArrayField(d, '$row_ids', 'row_ids', 'rowIds', '$ids', 'ids');
+    // console UI 单条已读发 data:{id}，归一为数组
+    if (ids.length === 0) {
+        const single = Number(d.id ?? d.$id);
+        if (Number.isFinite(single) && single > 0)
+            ids.push(single);
+    }
+    if (ids.length === 0)
+        return { error: '$row_ids required' };
+    const model = getInboxModel(ctx, table);
+    if (!model || typeof model.update !== 'function')
+        return { error: CONSUMED_NOT_WIRED };
+    const now = Date.now();
+    try {
+        for (const id of ids) {
+            await model.update({ consumed: 1, consumed_at: now }).where({ id });
+        }
+        return { data: { success: true, updated: ids.length } };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
 // ---------------------------------------------------------------- 请求审批
 async function actOnRequest(type, d, ctx) {
     const adapter = strField(d, '$adapter', 'adapter');
     const endpointId = strField(d, '$endpoint', 'endpointId', 'endpoint');
-    const requestId = strField(d, '$id', 'id', 'platformRequestId', 'platform_request_id');
+    const requestId = strField(d, '$id', 'id', 'platformRequestId', 'platform_request_id', 'requestId');
     if (!adapter || !endpointId || !requestId) {
         return { error: '$adapter, $endpoint, $id required' };
     }
     const resolved = resolveLiveEndpoint(ctx, adapter, endpointId);
     if ('error' in resolved)
         return resolved;
-    const endpoint = resolved.endpoint;
-    const approve = type === 'endpoint:requestApprove';
-    const methodNames = approve
-        ? ['approveRequest', 'approve_request', '$approveRequest']
-        : ['rejectRequest', 'reject_request', '$rejectRequest'];
-    const method = pickMethod(endpoint, methodNames);
+    const management = resolved.management;
+    const approve = type === 'request.approve';
+    const method = approve ? management.approveRequest : management.rejectRequest;
     if (!method) {
         return {
-            error: `请求审批未接线：当前平台（${adapter}）endpoint 不支持 ${methodNames[0]}，` +
+            error: `请求审批未接线：当前平台（${adapter}）endpoint 不支持 ${approve ? 'approveRequest' : 'rejectRequest'}，` +
                 '且新 Runtime 尚未挂载 pending request 注册表',
         };
     }
@@ -275,7 +398,7 @@ async function actOnRequest(type, d, ctx) {
         const extra = approve
             ? strField(d, '$remark', 'remark')
             : strField(d, '$reason', 'reason');
-        await method.call(endpoint, requestId, extra || undefined);
+        await method.call(management, requestId, extra || undefined);
         return { data: { success: true } };
     }
     catch (error) {
@@ -287,25 +410,10 @@ async function listFriends(d, ctx) {
     const resolved = requireEndpoint(d, ctx);
     if ('error' in resolved)
         return resolved;
-    const { endpoint, adapter } = resolved;
+    const { management, adapter } = resolved;
     try {
-        const map = (endpoint.friends ?? endpoint.fl);
-        if (map && typeof map.values === 'function') {
-            const friends = Array.from(map.values()).map((f) => ({
-                user_id: Number(f.user_id),
-                nickname: String(f.nickname ?? ''),
-                remark: String(f.remark ?? ''),
-            }));
-            return { data: { friends, count: friends.length } };
-        }
-        const getFriendList = pickMethod(endpoint, ['getFriendList', 'getFriends', 'listFriends']);
-        if (getFriendList) {
-            const raw = await getFriendList.call(endpoint);
-            const friends = unwrapList(raw).map((row) => ({
-                user_id: Number(row.user_id ?? row.userId ?? row.id ?? 0),
-                nickname: String(row.nickname ?? row.name ?? row.user_id ?? ''),
-                remark: String(row.remark ?? ''),
-            }));
+        if (management.listFriends) {
+            const friends = [...await management.listFriends()];
             return { data: { friends, count: friends.length } };
         }
         return { error: `当前适配器（${adapter}）不支持好友列表` };
@@ -318,23 +426,10 @@ async function listGroups(d, ctx) {
     const resolved = requireEndpoint(d, ctx);
     if ('error' in resolved)
         return resolved;
-    const { endpoint, adapter } = resolved;
+    const { management, adapter } = resolved;
     try {
-        const map = (endpoint.groups ?? endpoint.gl);
-        if (map && typeof map.values === 'function') {
-            const groups = Array.from(map.values()).map((g) => ({
-                group_id: Number(g.group_id),
-                name: String(g.group_name ?? g.name ?? g.group_id ?? ''),
-            }));
-            return { data: { groups, count: groups.length } };
-        }
-        const getGroupList = pickMethod(endpoint, ['getGroupList', 'getGroups', 'listGroups']);
-        if (getGroupList) {
-            const raw = await getGroupList.call(endpoint);
-            const groups = unwrapList(raw).map((row) => ({
-                group_id: Number(row.group_id ?? row.groupId ?? row.id ?? 0),
-                name: String(row.name ?? row.group_name ?? row.group_id ?? ''),
-            }));
+        if (management.listGroups) {
+            const groups = [...await management.listGroups()];
             return { data: { groups, count: groups.length } };
         }
         return { error: `当前适配器（${adapter}）不支持群列表` };
@@ -347,40 +442,10 @@ async function listChannels(d, ctx) {
     const resolved = requireEndpoint(d, ctx);
     if ('error' in resolved)
         return resolved;
-    const { endpoint, adapter } = resolved;
+    const { management, adapter } = resolved;
     try {
-        const channels = [];
-        const getGuildChannelList = pickMethod(endpoint, ['getGuildChannelList']);
-        if (getGuildChannelList) {
-            const list = await getGuildChannelList.call(endpoint);
-            for (const item of Array.isArray(list) ? list : []) {
-                const parent = normalizeParent(item.parent);
-                channels.push({
-                    id: String(item.id ?? ''),
-                    ...(item.name != null ? { name: String(item.name) } : {}),
-                    ...(parent ? { parent } : {}),
-                });
-            }
-            return { data: { channels, count: channels.length } };
-        }
-        const getGuilds = pickMethod(endpoint, ['getGuilds', 'listGuilds']);
-        const getChannels = pickMethod(endpoint, ['getChannels', 'listChannels']);
-        if (getGuilds && getChannels) {
-            const guilds = unwrapList(await getGuilds.call(endpoint));
-            for (const g of guilds) {
-                const gid = String(g.id ?? g.guild_id ?? '');
-                if (!gid)
-                    continue;
-                const guildName = String(g.name ?? g.guild_name ?? gid);
-                const chs = unwrapList(await getChannels.call(endpoint, gid));
-                for (const c of chs) {
-                    channels.push({
-                        id: String(c.id ?? c.channel_id ?? ''),
-                        name: String(c.name ?? c.channel_name ?? c.id ?? ''),
-                        parent: { type: 'guild', id: gid, name: guildName },
-                    });
-                }
-            }
+        if (management.listChannels) {
+            const channels = [...await management.listChannels()];
             return { data: { channels, count: channels.length } };
         }
         return { error: `当前适配器（${adapter}）不支持频道列表` };
@@ -399,22 +464,14 @@ async function listGroupMembers(d, ctx) {
     const resolved = resolveLiveEndpoint(ctx, adapter, endpointId);
     if ('error' in resolved)
         return resolved;
-    const { endpoint } = resolved;
+    const { management } = resolved;
     try {
-        const method = pickMethod(endpoint, ['getGroupMemberList', 'listMembers', 'getMemberList']);
+        const method = management.listGroupMembers;
         if (!method) {
             return { error: `当前适配器（${adapter}）不支持群成员列表` };
         }
-        const raw = await method.call(endpoint, groupId);
-        if (Array.isArray(raw)) {
-            return { data: { members: raw, count: raw.length } };
-        }
-        // Map（icqq 风格 gml）→ values 数组
-        if (raw && typeof raw.values === 'function') {
-            const members = Array.from(raw.values());
-            return { data: { members, count: members.length } };
-        }
-        return { data: raw ?? { members: [], count: 0 } };
+        const members = [...await method(groupId)];
+        return { data: { members, count: members.length } };
     }
     catch (error) {
         return { error: errorMessage(error) };
@@ -434,8 +491,8 @@ async function groupWriteOp(d, ctx, spec) {
     const resolved = resolveLiveEndpoint(ctx, adapter, endpointId);
     if ('error' in resolved)
         return resolved;
-    const { endpoint } = resolved;
-    const method = pickMethod(endpoint, spec.methods);
+    const { management } = resolved;
+    const method = management[spec.method];
     if (!method) {
         return { error: `当前适配器（${adapter}）不支持${spec.unsupported}` };
     }
@@ -448,7 +505,7 @@ async function groupWriteOp(d, ctx, spec) {
                 : undefined,
             enable: typeof enableRaw === 'boolean' ? enableRaw : undefined,
         });
-        await method.call(endpoint, ...args);
+        await method.call(management, ...args);
         return { data: { success: true } };
     }
     catch (error) {
@@ -465,14 +522,13 @@ async function deleteFriend(d, ctx) {
     const resolved = resolveLiveEndpoint(ctx, adapter, endpointId);
     if ('error' in resolved)
         return resolved;
-    const { endpoint } = resolved;
-    const method = pickMethod(endpoint, ['deleteFriend', 'delete_friend']);
+    const { management } = resolved;
+    const method = management.deleteFriend;
     if (!method) {
         return { error: '当前适配器暂不支持删除好友' };
     }
     try {
-        const numeric = Number(userId);
-        await method.call(endpoint, Number.isFinite(numeric) && userId.trim() !== '' ? numeric : userId);
+        await method(userId);
         return { data: { success: true } };
     }
     catch (error) {
@@ -508,15 +564,25 @@ function optionalNum(d, ...keys) {
     }
     return undefined;
 }
-function pickMethod(endpoint, names) {
-    for (const name of names) {
-        const fn = endpoint[name];
-        if (typeof fn === 'function')
-            return fn;
+/** 数字数组字段（$row_ids 等）：取首个数组值，收敛为有限数字。 */
+function numArrayField(d, ...keys) {
+    for (const key of keys) {
+        const value = d[key];
+        if (!Array.isArray(value))
+            continue;
+        return value
+            .map((item) => Number(item))
+            .filter((item) => Number.isFinite(item));
     }
-    return undefined;
+    return [];
 }
 function resolveLiveEndpoint(ctx, adapter, endpointId) {
+    if (ctx.resolveEndpointManagement) {
+        const management = ctx.resolveEndpointManagement(adapter, endpointId);
+        if (!management)
+            return { error: 'endpoint not found' };
+        return { management, adapter, endpointId };
+    }
     if (!ctx.resolveEndpoint) {
         return { error: 'Endpoint registry is not configured' };
     }
@@ -524,7 +590,14 @@ function resolveLiveEndpoint(ctx, adapter, endpointId) {
     if (!endpoint || typeof endpoint !== 'object') {
         return { error: 'endpoint not found' };
     }
-    return { endpoint: endpoint, adapter, endpointId };
+    const management = endpoint.management;
+    return {
+        management: management && typeof management === 'object'
+            ? management
+            : {},
+        adapter,
+        endpointId,
+    };
 }
 function requireEndpoint(d, ctx) {
     const adapter = strField(d, '$adapter', 'adapter');
@@ -533,15 +606,6 @@ function requireEndpoint(d, ctx) {
         return { error: '$adapter and $endpoint required' };
     return resolveLiveEndpoint(ctx, adapter, endpointId);
 }
-/** 兼容数组 / `{ data: [...] }` / `{ list: [...] }` 的列表返回。 */
-function unwrapList(raw) {
-    const arr = Array.isArray(raw)
-        ? raw
-        : raw && typeof raw === 'object'
-            ? (raw.data ?? raw.list)
-            : undefined;
-    return (Array.isArray(arr) ? arr : []).filter((item) => !!item && typeof item === 'object');
-}
 function normalizeParent(raw) {
     if (!raw || typeof raw !== 'object')
         return undefined;

package/lib/console-rpc.d.ts

@@ -1,5 +1,6 @@
 import type { AuthScope } from './token-registry.js';
 import type { DatabaseHostConsole } from '@zhin.js/plugin-runtime';
+import { type ConsoleEndpointSummary } from '@zhin.js/console-protocol';
 import { type ConsoleRpcExtendedCtx } from './console-rpc-extended.js';
 export type RuntimeConsoleRpcMessage = {
     readonly type?: unknown;
@@ -63,18 +64,17 @@ export type RuntimeConsoleRpcContext = {
     database?: DatabaseHostConsole;
     /** Full-scope: request process restart (CLI daemon watches exit code). */
     requestRestart?(): Promise<void> | void;
+    /**
+     * Optional console event sink (`/api/events` SSE fan-out). Called after
+     * successful mutations: `config:updated` / `system:restarting`.
+     */
+    publishEvent?(type: string, data: unknown): void;
     /** Extended RPC surface（cron/schedule、endpoint 社交/inbox），fullScope 由 authScope 推导。 */
     extended?: Omit<ConsoleRpcExtendedCtx, 'fullScope'>;
 };
-export type RuntimeEndpointPhase = 'pending' | 'starting' | 'online' | 'failed' | 'unconfigured';
-export type RuntimeEndpointSummary = {
-    readonly name: string;
-    readonly adapter: string;
-    readonly connected: boolean;
-    readonly status: 'online' | 'offline';
-    readonly phase?: RuntimeEndpointPhase;
-    readonly pendingLogin?: boolean;
-};
+export type RuntimeEndpointPhase = NonNullable<ConsoleEndpointSummary['phase']>;
+/** @deprecated Prefer `ConsoleEndpointSummary` from `@zhin.js/console-protocol`. */
+export type RuntimeEndpointSummary = ConsoleEndpointSummary;
 export type RuntimeDatabaseInfo = {
     readonly dialect: string | null;
     readonly connected: boolean;