@zhin.js/adapter-sandbox 5.0.5 → 5.0.6

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @zhin.js/adapter-process
 
+## 5.0.6
+
+### Patch Changes
+
+- cc5c94d: 约定式插件运行时迁移（breaking）：插件与适配器由 `usePlugin()` / `extends Adapter` 迁移为 `definePlugin` / `defineAdapter` + `plugin.ts` + 约定目录（`adapters/`、`commands/`、`components/`、`tools/` 等）。
+
+  - 新增约定式运行时包：`@zhin.js/plugin-runtime`、`@zhin.js/adapter`、`@zhin.js/runtime`、`@zhin.js/host-http`（首版 1.0.0 走 init-publish，不在本 changeset 内 bump）。
+  - 全部 20 个平台适配器改为约定式 `defineAdapter`，旧 `usePlugin` / `extends Adapter` / `segment-mapper` 生产入口已删除；onebot11 反向 WSS、onebot12 webhook/wss、milky sse/webhook/wss、satori webhook、kook webhook、qq webhook/middleware 等 slice 1 推迟的连接模式已补齐。
+  - 游戏 / 工具 / 服务插件同步迁移到约定目录结构。
+  - CLI 增加 plugin-runtime host installer（http/database/outbound/schedule/console 等）。
+
+  后续加固（同批）：
+
+  - CLI：`zhin runtime start --daemon`（pidfile/崩溃拉起/风暴保护），orphan watchdog 防僵尸进程；legacy `zhin dev` / `zhin start` 已移除（含 `zhin restart`），`zhin stop` 兼容新 daemon。
+  - 安全：builtin 工具统一走 `security/policy-facade.ts` 的 `runToolPolicies`（声明式策略表，deny 优先）；审计日志 close flush + 背压队列；`splitCompoundCommand` 引号感知、`extractCommandName` 去引号堵绕过。
+  - 日志：Logger 双堆栈修复、本地时区、`getLogger` 挂树（`setLevel` 递归生效）、第三方库（log4js/discord）桥接、启动人读总结。
+  - 结构：`plugins/games/shared` 迁为 `packages/game-kit`（`@zhin.js/game-kit`）；死目录 `plugins/adapters/common` 删除。
+  - 脚手架：`create-zhin-app` / `zhin new` / scaffold-wizard 生成物改为 Plugin Runtime 形态（minimal-bot 同构，新配置格式）。
+  - Console：endpoint.list 真实名称与 phase、schema:get-all 按 instanceKey 映射、db:\* 接 DatabaseHost。
+
+  注：按仓库发布惯例（见 1bb345dd2），本次 breaking 迁移统一使用 patch，避免 zhin.js 5.0 级联。
+
+- Updated dependencies [16ec4e8]
+- Updated dependencies [cc5c94d]
+- Updated dependencies [447f3e2]
+  - @zhin.js/core@1.3.5
+  - @zhin.js/host-http@1.0.1
+  - @zhin.js/logger@1.0.75
+  - @zhin.js/plugin-runtime@1.0.1
+  - @zhin.js/adapter@1.0.1
+  - @zhin.js/page@1.0.1
+
 ## 5.0.5
 
 ### Patch Changes

package/README.md

@@ -18,12 +18,28 @@ pnpm add @zhin.js/adapter-sandbox
 
 ## 依赖
 
