@zhin.js/host-http 1.1.0 → 1.1.2

package/src/console-rpc-extended/workroom-rpc.ts

@@ -0,0 +1,116 @@
+import type { ConsoleRpcExtendedCtx, ExtendedRpcResult } from './contracts.js';
+import {
+  errorMessage, optionalRpcText, optionalRpcTextArray, requiredRpcBoolean, requiredRpcInteger,
+  requiredRpcText, requiredRpcValue,
+} from './rpc-values.js';
+
+export async function mutateWorkroomProfile(
+  type: 'workroom.profile.status' | 'workroom.profile.bootstrap'
+    | '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}` };
+  }
+  if (type === 'workroom.profile.status') {
+    try {
+      return { data: await control.getPlanningStatus(
+        requiredRpcText(data.projectId, 'projectId'),
+        ctx.authenticatedPrincipal,
+      ) };
+    } catch (error) {
+      return { error: errorMessage(error) };
+    }
+  }
+  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.bootstrap') {
+      const projectId = requiredRpcText(data.projectId, 'projectId');
+      const includeTools = optionalRpcTextArray(data.includeTools, 'includeTools');
+      const includeSkills = optionalRpcTextArray(data.includeSkills, 'includeSkills');
+      return { data: await control.bootstrapPlanning(Object.freeze({
+        operationId,
+        projectId,
+        expectedRegistryRevision: requiredRpcInteger(
+          data.expectedRegistryRevision,
+          'expectedRegistryRevision',
+          -1,
+        ),
+        ...(includeTools ? { includeTools } : {}),
+        ...(includeSkills ? { includeSkills } : {}),
+      }), principal) };
+    }
+    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) };
+  }
+}
+
+export 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) };
+  }
+}

package/src/console-rpc.ts

@@ -1,12 +1,14 @@
 import type { AuthScope } from './token-registry.js';
 import type { DatabaseHostConsole } from '@zhin.js/plugin-runtime';
 import {
+  CONFIG_RPC,
+  ENDPOINT_RPC,
+  type ConsoleConfigSource,
   type ConsoleEndpointSummary,
   assertDemoConsoleRpcAllowed,
-  endpointSendResult,
-  normalizeConsoleRpcMessage,
 } from '@zhin.js/console-protocol';
