@zhin.js/host-http 1.0.10 → 1.0.12

package/lib/console-rpc-extended.js

@@ -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 内
@@ -19,6 +21,7 @@ import { assertDemoConsoleRpcAllowed, normalizeConsoleRpcType, } from '@zhin.js/
 const TABLE_MESSAGE = 'unified_inbox_message';
 const TABLE_REQUEST = 'unified_inbox_request';
 const TABLE_NOTICE = 'unified_inbox_notice';
+const MAX_INBOX_OFFSET = 10_000;
 const CRON_NOT_WIRED = '持久化调度未接线：当前 Plugin Runtime ScheduleHost 仅支持插件注册的内存任务（list），' +
     '不支持 add/remove/pause/resume（需要 @zhin.js/agent 持久化调度引擎）';
 const CONSUMED_NOT_WIRED = '收件箱已读标记未接线：unified_inbox_request/notice 表未注册或 DatabaseHost 未启动';
@@ -51,6 +54,12 @@ export async function dispatchExtendedConsoleRpc(type, data, 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':
@@ -86,10 +95,126 @@ export async function dispatchExtendedConsoleRpc(type, data, ctx) {
             });
         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, data, ctx) {
+    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, data, ctx) {
+    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, name) {
+    if (value === undefined || value === null)
+        throw new Error(`${name} is required`);
+    return structuredClone(value);
+}
+function requiredRpcText(value, name) {
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
+        throw new Error(`${name} is invalid`);
+    }
+    return value;
+}
+function optionalRpcText(value, name) {
+    return value === undefined ? undefined : requiredRpcText(value, name);
+}
+function requiredRpcInteger(value, name, minimum = 1) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum)
+        throw new Error(`${name} is invalid`);
+    return Number(value);
+}
+function requiredRpcBoolean(value, name) {
+    if (typeof value !== 'boolean')
+        throw new Error(`${name} is invalid`);
+    return value;
+}
 // ---------------------------------------------------------------- cron
 function listSchedule(ctx) {
     const host = ctx.scheduleHost;
@@ -206,21 +331,30 @@ function getInboxModel(ctx, table) {
 async function readInboxRows(ctx, table, where, options) {
     const model = getInboxModel(ctx, table);
     if (!model)
-        return { rows: [], enabled: false };
+        return { rows: [], enabled: false, offsetApplied: false };
     try {
         let selection = 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;
+        }
+        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 && typeof selection.limit === 'function') {
-            selection = selection.limit(options.limit);
+        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 };
     }
 }
 async function listInbox(d, ctx, table, key, mapRow) {
@@ -228,29 +362,60 @@ async function listInbox(d, ctx, table, key, mapRow) {
     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, ctx) {
     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,
@@ -261,7 +426,7 @@ async function listPendingRequests(d, ctx) {
         .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(d, ctx) {
     const adapter = strField(d, '$adapter', 'adapter');
@@ -271,7 +436,7 @@ async function listInboxMessages(d, ctx) {
     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);
@@ -338,16 +503,18 @@ function mapRequestRow(row) {
 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;
+    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,
@@ -359,6 +526,8 @@ function mapNoticeRow(row) {
         payload: row.payload,
         created_at: row.created_at,
         timestamp: row.created_at,
+        consumed: row.consumed,
+        consumed_at: row.consumed_at ?? undefined,
     };
 }
 // ---------------------------------------------------------------- consumed 标记
@@ -414,6 +583,50 @@ async function actOnRequest(type, d, ctx) {
         return { data: { success: true } };
     });
 }
+function listLoginPending(ctx) {
+    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, ctx) {
+    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
+        : String(raw ?? '');
+    const ok = assist.submit(id, value);
+    if (!ok)
+        return { error: `login task not found: ${id}` };
+    return { data: { success: true } };
+}
+function cancelLogin(d, ctx) {
+    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(d, ctx) {
     const endpoint = requireEndpointAddress(d);
@@ -530,6 +743,20 @@ function numField(d, fallback, ...keys) {
     }
     return fallback;
 }
+function boundedIntegerField(d, fallback, minimum, maximum, ...keys) {
+    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, fallback, ...keys) {
+    for (const key of keys) {
+        const value = d[key];
+        if (typeof value === 'boolean')
+            return value;
+    }
+    return fallback;
+}
 function optionalNum(d, ...keys) {
     for (const key of keys) {
         if (d[key] == null)

package/lib/console-rpc.d.ts

@@ -50,6 +50,16 @@ export type RuntimeConsoleRpcContext = {
     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<{

package/lib/console-rpc.js

@@ -116,6 +116,41 @@ export async function dispatchRuntimeConsoleRpc(message, ctx) {
             }
             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;
@@ -664,6 +699,10 @@ export function isDemoHttpAllowed(method, pathname, apiBase) {
     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).
@@ -676,3 +715,12 @@ export function isDemoHttpAllowed(method, pathname, apiBase) {
         return true;
     return false;
 }
+const DEMO_INTROSPECTION_PATHS = new Set([
+    '/introspection/commands',
+    '/introspection/middlewares',
+    '/introspection/components',
+    '/introspection/endpoints',
+    '/introspection/bindings',
+    '/introspection/tools',
+    '/introspection/mcp',
+]);

package/lib/http-host.d.ts

@@ -1,7 +1,7 @@
 import { type IncomingMessage, type ServerResponse } from 'node:http';
 import { WebSocket } from 'ws';
 import { type GenerationAdmissionBindable } from '@zhin.js/plugin-runtime';
-import { TokenRegistry, type AuthScope, type ScopedTokenConfig } from './token-registry.js';
+import { TokenRegistry, type AuthenticatedTokenPrincipal, type AuthScope, type ScopedTokenConfig } from './token-registry.js';
 import { type ListedRoute, type RouteMeta } from './openapi.js';
 export declare const REMOTE_CONSOLE_ORIGIN = "https://console.zhin.dev";
 export interface WsConnection {
@@ -34,7 +34,7 @@ export interface HttpHostOptions {
     /** Extra HTTP path prefixes that skip auth even under `apiBase`. */
     readonly authExemptPaths?: readonly string[];
 }
-export type HttpHandler = (request: IncomingMessage, response: ServerResponse, url: URL, authScope: AuthScope) => void | Promise<void>;
+export type HttpHandler = (request: IncomingMessage, response: ServerResponse, url: URL, authScope: AuthScope, authenticatedPrincipal?: AuthenticatedTokenPrincipal) => void | Promise<void>;
 export interface HttpRouteRegistration {
     (): void;
 }

package/lib/http-host.js

@@ -218,7 +218,7 @@ export function createHttpHost(options = {}) {
                 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;
@@ -232,7 +232,7 @@ export function createHttpHost(options = {}) {
             };
             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();
         }
@@ -272,7 +272,8 @@ export function createHttpHost(options = {}) {
             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() {
         return Object.freeze(httpRoutes

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export { createHttpHost, httpHostToken, REMOTE_CONSOLE_ORIGIN, type HttpHandler, type HttpHost, type ProcessHttpHost, type HttpHostAddress, type HttpHostOptions, type HttpRouteRegistration, type WsConnection, type WsHandle, } from './http-host.js';
-export { TokenRegistry, extractBearerToken, isDemoWebSocketPath, type AuthScope, type ScopedTokenConfig, type TokenRegistryConfig, } from './token-registry.js';
+export { TokenRegistry, extractBearerToken, isDemoWebSocketPath, type AuthenticatedTokenPrincipal, type AuthScope, type ScopedTokenConfig, type TokenRegistryConfig, } from './token-registry.js';
 export { timingSafeEqualString } from './timing-safe-equal.js';
 export { createConsoleEventHub, type ConsoleEventHub, } from './console-events.js';
 export { buildOpenApiDocument, patternToOpenApiPath, routeRequiresBearerAuth, type BuildOpenApiOptions, type ListedRoute, type OpenApiParameter, type RouteMeta, } from './openapi.js';
@@ -7,4 +7,4 @@ export { HttpBodyError, readJsonBody, } from './json-body.js';
 export { dispatchRuntimeConsoleRpc, isDemoHttpAllowed, pickRpcReply, type RuntimeConsolePage, type RuntimeConsoleRpcContext, type RuntimeConsoleRpcMessage, type RuntimeConsoleRpcReply, type RuntimeEndpointSendInput, type RuntimeEndpointSummary, } from './console-rpc.js';
 export { buildProjectFileTree, FILE_MANAGER_ALLOWED, FILE_MANAGER_BLOCKED, isProjectPathAllowed, listEnvFiles, readProjectFile, saveProjectFile, type FileTreeNode, } from './project-files.js';
 export { registerConsoleRestPages, type ConsoleAgentIntrospection, type ConsoleAgentRuntime, type ConsoleAgentSessionTree, type ConsoleRestCtx, type ConsoleRestPagesOptions, } from './console-rest-pages.js';
-export { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx, type ConsoleScheduleEngine, type ExtendedRpcResult, } from './console-rpc-extended.js';
+export { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx, type ConsoleScheduleEngine, type ConsoleWorkroomProfileControlPort, type ConsoleWorkroomKnowledgeControlPort, type ExtendedRpcResult, } from './console-rpc-extended.js';

package/lib/token-registry.d.ts

@@ -3,7 +3,13 @@ export type AuthScope = 'full' | 'demo';
 export type ScopedTokenConfig = {
     readonly token: string;
     readonly scope: AuthScope;
+    /** Root-configured subject binding; never accepted from an HTTP payload. */
+    readonly principalId?: string;
 };
+export interface AuthenticatedTokenPrincipal {
+    readonly principalId: string;
+    readonly scope: AuthScope;
+}
 export type TokenRegistryConfig = {
     readonly primaryToken?: string;
     readonly scopedTokens?: readonly ScopedTokenConfig[];
@@ -12,6 +18,7 @@ export declare class TokenRegistry {
     #private;
     constructor(config?: TokenRegistryConfig);
     resolve(token: string): AuthScope | null;
+    resolvePrincipal(token: string): AuthenticatedTokenPrincipal | null;
     hasAnyToken(): boolean;
     primaryTokenPrefixForLog(): string;
 }

package/lib/token-registry.js

@@ -3,18 +3,39 @@ export class TokenRegistry {
     #entries = new Map();
     constructor(config = {}) {
         if (config.primaryToken)
-            this.#entries.set(config.primaryToken, 'full');
-        for (const { token, scope } of config.scopedTokens ?? []) {
-            if (token)
-                this.#entries.set(token, scope);
+            this.#entries.set(config.primaryToken, Object.freeze({ scope: 'full' }));
+        for (const { token, scope, principalId } of config.scopedTokens ?? []) {
+            if (!token)
+                continue;
+            if (principalId !== undefined && (!principalId.trim() || principalId !== principalId.trim())) {
+                throw new Error('HTTP token principalId is invalid');
+            }
+            const candidate = Object.freeze({ scope, ...(principalId === undefined ? {} : { principalId }) });
+            const existing = this.#entries.get(token);
+            if (existing && (existing.scope !== candidate.scope || existing.principalId !== candidate.principalId)) {
+                throw new Error('HTTP token has conflicting authority bindings');
+            }
+            this.#entries.set(token, candidate);
         }
     }
     resolve(token) {
         if (!token)
             return null;
-        for (const [known, scope] of this.#entries) {
+        for (const [known, binding] of this.#entries) {
             if (timingSafeEqualString(known, token))
-                return scope;
+                return binding.scope;
+        }
+        return null;
+    }
+    resolvePrincipal(token) {
+        if (!token)
+            return null;
+        for (const [known, binding] of this.#entries) {
+            if (timingSafeEqualString(known, token)) {
+                return binding.principalId
+                    ? Object.freeze({ principalId: binding.principalId, scope: binding.scope })
+                    : null;
+            }
         }
         return null;
     }
@@ -22,8 +43,8 @@ export class TokenRegistry {
         return this.#entries.size > 0;
     }
     primaryTokenPrefixForLog() {
-        for (const [tok, scope] of this.#entries) {
-            if (scope === 'full')
+        for (const [tok, binding] of this.#entries) {
+            if (binding.scope === 'full')
                 return tok.slice(0, 6);
         }
         const first = this.#entries.keys().next().value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/host-http",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Minimal HTTP and WebSocket host for Plugin Runtime (no Koa)",
   "type": "module",
   "main": "./lib/index.js",
@@ -18,10 +18,10 @@
   ],
   "dependencies": {
     "ws": "^8.21.1",
-    "@zhin.js/console-protocol": "1.1.2",
+    "@zhin.js/console-protocol": "1.1.4",
     "@zhin.js/host-http-contract": "1.0.1",
     "@zhin.js/logger": "1.0.76",
-    "@zhin.js/plugin-runtime": "1.1.6"
+    "@zhin.js/plugin-runtime": "1.1.7"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",