-Sandbox 适配器需要以下服务插件：
+### Plugin Runtime（新，`zhin runtime start`）
+
+- `@zhin.js/adapter` — 约定式 `adapters/sandbox.ts`
+- `@zhin.js/host-http` — Root 提供的 `httpHostToken`（WebSocket `/sandbox` + Console HTTP）
+- `@zhin.js/core` — `messageGatewayToken` / ImRuntime 入站出站
+- `@zhin.js/page` + `pages/sandbox.tsx` — ADR 0046 约定页（`definePage`）
+
+Root 在 `zhin runtime start` 时装载 `@zhin.js/host-http`、`ConsoleRuntime` 与
+`ClientBuildModuleRuntime`。打开 `http://<host>:<port>/console` 可浏览页面；Sandbox 页
+（路由形如 `/…/p-sandbox`）内置 WebSocket `/sandbox` 聊天壳。
+
+旧 `client/`（`register(api)` / `pageManager.addEntry`）仅保留给 legacy Host 栈参考，
+**不是** Plugin Runtime 生产入口。
+
+### 旧 Host 栈（`zhin dev` / full-bot）
 
 - `@zhin.js/host-router` — HTTP 服务（提供 Router 和 WebSocket）
 - `@zhin.js/host-api` — Host 侧 Console API（`addEntry` 注册 Sandbox 扩展）
 - `@zhin.js/client` — Remote Console 客户端 SDK（UI 在 zhin-console 仓库）
 
+出站 wire 只做 JSON 封装；旧 `segment-mapper`（canonical segments）归一化上移到 gateway/core 渲染链。
+
 ## 配置
 
 **推荐（与 [minimal-bot](../../../examples/minimal-bot/) 一致）**：`endpoints: []`，在 Remote Console 打开「沙盒」页时经 `/sandbox` WebSocket **自动创建** bot（如 `sandbox-xxxx`），无需在 yaml 里写 `context: sandbox`。

package/adapters/sandbox.ts

@@ -0,0 +1,26 @@
+/**
+ * Convention entry: discover `adapters/sandbox.ts` → defineAdapter.
+ */
+import { defineAdapter } from '@zhin.js/adapter';
+import { messageGatewayToken } from '@zhin.js/core/runtime';
+import { httpHostToken } from '@zhin.js/host-http';
+import { SandboxWsEndpoint } from '../src/endpoint.js';
+import {
+  resolveSandboxEndpoint,
+  type SandboxAdapterConfig,
+} from '../src/protocol.js';
+
+export { SandboxWsEndpoint } from '../src/endpoint.js';
+export type { SandboxEndpointOptions } from '../src/endpoint.js';
+
+export default defineAdapter<SandboxAdapterConfig>({
+  capabilities: ['inbound', 'outbound'],
+  create(context) {
+    return new SandboxWsEndpoint({
+      id: context.id,
+      gateway: context.use(messageGatewayToken),
+      http: context.use(httpHostToken),
+      defaults: resolveSandboxEndpoint(context.config),
+    });
+  },
+});

package/lib/endpoint.d.ts

@@ -0,0 +1,25 @@
+import type { EndpointInstance } from '@zhin.js/adapter';
+import type { MessageGateway } from '@zhin.js/core/runtime';
+import type { HttpHost } from '@zhin.js/host-http';
+import type { CapabilityId } from '@zhin.js/plugin-runtime';
+import { type ResolvedSandboxBot } from './protocol.js';
+export interface SandboxEndpointOptions {
+    readonly id: CapabilityId;
+    readonly gateway: MessageGateway;
+    readonly http: HttpHost;
+    readonly defaults: ResolvedSandboxBot;
+}
+export declare class SandboxWsEndpoint implements EndpointInstance {
+    #private;
+    constructor(options: SandboxEndpointOptions);
+    /** Live endpoint name (config `name`) — Console endpoint.list/resolve uses it. */
+    get name(): string;
+    start(): void;
+    open(): void;
+    close(): void;
+    stop(): void;
+    send({ target, payload }: {
+        readonly target: string;
+        readonly payload: unknown;
+    }): unknown;
+}

package/lib/endpoint.js

