@zhin.js/client 1.1.5 → 1.1.7

package/client/index.ts

@@ -7,18 +7,19 @@ export {
   INBOX_RPC,
   SIDE_EVENT_PUSH,
   SIDE_EVENT_RPC,
-  normalizeConsolePushMessage,
-  normalizeConsolePushType,
   parseConsoleInboxEvent,
   type ConsoleInboxEvent,
   type ConsoleInboxEventKind,
+  type ConsoleInboxMessageRow,
   type ConsoleInboxNoticeRow,
   type ConsoleInboxNoticesQuery,
   type ConsoleInboxNoticesResult,
+  type ConsoleInboxRequestRow,
   type ConsoleEndpointPhase,
   type ConsoleEndpointSummary,
   type ConsoleEventActor,
   type ConsoleEventChannel,
+  type ConsoleEventParent,
   type EndpointManagementCapability,
   parseConsoleSseFrame,
   type ConsoleEventDelivery,
@@ -64,22 +65,32 @@ export {
 // Segment IM visibility (inbox vs agent panel)
 export { segmentsForImDelivery, segmentsForAgentPanel } from "./segments.js";
 
-// Console app singleton (pagemanager / registry style)
+// Owner-scoped Console client and application registry
 export {
-  app,
-  type ConsoleApp,
+  ConsoleApp,
+  createConsoleApp,
   type AddRouteInput,
   type AddToolInput,
   type ConsoleRouteRecord,
   type RouteTreeNode,
   type ToolTreeNode,
+  type SidebarRenderer,
+  type ToolbarRenderer,
   type ConsoleRouteRenderer,
-} from "./app";
-
-// WebSocket (business data only)
-export * from "./websocket";
+} from "./app.js";
+export {
+  ConsoleClient,
+  createConsoleClient,
+  type ConsoleClientOptions,
+} from './console-client.js';
+export {
+  ConsoleClientProvider,
+  useConsoleClient,
+  type ConsoleClientProviderProps,
+} from './console-client-context.js';
 
-export { configureConsole, getRuntimeEnv } from "./runtime/index.js";
+// Owner-scoped REST/SSE transport
+export * from "./transport/index.js";
 
 export {
   createRegistryStore,
@@ -94,17 +105,14 @@ export {
   getApiBase,
   getToken,
   resolveApiUrl,
-  resolveWebSocketUrl,
 } from "./console-utils/remoteApi.js";
 
 export {
   fetchConsoleEntries,
-  createPluginRegisterHostApi,
   getRegisterFn,
   loadConsoleEntries,
   registerConsolePluginsFromEntries,
   resolveEntryRegister,
-  type CreatePluginRegisterHostApiOptions,
   type FetchConsoleEntriesOptions,
   type LoadConsoleEntriesOptions,
 } from "./bootstrap/loadConsoleEntries.js";

package/client/persistence/idb-store.test.ts

@@ -118,22 +118,4 @@ describe("applyConsoleEvent inbox record ids", () => {
     expect(rows[0]?.id).toBe('runtime-a:7');
     expect(rows[0]?.updatedAt).toBe(1700000000000);
   });
-
-  it("reads legacy records that only carry endpointKey (camelCase)", async () => {
-    // 旧版（DB v1 时代）记录只有 endpointKey 字段，升级后仍需能被列出
-    const { idbPutInbox } = await import("./idb-store.js");
-    const legacy = {
-      id: "icqq:bot-1:message:1700000000000:legacy",
-      adapter: "icqq",
-      endpointKey: "bot-1",
-      kind: "message",
-      payload: {},
-      updatedAt: 1700000000000,
-    };
-    await idbPutInbox(legacy as unknown as Parameters<typeof idbPutInbox>[0]);
-
-    const rows = await idbListInbox("icqq", "bot-1", "message");
-    expect(rows).toHaveLength(1);
-    expect(rows[0].id).toBe(legacy.id);
-  });
 });

package/client/persistence/idb-store.ts

@@ -5,8 +5,6 @@ const DB_VERSION = 2;
 const STORE_INBOX = "inbox";
 const STORE_PENDING = "pending";
 
