@aiot-nexus/plugin-sdk 1.0.2 → 1.1.1

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;

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

@@ -0,0 +1,195 @@
+"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.beginManifestAndRendererDeployment = exports.beginRendererDeployment = exports.beginPluginPackageDeployment = exports.resolveNexusExecutable = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dev_1 = require("./dev");
+function resolveNexusExecutable(hostPath) {
+    const resolved = path.resolve(hostPath);
+    if (!fs.existsSync(resolved)) {
+        throw new dev_1.PluginDevError("Nexus host path does not exist: " + resolved);
+    }
+    const stat = fs.statSync(resolved);
+    const executable = stat.isDirectory() ? path.join(resolved, "nexus.exe") : resolved;
+    if (!fs.existsSync(executable) || !fs.statSync(executable).isFile()) {
+        throw new dev_1.PluginDevError("Nexus executable is missing: " + executable);
+    }
+    if (process.platform === "win32" && path.extname(executable).toLowerCase() !== ".exe") {
+        throw new dev_1.PluginDevError("Nexus host must be a Windows executable: " + executable);
+    }
+    return executable;
+}
+exports.resolveNexusExecutable = resolveNexusExecutable;
+function beginPluginPackageDeployment(packageDirectory, nexusExecutable, pluginId) {
+    const pluginsDirectory = path.join(path.dirname(nexusExecutable), "Plugins");
+    fs.mkdirSync(pluginsDirectory, { recursive: true });
+    const targetDirectory = path.join(pluginsDirectory, pluginId);
+    assertDirectChild(pluginsDirectory, targetDirectory);
+    return activateReplacements([prepareReplacement(packageDirectory, targetDirectory)]);
+}
+exports.beginPluginPackageDeployment = beginPluginPackageDeployment;
+function beginRendererDeployment(rendererDirectory, deployedPluginDirectory) {
+    const targetDirectory = path.join(deployedPluginDirectory, "renderer");
+    assertDirectChild(deployedPluginDirectory, targetDirectory);
+    return activateReplacements([prepareReplacement(rendererDirectory, targetDirectory)]);
+}
+exports.beginRendererDeployment = beginRendererDeployment;
+function beginManifestAndRendererDeployment(manifestPath, rendererDirectory, deployedPluginDirectory) {
+    const targetManifestPath = path.join(deployedPluginDirectory, "manifest.json");
+    const targetRendererDirectory = path.join(deployedPluginDirectory, "renderer");
+    assertDirectChild(deployedPluginDirectory, targetManifestPath);
+    assertDirectChild(deployedPluginDirectory, targetRendererDirectory);
+    const prepared = prepareReplacements([
+        { sourcePath: rendererDirectory, targetPath: targetRendererDirectory },
+        { sourcePath: manifestPath, targetPath: targetManifestPath }
+    ]);
+    return activateReplacements(prepared);
+}
+exports.beginManifestAndRendererDeployment = beginManifestAndRendererDeployment;
+function prepareReplacements(items) {
+    const prepared = [];
+    try {
+        for (const item of items) {
+            prepared.push(prepareReplacement(item.sourcePath, item.targetPath));
+        }
+        return prepared;
+    }
+    catch (error) {
+        rollbackPrepared(prepared);
+        throw error;
+    }
+}
+function prepareReplacement(sourcePath, targetPath) {
+    if (!fs.existsSync(sourcePath)) {
+        throw new dev_1.PluginDevError("Plugin deployment source is missing: " + sourcePath);
+    }
+    const parentDirectory = path.dirname(targetPath);
+    fs.mkdirSync(parentDirectory, { recursive: true });
+    const suffix = String(process.pid) + "-" + crypto.randomBytes(8).toString("hex");
+    const safeName = path.basename(targetPath).replace(/[^A-Za-z0-9._-]/g, "_");
+    const stagedPath = path.join(parentDirectory, ".nexus-plugin-dev-" + safeName + "-stage-" + suffix);
+    const backupPath = path.join(parentDirectory, ".nexus-plugin-dev-" + safeName + "-backup-" + suffix);
+    try {
+        copyPath(sourcePath, stagedPath);
+    }
+    catch (error) {
+        removePath(stagedPath);
+        throw new dev_1.PluginDevError("Could not stage plugin deployment: " + errorMessage(error));
+    }
+    return {
+        targetPath,
+        stagedPath,
+        backupPath,
+        targetExisted: fs.existsSync(targetPath),
+        activated: false
+    };
+}
+function activateReplacements(prepared) {
+    try {
+        for (const item of prepared) {
+            if (item.targetExisted) {
+                fs.renameSync(item.targetPath, item.backupPath);
+            }
+            try {
+                fs.renameSync(item.stagedPath, item.targetPath);
+                item.activated = true;
+            }
+            catch (error) {
+                if (item.targetExisted && fs.existsSync(item.backupPath)) {
+                    fs.renameSync(item.backupPath, item.targetPath);
+                }
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        rollbackPrepared(prepared);
+        throw new dev_1.PluginDevError("Could not activate staged plugin deployment: " + errorMessage(error));
+    }
+    let finished = false;
+    return {
+        targetPath: prepared[0].targetPath,
+        commit() {
+            if (finished) {
+                return;
+            }
+            for (const item of prepared) {
+                removePath(item.backupPath);
+                removePath(item.stagedPath);
+            }
+            finished = true;
+        },
+        rollback() {
+            if (finished) {
+                return;
+            }
+            rollbackPrepared(prepared);
+            finished = true;
+        }
+    };
+}
+function rollbackPrepared(prepared) {
+    for (const item of prepared.slice().reverse()) {
+        if (item.activated) {
+            removePath(item.targetPath);
+            item.activated = false;
+        }
+        if (item.targetExisted && fs.existsSync(item.backupPath)) {
+            fs.renameSync(item.backupPath, item.targetPath);
+        }
+        removePath(item.stagedPath);
+        removePath(item.backupPath);
+    }
+}
+function copyPath(sourcePath, targetPath) {
+    const stat = fs.lstatSync(sourcePath);
+    if (stat.isSymbolicLink()) {
+        throw new Error("Symbolic links are not supported: " + sourcePath);
+    }
+    if (stat.isFile()) {
+        fs.copyFileSync(sourcePath, targetPath);
+        return;
+    }
+    if (!stat.isDirectory()) {
+        throw new Error("Unsupported deployment entry: " + sourcePath);
+    }
+    fs.mkdirSync(targetPath, { recursive: true });
+    for (const entry of fs.readdirSync(sourcePath, { withFileTypes: true })) {
+        copyPath(path.join(sourcePath, entry.name), path.join(targetPath, entry.name));
+    }
+}
+function removePath(value) {
+    fs.rmSync(value, { recursive: true, force: true });
+}
+function assertDirectChild(parentDirectory, targetPath) {
+    if (path.dirname(path.resolve(targetPath)).toLowerCase() !== path.resolve(parentDirectory).toLowerCase()) {
+        throw new dev_1.PluginDevError("Plugin deployment target escaped its expected directory: " + targetPath);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,21 @@
+import { type PluginDebugSelection, type PluginDebugTarget, type PluginMainInspectorMode } from "./dev";
+import { NexusDevControlServer } from "./nexus-dev-control";
+import type { PluginManifest } from "./types";
+export interface PluginNexusDevOptions extends PluginDebugSelection {
+    hostPath: string;
+    openDevTools: boolean;
+    inspectorMode?: PluginMainInspectorMode;
+    inspectorPort?: number;
+}
+export interface PluginNexusDevIo {
+    stdout(message: string): void;
+    stderr(message: string): void;
+}
+export type PluginSourceChangeKind = "renderer" | "manifest" | "restart";
+export declare function runPluginNexusDev(options: PluginNexusDevOptions, io: PluginNexusDevIo): Promise<number>;
+export declare function classifyPluginSourceChange(projectDirectory: string, changedPath: string): PluginSourceChangeKind | undefined;
+export declare function manifestChangeRequiresRestart(previous: PluginManifest, next: PluginManifest): boolean;
+export declare function mergePluginSourceChange(current: PluginSourceChangeKind | undefined, incoming: PluginSourceChangeKind): PluginSourceChangeKind;
+export declare function createNexusHostArguments(control: Pick<NexusDevControlServer, "pipePath" | "token">, target: PluginDebugTarget, options: Pick<PluginNexusDevOptions, "openDevTools" | "inspectorMode" | "inspectorPort">): string[];
+export declare function isRetryablePluginDeploymentError(error: unknown): boolean;
+export declare function shouldSuppressNativeBuildEvent(changedPath: string, buildRunning: boolean, ignoreUntil: number, now?: number): boolean;