@@ -0,0 +1,155 @@
+/**
+ * SandboxWsEndpoint — WebSocket lifecycle and MessageGateway bridge for /sandbox.
+ */
+import { randomUUID } from 'node:crypto';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { bindSandboxWsSocket, formatSandboxOutbound, parseSandboxWsPayload, whenWsOpen, } from './protocol.js';
+const logger = getLogger('sandbox');
+export class SandboxWsEndpoint {
+    #options;
+    #connections = new Map();
+    #wsHandleRelease;
+    #open = false;
+    #started = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    /** Live endpoint name (config `name`) — Console endpoint.list/resolve uses it. */
+    get name() {
+        return this.#options.defaults.name;
+    }
+    start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        const handle = this.#options.http.ws('/sandbox');
+        this.#wsHandleRelease = handle.onConnection((connection) => {
+            this.#acceptConnection(connection);
+        });
+        if (!this.#options.defaults.randomNamePerConnection) {
+            this.#ensurePlaceholder(this.#options.defaults.name, this.#options.defaults.owner);
+        }
+        logger.info(formatCompact({
+            op: 'sandbox_ws_mounted',
+            path: '/sandbox',
+            endpoint: this.#options.defaults.name,
+        }));
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    stop() {
+        this.#open = false;
+        this.#wsHandleRelease?.();
+        this.#wsHandleRelease = undefined;
+        for (const connection of this.#connections.values())
+            connection.release();
+        this.#connections.clear();
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'sandbox_stopped' }));
+    }
+    send({ target, payload }) {
+        if (!this.#open)
+            return undefined;
+        const connection = this.#connections.get(target);
+        if (!connection) {
+            logger.debug(formatCompact({ op: 'sandbox_send_miss', target }));
+            return undefined;
+        }
+        if (connection.placeholder) {
+            logger.debug(formatCompact({ op: 'sandbox_send_placeholder', target }));
+            return undefined;
+        }
+        connection.socket.send(formatSandboxOutbound(payload));
+        logger.debug(formatCompact({ op: 'sandbox_send', target }));
+        return payload;
+    }
+    #acceptConnection(connection) {
+        const target = this.#options.defaults.randomNamePerConnection
+            ? `sandbox-${randomUUID().slice(0, 8)}`
+            : this.#options.defaults.name;
+        const owner = this.#options.defaults.owner;
+        const socket = connection.socket;
+        if (this.#connections.has(target)) {
+            this.#connections.get(target)?.release();
+            this.#connections.delete(target);
+        }
+        const release = bindSandboxWsSocket(socket, {
+            onMessage: (raw) => {
+                if (!this.#open)
+                    return;
+                const parsed = parseSandboxWsPayload(raw);
+                logger.debug(formatCompact({
+                    op: 'sandbox_recv',
+                    target,
+                    sender: parsed.id || owner,
+                    text: parsed.text.slice(0, 80),
+                }));
+                void this.#options.gateway.receive({
+                    adapter: this.#options.id,
+                    target,
+                    content: parsed.text,
+                    sender: parsed.id || owner,
+                    metadata: Object.freeze({
+                        type: parsed.type,
+                        elements: parsed.content,
+                        timestamp: parsed.timestamp,
+                        ...(parsed.action ? { action: parsed.action } : {}),
+                    }),
+                }).catch((err) => {
+                    logger.warn(formatCompact({
+                        op: 'sandbox_gateway_receive_failed',
+                        target,
+                        error: err instanceof Error ? err.message : String(err),
+                    }));
+                });
+            },
+            onClose: () => {
+                this.#connections.delete(target);
+                logger.debug(formatCompact({ op: 'sandbox_ws_closed', target }));
+            },
+            onError: (err) => {
+                logger.warn(formatCompact({
+                    op: 'sandbox_ws_error',
+                    target,
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            },
+        });
+        this.#connections.set(target, Object.freeze({ target, owner, socket, release }));
+        logger.debug(formatCompact({ op: 'sandbox_ws_connected', target, owner }));
+        if (!this.#options.defaults.randomNamePerConnection) {
+            const readyPayload = JSON.stringify({
+                type: 'ready',
+                id: owner,
+                endpoint: target,
+                content: [{
+                        type: 'text',
+                        data: {
+                            text: [
+                                `已连接 Sandbox「${target}」`,
+                                '与 Node Host 控制台沙盒协议一致（/sandbox）',
+                                '命令: help · ping · zt · status',
+                            ].join('\n'),
+                        },
+                    }],
+                timestamp: Date.now(),
+            });
+            whenWsOpen(socket, () => socket.send(readyPayload));
+        }
+    }
+    #ensurePlaceholder(name, owner) {
+        if (this.#connections.has(name))
+            return;
+        this.#connections.set(name, Object.freeze({
+            target: name,
+            owner,
+            socket: { send: () => undefined, close: () => undefined },
+            release: () => undefined,
+            placeholder: true,
+        }));
+    }
+}