-let inboxEventSeq = 0;
-
 export type InboxRecord = {
   id: string;
   adapter: string;
@@ -60,8 +58,7 @@ export async function idbListInbox(
   return all.filter(
     (r) =>
       r.adapter === adapter &&
-      (r.endpoint_id === endpoint_id ||
-        (r as { endpointKey?: string }).endpointKey === endpoint_id) &&
+      r.endpoint_id === endpoint_id &&
       r.kind === kind,
   );
 }
@@ -86,9 +83,9 @@ export async function applyConsoleEvent(event: {
     : null;
   await idbPutInbox({
     // Resumable Host events are idempotent across history/live redelivery.
-    // Legacy/unsequenced sources retain collision-safe append ids.
+    // Unsequenced sources use a collision-safe append id without shared state.
     id: resumableId
-      ?? `${parsed.adapter}:${parsed.endpointKey}:${parsed.type}:${updatedAt}:${inboxEventSeq++}:${Math.random().toString(36).slice(2, 8)}`,
+      ?? `${parsed.adapter}:${parsed.endpointKey}:${parsed.type}:${updatedAt}:${crypto.randomUUID()}`,
     adapter: parsed.adapter,
     endpoint_id: parsed.endpointKey,
     kind: parsed.kind,

package/client/segments.test.ts

@@ -6,10 +6,12 @@ describe('console segmentsForImDelivery', () => {
     const full = [
       { type: 'thinking', data: { text: 'plan' } },
       { type: 'text', data: { text: 'hi' } },
+      { type: 'share', data: { title: 'Example', url: 'https://example.com' } },
       { type: 'tool_call', data: { name: 'bash' } },
     ];
     expect(segmentsForImDelivery(full)).toEqual([
       { type: 'text', data: { text: 'hi' } },
+      { type: 'share', data: { title: 'Example', url: 'https://example.com' } },
     ]);
     expect(segmentsForAgentPanel(full)).toEqual(full);
   });

package/client/segments.ts

@@ -4,7 +4,7 @@ import type { MessageSegment } from './types.js';
 const IM_VISIBLE_TYPES = new Set([
   'text', 'mention', 'image', 'video', 'audio', 'voice', 'record', 'file',
   'face', 'reply', 'forward', 'link', 'dice', 'rps', 'markdown', 'html',
-  'qrcode', 'tts', 'keyboard', 'action',
+  'qrcode', 'tts', 'keyboard', 'action', 'share',
 ]);
 
 const AI_ONLY_TYPES = new Set(['thinking', 'tool_call']);

package/client/{websocket/manager.test.ts → transport/console-transport.test.ts}

@@ -6,8 +6,8 @@ vi.mock("../persistence/idb-store.js", () => ({
   applyConsoleEvent: (...args: unknown[]) => mockApplyConsoleEvent(...args),
 }));
 
-import { WebSocketManager } from "./manager.js";
-import { ConnectionState, type WebSocketMessage } from "./types.js";
+import { ConsoleTransport } from "./console-transport.js";
+import { ConnectionState } from "./types.js";
 
 function mockStorage(map: Record<string, string> = {}): Storage {
   return {
@@ -80,7 +80,7 @@ function mockConsoleTransport(sse: () => Response | Promise<Response>) {
   });
 }
 
-describe("WebSocketManager REST/SSE transport", () => {
+describe("ConsoleTransport REST/SSE transport", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     mockApplyConsoleEvent.mockClear();
@@ -97,7 +97,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     const fetchMock = mockConsoleTransport(() => sseResponse(200));
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager({ reconnectInterval: 100, maxReconnectAttempts: 3 });
+    const manager = new ConsoleTransport({ reconnectInterval: 100, maxReconnectAttempts: 3 });
     const states: boolean[] = [];
     manager.onConnectionChange((c) => states.push(c));
     manager.connect();
@@ -122,7 +122,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     const fetchMock = mockConsoleTransport(() => sseResponse(200));
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     manager.connect();
     await vi.advanceTimersByTimeAsync(0);
     await Promise.resolve();
@@ -144,7 +144,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     });
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager({
+    const manager = new ConsoleTransport({
       reconnectInterval: 100,
       maxReconnectAttempts: 5,
     });
@@ -172,13 +172,21 @@ describe("WebSocketManager REST/SSE transport", () => {
     const fetchMock = vi.fn(async () => ({
       ok: true,
       status: 200,
-      json: async () => ({ success: true, data: { yaml: "http:\n  port: 1\n" } }),
+      json: async () => ({
+        success: true,
+        data: {
+          source: "http:\n  port: 1\n",
+          format: 'yaml',
+          revision: 'a'.repeat(64),
+          configKeys: [],
+        },
+      }),
     } as Response));
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager();
-    const data = await manager.getConfigYaml();
-    expect(data.yaml).toContain("port");
+    const manager = new ConsoleTransport();
+    const data = await manager.getConfigSource();
+    expect(data.source).toContain("port");
     const init = fetchMock.mock.calls[0]![1] as RequestInit;
     expect((init.headers as Record<string, string>).Authorization).toBeUndefined();
     expect(init.method).toBe("POST");
@@ -193,31 +201,39 @@ describe("WebSocketManager REST/SSE transport", () => {
     } as Response));
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     await manager.setConfig("sandbox", { endpoints: [] });
     const init = fetchMock.mock.calls[0]![1] as RequestInit;
     expect((init.headers as Record<string, string>).Authorization).toBe("Bearer t");
   });
 
-  it("normalizes legacy endpoint push names and payload aliases before callbacks", async () => {
-    installBrowserGlobals();
-    const received: WebSocketMessage[] = [];
-    const manager = new WebSocketManager({}, {
-      onMessage: (message) => received.push(message),
+  it('exposes marketplace discovery and lifecycle methods for Console pages', async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: 'token' }));
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        success: true,
+        data: String(input).includes('/marketplace/search') ? { items: [] } : { ok: true },
+      }),
+      headers: init?.headers,
+    } as Response));
+    const manager = new ConsoleTransport({ fetch: fetchMock });
+
+    await manager.searchMarketplace({ keyword: 'telegram', official: true });
+    await manager.getMarketplacePlugin('@zhin.js/adapter-telegram');
+    await manager.getPluginUpdates();
+    await manager.setPluginEnabled('telegram', false);
+
+    expect(String(fetchMock.mock.calls[0]![0])).toContain('/pub/marketplace/search?q=telegram&official=true');
+    expect(String(fetchMock.mock.calls[1]![0])).toContain('%40zhin.js%2Fadapter-telegram');
+    expect(String(fetchMock.mock.calls[2]![0])).toContain('/api/marketplace/updates');
+    const lifecycleBody = JSON.parse(String((fetchMock.mock.calls[3]![1] as RequestInit).body));
+    expect(lifecycleBody).toMatchObject({
+      type: 'plugin:set-enabled',
+      instanceKey: 'telegram',
+      enabled: false,
     });
-
-    (manager as unknown as { handleMessage(event: MessageEvent): void }).handleMessage({
-      data: '{"type":"endpoint:message","data":{"$adapter":"sandbox","endpoint":"bot"}}',
-    } as MessageEvent);
-    await Promise.resolve();
-
-    expect(received).toEqual([expect.objectContaining({
-      type: "message.receive",
-      data: expect.objectContaining({ adapter: "sandbox", endpointKey: "bot" }),
-    })]);
-    expect(mockApplyConsoleEvent).toHaveBeenCalledWith(expect.objectContaining({
-      type: "message.receive",
-    }));
   });
 
   it("stops reconnecting after maxReconnectAttempts", async () => {
@@ -225,7 +241,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     const fetchMock = mockConsoleTransport(() => sseResponse(500, null));
     vi.stubGlobal("fetch", fetchMock);
 
-    const manager = new WebSocketManager({
+    const manager = new ConsoleTransport({
       reconnectInterval: 10,
       maxReconnectAttempts: 2,
     });
@@ -270,7 +286,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     ));
     vi.stubGlobal('fetch', fetchMock);
     const received: Array<{ eventId: number; delivery?: string }> = [];
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     manager.onConsoleEvent('message.receive', (event) => received.push({ eventId: event.eventId, delivery: event.delivery }));
     manager.connect();
     await vi.advanceTimersByTimeAsync(0);
@@ -301,7 +317,7 @@ describe("WebSocketManager REST/SSE transport", () => {
     });
     vi.stubGlobal('fetch', fetchMock);
     const received: number[] = [];
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     manager.onConsoleEvent('message.receive', (event) => received.push(event.eventId));
     const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
     await recover.recoverEventHistory(new AbortController().signal);
@@ -320,7 +336,7 @@ describe("WebSocketManager REST/SSE transport", () => {
       return { ...body, data: { ...body.data, gap: true, oldestAvailableEventId: 8 } };
     };
     vi.stubGlobal('fetch', vi.fn(async () => response));
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     const gaps: unknown[] = [];
     manager.onConsoleEventRecoveryGap((gap) => gaps.push(gap));
     const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
@@ -340,10 +356,39 @@ describe("WebSocketManager REST/SSE transport", () => {
       data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
     };
     vi.stubGlobal('fetch', vi.fn(async () => eventHistoryResponse([historyEvent], 'runtime-a', 1)));
-    const manager = new WebSocketManager();
+    const manager = new ConsoleTransport();
     const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
     await recover.recoverEventHistory(new AbortController().signal);
 
     expect(Object.keys(stored).filter((key) => key.includes('event-cursor'))).toEqual([]);
   });
+
+  it('makes disposal terminal and idempotent', () => {
+    const transport = new ConsoleTransport();
+    transport.dispose();
+    transport.dispose();
+
+    expect(transport.getState()).toBe(ConnectionState.DISCONNECTED);
+    expect(() => transport.connect()).toThrow('ConsoleTransport has been disposed');
+    expect(() => transport.onConnectionChange(() => {}))
+      .toThrow('ConsoleTransport has been disposed');
+  });
+
+  it('rejects a stale connection result after disposal', async () => {
+    installBrowserGlobals();
+    let resolveHistory!: (response: Response) => void;
+    const fetchMock = vi.fn(() => new Promise<Response>((resolve) => {
+      resolveHistory = resolve;
+    }));
+    const transport = new ConsoleTransport({ fetch: fetchMock });
+
+    transport.connect();
+    transport.dispose();
+    resolveHistory(eventHistoryResponse());
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(transport.getState()).toBe(ConnectionState.DISCONNECTED);
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
 });