@aiot-nexus/plugin-sdk 1.0.2 → 1.1.0

package/README.md

@@ -22,6 +22,7 @@ nexus-plugin validate <plugin-package-directory>
 nexus-plugin create <plugin-id> --template minimal|sqlite --output <parent-directory>
 nexus-plugin dev [plugin-project-directory]
 nexus-plugin dev:web [plugin-project-directory]
+nexus-plugin dev:nexus [plugin-project-directory] --host <nexus.exe-or-directory>
 ```
 
 `npm run pack:sdk` 将离线安装包写入 `package/`。该目录是本地构建产物，不进入 Git。`npm run publish:sdk` 发布到官方 npm registry；`prepack` 会强制运行测试、构建并核对实际 npm 文件清单，缺少任一公开入口时拒绝发布。
@@ -43,7 +44,7 @@ nexus-plugin create my-frame-plugin \
 - 目标目录非空时命令以返回码 `2` 拒绝覆盖。生成或安装失败返回 `1`。
 - 两套模板均读取宿主 `PluginRendererContext.language` 和 `themeMode`，通过 `onContextChanged` 在同一 iframe 内响应运行时语言与主题切换，并内置 `zh-CN` / `en-US` renderer 文案；manifest 使用相同文化资源本地化宿主入口。模板页面自身不提供语言或主题选择控件。
 
-默认来源从 npm registry 安装。离线开发时先执行 `npm run pack:sdk`，再通过 `--sdk-source /path/to/aiot-nexus-plugin-sdk-1.0.2.tgz` 指定本地包；CLI 会把本地包一并放入生成工程。
+默认来源从 npm registry 安装。离线开发时先执行 `npm run pack:sdk`，再通过 `--sdk-source /path/to/aiot-nexus-plugin-sdk-1.1.0.tgz` 指定本地包；CLI 会把本地包一并放入生成工程。
 
 ## 独立调试
 
@@ -81,3 +82,21 @@ nexus-plugin dev [plugin-project-directory]
 调试宿主工具栏中的语言和主题选择器用于模拟 Nexus 主框架 context，不属于插件页面。切换后调试宿主向同一 iframe 重发框架 `1.0.0` 已有的 `init` 消息；SDK 将后续 `init` 作为 context 更新并原地刷新语言和主题，同时仍接受可选的 `context-changed` 消息。调试宿主还复用正式的 `nexus-plugin://` 资源协议、iframe sandbox、CSP、消息结构、operation 校验以及当前 Host API 权限语义，但不包含 Nexus 的完整页面路由、Pinia 状态和应用级功能。交付前仍需把 `dist/<plugin-id>/` 放入正式 Nexus 完成集成验证。
 
 浏览器 UI 命令支持 `--no-build`、`--no-open`、`--port <port>`，以及与 Electron 调试宿主相同的 `--language`、`--theme`、`--surface` 和 `--contribution-id` 参数。它使用普通 `http://127.0.0.1` iframe，不模拟 `nexus-plugin://` 协议或 Electron sandbox，因此只作为 UI 开发入口。Renderer-only 输出不会覆盖正式插件制品。
+
+## 使用正式 Nexus 调试
+
+已经安装并构建插件后，可直接把编译好的正式 Nexus 作为宿主：
+
+```powershell
+npm run dev:nexus -- --host D:\prj\tmp\aiot-nexus\dist\electron\nexus-win32-x64\nexus.exe
+```
+
+`dev:nexus` 首次启动会完成正式构建，通过 staging 原子部署到 `<exeDir>/Plugins/<pluginId>/`，再由 CLI 以 `--plugin-dev`、随机控制管道和会话令牌启动 Nexus。开发通道只在这次由 CLI 管理的进程中启用；普通双击或不带 `--plugin-dev` 启动时不会创建控制管道，也不会打开 DevTools。
+
+| 修改范围 | 行为 |
+| --- | --- |
+| `src/renderer/**` | 只运行 `build:web` 并替换 renderer；宿主 PID 不变，iframe 重新完成 `ready/init`。 |
+| `src/manifest.json` 的展示、贡献点等安全字段 | 构建 renderer、原子替换 manifest 后重扫插件目录；宿主 PID 不变。 |
+| `src/main.ts`、依赖、原生模块或主进程相关 manifest 字段 | 完整构建成功后请求旧宿主退出，替换完整插件包并启动新宿主；宿主 PID 变化。 |
+
+更新构建或 manifest 重扫失败时保留上一个可运行部署；新宿主启动失败时回滚插件包并恢复旧版本。`mainEntry` 不通过清理 `require.cache` 热替换，主进程变化始终使用完整重启。默认打开 Renderer DevTools；可传 `--no-devtools`。主进程调试支持 `--inspect[=<port>]` 和 `--inspect-brk[=<port>]`，贡献点选择支持 `--surface` 与 `--contribution-id`。按 `Ctrl+C` 停止 CLI 时，CLI 会关闭其启动的正式宿主。