package/lib/index.d.ts

@@ -1,22 +1,2 @@
-import { usePlugin } from "zhin.js";
-import { SandboxWsHostAdapter } from "./sandbox-ws.js";
-type SandboxRouter = {
-    ws: (path: string) => NonNullable<SandboxAdapter["wss"]>;
-};
-declare module "zhin.js" {
-    interface Adapters {
-        sandbox: SandboxAdapter;
-    }
-}
-/** Node：`Router.ws` */
-export declare class SandboxAdapter extends SandboxWsHostAdapter {
-    wss?: {
-        on: (ev: string, fn: (...args: unknown[]) => void) => void;
-        close: () => void;
-    };
-    constructor(plugin: ReturnType<typeof usePlugin>);
-    start(): Promise<void>;
-    setupWebSocket(router: SandboxRouter): Promise<void>;
-}
-export { SandboxWsEndpoint, SandboxWsHostAdapter, resolveSandboxEndpoint, bindSandboxWsSocket, parseSandboxWsPayload, type ResolvedSandboxBot, type SandboxWsConfig, type SandboxWsSocket, } from "./sandbox-ws.js";
-//# sourceMappingURL=index.d.ts.map
+export { bindSandboxWsSocket, formatSandboxOutbound, parseSandboxWsPayload, resolveSandboxEndpoint, whenWsOpen, type MessageElement, type MessageType, type ResolvedSandboxBot, type SandboxAdapterConfig, type SandboxWsSocket, } from './protocol.js';
+export { SandboxWsEndpoint, type SandboxEndpointOptions, } from './endpoint.js';

package/lib/index.js

@@ -1,67 +1,2 @@
-import path from "node:path";
-import { usePlugin } from "zhin.js";
-import { SandboxWsHostAdapter, resolveSandboxEndpoint, } from "./sandbox-ws.js";
-const plugin = usePlugin();
-const logger = plugin.logger;
-/** Node：`Router.ws` */
-export class SandboxAdapter extends SandboxWsHostAdapter {
-    wss;
-    constructor(plugin) {
-        const appConfig = (plugin.inject("config")?.getPrimary() ?? {});
-        super(plugin, resolveSandboxEndpoint(appConfig));
-    }
-    async start() {
-        await super.start();
-        this.registerConfiguredPlaceholder();
-        logger.debug(`Sandbox placeholder: ${this.defaults.name} (offline until /sandbox WS)`);
-    }
-    async setupWebSocket(router) {
-        if (this.wss)
-            return;
-        this.wss = router.ws("/sandbox");
-        this.wss.on("connection", (...args) => {
-            const ws = args[0];
-            const req = args[1];
-            logger.debug(`New sandbox connection from ${req.socket?.remoteAddress ?? "unknown"}`);
-            const endpoint = this.acceptWebSocket(ws);
-            ws.on("close", () => {
-                logger.debug(`Sandbox connection closed: ${endpoint.$config.name}`);
-                this.endpoints.delete(endpoint.$id);
-            });
-            ws.on("error", (error) => {
-                logger.error(`Sandbox WebSocket error for ${endpoint.$config.name}:`, error);
-            });
-        });
-        logger.debug("Sandbox WebSocket server started at /sandbox (Node Router.ws)");
-    }
-}
-const { provide } = usePlugin();
-provide({
-    name: "sandbox",
-    description: "Sandbox Adapter — Node Router.ws",
-    mounted: async (p) => {
-        const adapter = new SandboxAdapter(p);
-        await adapter.start();
-        return adapter;
-    },
-    dispose: async (adapter) => {
-        for (const endpoint of adapter.endpoints.values()) {
-            await endpoint.$disconnect();
-        }
-        adapter.wss?.close();
-        await adapter.stop();
-    },
-});
-plugin.useContext("router", 'sandbox', async (router, adapter) => {
-    await adapter.setupWebSocket(router);
-});
-plugin.useContext("web", (pageManager) => {
-    pageManager.addEntry({
-        id: "sandbox",
-        development: path.resolve(import.meta.dirname, "../client/index.tsx"),
-        production: path.resolve(import.meta.dirname, "../dist/index.js"),
-        meta: { name: "Sandbox" },
-    });
-});
-export { SandboxWsEndpoint, SandboxWsHostAdapter, resolveSandboxEndpoint, bindSandboxWsSocket, parseSandboxWsPayload, } from "./sandbox-ws.js";
-//# sourceMappingURL=index.js.map
+export { bindSandboxWsSocket, formatSandboxOutbound, parseSandboxWsPayload, resolveSandboxEndpoint, whenWsOpen, } from './protocol.js';
+export { SandboxWsEndpoint, } from './endpoint.js';

