@zhin.js/host-http 1.0.10 → 1.0.12

package/src/console-rpc-extended.ts

@@ -8,7 +8,9 @@
  * 数据源约定（只读真实数据源，不做内存假数据）：
  * - cron：`ctx.scheduleHost`（Plugin Runtime ScheduleHost，仅 register/list，
  *   无持久化引擎，故 cron:add/remove/pause/resume 报"未接线"）。
- * - inbox：`ctx.databaseHost.models`（unified_inbox_message/request/notice 三张表，
+ * - 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 内
@@ -24,6 +26,7 @@ import {
 const TABLE_MESSAGE = 'unified_inbox_message';
 const TABLE_REQUEST = 'unified_inbox_request';
 const TABLE_NOTICE = 'unified_inbox_notice';
+const MAX_INBOX_OFFSET = 10_000;
 
 export interface ConsoleRpcExtendedCtx {
   /** full scope 才允许写操作；demo scope 只放行只读 RPC。 */
@@ -39,8 +42,65 @@ export interface ConsoleRpcExtendedCtx {
   ) => Promise<T | null>;
   /** Plugin Runtime DatabaseHost 的 models 视图。 */
   databaseHost?: { models: { get(name: string): unknown } };
-  /** Agent Host 持久化调度引擎（@zhin.js/agent getAssistantRuntime().engine），未 init 时返回 null。 */
+  /** Narrow generation-bound persistent-job port; null when Assistant is disabled. */
   resolveScheduleEngine?: () => ConsoleScheduleEngine | null | undefined;
+  /** LoginAssist list/submit/cancel（刷新后仍可消费扫码/滑块待办）。 */
+  loginAssist?: {
+    listPending(): readonly {
+      id: string;
+      adapter: string;
+      endpointKey: string;
+      type: string;
+      payload: Record<string, unknown>;
+      createdAt: number;
+      expiresAt?: number;
+    }[];
+    submit(id: string, value: string | Record<string, unknown>): boolean;
+    cancel(id: string, reason?: string): boolean;
+  };
+  /** Authenticated Root adapter; mutation DTOs deliberately contain no principal/decision fields. */
+  workroomProfileControl?: ConsoleWorkroomProfileControlPort;
+  /** Authenticated HTTP principal; never accepted from the RPC body. */
+  authenticatedPrincipal?: Readonly<{ principalId: string }>;
+  workroomKnowledgeControl?: ConsoleWorkroomKnowledgeControlPort;
+}
+
+export interface ConsoleWorkroomProfileControlPort {
+  publishPack(command: Readonly<{ operationId: string; pack: unknown }>,
+    authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
+  publishProfile(command: Readonly<{
+    operationId: string;
+    projectId: string;
+    expectedRegistryRevision: number;
+    overlay: unknown;
+    activate: boolean;
+  }>, authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
+  publishRollback(command: Readonly<{
+    operationId: string;
+    projectId: string;
+    expectedRegistryRevision: number;
+    restoredFromRevisionId: string;
+    overlay: unknown;
+    activate: boolean;
+  }>, authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
+  publishPlanningPolicy(command: Readonly<{
+    operationId: string;
+    projectId: string;
+    profileRevisionId: string;
+    revision: number;
+    expectedPreviousDigest?: string;
+    policy: unknown;
+  }>, authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
+}
+
+export interface ConsoleWorkroomKnowledgeControlPort {
+  read(projectId: string): Promise<unknown>;
+  publish(command: Readonly<{
+    operationId: string; projectId: string; expectedRevision: number; entries: readonly unknown[];
+  }>, authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
+  rollback(command: Readonly<{
+    operationId: string; projectId: string; expectedRevision: number; restoreRevision: number;
+  }>, authenticatedPrincipal: Readonly<{ principalId: string }>): Promise<unknown>;
 }
 
 export interface ConsoleScheduleEngine {
@@ -72,6 +132,8 @@ interface InboxSelection {
   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,
@@ -94,6 +156,17 @@ interface EndpointManagementPort {
     parent?: { type: string; id: string; name?: string };
   }[]>;
   listGroupMembers?(groupId: string): Promise<readonly unknown[]>;
+  listRequests?(): Promise<readonly {
+    platform_request_id: string;
+    type: string;
+    scene_type?: string | null;
+    scene_id: string;
+    sub_type?: string | null;
+    actor_id: string;
+    actor_name?: string | null;
+    comment?: string | null;
+    created_at: number;
+  }[]>;
   approveRequest?(requestId: string, remark?: string): Promise<void>;
   rejectRequest?(requestId: string, reason?: string): Promise<void>;
   kickGroupMember?(groupId: string, userId: string): Promise<void>;
@@ -140,6 +213,13 @@ export async function dispatchExtendedConsoleRpc(
     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':
@@ -178,11 +258,132 @@ export async function dispatchExtendedConsoleRpc(
     case 'endpoint.delete_friend':
       return deleteFriend(d, ctx);
 
+    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;
   }
 }
 
+async function mutateWorkroomProfile(
+  type: 'workroom.profile.pack.publish' | 'workroom.profile.publish'
+    | 'workroom.profile.rollback' | 'workroom.profile.policy.publish',
+  data: Record<string, unknown>,
+  ctx: ConsoleRpcExtendedCtx,
+): Promise<ExtendedRpcResult> {
+  const control = ctx.workroomProfileControl;
+  if (!control) return { error: 'Workroom Profile authority control is unavailable' };
+  for (const forbidden of [
+    'authenticatedPrincipalId', 'principalId', 'decision', 'governance', 'approval', 'authority',
+  ]) {
+    if (forbidden in data) return { error: `Console Workroom Profile request cannot carry ${forbidden}` };
+  }
+  const principal = ctx.authenticatedPrincipal;
+  if (!principal) return { error: 'Workroom Profile control requires an authenticated principal' };
+  try {
+    const operationId = requiredRpcText(data.operationId, 'operationId');
+    if (type === 'workroom.profile.pack.publish') {
+      return { data: await control.publishPack(Object.freeze({ operationId, pack: requiredRpcValue(data.pack, 'pack') }), principal) };
+    }
+    const projectId = requiredRpcText(data.projectId, 'projectId');
+    if (type === 'workroom.profile.policy.publish') {
+      const expectedPreviousDigest = optionalRpcText(data.expectedPreviousDigest, 'expectedPreviousDigest');
+      return { data: await control.publishPlanningPolicy(Object.freeze({
+        operationId,
+        projectId,
+        profileRevisionId: requiredRpcText(data.profileRevisionId, 'profileRevisionId'),
+        revision: requiredRpcInteger(data.revision, 'revision'),
+        ...(expectedPreviousDigest ? { expectedPreviousDigest } : {}),
+        policy: requiredRpcValue(data.policy, 'policy'),
+      }), principal) };
+    }
+    const common = {
+      operationId,
+      projectId,
+      expectedRegistryRevision: requiredRpcInteger(data.expectedRegistryRevision, 'expectedRegistryRevision', -1),
+      overlay: requiredRpcValue(data.overlay, 'overlay'),
+      activate: requiredRpcBoolean(data.activate, 'activate'),
+    };
+    return type === 'workroom.profile.rollback'
+      ? { data: await control.publishRollback(Object.freeze({
+          ...common,
+          restoredFromRevisionId: requiredRpcText(data.restoredFromRevisionId, 'restoredFromRevisionId'),
+        }), principal) }
+      : { data: await control.publishProfile(Object.freeze(common), principal) };
+  } catch (error) {
+    return { error: errorMessage(error) };
+  }
+}
+
+async function mutateWorkroomKnowledge(
+  type: 'workroom.knowledge.get' | 'workroom.knowledge.publish' | 'workroom.knowledge.rollback',
+  data: Record<string, unknown>,
+  ctx: ConsoleRpcExtendedCtx,
+): Promise<ExtendedRpcResult> {
+  const control = ctx.workroomKnowledgeControl;
+  if (!control) return { error: 'Workroom Knowledge control is unavailable' };
+  for (const forbidden of [
+    'authenticatedPrincipalId', 'principalId', 'ownerPrincipalId', 'source', 'decision',
+    'governance', 'approval', 'authority', 'body', 'content',
+  ]) {
+    if (forbidden in data) return { error: `Console Workroom Knowledge request cannot carry ${forbidden}` };
+  }
+  try {
+    const projectId = requiredRpcText(data.projectId, 'projectId');
+    if (type === 'workroom.knowledge.get') return { data: await control.read(projectId) };
+    const principal = ctx.authenticatedPrincipal;
+    if (!principal) return { error: 'Workroom Knowledge mutation requires an authenticated principal' };
+    const common = {
+      operationId: requiredRpcText(data.operationId, 'operationId'), projectId,
+      expectedRevision: requiredRpcInteger(data.expectedRevision, 'expectedRevision', -1),
+    };
+    if (type === 'workroom.knowledge.rollback') {
+      return { data: await control.rollback(Object.freeze({
+        ...common, restoreRevision: requiredRpcInteger(data.restoreRevision, 'restoreRevision', 0),
+      }), principal) };
+    }
+    if (!Array.isArray(data.entries)) throw new Error('entries is invalid');
+    return { data: await control.publish(Object.freeze({ ...common, entries: structuredClone(data.entries) }), principal) };
+  } catch (error) {
+    return { error: errorMessage(error) };
+  }
+}
+
+function requiredRpcValue(value: unknown, name: string): unknown {
+  if (value === undefined || value === null) throw new Error(`${name} is required`);
+  return structuredClone(value);
+}
+
+function requiredRpcText(value: unknown, name: string): string {
+  if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
+    throw new Error(`${name} is invalid`);
+  }
+  return value;
+}
+
+function optionalRpcText(value: unknown, name: string): string | undefined {
+  return value === undefined ? undefined : requiredRpcText(value, name);
+}
+
+function requiredRpcInteger(value: unknown, name: string, minimum = 1): number {
+  if (!Number.isSafeInteger(value) || Number(value) < minimum) throw new Error(`${name} is invalid`);
+  return Number(value);
+}
+
+function requiredRpcBoolean(value: unknown, name: string): boolean {
+  if (typeof value !== 'boolean') throw new Error(`${name} is invalid`);
+  return value;
+}
+
 // ---------------------------------------------------------------- cron
 
 function listSchedule(ctx: ConsoleScheduleListCtx): Promise<ExtendedRpcResult> | ExtendedRpcResult {
@@ -311,23 +512,34 @@ async function readInboxRows(
     orderBy?: { field: string; direction?: 'ASC' | 'DESC' };
     /** DB 侧 limit 下推（模型不支持时由调用方内存分页兜底）。 */
     limit?: number;
+    /** DB 侧 offset 下推（模型不支持时由调用方内存分页兜底）。 */
+    offset?: number;
   },
-): Promise<{ rows: Record<string, unknown>[]; enabled: boolean }> {
+): Promise<{ rows: Record<string, unknown>[]; enabled: boolean; offsetApplied: boolean }> {
   const model = getInboxModel(ctx, table);
-  if (!model) return { rows: [], enabled: false };
+  if (!model) return { rows: [], enabled: false, offsetApplied: false };
   try {
     let selection: InboxSelection = model.select().where(where);
+    let orderApplied = options?.orderBy == null;
     if (options?.orderBy && typeof selection.orderBy === 'function') {
       selection = selection.orderBy(options.orderBy.field, options.orderBy.direction ?? 'DESC');
+      orderApplied = true;
     }
-    if (options?.limit != null && typeof selection.limit === 'function') {
-      selection = selection.limit(options.limit);
+    const offset = options?.offset ?? 0;
+    const offsetSelection = orderApplied ? selection.offset : undefined;
+    const canApplyOffset = typeof offsetSelection === 'function';
+    const offsetApplied = offset === 0 || canApplyOffset;
+    if (offset > 0 && canApplyOffset) {
+      selection = offsetSelection.call(selection, offset);
+    }
+    if (options?.limit != null && orderApplied && typeof selection.limit === 'function') {
+      selection = selection.limit(options.limit + (offsetApplied ? 0 : offset));
     }
     const rows = await selection;
-    return { rows: Array.isArray(rows) ? rows : [], enabled: true };
+    return { rows: Array.isArray(rows) ? rows : [], enabled: true, offsetApplied };
   } catch {
     // 表未创建 / 方言未启动等场景降级为空，不向上抛。
-    return { rows: [], enabled: false };
+    return { rows: [], enabled: false, offsetApplied: false };
   }
 }
 
@@ -341,25 +553,31 @@ async function listInbox(
   const adapter = strField(d, '$adapter', 'adapter');
   const endpointKey = strField(d, '$endpoint', 'endpointKey', 'endpoint');
   if (!adapter || !endpointKey) return { error: '$adapter and $endpoint required' };
-  const limit = Math.min(numField(d, 30, '$limit', 'limit'), 100);
-  const offset = Math.max(0, numField(d, 0, '$offset', 'offset'));
-  const { rows, enabled } = await readInboxRows(ctx, table, {
+  const limit = boundedIntegerField(d, 30, 1, 100, '$limit', 'limit');
+  const offset = boundedIntegerField(
+    d, 0, 0, MAX_INBOX_OFFSET, '$offset', 'offset',
+  );
+  const unreadOnly = table === TABLE_NOTICE
+    && boolField(d, false, '$unread_only', 'unreadOnly', 'unread_only');
+  const { rows, enabled, offsetApplied } = await readInboxRows(ctx, table, {
     adapter,
     endpoint_id: endpointKey,
+    ...(unreadOnly ? { consumed: 0 } : {}),
   }, {
     // sort/limit 下推到 DB 侧（内存 sort/slice 保留，作为无下推能力模型的兜底）
     orderBy: { field: 'created_at', direction: 'DESC' },
-    limit: offset + limit,
+    limit,
+    offset,
   });
   const sorted = rows
     .slice()
     .sort((a, b) => Number(b.created_at ?? 0) - Number(a.created_at ?? 0))
-    .slice(offset, offset + limit)
+    .slice(offsetApplied ? 0 : offset, (offsetApplied ? 0 : offset) + limit)
     .map(mapRow);
   return { data: { [key]: sorted, inboxEnabled: enabled } };
 }
 
-/** request.list —— 未处理的好友/群请求（unified_inbox_request 中 resolved=0）。 */
+/** request.list —— 优先 live EndpointManagement.listRequests；否则回退 unified_inbox_request。 */
 async function listPendingRequests(
   d: Record<string, unknown>,
   ctx: ConsoleRpcExtendedCtx,
@@ -367,6 +585,32 @@ async function listPendingRequests(
   const adapter = strField(d, '$adapter', 'adapter');
   const endpointKey = strField(d, '$endpoint', 'endpointKey', 'endpoint');
   if (!adapter || !endpointKey) return { error: '$adapter and $endpoint required' };
+
+  if (ctx.withEndpointManagement) {
+    try {
+      const live = await ctx.withEndpointManagement(adapter, endpointKey, async (management) => {
+        if (!management.listRequests) return undefined;
+        const pending = await management.listRequests();
+        const requests = pending.map((row) => mapRequestRow({
+          platform_request_id: row.platform_request_id,
+          type: row.type,
+          scene_type: row.scene_type ?? null,
+          scene_id: row.scene_id,
+          sub_type: row.sub_type ?? null,
+          actor_id: row.actor_id,
+          actor_name: row.actor_name ?? null,
+          comment: row.comment ?? null,
+          created_at: row.created_at,
+          resolved: 0,
+        }));
+        return { data: { requests, inboxEnabled: false, source: 'endpoint' } };
+      });
+      if (live) return live;
+    } catch (error) {
+      return { error: errorMessage(error) };
+    }
+  }
+
   const { rows, enabled } = await readInboxRows(ctx, TABLE_REQUEST, {
     adapter,
     endpoint_id: endpointKey,
@@ -377,7 +621,7 @@ async function listPendingRequests(
     .filter((row) => Number(row.resolved ?? 0) === 0)
     .sort((a, b) => Number(a.created_at ?? 0) - Number(b.created_at ?? 0))
     .map(mapRequestRow);
-  return { data: { requests, inboxEnabled: enabled } };
+  return { data: { requests, inboxEnabled: enabled, source: 'inbox' } };
 }
 
 async function listInboxMessages(
@@ -391,7 +635,7 @@ async function listInboxMessages(
   if (!adapter || !endpointKey || !channelId || !channelType) {
     return { error: '$adapter, $endpoint, $channel_id, $channel_type required' };
   }
-  const limit = Math.min(numField(d, 50, '$limit', 'limit'), 100);
+  const limit = boundedIntegerField(d, 50, 1, 100, '$limit', 'limit');
   const beforeTs = optionalNum(d, '$before_ts', 'beforeTs', 'before_ts');
   const beforeId = optionalNum(d, '$before_id', 'beforeId', 'before_id');
   const parent = normalizeParent(d.$parent ?? d.parent);
@@ -461,16 +705,18 @@ function mapRequestRow(row: Record<string, unknown>): Record<string, unknown> {
 function mapNoticeRow(row: Record<string, unknown>): Record<string, unknown> {
   const actorId = row.actor_id ?? undefined;
   const actorName = row.actor_name ?? undefined;
-  const sceneId = row.scene_id;
-  const sceneType = row.scene_type ?? undefined;
+  const sceneId = String(row.scene_id ?? '');
+  const sceneType = row.scene_type == null ? undefined : String(row.scene_type);
   return {
     id: row.id,
     platform_notice_id: row.platform_notice_id,
     type: row.type,
+    noticeType: row.type,
     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: actorId,
     actor_name: actorName,
@@ -482,6 +728,8 @@ function mapNoticeRow(row: Record<string, unknown>): Record<string, unknown> {
     payload: row.payload,
     created_at: row.created_at,
     timestamp: row.created_at,
+    consumed: row.consumed,
+    consumed_at: row.consumed_at ?? undefined,
   };
 }
 
@@ -546,6 +794,52 @@ async function actOnRequest(
   });
 }
 
+function listLoginPending(ctx: ConsoleRpcExtendedCtx): ExtendedRpcResult {
+  const assist = ctx.loginAssist;
+  if (!assist) return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+  const tasks = assist.listPending().map((task) => ({
+    id: task.id,
+    adapter: task.adapter,
+    endpointKey: task.endpointKey,
+    type: task.type,
+    payload: task.payload,
+    createdAt: task.createdAt,
+    expiresAt: task.expiresAt,
+  }));
+  return { data: { tasks, count: tasks.length } };
+}
+
+function submitLogin(
+  d: Record<string, unknown>,
+  ctx: ConsoleRpcExtendedCtx,
+): ExtendedRpcResult {
+  const assist = ctx.loginAssist;
+  if (!assist) return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+  const id = strField(d, '$id', 'id', 'taskId');
+  if (!id) return { error: '$id required' };
+  const raw = d.$value ?? d.value ?? d.ticket ?? d.code ?? '';
+  const value = typeof raw === 'string' || (raw && typeof raw === 'object')
+    ? raw as string | Record<string, unknown>
+    : String(raw ?? '');
+  const ok = assist.submit(id, value);
+  if (!ok) return { error: `login task not found: ${id}` };
+  return { data: { success: true } };
+}
+
+function cancelLogin(
+  d: Record<string, unknown>,
+  ctx: ConsoleRpcExtendedCtx,
+): ExtendedRpcResult {
+  const assist = ctx.loginAssist;
+  if (!assist) return { error: '登录辅助未接线（LoginAssist 未挂载）' };
+  const id = strField(d, '$id', 'id', 'taskId');
+  if (!id) return { error: '$id required' };
+  const reason = strField(d, '$reason', 'reason') || 'cancelled';
+  const ok = assist.cancel(id, reason);
+  if (!ok) return { error: `login task not found: ${id}` };
+  return { data: { success: true } };
+}
+
 // ---------------------------------------------------------------- 社交读取
 
 async function listFriends(
@@ -695,6 +989,26 @@ function numField(d: Record<string, unknown>, fallback: number, ...keys: string[
   return fallback;
 }
 
+function boundedIntegerField(
+  d: Record<string, unknown>,
+  fallback: number,
+  minimum: number,
+  maximum: number,
+  ...keys: string[]
+): number {
+  const value = numField(d, fallback, ...keys);
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(maximum, Math.max(minimum, Math.trunc(value)));
+}
+
+function boolField(d: Record<string, unknown>, fallback: boolean, ...keys: string[]): boolean {
+  for (const key of keys) {
+    const value = d[key];
+    if (typeof value === 'boolean') return value;
+  }
+  return fallback;
+}
+
 function optionalNum(d: Record<string, unknown>, ...keys: string[]): number | undefined {
   for (const key of keys) {
     if (d[key] == null) continue;

package/src/console-rpc.ts

@@ -81,6 +81,16 @@ export type RuntimeConsoleRpcContext = {
    * Returns whether a process restart is required (always true without ConfigFeature).
    */
   setConfigKey?(pluginName: string, data: unknown): Promise<{ restartRequired: boolean }>;
+  /** Atomic, revision-checked runtime Workroom Catalog read/write. */
+  readWorkroomCatalog?(): Promise<Readonly<{
+    agents: Readonly<Record<string, unknown>>;
+    workrooms: Readonly<Record<string, unknown>>;
+    revision: string;
+  }>>;
+  setWorkroomCatalog?(
+    workrooms: unknown,
+    expectedRevision: string,
+  ): Promise<Readonly<{ revision: string; restartRequired: boolean }>>;
   /** Project file manager (allowlisted paths under project root). */
   listProjectFiles?(): Promise<readonly unknown[]>;
   readProjectFile?(filePath: string): Promise<{ content: string; size: number }>;
@@ -240,6 +250,39 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
+    case 'workrooms:get': {
+      try {
+        if (!ctx.readWorkroomCatalog) {
+          emit({ requestId, error: 'Workroom Catalog read is not configured' });
+          return payloads;
+        }
+        emit({ requestId, data: await ctx.readWorkroomCatalog() });
+      } catch (error) {
+        emit({ requestId, error: error instanceof Error ? error.message : String(error) });
+      }
+      return payloads;
+    }
+    case 'workrooms:set': {
+      try {
+        if (!ctx.setWorkroomCatalog) {
+          emit({ requestId, error: 'Workroom Catalog write is not configured' });
+          return payloads;
+        }
+        const expectedRevision = typeof message.expectedRevision === 'string'
+          ? message.expectedRevision
+          : '';
+        if (!/^[a-f0-9]{64}$/u.test(expectedRevision)) {
+          emit({ requestId, error: 'expectedRevision is required' });
+          return payloads;
+        }
+        const result = await ctx.setWorkroomCatalog(message.data, expectedRevision);
+        ctx.publishEvent?.('workrooms:updated', { revision: result.revision });
+        emit({ requestId, data: { success: true, ...result } });
+      } catch (error) {
+        emit({ requestId, error: error instanceof Error ? error.message : String(error) });
+      }
+      return payloads;
+    }
     case 'config:save-yaml': {
       try {
         const yaml = message.yaml;
@@ -758,6 +801,8 @@ export function isDemoHttpAllowed(method: string, pathname: string, apiBase: str
   const normalizedBase = apiBase.replace(/\/$/u, '') || '/api';
   const m = method.toUpperCase();
   if (m === 'GET' && pathname === `${normalizedBase}/events`) return true;
+  if (m === 'GET' && pathname === `${normalizedBase}/events/history`) return true;
+  if (m === 'GET' && DEMO_INTROSPECTION_PATHS.has(pathname.slice(normalizedBase.length))) return true;
   if (m === 'POST' && pathname === `${normalizedBase}/console/request`) return true;
   // Read-only dashboard / plugin inspection routes (legacy host-api parity).
   if (m === 'GET' && pathname === `${normalizedBase}/system/status`) return true;
@@ -766,3 +811,13 @@ export function isDemoHttpAllowed(method: string, pathname: string, apiBase: str
     || pathname.startsWith(`${normalizedBase}/plugins/`))) return true;
   return false;
 }
+
+const DEMO_INTROSPECTION_PATHS: ReadonlySet<string> = new Set([
+  '/introspection/commands',
+  '/introspection/middlewares',
+  '/introspection/components',
+  '/introspection/endpoints',
+  '/introspection/bindings',
+  '/introspection/tools',
+  '/introspection/mcp',
+]);

package/src/http-host.ts

@@ -17,6 +17,7 @@ import {
   TokenRegistry,
   extractBearerToken,
   isDemoWebSocketPath,
+  type AuthenticatedTokenPrincipal,
   type AuthScope,
   type ScopedTokenConfig,
   type TokenRegistryConfig,
@@ -73,6 +74,7 @@ export type HttpHandler = (
   response: ServerResponse,
   url: URL,
   authScope: AuthScope,
+  authenticatedPrincipal?: AuthenticatedTokenPrincipal,
 ) => void | Promise<void>;
 
 export interface HttpRouteRegistration {
@@ -323,7 +325,7 @@ export function createHttpHost(options: HttpHostOptions = {}): ProcessHttpHost {
         return;
       }
       if (!release) {
-        await route.handler(request, response, url, auth.scope);
+        await route.handler(request, response, url, auth.scope, auth.principal);
         return;
       }
       let released = false;
@@ -336,7 +338,7 @@ export function createHttpHost(options: HttpHostOptions = {}): ProcessHttpHost {
       };
       response.once('finish', releaseResponse);
       response.once('close', releaseResponse);
-      await route.handler(request, response, url, auth.scope);
+      await route.handler(request, response, url, auth.scope, auth.principal);
       if (response.writableFinished || response.destroyed) releaseResponse();
     } catch (err) {
       // 统一把请求体错误（400/413）映射回对应状态码，
@@ -363,7 +365,7 @@ export function createHttpHost(options: HttpHostOptions = {}): ProcessHttpHost {
     request: IncomingMessage,
     url: URL,
     pathname: string,
-  ): { ok: true; scope: AuthScope } | { ok: false } {
+  ): { ok: true; scope: AuthScope; principal?: AuthenticatedTokenPrincipal } | { ok: false } {
     if (!requiresHttpAuth(pathname, apiBase, authExempt)) {
       return { ok: true, scope: 'full' };
     }
@@ -380,7 +382,8 @@ export function createHttpHost(options: HttpHostOptions = {}): ProcessHttpHost {
       const method = (request.method ?? 'GET').toUpperCase();
       if (!isDemoHttpAllowed(method, pathname, apiBase)) return { ok: false };
     }
-    return { ok: true, scope };
+    const principal = tokenRegistry.resolvePrincipal(token);
+    return { ok: true, scope, ...(principal ? { principal } : {}) };
   }
 
   function listListedRoutes(): readonly ListedRoute[] {

package/src/index.ts

@@ -15,6 +15,7 @@ export {
   TokenRegistry,
   extractBearerToken,
   isDemoWebSocketPath,
+  type AuthenticatedTokenPrincipal,
   type AuthScope,
   type ScopedTokenConfig,
   type TokenRegistryConfig,
@@ -70,5 +71,7 @@ export {
   dispatchExtendedConsoleRpc,
   type ConsoleRpcExtendedCtx,
   type ConsoleScheduleEngine,
+  type ConsoleWorkroomProfileControlPort,
+  type ConsoleWorkroomKnowledgeControlPort,
   type ExtendedRpcResult,
 } from './console-rpc-extended.js';