package/dist/src/cli/run.d.ts

@@ -3,5 +3,5 @@ export interface CliIo {
     stdout(message: string): void;
     stderr(message: string): void;
 }
-export declare function runCli(args: string[], io: CliIo): number;
+export declare function runCli(args: string[], io: CliIo): number | Promise<number>;
 export declare function usage(): string;

package/dist/src/cli/run.js

@@ -29,6 +29,7 @@ const index_1 = require("../index");
 const scaffold_1 = require("../scaffold");
 const dev_1 = require("../dev");
 const web_dev_1 = require("../web-dev");
+const nexus_dev_1 = require("../nexus-dev");
 const nodeEngine = ">=16.20.0 <17";
 function runCli(args, io) {
     const command = args[0];
@@ -70,6 +71,9 @@ function runCli(args, io) {
     if (command === "dev:web") {
         return runWebDev(args.slice(1), io);
     }
+    if (command === "dev:nexus") {
+        return runNexusDev(args.slice(1), io);
+    }
     return usageError(io, command ? "Unknown command: " + command : "A command is required.");
 }
 exports.runCli = runCli;
@@ -85,10 +89,100 @@ function usage() {
         "    [--contribution-id <id>] [--no-devtools]",
         "  nexus-plugin dev:web [plugin-project-directory] [--no-build] [--no-open] [--port <port>]",
         "    [--language <culture>] [--theme system|light|dark] [--surface business|tool|settings]",
+        "    [--contribution-id <id>]",
+        "  nexus-plugin dev:nexus [plugin-project-directory] --host <nexus.exe-or-directory>",
+        "    [--inspect[=<port>] | --inspect-brk[=<port>]] [--no-devtools]",
+        "    [--language <culture>] [--theme system|light|dark] [--surface business|tool|settings]",
         "    [--contribution-id <id>]"
     ].join("\n");
 }
 exports.usage = usage;