package/lib/protocol.d.ts

@@ -0,0 +1,52 @@
+/** Sandbox WebSocket wire protocol helpers (no legacy Adapter/Endpoint). */
+export type MessageType = 'private' | 'group' | 'guild' | 'direct' | 'channel';
+export interface MessageElement {
+    readonly type: string;
+    readonly data?: Record<string, unknown>;
+}
+export interface SandboxWsSocket {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    on?(event: 'message' | 'close' | 'error', listener: (...args: unknown[]) => void): void;
+    off?(event: 'message' | 'close' | 'error', listener: (...args: unknown[]) => void): void;
+    addEventListener?(type: 'message' | 'close' | 'error', listener: (ev: Event | MessageEvent | CloseEvent) => void): void;
+    removeEventListener?(type: 'message' | 'close' | 'error', listener: (ev: Event | MessageEvent | CloseEvent) => void): void;
+}
+export type ResolvedSandboxBot = {
+    readonly context: 'sandbox';
+    readonly name: string;
+    readonly owner: string;
+    readonly randomNamePerConnection: boolean;
+};
+export interface SandboxAdapterConfig {
+    readonly endpoints?: ReadonlyArray<{
+        readonly context?: string;
+        readonly name?: string;
+        readonly owner?: string;
+    }>;
+}
+export declare function resolveSandboxEndpoint(appConfig: SandboxAdapterConfig): ResolvedSandboxBot;
+export declare function bindSandboxWsSocket(ws: SandboxWsSocket, handlers: {
+    onMessage: (raw: string) => void;
+    onClose: () => void;
+    onError?: (err: unknown) => void;
+}): () => void;
+export declare function parseSandboxWsPayload(raw: string): {
+    type: MessageType;
+    id: string;
+    content: MessageElement[];
+    timestamp: number;
+    text: string;
+    action?: {
+        id: string;
+        payload: string;
+    };
+};
+/**
+ * Wire-encode an already-rendered outbound payload.
+ * Canonical segment mapping (old `segment-mapper` re-export of `to/fromCanonicalSegments`
+ * from legacy `zhin.js`) is intentionally not done here — the gateway/core render path
+ * owns that before `endpoint.send`.
+ */
+export declare function formatSandboxOutbound(payload: unknown): string;
+export declare function whenWsOpen(ws: SandboxWsSocket, fn: () => void): void;

package/lib/protocol.js

