@aiot-nexus/plugin-sdk 1.0.2 → 1.1.0

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;