+function runNexusDev(args, io) {
+    if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+        io.stdout(usage());
+        return 0;
+    }
+    let projectDirectory = io.cwd();
+    let index = 0;
+    if (args[0] && !args[0].startsWith("--")) {
+        projectDirectory = path.resolve(io.cwd(), args[0]);
+        index = 1;
+    }
+    const options = {
+        projectDirectory,
+        openDevTools: true
+    };
+    const seen = new Set();
+    for (; index < args.length; index += 1) {
+        const option = args[index];
+        if (option === "--no-devtools") {
+            if (seen.has(option)) {
+                return usageError(io, "Duplicate option: " + option);
+            }
+            seen.add(option);
+            options.openDevTools = false;
+            continue;
+        }
+        const inspector = parseInspectorOption(option);
+        if (inspector) {
+            if (options.inspectorMode) {
+                return usageError(io, "Only one main-process inspector option can be used.");
+            }
+            const key = "--" + inspector.mode;
+            if (seen.has(key)) {
+                return usageError(io, "Duplicate option: " + key);
+            }
+            seen.add(key);
+            options.inspectorMode = inspector.mode;
+            options.inspectorPort = inspector.port;
+            continue;
+        }
+        if (!["--host", "--language", "--theme", "--surface", "--contribution-id"].includes(option)) {
+            return usageError(io, "Unknown dev:nexus option: " + option);
+        }
+        if (seen.has(option)) {
+            return usageError(io, "Duplicate option: " + option);
+        }
+        seen.add(option);
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            return usageError(io, option + " requires a value.");
+        }
+        index += 1;
+        if (option === "--host") {
+            options.hostPath = path.resolve(io.cwd(), value);
+        }
+        else if (option === "--language") {
+            options.language = value;
+        }
+        else if (option === "--theme") {
+            if (value !== "system" && value !== "light" && value !== "dark") {
+                return usageError(io, "theme must be system, light, or dark.");
+            }
+            options.themeMode = value;
+        }
+        else if (option === "--surface") {
+            if (value !== "business" && value !== "tool" && value !== "settings") {
+                return usageError(io, "surface must be business, tool, or settings.");
+            }
+            options.surface = value;
+        }
+        else {
+            options.contributionId = value;
+        }
+    }
+    if (!options.hostPath) {
+        return usageError(io, "dev:nexus requires --host <nexus.exe-or-directory>.");
+    }
+    return (0, nexus_dev_1.runPluginNexusDev)(options, io).catch((error) => {
+        if (error instanceof dev_1.PluginDevError) {
+            io.stderr(error.message);
+            return error.exitCode;
+        }
+        io.stderr("Packaged Nexus plugin development failed: " + (error instanceof Error ? error.message : String(error)));
+        return 1;
+    });
+}
 function runWebDev(args, io) {
     if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
         io.stdout(usage());

package/dist/src/cli.js

@@ -2,8 +2,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const run_1 = require("./cli/run");
-process.exitCode = (0, run_1.runCli)(process.argv.slice(2), {
+const result = (0, run_1.runCli)(process.argv.slice(2), {
     cwd: () => process.cwd(),
     stdout: (message) => process.stdout.write(message + "\n"),
     stderr: (message) => process.stderr.write(message + "\n")
 });
+if (typeof result === "number") {
+    process.exitCode = result;
+}
+else {
+    result.then((exitCode) => { process.exitCode = exitCode; }, (error) => {
+        process.stderr.write("nexus-plugin failed: " + (error instanceof Error ? error.message : String(error)) + "\n");
+        process.exitCode = 1;
+    });
+}

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 import pluginManifestSchema from "../.generated/plugin-manifest.schema.json";
-export declare const PLUGIN_SDK_VERSION = "1.0.2";
+export declare const PLUGIN_SDK_VERSION = "1.1.0";
 export { pluginManifestSchema };
 export * from "../.generated/plugin-framework-version";
 export * from "./types";

package/dist/src/index.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pluginManifestSchema = exports.PLUGIN_SDK_VERSION = void 0;
 const plugin_manifest_schema_json_1 = __importDefault(require("../.generated/plugin-manifest.schema.json"));
 exports.pluginManifestSchema = plugin_manifest_schema_json_1.default;
-exports.PLUGIN_SDK_VERSION = "1.0.2";
+exports.PLUGIN_SDK_VERSION = "1.1.0";
 __exportStar(require("../.generated/plugin-framework-version"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./browser/frame-client"), exports);

package/dist/src/nexus-dev-control.d.ts

@@ -0,0 +1,42 @@
+export type NexusDevUpdateType = "rendererUpdated" | "manifestUpdated";
+export interface NexusDevUpdateResult {
+    ok: boolean;
+    message: string;
+    requiresRestart?: boolean;
+}
+export declare class NexusDevControlServer {
+    readonly token: string;
+    readonly pipePath: string;
+    private server;
+    private socket;
+    private receiveBuffer;
+    private helloAccepted;
+    private authenticated;
+    private authenticationResolve;
+    private authenticationReject;
+    private authenticationPromise;
+    private disconnectionPromise;
+    private disconnectionResolve;
+    private disconnectHandler;
+    private readonly pendingUpdates;
+    private readonly pendingShutdowns;
+    private nextRequestId;
+    start(): Promise<void>;
+    waitForAuthentication(timeoutMs?: number): Promise<void>;
+    sendUpdate(type: NexusDevUpdateType, pluginId: string): Promise<NexusDevUpdateResult>;
+    requestShutdown(): Promise<void>;
+    waitForDisconnection(timeoutMs?: number): Promise<void>;
+    setDisconnectHandler(handler: (error: Error) => void): () => void;
+    isConnected(): boolean;
+    close(): Promise<void>;
+    private handleConnection;
+    private handleData;
+    private handleMessage;
+    private handleDisconnect;
+    private rejectPending;
+    private rejectPendingShutdowns;
+    private ensureAuthenticationPromise;
+    private ensureDisconnectionPromise;
+    private rejectAuthentication;
+}
+export declare function helloProofPayload(version: number, pid: number, nonce: string): string;

package/dist/src/nexus-dev-control.js

@@ -0,0 +1,401 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helloProofPayload = exports.NexusDevControlServer = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const dev_1 = require("./dev");
+const protocolVersion = 1;
+const maximumMessageBytes = 64 * 1024;
+const requestTimeoutMs = 10000;
+class NexusDevControlServer {
+    constructor() {
+        this.token = crypto.randomBytes(32).toString("hex");
+        this.pipePath = createPipePath();
+        this.receiveBuffer = Buffer.alloc(0);
+        this.helloAccepted = false;
+        this.authenticated = false;
+        this.pendingUpdates = new Map();
+        this.pendingShutdowns = new Map();
+        this.nextRequestId = 1;
+    }
+    async start() {
+        if (this.server) {
+            return;
+        }
+        await removeUnixSocket(this.pipePath);
+        const server = net.createServer((socket) => this.handleConnection(socket));
+        this.server = server;
+        await new Promise((resolve, reject) => {
+            const handleError = (error) => {
+                server.removeListener("listening", handleListening);
+                reject(error);
+            };
+            const handleListening = () => {
+                server.removeListener("error", handleError);
+                resolve();
+            };
+            server.once("error", handleError);
+            server.once("listening", handleListening);
+            server.listen(this.pipePath);
+        }).catch((error) => {
+            this.server = undefined;
+            throw new dev_1.PluginDevError("Plugin development control pipe could not start: " + errorMessage(error));
+        });
+    }
+    async waitForAuthentication(timeoutMs = 15000) {
+        if (this.authenticated) {
+            return;
+        }
+        const authenticationPromise = this.ensureAuthenticationPromise();
+        if (timeoutMs <= 0) {
+            await authenticationPromise;
+            return;
+        }
+        let timer;
+        try {
+            await Promise.race([
+                authenticationPromise,
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new dev_1.PluginDevError("Nexus did not authenticate the plugin development control connection.")), timeoutMs);
+                })
+            ]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    sendUpdate(type, pluginId) {
+        if (!this.authenticated || !this.socket || this.socket.destroyed) {
+            return Promise.reject(new dev_1.PluginDevError("Nexus plugin development control connection is not ready."));
+        }
+        const requestId = String(process.pid) + "-" + String(this.nextRequestId++);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingUpdates.delete(requestId);
+                reject(new dev_1.PluginDevError("Nexus timed out while applying " + type + "."));
+            }, requestTimeoutMs);
+            this.pendingUpdates.set(requestId, { type, pluginId, resolve, reject, timer });
+            this.socket?.write(JSON.stringify({ type, pluginId, requestId }) + "\n");
+        });
+    }
+    requestShutdown() {
+        if (!this.authenticated || !this.socket || this.socket.destroyed) {
+            return Promise.reject(new dev_1.PluginDevError("Nexus plugin development control connection is not ready."));
+        }
+        const requestId = String(process.pid) + "-shutdown-" + String(this.nextRequestId++);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingShutdowns.delete(requestId);
+                reject(new dev_1.PluginDevError("Nexus timed out while accepting the plugin development restart."));
+            }, requestTimeoutMs);
+            this.pendingShutdowns.set(requestId, { resolve, reject, timer });
+            this.socket?.write(JSON.stringify({ type: "shutdown", requestId }) + "\n");
+        });
+    }
+    waitForDisconnection(timeoutMs = 10000) {
+        if (!this.socket) {
+            return Promise.resolve();
+        }
+        const disconnectionPromise = this.ensureDisconnectionPromise();
+        return withTimeout(disconnectionPromise, timeoutMs, "Nexus did not close the plugin development control connection.");
+    }
+    setDisconnectHandler(handler) {
+        this.disconnectHandler = handler;
+        return () => {
+            if (this.disconnectHandler === handler) {
+                this.disconnectHandler = undefined;
+            }
+        };
+    }
+    isConnected() {
+        return Boolean(this.authenticated && this.socket && !this.socket.destroyed);
+    }
+    async close() {
+        this.rejectPending(new dev_1.PluginDevError("Plugin development control connection closed."));
+        this.rejectPendingShutdowns(new dev_1.PluginDevError("Plugin development control connection closed."));
+        this.rejectAuthentication(new dev_1.PluginDevError("Plugin development control connection closed."));
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = undefined;
+        }
+        this.disconnectionResolve?.();
+        this.disconnectionPromise = undefined;
+        this.disconnectionResolve = undefined;
+        const server = this.server;
+        this.server = undefined;
+        if (server) {
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+        await removeUnixSocket(this.pipePath);
+    }
+    handleConnection(socket) {
+        if (this.socket) {
+            socket.destroy();
+            return;
+        }
+        this.socket = socket;
+        this.ensureAuthenticationPromise();
+        this.ensureDisconnectionPromise();
+        socket.on("data", (chunk) => this.handleData(socket, chunk));
+        socket.on("error", (error) => this.handleDisconnect(socket, error));
+        socket.on("close", () => this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control connection disconnected.")));
+    }
+    handleData(socket, chunk) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+        while (true) {
+            const newlineIndex = this.receiveBuffer.indexOf(0x0a);
+            if (newlineIndex < 0) {
+                if (this.receiveBuffer.length > maximumMessageBytes) {
+                    this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control message exceeded the size limit."));
+                }
+                return;
+            }
+            if (newlineIndex > maximumMessageBytes) {
+                this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control message exceeded the size limit."));
+                return;
+            }
+            const line = this.receiveBuffer.subarray(0, newlineIndex);
+            this.receiveBuffer = this.receiveBuffer.subarray(newlineIndex + 1);
+            if (line.length > 0 && !this.handleMessage(socket, line)) {
+                return;
+            }
+        }
+    }
+    handleMessage(socket, line) {
+        let value;
+        try {
+            value = JSON.parse(line.toString("utf8"));
+        }
+        catch {
+            this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control message is not valid JSON."));
+            return false;
+        }
+        if (!this.helloAccepted) {
+            if (!isHelloMessage(value) || !verifyHelloProof(value, this.token)) {
+                this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control proof is invalid."));
+                return false;
+            }
+            this.helloAccepted = true;
+            this.socket?.write(JSON.stringify({ type: "authenticate", token: this.token }) + "\n");
+            return true;
+        }
+        if (!this.authenticated && isAuthenticatedMessage(value)) {
+            this.authenticated = true;
+            this.authenticationResolve?.();
+            this.authenticationResolve = undefined;
+            this.authenticationReject = undefined;
+            return true;
+        }
+        if (!this.authenticated) {
+            this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control authentication response is invalid."));
+            return false;
+        }
+        if (isUpdateResult(value)) {
+            const pending = this.pendingUpdates.get(value.requestId);
+            if (!pending) {
+                return true;
+            }
+            if (value.updateType !== pending.type || value.pluginId !== pending.pluginId) {
+                const error = new dev_1.PluginDevError("Nexus plugin development update result did not match its request.");
+                this.pendingUpdates.delete(value.requestId);
+                clearTimeout(pending.timer);
+                pending.reject(error);
+                this.handleDisconnect(socket, error);
+                return false;
+            }
+            this.pendingUpdates.delete(value.requestId);
+            clearTimeout(pending.timer);
+            pending.resolve({
+                ok: value.ok,
+                message: value.message,
+                ...(value.requiresRestart ? { requiresRestart: true } : {})
+            });
+            return true;
+        }
+        if (isShutdownResult(value)) {
+            const pending = this.pendingShutdowns.get(value.requestId);
+            if (!pending) {
+                return true;
+            }
+            this.pendingShutdowns.delete(value.requestId);
+            clearTimeout(pending.timer);
+            if (value.ok) {
+                pending.resolve();
+            }
+            else {
+                pending.reject(new dev_1.PluginDevError(value.message));
+            }
+            return true;
+        }
+        this.handleDisconnect(socket, new dev_1.PluginDevError("Nexus plugin development control message is invalid."));
+        return false;
+    }
+    handleDisconnect(socket, error) {
+        if (socket !== this.socket) {
+            return;
+        }
+        const wasAuthenticated = this.authenticated;
+        this.socket = undefined;
+        this.helloAccepted = false;
+        this.authenticated = false;
+        this.receiveBuffer = Buffer.alloc(0);
+        if (socket && !socket.destroyed) {
+            socket.destroy();
+        }
+        this.rejectAuthentication(error);
+        this.rejectPending(error);
+        this.rejectPendingShutdowns(error);
+        this.disconnectionResolve?.();
+        this.disconnectionPromise = undefined;
+        this.disconnectionResolve = undefined;
+        if (wasAuthenticated) {
+            this.disconnectHandler?.(error);
+        }
+    }
+    rejectPending(error) {
+        for (const pending of this.pendingUpdates.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingUpdates.clear();
+    }
+    rejectPendingShutdowns(error) {
+        for (const pending of this.pendingShutdowns.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingShutdowns.clear();
+    }
+    ensureAuthenticationPromise() {
+        if (!this.authenticationPromise) {
+            this.authenticationPromise = new Promise((resolve, reject) => {
+                this.authenticationResolve = resolve;
+                this.authenticationReject = reject;
+            });
+        }
+        return this.authenticationPromise;
+    }
+    ensureDisconnectionPromise() {
+        if (!this.disconnectionPromise) {
+            this.disconnectionPromise = new Promise((resolve) => {
+                this.disconnectionResolve = resolve;
+            });
+        }
+        return this.disconnectionPromise;
+    }
+    rejectAuthentication(error) {
+        this.authenticationReject?.(error);
+        this.authenticationPromise = undefined;
+        this.authenticationReject = undefined;
+        this.authenticationResolve = undefined;
+    }
+}
+exports.NexusDevControlServer = NexusDevControlServer;
+function withTimeout(promise, timeoutMs, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new dev_1.PluginDevError(message)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function createPipePath() {
+    const suffix = String(process.pid) + "-" + crypto.randomBytes(12).toString("hex");
+    return process.platform === "win32"
+        ? "\\\\.\\pipe\\nexus-plugin-dev-" + suffix
+        : path.join(os.tmpdir(), "nexus-plugin-dev-" + suffix + ".sock");
+}
+function verifyHelloProof(value, token) {
+    if (value.proof === undefined) {
+        return true;
+    }
+    const expected = crypto.createHmac("sha256", token)
+        .update(helloProofPayload(value.protocolVersion, value.pid, value.nonce), "utf8")
+        .digest("hex");
+    return value.proof.length === expected.length
+        && crypto.timingSafeEqual(Buffer.from(value.proof, "utf8"), Buffer.from(expected, "utf8"));
+}
+function helloProofPayload(version, pid, nonce) {
+    return "nexus-plugin-dev:" + String(version) + ":" + String(pid) + ":" + nonce;
+}
+exports.helloProofPayload = helloProofPayload;
+function isHelloMessage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return value.type === "hello"
+        && value.protocolVersion === protocolVersion
+        && typeof value.pid === "number" && Number.isSafeInteger(value.pid) && value.pid > 0
+        && typeof value.nonce === "string" && /^[a-f0-9]{32}$/i.test(value.nonce)
+        && (value.proof === undefined || (typeof value.proof === "string" && /^[a-f0-9]{64}$/i.test(value.proof)));
+}
+function isAuthenticatedMessage(value) {
+    return isRecord(value)
+        && value.type === "authenticated"
+        && value.protocolVersion === protocolVersion
+        && typeof value.pid === "number" && Number.isSafeInteger(value.pid) && value.pid > 0;
+}
+function isUpdateResult(value) {
+    return isRecord(value)
+        && value.type === "updateResult"
+        && typeof value.requestId === "string"
+        && (value.updateType === "rendererUpdated" || value.updateType === "manifestUpdated")
+        && typeof value.pluginId === "string"
+        && typeof value.ok === "boolean"
+        && typeof value.message === "string"
+        && (value.requiresRestart === undefined || typeof value.requiresRestart === "boolean");
+}
+function isShutdownResult(value) {
+    return isRecord(value)
+        && value.type === "shutdownResult"
+        && typeof value.requestId === "string"
+        && typeof value.ok === "boolean"
+        && typeof value.message === "string";
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function removeUnixSocket(pipePath) {
+    if (process.platform !== "win32") {
+        await fs.promises.rm(pipePath, { force: true });
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/nexus-dev-deployment.d.ts

@@ -0,0 +1,9 @@
+export interface PluginDeploymentTransaction {
+    readonly targetPath: string;
+    commit(): void;
+    rollback(): void;
+}
+export declare function resolveNexusExecutable(hostPath: string): string;
+export declare function beginPluginPackageDeployment(packageDirectory: string, nexusExecutable: string, pluginId: string): PluginDeploymentTransaction;
+export declare function beginRendererDeployment(rendererDirectory: string, deployedPluginDirectory: string): PluginDeploymentTransaction;
+export declare function beginManifestAndRendererDeployment(manifestPath: string, rendererDirectory: string, deployedPluginDirectory: string): PluginDeploymentTransaction;