@@ -0,0 +1,135 @@
+/** Sandbox WebSocket wire protocol helpers (no legacy Adapter/Endpoint). */
+export function resolveSandboxEndpoint(appConfig) {
+    const entry = appConfig.endpoints?.find((item) => item.context === 'sandbox');
+    const fixedName = typeof entry?.name === 'string' ? entry.name : undefined;
+    const name = fixedName || process.env.SANDBOX_BOT_NAME || 'sandbox-bot';
+    const owner = (typeof entry?.owner === 'string' && entry.owner)
+        || process.env.SANDBOX_BOT_OWNER
+        || 'sandbox-user';
+    return {
+        context: 'sandbox',
+        name,
+        owner,
+        randomNamePerConnection: !fixedName,
+    };
+}
+export function bindSandboxWsSocket(ws, handlers) {
+    if (typeof ws.on === 'function') {
+        const onMessage = (...args) => {
+            const data = args[0];
+            const raw = typeof data === 'string'
+                ? data
+                : data instanceof ArrayBuffer
+                    ? new TextDecoder().decode(data)
+                    : Buffer.isBuffer(data)
+                        ? data.toString()
+                        : String(data ?? '');
+            handlers.onMessage(raw);
+        };
+        ws.on('message', onMessage);
+        ws.on('close', handlers.onClose);
+        if (handlers.onError)
+            ws.on('error', handlers.onError);
+        return () => {
+            ws.off?.('message', onMessage);
+            ws.off?.('close', handlers.onClose);
+            if (handlers.onError)
+                ws.off?.('error', handlers.onError);
+        };
+    }
+    const onMessage = (ev) => {
+        const data = ev.data;
+        handlers.onMessage(typeof data === 'string' ? data : '');
+    };
+    const onClose = () => handlers.onClose();
+    const onError = handlers.onError
+        ? () => handlers.onError?.(new Error('WebSocket error'))
+        : undefined;
+    ws.addEventListener('message', onMessage);
+    ws.addEventListener('close', onClose);
+    if (onError)
+        ws.addEventListener('error', onError);
+    return () => {
+        ws.removeEventListener('message', onMessage);
+        ws.removeEventListener('close', onClose);
+        if (onError)
+            ws.removeEventListener('error', onError);
+    };
+}
+export function parseSandboxWsPayload(raw) {
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        payload = { text: raw };
+    }
+    const type = payload.type ?? 'private';
+    const id = payload.id ?? 'sandbox-user';
+    const content = typeof payload.content === 'string'
+        ? [{ type: 'text', data: { text: payload.content } }]
+        : Array.isArray(payload.content)
+            ? payload.content
+            : [{ type: 'text', data: { text: payload.text ?? raw } }];
+    const actionSegment = content.find((segment) => segment.type === 'action');
+    let action;
+    if (actionSegment?.data) {
+        const actionPayload = typeof actionSegment.data.payload === 'string'
+            ? actionSegment.data.payload
+            : typeof actionSegment.data.id === 'string'
+                ? actionSegment.data.id
+                : '';
+        const actionId = typeof actionSegment.data.id === 'string'
+            ? actionSegment.data.id
+            : actionPayload;
+        if (actionId || actionPayload) {
+            action = { id: actionId || actionPayload, payload: actionPayload || actionId };
+        }
+    }
+    let text = content
+        .flatMap((segment) => (segment.type === 'text' && typeof segment.data?.text === 'string'
+        ? [segment.data.text]
+        : []))
+        .join('\n');
+    if (!text.trim()) {
+        text = (typeof payload.text === 'string' && payload.text.trim())
+            ? payload.text
+            : action?.payload ?? raw;
+    }
+    return { type, id, content, timestamp: payload.timestamp ?? Date.now(), text, action };
+}
+/**
+ * Wire-encode an already-rendered outbound payload.
+ * Canonical segment mapping (old `segment-mapper` re-export of `to/fromCanonicalSegments`
+ * from legacy `zhin.js`) is intentionally not done here — the gateway/core render path
+ * owns that before `endpoint.send`.
+ */
+export function formatSandboxOutbound(payload) {
+    if (typeof payload === 'string') {
+        return JSON.stringify({
+            content: [{ type: 'text', data: { text: payload } }],
+            timestamp: Date.now(),
+        });
+    }
+    if (Array.isArray(payload)) {
+        return JSON.stringify({
+            content: payload,
+            timestamp: Date.now(),
+        });
+    }
+    return JSON.stringify({ content: payload, timestamp: Date.now() });
+}
+/** WebSocket.OPEN 常量值；Node <22 无全局 WebSocket，不能用 WebSocket.OPEN。 */
+const WS_OPEN = 1;
+export function whenWsOpen(ws, fn) {
+    const std = ws;
+    if (typeof std.readyState === 'number') {
+        if (std.readyState === WS_OPEN) {
+            fn();
+            return;
+        }
+        std.addEventListener('open', fn, { once: true });
+        return;
+    }
+    fn();
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhin.js/adapter-sandbox",
-  "version": "5.0.5",
-  "description": "Zhin.js adapter for local testing and development",
+  "version": "5.0.6",
+  "description": "Zhin.js Sandbox adapter for Plugin Runtime (WebSocket /sandbox)",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -13,9 +13,12 @@
     }
   },
   "files": [
+    "adapters",
+    "pages",
+    "plugin.ts",
+    "schema.json",
     "src",
     "lib",
-    "client",
     "dist",
     "agent",
     "README.md",
@@ -43,35 +46,34 @@
     "directory": "plugins/adapters/sandbox"
   },
   "dependencies": {
-    "lucide-react": "^1.22.0"
+    "react": "^19.1.0",
+    "@zhin.js/console-contract": "1.0.0",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/logger": "1.0.75",
+    "@zhin.js/page": "1.0.1",
+    "@zhin.js/plugin-runtime": "1.0.1"
   },
   "devDependencies": {
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
     "typescript": "^6.0.3",
-    "@zhin.js/cli": "1.0.93",
-    "@zhin.js/client": "2.0.5",
-    "@zhin.js/contract": "1.0.3",
-    "@zhin.js/core": "1.3.4",
-    "@zhin.js/host-api": "2.0.5",
-    "@zhin.js/host-router": "2.0.3",
-    "zhin.js": "4.1.2"
+    "vitest": "^4.1.10",
+    "ws": "^8.21.0",
+    "@zhin.js/pagemanager": "2.0.4",
+    "@zhin.js/runtime": "1.0.1"
   },
   "peerDependencies": {
-    "@zhin.js/core": "1.3.4",
-    "@zhin.js/client": "2.0.5",
-    "@zhin.js/host-router": "2.0.3",
-    "@zhin.js/host-api": "2.0.5",
-    "@zhin.js/contract": "1.0.3"
+    "react": "^19.0.0",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/console-contract": "1.0.0",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/page": "1.0.1",
+    "@zhin.js/plugin-runtime": "1.0.1"
   },
   "peerDependenciesMeta": {
-    "@zhin.js/host-router": {
-      "optional": true
-    },
-    "@zhin.js/host-api": {
-      "optional": true
-    },
-    "@zhin.js/client": {
+    "react": {
       "optional": true
     }
   },
@@ -82,8 +84,27 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
+  "zhin": {
+    "protocol": 1,
+    "type": "plugin",
+    "entry": "./plugin.ts",
+    "engine": "^1.0.0",
+    "runtime": "trusted",
+    "features": [
+      {
+        "package": "@zhin.js/adapter",
+        "api": "^1.0.0"
+      },
+      {
+        "package": "@zhin.js/page",
+        "api": "^1.0.0"
+      }
+    ],
+    "plugins": []
+  },
   "scripts": {
-    "build": "zhin build",
-    "clean": "rimraf lib"
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "test": "NODE_OPTIONS=--experimental-strip-types vitest run --root ../../.. plugins/adapters/sandbox/tests"
   }
 }