-import { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx } from './console-rpc-extended.js';
+import { dispatchExtendedConsoleRpc, type ConsoleRpcExtendedCtx } from './console-rpc-extended/index.js';
+import { dispatchPluginConsoleRpc } from './console-plugin-rpc.js';
 
 /**
  * Console RPC 请求结构：未锚定 endpoint 的会话地址（结构对齐
@@ -23,17 +25,14 @@ export interface ConversationAddress {
   readonly threadId?: string;
 }
 
-/** `$channel_type`/`$channel_id`/`$parent` wire 字段 → 会话地址（RPC 边界组帧）。 */
+/** Canonical Console wire fields → runtime conversation address. */
 function wireConversation(
   channelType: string,
   channelId: string,
   parent: unknown,
 ): ConversationAddress {
-  // console 旧 wire 允许 channel_id 自带场景前缀（`group:123`），解析结果优先
-  const prefixed = /^(private|group|channel|direct|c2c|temp):(.+)$/iu.exec(channelId);
-  const rawKind = channelType || prefixed?.[1] || 'private';
   const kind: ConversationAddress['kind'] =
-    rawKind === 'group' || rawKind === 'channel' ? rawKind : 'private';
+    channelType === 'group' || channelType === 'channel' ? channelType : 'private';
   const wire = parent && typeof parent === 'object'
     ? parent as { readonly type?: unknown; readonly id?: unknown }
     : undefined;
@@ -41,7 +40,7 @@ function wireConversation(
   const parentId = typeof wire?.id === 'string' && wire.id ? wire.id : undefined;
   return {
     kind,
-    id: prefixed ? prefixed[2]! : channelId,
+    id: channelId,
     ...(parentKind && parentId ? { parent: { kind: parentKind, id: parentId } } : {}),
   };
 }
@@ -54,6 +53,64 @@ export type RuntimeConsoleRpcMessage = {
 
 export type RuntimeConsoleRpcReply = Record<string, unknown>;
 
+export interface PluginInstallPlan {
+  readonly packageName: string;
+  readonly instanceKey: string;
+  readonly alreadyDeclared: boolean;
+  readonly alreadyInstalled: boolean;
+  readonly restartRequired: boolean;
+  readonly changes: Readonly<{
+    readonly packageManifest: 'unchanged' | 'add-plugin';
+    readonly config: 'unchanged' | 'create-entry' | 'schema-required';
+  }>;
+  readonly warnings: readonly string[];
+}
+
+export interface PluginUninstallPlan {
+  readonly packageName: string;
+  readonly instanceKey: string;
+  readonly installed: boolean;
+  readonly declared: boolean;
+  readonly hasConfig: boolean;
+  readonly restartRequired: boolean;
+}
+
+export interface PluginUpdatePlan {
+  readonly packageName: string;
+  readonly instanceKey: string;
+  readonly currentVersion: string | null;
+  readonly targetVersion: string;
+  readonly installed: boolean;
+  readonly declared: boolean;
+  readonly alreadyCurrent: boolean;
+  readonly restartRequired: boolean;
+}
+
+export interface PluginManagementPort {
+  planInstall(packageName: string): Promise<PluginInstallPlan>;
+  install?(packageName: string, expectedRevision?: string): Promise<Readonly<{
+    readonly plan: PluginInstallPlan;
+    readonly restartRequired: boolean;
+  }>>;
+  planUninstall?(packageName: string): Promise<PluginUninstallPlan>;
+  uninstall?(packageName: string, expectedRevision?: string): Promise<Readonly<{
+    readonly plan: PluginUninstallPlan;
+    readonly restartRequired: boolean;
+  }>>;
+  planUpdate?(packageName: string, targetVersion: string): Promise<PluginUpdatePlan>;
+  update?(packageName: string, targetVersion: string, expectedRevision?: string): Promise<Readonly<{
+    readonly plan: PluginUpdatePlan;
+    readonly installedVersion: string;
+    readonly restartRequired: boolean;
+  }>>;
+}
+
+export interface PluginConfigValidation {
+  readonly valid: boolean;
+  readonly errors: readonly { readonly path: string; readonly message: string }[];
+  readonly missingEnv: readonly string[];
+}
+
 export type RuntimeConsolePage = {
   readonly id: string;
   readonly localName: string;
@@ -68,17 +125,16 @@ export type RuntimeConsoleRpcContext = {
   readonly authScope: AuthScope;
   listPages(): Promise<readonly RuntimeConsolePage[]>;
   /** Optional project config accessors for read-only config RPCs. */
-  readConfigYaml?(): Promise<string>;
-  listPluginKeys?(): Promise<readonly string[]>;
+  readConfigSource?(): Promise<ConsoleConfigSource>;
   readConfigDocument?(): Promise<Record<string, unknown>>;
-  /**
-   * Full-scope write: replace project config file contents (YAML or JSON text).
-   * Runtime Host does not hot-reload the process — callers should restart.
-   */
-  writeConfigYaml?(yaml: string): Promise<void>;
+  /** Full-scope, revision-checked replacement of the active Root config source. */
+  replaceConfigSource?(
+    source: string,
+    expectedRevision: string,
+  ): Promise<{ readonly revision: string; readonly restartRequired: boolean }>;
   /**
    * Full-scope write: set `document[pluginName] = data` and persist.
-   * Returns whether a process restart is required (always true without ConfigFeature).
+   * Returns whether a process restart is required.
    */
   setConfigKey?(pluginName: string, data: unknown): Promise<{ restartRequired: boolean }>;
   /** Persist a declared child Plugin lifecycle state. Takes effect after restart. */
@@ -86,6 +142,10 @@ export type RuntimeConsoleRpcContext = {
     instanceKey: string,
     enabled: boolean,
   ): Promise<Readonly<{ disabled: readonly string[] }>>;
+  /** Read-only install planning shared by Console Web and CLI surfaces. */
+  pluginManagement?: PluginManagementPort;
+  validatePluginConfig?(pluginName: string, data: unknown): Promise<PluginConfigValidation>;
+  diagnosePlugin?(pluginName: string): Promise<unknown>;
   /** Atomic, revision-checked runtime Workroom Catalog read/write. */
   readWorkroomCatalog?(): Promise<Readonly<{
     agents: Readonly<Record<string, unknown>>;
@@ -109,8 +169,8 @@ export type RuntimeConsoleRpcContext = {
   getSchema?(pluginName?: string): Promise<unknown>;
   getAllSchemas?(): Promise<Record<string, unknown>>;
   /** Optional Adapter endpoint Console surface (Sandbox / Remote Console). */
-  listEndpoints?(): Promise<readonly RuntimeEndpointSummary[]>;
-  getEndpoint?(adapter: string, endpointKey: string): Promise<RuntimeEndpointSummary | null>;
+  listEndpoints?(): Promise<readonly ConsoleEndpointSummary[]>;
+  getEndpoint?(adapter: string, endpointKey: string): Promise<ConsoleEndpointSummary | null>;
   sendEndpointMessage?(input: RuntimeEndpointSendInput): Promise<{ messageId: string }>;
   /** Optional Database host surface (CLI wires DatabaseHost from plugin-runtime). */
   dbInfo?(): Promise<RuntimeDatabaseInfo> | RuntimeDatabaseInfo;
@@ -127,11 +187,6 @@ export type RuntimeConsoleRpcContext = {
   extended?: Omit<ConsoleRpcExtendedCtx, 'fullScope'>;
 };
 
-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;
@@ -165,7 +220,6 @@ export async function dispatchRuntimeConsoleRpc(
   const emit = (payload: RuntimeConsoleRpcReply) => {
     payloads.push(payload);
   };
-  message = normalizeConsoleRpcMessage(message);
   const type = String(message.type ?? '');
   const requestId = message.requestId as number | string | undefined;
 
@@ -192,6 +246,12 @@ export async function dispatchRuntimeConsoleRpc(
     }
   }
 
+  const pluginReply = await dispatchPluginConsoleRpc(type, message, ctx);
+  if (pluginReply !== undefined) {
+    emit(pluginReply);
+    return payloads;
+  }
+
   switch (type) {
     case 'ping':
       emit({ type: 'pong', requestId });
@@ -217,11 +277,12 @@ export async function dispatchRuntimeConsoleRpc(
       emit({ requestId, data: pages });
       return payloads;
     }
-    case 'config:get-yaml': {
+    case CONFIG_RPC.GET_SOURCE: {
       try {
-        const yaml = ctx.readConfigYaml ? await ctx.readConfigYaml() : '';
-        const pluginKeys = ctx.listPluginKeys ? await ctx.listPluginKeys() : [];
-        emit({ requestId, data: { yaml, pluginKeys } });
+        const config: ConsoleConfigSource = ctx.readConfigSource
+          ? await ctx.readConfigSource()
+          : { source: '', format: 'yaml', revision: '', configKeys: [] };
+        emit({ requestId, data: config });
       } catch (error) {
         emit({
           requestId,
@@ -230,7 +291,7 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
-    case 'config:get-all': {
+    case CONFIG_RPC.GET_ALL: {
       try {
         const document = ctx.readConfigDocument ? await ctx.readConfigDocument() : {};
         emit({ requestId, data: document });
@@ -242,11 +303,9 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
-    case 'config:get': {
+    case CONFIG_RPC.GET: {
       try {
-        // 兼容 console UI 的 data:{plugin} / data:{key} 形状
-        const data = (message.data ?? {}) as Record<string, unknown>;
-        const key = String(message.key ?? message.pluginName ?? data.pluginName ?? data.plugin ?? data.key ?? '');
+        const key = String(message.pluginName ?? '');
         const document = ctx.readConfigDocument ? await ctx.readConfigDocument() : {};
         emit({ requestId, data: key ? document[key] : document });
       } catch (error) {
@@ -290,22 +349,33 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
-    case 'config:save-yaml': {
+    case CONFIG_RPC.REPLACE_SOURCE: {
       try {
-        const yaml = message.yaml;
-        if (typeof yaml !== 'string') {
-          emit({ requestId, error: 'yaml field is required' });
+        const source = message.source;
+        const expectedRevision = message.expectedRevision;
+        if (typeof source !== 'string') {
+          emit({ requestId, error: 'source field is required' });
+          return payloads;
+        }
+        if (typeof expectedRevision !== 'string' || !/^[a-f0-9]{64}$/u.test(expectedRevision)) {
+          emit({ requestId, error: 'expectedRevision is required' });
           return payloads;
         }
-        if (!ctx.writeConfigYaml) {
+        if (!ctx.replaceConfigSource) {
           emit({ requestId, error: 'Config write is not configured' });
           return payloads;
         }
-        await ctx.writeConfigYaml(yaml);
+        const result = await ctx.replaceConfigSource(source, expectedRevision);
         ctx.publishEvent?.('config:updated', { pluginName: null, keys: [] });
         emit({
           requestId,
-          data: { success: true, message: '配置已保存，需重启生效' },
+          data: {
+            success: true,
+            ...result,
+            message: result.restartRequired
+              ? '配置已保存，需重启进程才能生效'
+              : '配置已保存',
+          },
         });
       } catch (error) {
         emit({
@@ -315,7 +385,7 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
-    case 'config:set': {
+    case CONFIG_RPC.SET: {
       try {
         const pluginName = message.pluginName;
         if (typeof pluginName !== 'string' || !pluginName) {
@@ -326,6 +396,17 @@ export async function dispatchRuntimeConsoleRpc(
           emit({ requestId, error: 'Config write is not configured' });
           return payloads;
         }
+        if (ctx.validatePluginConfig) {
+          const validation = await ctx.validatePluginConfig(pluginName, message.data);
+          if (!validation.valid) {
+            emit({
+              requestId,
+              error: '配置校验失败',
+              data: validation,
+            });
+            return payloads;
+          }
+        }
         const result = await ctx.setConfigKey(pluginName, message.data);
         ctx.publishEvent?.('config:updated', {
           pluginName,
@@ -471,10 +552,9 @@ export async function dispatchRuntimeConsoleRpc(
     }
     case 'schema:get': {
       try {
-        // 兼容 console UI 的 data:{plugin} / data:{pluginName} 形状（SDK 发顶层 pluginName）
-        const data = (message.data ?? {}) as Record<string, unknown>;
-        const candidate = message.pluginName ?? data.pluginName ?? data.plugin;
-        const pluginName = typeof candidate === 'string' ? candidate : undefined;
+        const pluginName = typeof message.pluginName === 'string'
+          ? message.pluginName
+          : undefined;
         const schema = ctx.getSchema ? await ctx.getSchema(pluginName) : null;
         emit({ requestId, data: schema });
       } catch (error) {
@@ -678,11 +758,11 @@ export async function dispatchRuntimeConsoleRpc(
     }
     case 'endpoint.info': {
       try {
-        const data = message as Record<string, unknown>;
-        const adapter = String(data.$adapter ?? '');
-        const endpointKey = String(data.$endpoint ?? '');
+        const data = recordField(message.data) ?? message;
+        const adapter = String(data.adapter ?? '');
+        const endpointKey = String(data.endpointKey ?? '');
         if (!adapter || !endpointKey) {
-          emit({ requestId, error: '$adapter and $endpoint required' });
+          emit({ requestId, error: 'adapter and endpointKey are required' });
           return payloads;
         }
         if (!ctx.getEndpoint) {
@@ -703,19 +783,67 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
+    case ENDPOINT_RPC.TEST: {
+      const data = recordField(message.data) ?? message;
+      const adapter = stringField(data, 'adapter');
+      const endpointKey = stringField(data, 'endpointKey');
+      if (!adapter || !endpointKey) {
+        emit({ requestId, error: 'adapter and endpointKey are required' });
+        return payloads;
+      }
+      if (!ctx.getEndpoint) {
+        emit({ requestId, error: 'Endpoint registry is not configured' });
+        return payloads;
+      }
+      const startedAt = Date.now();
+      try {
+        const endpoint = await ctx.getEndpoint(adapter, endpointKey);
+        if (!endpoint) {
+          emit({ requestId, data: {
+            reachable: false,
+            connected: false,
+            phase: 'unconfigured',
+            latencyMs: Date.now() - startedAt,
+            message: 'Endpoint 未注册到当前 generation',
+          } });
+          return payloads;
+        }
+        emit({ requestId, data: {
+          reachable: endpoint.connected && endpoint.status === 'online',
+          connected: endpoint.connected,
+          status: endpoint.status,
+          phase: endpoint.phase ?? (endpoint.connected ? 'online' : 'pending'),
+          pendingLogin: endpoint.pendingLogin ?? false,
+          latencyMs: Date.now() - startedAt,
+          message: endpoint.connected
+            ? 'Endpoint 已连接'
+            : endpoint.pendingLogin
+              ? 'Endpoint 等待登录操作'
+              : 'Endpoint 当前离线',
+        } });
+      } catch (error) {
+        emit({ requestId, data: {
+          reachable: false,
+          connected: false,
+          phase: 'failed',
+          latencyMs: Date.now() - startedAt,
+          message: error instanceof Error ? error.message : String(error),
+        } });
+      }
+      return payloads;
+    }
     case 'endpoint.send_message': {
       try {
-        const data = message as Record<string, unknown>;
-        const adapter = String(data.$adapter ?? '');
-        const endpointKey = String(data.$endpoint ?? '');
-        const channelId = String(data.$channel_id ?? '');
-        const channelType = String(data.$channel_type ?? '');
-        const content = data.$content;
-        // channelType 可省：wireConversation 归一为 private（与旧 RPC 行为对齐）。
-        if (!adapter || !endpointKey || !channelId || content === undefined) {
+        const data = recordField(message.data) ?? message;
+        const adapter = String(data.adapter ?? '');
+        const endpointKey = String(data.endpointKey ?? '');
+        const channelId = String(data.channelId ?? data.id ?? '');
+        const channelType = String(data.channelType ?? data.type ?? '');
+        const content = data.content;
+        if (!adapter || !endpointKey || !channelId || !channelType || content === undefined) {
           emit({
             requestId,
-            error: '$adapter, $endpoint, $channel_id, $content required',
+            error: 'adapter, endpointKey, channelId, channelType, and content are required',
           });
           return payloads;
         }
@@ -726,11 +854,10 @@ export async function dispatchRuntimeConsoleRpc(
         const result = await ctx.sendEndpointMessage({
           adapter,
           endpointKey,
-          conversation: wireConversation(channelType, channelId, data.$parent),
+          conversation: wireConversation(channelType, channelId, data.parent),
           content,
         });
-        // Legacy contract: { message_id }. Keep messageId for new callers.
-        emit({ requestId, data: endpointSendResult(result.messageId) });
+        emit({ requestId, data: { messageId: result.messageId } });
       } catch (error) {
         emit({
           requestId,
@@ -761,41 +888,6 @@ export async function dispatchRuntimeConsoleRpc(
       }
       return payloads;
     }
-    case 'plugin:set-enabled': {
-      try {
-        const instanceKey = typeof message.instanceKey === 'string' ? message.instanceKey : '';
-        const enabled = message.enabled;
-        if (!instanceKey || typeof enabled !== 'boolean') {
-          emit({ requestId, error: 'instanceKey and boolean enabled are required' });
-          return payloads;
-        }
-        if (!ctx.setPluginEnabled) {
-          emit({ requestId, error: 'Plugin lifecycle management is not configured' });
-          return payloads;
-        }
-        const lifecycle = await ctx.setPluginEnabled(instanceKey, enabled);
-        ctx.publishEvent?.('plugin:lifecycle-updated', { instanceKey, enabled });
-        emit({
-          requestId,
-          data: {
-            success: true,
-            instanceKey,
-            enabled,
-            disabled: lifecycle.disabled,
-            restartRequired: true,
-            message: `${instanceKey} 已${enabled ? '启用' : '停用'}，Host 正在重启`,
-          },
-        });
-        if (ctx.requestRestart) {
-          setTimeout(() => {
-            void Promise.resolve(ctx.requestRestart?.()).catch(() => undefined);
-          }, 500);
-        }
-      } catch (error) {
-        emit({ requestId, error: error instanceof Error ? error.message : String(error) });
-      }
-      return payloads;
-    }
     default:
       if (type.startsWith('db:')) {
         emit({

package/src/index.ts

@@ -55,8 +55,13 @@ export {
   type RuntimeConsoleRpcMessage,
   type RuntimeConsoleRpcReply,
   type RuntimeEndpointSendInput,
-  type RuntimeEndpointSummary,
+  type PluginInstallPlan,
+  type PluginUninstallPlan,
+  type PluginUpdatePlan,
+  type PluginManagementPort,
+  type PluginConfigValidation,
 } from './console-rpc.js';
+export { dispatchPluginConsoleRpc } from './console-plugin-rpc.js';
 export {
   buildProjectFileTree,
   FILE_MANAGER_ALLOWED,
@@ -82,4 +87,4 @@ export {
   type ConsoleWorkroomProfileControlPort,
   type ConsoleWorkroomKnowledgeControlPort,
   type ExtendedRpcResult,
-} from './console-rpc-extended.js';
+} from './console-rpc-extended/index.js';

package/src/marketplace-registry.ts

@@ -0,0 +1,58 @@
+export interface MarketplaceRegistryOptions {
+  readonly fetchFn: typeof fetch;
+  readonly url: string;
+  readonly ttlMs: number;
+  readonly now?: () => number;
+}
+
+interface MarketplaceSnapshot {
+  readonly plugins: readonly unknown[];
+  readonly expiresAt: number;
+}
+
+/** Host-owned plugin registry reader with TTL caching and request coalescing. */
+export class MarketplaceRegistry {
+  readonly #fetch: typeof fetch;
+  readonly #url: string;
+  readonly #ttlMs: number;
+  readonly #now: () => number;
+  #snapshot?: MarketplaceSnapshot;
+  #inflight?: Promise<readonly unknown[]>;
+
+  constructor(options: MarketplaceRegistryOptions) {
+    this.#fetch = options.fetchFn;
+    this.#url = options.url;
+    this.#ttlMs = options.ttlMs;
+    this.#now = options.now ?? Date.now;
+  }
+
+  list(): Promise<readonly unknown[]> {
+    const snapshot = this.#snapshot;
+    if (snapshot && this.#now() < snapshot.expiresAt) {
+      return Promise.resolve(snapshot.plugins);
+    }
+    if (this.#inflight) return this.#inflight;
+
+    const request = this.#load();
+    this.#inflight = request;
+    const clearInflight = () => {
+      if (this.#inflight === request) this.#inflight = undefined;
+    };
+    void request.then(clearInflight, clearInflight);
+    return request;
+  }
+
+  async #load(): Promise<readonly unknown[]> {
+    const response = await this.#fetch(this.#url, {
+      signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) throw new Error(`plugins.json fetch failed: ${response.status}`);
+    const json = (await response.json()) as { plugins?: unknown[] };
+    const plugins = Object.freeze([...(json.plugins ?? [])]);
+    this.#snapshot = Object.freeze({
+      plugins,
+      expiresAt: this.#now() + this.#ttlMs,
+    });
+    return plugins;
+  }
+}