@aiot-nexus/plugin-sdk 1.0.1 → 1.1.0

package/dist/src/nexus-dev.js

@@ -0,0 +1,569 @@
+"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.shouldSuppressNativeBuildEvent = exports.isRetryablePluginDeploymentError = exports.createNexusHostArguments = exports.mergePluginSourceChange = exports.manifestChangeRequiresRestart = exports.classifyPluginSourceChange = exports.runPluginNexusDev = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dev_1 = require("./dev");
+const nexus_dev_control_1 = require("./nexus-dev-control");
+const nexus_dev_deployment_1 = require("./nexus-dev-deployment");
+async function runPluginNexusDev(options, io) {
+    return new PluginNexusDevSession(options, io).run();
+}
+exports.runPluginNexusDev = runPluginNexusDev;
+class PluginNexusDevSession {
+    constructor(options, io) {
+        this.options = options;
+        this.io = io;
+        this.control = new nexus_dev_control_1.NexusDevControlServer();
+        this.deployedPluginDirectory = "";
+        this.expectedExits = new Set();
+        this.provisionalChildren = new Set();
+        this.restarting = false;
+        this.stopping = false;
+        this.terminalSettled = false;
+        this.terminalPromise = new Promise((resolve) => {
+            this.terminalResolve = resolve;
+        });
+        this.handleSignal = () => {
+            if (this.stopping) {
+                return;
+            }
+            this.stopping = true;
+            this.watcher?.close();
+            void (async () => {
+                await this.watcher?.drain();
+                await this.stopCurrentHost();
+                this.settleTerminal(0);
+            })();
+        };
+        this.projectDirectory = path.resolve(options.projectDirectory);
+        this.nexusExecutable = (0, nexus_dev_deployment_1.resolveNexusExecutable)(options.hostPath);
+    }
+    async run() {
+        this.io.stdout("Building plugin for the packaged Nexus host: " + this.projectDirectory);
+        (0, dev_1.buildPluginForDevelopment)(this.projectDirectory);
+        const target = (0, dev_1.preparePluginDebugTarget)({ ...this.options, projectDirectory: this.projectDirectory });
+        const deployment = (0, nexus_dev_deployment_1.beginPluginPackageDeployment)(target.packageDirectory, this.nexusExecutable, target.pluginId);
+        deployment.commit();
+        this.target = target;
+        this.deployedPluginDirectory = path.join(path.dirname(this.nexusExecutable), "Plugins", target.pluginId);
+        this.io.stdout("Deployed plugin package: " + this.deployedPluginDirectory
+            + "\nContribution: " + target.surface + ":" + target.contributionId);
+        try {
+            await this.control.start();
+            this.disposeDisconnectHandler = this.control.setDisconnectHandler((error) => {
+                if (!this.stopping && !this.restarting) {
+                    this.io.stderr("Packaged Nexus plugin development control disconnected: " + error.message);
+                    this.settleTerminal(1);
+                }
+            });
+            this.installSignalHandlers();
+            await this.launchHost(target);
+            if (this.stopping) {
+                return await this.terminalPromise;
+            }
+            this.watcher = new PluginSourceWatcher(this.projectDirectory, async (kind) => {
+                const currentTarget = this.requireTarget();
+                await applyPluginSourceChange(kind, this.options, currentTarget, this.deployedPluginDirectory, this.control, this.io, () => this.restartHost(), () => this.runBuild(() => (0, dev_1.buildPluginRendererForDevelopment)(currentTarget.projectDirectory)));
+            }, this.io);
+            this.watcher.start();
+            this.io.stdout("Watching plugin source changes. Press Ctrl+C to stop.");
+            return await this.terminalPromise;
+        }
+        finally {
+            this.stopping = true;
+            this.watcher?.close();
+            await this.watcher?.drain();
+            this.removeSignalHandlers();
+            this.disposeDisconnectHandler?.();
+            this.disposeDisconnectHandler = undefined;
+            await this.stopCurrentHost();
+            await this.control.close();
+        }
+    }
+    async restartHost() {
+        const previousTarget = this.requireTarget();
+        this.io.stdout("Building complete plugin package before restarting Nexus...");
+        this.runBuild(() => (0, dev_1.buildPluginForDevelopment)(this.projectDirectory));
+        const updatedTarget = (0, dev_1.preparePluginDebugTarget)({
+            projectDirectory: this.projectDirectory,
+            surface: previousTarget.surface,
+            contributionId: previousTarget.contributionId,
+            language: this.options.language,
+            themeMode: this.options.themeMode
+        });
+        if (updatedTarget.pluginId !== previousTarget.pluginId) {
+            throw new dev_1.PluginDevError("Plugin id cannot change during a Nexus development session.");
+        }
+        this.restarting = true;
+        let transaction;
+        let transactionCommitted = false;
+        try {
+            await this.shutdownHostForRestart();
+            transaction = await retryFileOperation(() => (0, nexus_dev_deployment_1.beginPluginPackageDeployment)(updatedTarget.packageDirectory, this.nexusExecutable, updatedTarget.pluginId), "replace the plugin package");
+            try {
+                const updatedChild = await this.launchHost(updatedTarget, true);
+                await this.ensureProvisionalHostIsStable(updatedChild);
+                this.acceptProvisionalHost(updatedChild);
+            }
+            catch (error) {
+                await this.stopCurrentHost();
+                await retryFileOperation(() => transaction?.rollback(), "roll back the plugin package");
+                const previousChild = await this.launchHost(previousTarget, true);
+                await this.ensureProvisionalHostIsStable(previousChild);
+                this.acceptProvisionalHost(previousChild);
+                throw new dev_1.PluginDevError("Updated Nexus host failed to start; the previous plugin package was restored. " + errorMessage(error));
+            }
+            transactionCommitted = true;
+            this.restarting = false;
+            try {
+                await retryFileOperation(() => transaction?.commit(), "remove the previous plugin package backup");
+            }
+            catch (error) {
+                this.io.stderr("Updated plugin is active, but its previous package backup could not be removed: " + errorMessage(error));
+            }
+            this.target = updatedTarget;
+            this.io.stdout("Packaged Nexus restarted for plugin mainEntry update. PID: " + String(this.child?.pid || "unknown"));
+        }
+        catch (error) {
+            if (!this.child) {
+                if (transaction && !transactionCommitted) {
+                    await retryFileOperation(() => transaction?.rollback(), "roll back the plugin package");
+                }
+                const previousChild = await this.launchHost(previousTarget, true);
+                await this.ensureProvisionalHostIsStable(previousChild);
+                this.acceptProvisionalHost(previousChild);
+            }
+            throw error;
+        }
+        finally {
+            this.restarting = false;
+        }
+    }
+    async launchHost(target, provisional = false) {
+        const hostArgs = createNexusHostArguments(this.control, target, this.options);
+        this.io.stdout("Starting packaged Nexus host: " + this.nexusExecutable);
+        const child = (0, child_process_1.spawn)(this.nexusExecutable, hostArgs, {
+            cwd: path.dirname(this.nexusExecutable),
+            env: process.env,
+            stdio: "inherit",
+            windowsHide: false
+        });
+        this.child = child;
+        if (provisional) {
+            this.provisionalChildren.add(child);
+        }
+        const hostExit = waitForHostExit(child);
+        this.childExit = hostExit;
+        hostExit.then((result) => this.handleHostExit(child, result), (error) => {
+            if (!this.restarting && !this.stopping) {
+                this.io.stderr(errorMessage(error));
+                this.settleTerminal(1);
+            }
+        });
+        await Promise.race([
+            this.control.waitForAuthentication(this.options.inspectorMode === "inspect-brk" ? 0 : 15000),
+            hostExit.then((result) => {
+                if (this.stopping) {
+                    return;
+                }
+                throw new dev_1.PluginDevError(formatEarlyHostExit(result));
+            })
+        ]);
+        if (this.stopping) {
+            return child;
+        }
+        this.io.stdout("Packaged Nexus plugin development control connected. PID: " + String(child.pid || "unknown"));
+        return child;
+    }
+    handleHostExit(child, result) {
+        if (this.child === child) {
+            this.child = undefined;
+            this.childExit = undefined;
+        }
+        const provisional = this.provisionalChildren.delete(child);
+        if (this.expectedExits.delete(child) || provisional || this.stopping) {
+            return;
+        }
+        const exitCode = result.status === null ? 1 : result.status;
+        this.io.stderr("Packaged Nexus host exited unexpectedly"
+            + (result.status === null ? "" : " with code " + String(result.status))
+            + (result.signal ? " (" + result.signal + ")" : "") + ".");
+        this.settleTerminal(exitCode === 0 ? 1 : exitCode);
+    }
+    async shutdownHostForRestart() {
+        const child = this.child;
+        const hostExit = this.childExit;
+        if (!child || !hostExit) {
+            throw new dev_1.PluginDevError("Packaged Nexus host is not running.");
+        }
+        this.expectedExits.add(child);
+        try {
+            await this.control.requestShutdown();
+        }
+        catch (error) {
+            this.expectedExits.delete(child);
+            throw error;
+        }
+        try {
+            await promiseWithTimeout(hostExit, 10000, "Nexus did not exit after accepting the plugin development restart.");
+        }
+        catch (error) {
+            child.kill();
+            await promiseWithTimeout(hostExit, 5000, "Nexus could not be stopped for the plugin development restart.");
+            this.io.stderr("Nexus required forced termination before plugin replacement: " + errorMessage(error));
+        }
+        await this.control.waitForDisconnection();
+    }
+    async stopCurrentHost() {
+        const child = this.child;
+        const hostExit = this.childExit;
+        if (!child || !hostExit) {
+            return;
+        }
+        this.expectedExits.add(child);
+        try {
+            await this.control.requestShutdown();
+            await promiseWithTimeout(hostExit, 5000, "Nexus did not exit during plugin development shutdown.");
+        }
+        catch {
+            child.kill();
+            try {
+                await promiseWithTimeout(hostExit, 3000, "Nexus did not terminate after plugin development shutdown.");
+            }
+            catch {
+                // The CLI is already stopping; do not start another host or a restart loop.
+            }
+        }
+    }
+    async ensureProvisionalHostIsStable(child) {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        if (this.child !== child || child.exitCode !== null || child.signalCode !== null || !this.control.isConnected()) {
+            throw new dev_1.PluginDevError("Restarted Nexus host did not remain connected after authentication.");
+        }
+    }
+    acceptProvisionalHost(child) {
+        if (this.child !== child || !this.control.isConnected()) {
+            throw new dev_1.PluginDevError("Restarted Nexus host disconnected before activation completed.");
+        }
+        this.provisionalChildren.delete(child);
+    }
+    runBuild(operation) {
+        return this.watcher ? this.watcher.runBuild(operation) : operation();
+    }
+    installSignalHandlers() {
+        process.on("SIGINT", this.handleSignal);
+        process.on("SIGTERM", this.handleSignal);
+    }
+    removeSignalHandlers() {
+        process.removeListener("SIGINT", this.handleSignal);
+        process.removeListener("SIGTERM", this.handleSignal);
+    }
+    requireTarget() {
+        if (!this.target) {
+            throw new dev_1.PluginDevError("Plugin development target is not ready.");
+        }
+        return this.target;
+    }
+    settleTerminal(exitCode) {
+        if (this.terminalSettled) {
+            return;
+        }
+        this.terminalSettled = true;
+        this.terminalResolve?.(exitCode);
+        this.terminalResolve = undefined;
+    }
+}
+function classifyPluginSourceChange(projectDirectory, changedPath) {
+    const relativePath = path.relative(path.resolve(projectDirectory), path.resolve(changedPath)).replace(/\\/g, "/");
+    if (relativePath.startsWith("../") || relativePath === ".." || path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    if (relativePath === "src/manifest.json") {
+        return "manifest";
+    }
+    if (relativePath.startsWith("src/renderer/") || relativePath === "tsconfig.renderer.json") {
+        return "renderer";
+    }
+    if (relativePath.toLowerCase().endsWith(".node") || relativePath === "binding.gyp") {
+        return "restart";
+    }
+    if (relativePath.startsWith("src/")
+        || relativePath.startsWith("scripts/")
+        || relativePath === "package.json"
+        || relativePath === "package-lock.json"
+        || relativePath === "npm-shrinkwrap.json"
+        || relativePath === "tsconfig.main.json") {
+        return "restart";
+    }
+    return undefined;
+}
+exports.classifyPluginSourceChange = classifyPluginSourceChange;
+function manifestChangeRequiresRestart(previous, next) {
+    const restartSensitiveFields = [
+        "schemaVersion",
+        "pluginId",
+        "pluginVersion",
+        "hostApiVersion",
+        "minHostVersion",
+        "permissions",
+        "mainEntry",
+        "deferred"
+    ];
+    return restartSensitiveFields.some((field) => stableJson(previous[field]) !== stableJson(next[field]));
+}
+exports.manifestChangeRequiresRestart = manifestChangeRequiresRestart;
+function mergePluginSourceChange(current, incoming) {
+    const priority = { renderer: 1, manifest: 2, restart: 3 };
+    return !current || priority[incoming] > priority[current] ? incoming : current;
+}
+exports.mergePluginSourceChange = mergePluginSourceChange;
+async function applyPluginSourceChange(kind, options, initialTarget, deployedPluginDirectory, control, io, restartHost, buildRenderer) {
+    if (kind === "restart") {
+        await restartHost();
+        return;
+    }
+    try {
+        io.stdout("Building plugin renderer update...");
+        const packageKind = buildRenderer();
+        const updatedTarget = (0, dev_1.preparePluginBrowserDebugTarget)({
+            projectDirectory: initialTarget.projectDirectory,
+            surface: initialTarget.surface,
+            contributionId: initialTarget.contributionId,
+            language: options.language,
+            themeMode: options.themeMode
+        }, packageKind);
+        if (updatedTarget.pluginId !== initialTarget.pluginId) {
+            throw new dev_1.PluginDevError("Plugin id cannot change during a Nexus development session.");
+        }
+        const rendererDirectory = path.join(updatedTarget.packageDirectory, "renderer");
+        if (kind === "manifest") {
+            const previousManifest = readManifest(path.join(deployedPluginDirectory, "manifest.json"));
+            if (manifestChangeRequiresRestart(previousManifest, updatedTarget.manifest)) {
+                await restartHost();
+                return;
+            }
+            const transaction = (0, nexus_dev_deployment_1.beginManifestAndRendererDeployment)(path.join(updatedTarget.packageDirectory, "manifest.json"), rendererDirectory, deployedPluginDirectory);
+            await finishUpdateTransaction(transaction, "manifestUpdated", initialTarget.pluginId, control, io);
+            return;
+        }
+        const transaction = (0, nexus_dev_deployment_1.beginRendererDeployment)(rendererDirectory, deployedPluginDirectory);
+        await finishUpdateTransaction(transaction, "rendererUpdated", initialTarget.pluginId, control, io);
+    }
+    catch (error) {
+        io.stderr("Plugin update failed; the previous deployed version remains active: " + errorMessage(error));
+    }
+}
+async function finishUpdateTransaction(transaction, updateType, pluginId, control, io) {
+    let result;
+    try {
+        result = await control.sendUpdate(updateType, pluginId);
+    }
+    catch (error) {
+        transaction.rollback();
+        throw error;
+    }
+    if (!result.ok) {
+        transaction.rollback();
+        if (updateType === "manifestUpdated") {
+            const rollbackResult = await control.sendUpdate("manifestUpdated", pluginId);
+            if (!rollbackResult.ok) {
+                throw new dev_1.PluginDevError(result.message + " Rollback scan also failed: " + rollbackResult.message);
+            }
+        }
+        throw new dev_1.PluginDevError(result.message);
+    }
+    transaction.commit();
+    io.stdout((updateType === "rendererUpdated" ? "Plugin renderer reloaded." : "Plugin manifest rescanned.")
+        + (result.requiresRestart ? " Existing mainEntry state will remain active until the next host restart." : ""));
+}
+function createNexusHostArguments(control, target, options) {
+    const args = [];
+    if (options.inspectorMode) {
+        args.push("--" + options.inspectorMode + "=" + String(options.inspectorPort || 9229));
+    }
+    args.push("--plugin-dev", "--plugin-dev-control=" + control.pipePath, "--plugin-dev-token=" + control.token, "--page=" + resolveContributionPage(target));
+    if (target.surface !== "business") {
+        args.push("--page-param=nexusPluginDevContribution=" + target.contributionId);
+    }
+    if (!options.openDevTools) {
+        args.push("--plugin-dev-no-devtools");
+    }
+    return args;
+}
+exports.createNexusHostArguments = createNexusHostArguments;
+function resolveContributionPage(target) {
+    if (target.surface === "tool") {
+        return "toolbox";
+    }
+    if (target.surface === "settings") {
+        return "settings";
+    }
+    const entry = target.manifest.businessEntries?.find((item) => {
+        return item.component === "PluginFrame"
+            && (item.businessId === target.contributionId || item.pageRoute === target.contributionId);
+    });
+    return entry?.pageRoute || entry?.businessId || target.contributionId;
+}
+function waitForHostExit(child) {
+    return new Promise((resolve, reject) => {
+        child.once("error", (error) => reject(new dev_1.PluginDevError("Packaged Nexus host could not start: " + error.message)));
+        child.once("exit", (status, signal) => resolve({ status, signal }));
+    });
+}
+function formatEarlyHostExit(result) {
+    return "Packaged Nexus host exited before plugin development control authentication"
+        + (result.status === null ? "" : " with code " + String(result.status))
+        + (result.signal ? " (" + result.signal + ")" : "") + ".";
+}
+class PluginSourceWatcher {
+    constructor(projectDirectory, applyChange, io) {
+        this.projectDirectory = projectDirectory;
+        this.applyChange = applyChange;
+        this.io = io;
+        this.queue = Promise.resolve();
+        this.closed = false;
+        this.suppressNativeEvents = false;
+        this.ignoreNativeEventsUntil = 0;
+    }
+    start() {
+        this.watcher = fs.watch(this.projectDirectory, { recursive: true }, (_eventType, fileName) => {
+            if (!fileName || this.closed) {
+                return;
+            }
+            const changedPath = path.join(this.projectDirectory, fileName.toString());
+            if (shouldSuppressNativeBuildEvent(changedPath, this.suppressNativeEvents, this.ignoreNativeEventsUntil)) {
+                return;
+            }
+            const kind = classifyPluginSourceChange(this.projectDirectory, changedPath);
+            if (!kind) {
+                return;
+            }
+            this.pendingKind = mergePluginSourceChange(this.pendingKind, kind);
+            if (this.timer) {
+                clearTimeout(this.timer);
+            }
+            this.timer = setTimeout(() => this.flush(), 180);
+        });
+        this.watcher.on("error", (error) => this.io.stderr("Plugin source watcher failed: " + error.message));
+    }
+    close() {
+        this.closed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this.watcher?.close();
+        this.watcher = undefined;
+    }
+    drain() {
+        return this.queue;
+    }
+    runBuild(operation) {
+        this.suppressNativeEvents = true;
+        try {
+            return operation();
+        }
+        finally {
+            this.suppressNativeEvents = false;
+            this.ignoreNativeEventsUntil = Date.now() + 750;
+        }
+    }
+    flush() {
+        this.timer = undefined;
+        const kind = this.pendingKind;
+        this.pendingKind = undefined;
+        if (!kind || this.closed) {
+            return;
+        }
+        this.queue = this.queue
+            .then(() => this.applyChange(kind))
+            .catch((error) => this.io.stderr("Plugin update queue failed: " + errorMessage(error)));
+    }
+}
+function readManifest(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new dev_1.PluginDevError("Deployed plugin manifest is invalid: " + errorMessage(error));
+    }
+}
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return "[" + value.map(stableJson).join(",") + "]";
+    }
+    if (value && typeof value === "object") {
+        return "{" + Object.keys(value).sort().map((key) => {
+            return JSON.stringify(key) + ":" + stableJson(value[key]);
+        }).join(",") + "}";
+    }
+    return JSON.stringify(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRetryablePluginDeploymentError(error) {
+    const value = errorMessage(error).toUpperCase();
+    return value.includes("EBUSY") || value.includes("EPERM") || value.includes("EACCES") || value.includes("FILE IS BEING USED");
+}
+exports.isRetryablePluginDeploymentError = isRetryablePluginDeploymentError;
+function shouldSuppressNativeBuildEvent(changedPath, buildRunning, ignoreUntil, now = Date.now()) {
+    return changedPath.toLowerCase().endsWith(".node") && (buildRunning || now <= ignoreUntil);
+}
+exports.shouldSuppressNativeBuildEvent = shouldSuppressNativeBuildEvent;
+async function retryFileOperation(operation, label) {
+    const delays = [0, 75, 150, 300, 600, 900, 1200];
+    let lastError;
+    for (const delay of delays) {
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        try {
+            return operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryablePluginDeploymentError(error)) {
+                throw error;
+            }
+        }
+    }
+    throw new dev_1.PluginDevError("Could not " + label + " after waiting for Nexus file locks: " + errorMessage(lastError));
+}
+function promiseWithTimeout(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);
+        });
+    });
+}

package/dist/src/scaffold.js

@@ -199,7 +199,10 @@ function vendorSdkArchive(pluginDirectory, sourcePath) {
 function createPackageJson(options, sdkSource) {
     const scripts = {
         build: "node scripts/build.js && npm run validate",
+        "build:web": "node scripts/build.js --renderer-only",
         dev: "nexus-plugin dev .",
+        "dev:web": "nexus-plugin dev:web .",
+        "dev:nexus": "nexus-plugin dev:nexus .",
         "dev:debug": "nexus-plugin dev . --inspect-brk=9229",
         typecheck: "tsc -p tsconfig.main.json --noEmit && tsc -p tsconfig.renderer.json --noEmit",
         validate: "nexus-plugin validate dist/" + options.pluginId

package/dist/src/validation.d.ts

@@ -6,4 +6,7 @@ export interface PluginPackageValidationResult {
     manifest?: PluginManifest;
     errors: string[];
 }
-export declare function validatePluginPackage(packageDirectory: string): PluginPackageValidationResult;
+export interface PluginPackageValidationOptions {
+    target?: "package" | "renderer";
+}
+export declare function validatePluginPackage(packageDirectory: string, options?: PluginPackageValidationOptions): PluginPackageValidationResult;

package/dist/src/validation.js

@@ -34,17 +34,17 @@ const plugin_manifest_schema_json_1 = __importDefault(require("../.generated/plu
 const plugin_framework_version_1 = require("../.generated/plugin-framework-version");
 const manifestValidator = new _2020_1.default({ allErrors: true, strict: true })
     .compile(plugin_manifest_schema_json_1.default);
-function validatePluginPackage(packageDirectory) {
+function validatePluginPackage(packageDirectory, options = {}) {
     const resolvedDirectory = path.resolve(packageDirectory);
     try {
-        return validateResolvedPluginPackage(resolvedDirectory);
+        return validateResolvedPluginPackage(resolvedDirectory, options);
     }
     catch (error) {
         return invalid(resolvedDirectory, "Plugin package could not be inspected: " + errorMessage(error));
     }
 }
 exports.validatePluginPackage = validatePluginPackage;
-function validateResolvedPluginPackage(resolvedDirectory) {
+function validateResolvedPluginPackage(resolvedDirectory, options) {
     const errors = [];
     if (!fs.existsSync(resolvedDirectory)) {
         return invalid(resolvedDirectory, "Plugin package directory does not exist.");
@@ -88,7 +88,7 @@ function validateResolvedPluginPackage(resolvedDirectory) {
     if (!(0, plugin_framework_version_1.parsePluginCompatibleVersion)(manifest.minHostVersion)) {
         errors.push("minHostVersion contains an unsupported numeric version.");
     }
-    validateEntry(resolvedDirectory, "mainEntry", manifest.mainEntry, errors);
+    validateEntry(resolvedDirectory, "mainEntry", manifest.mainEntry, errors, options.target !== "renderer");
     validateEntry(resolvedDirectory, "rendererEntry", manifest.rendererEntry, errors);
     if (manifest.rendererEntry && path.extname(manifest.rendererEntry).toLowerCase() !== ".html") {
         errors.push("rendererEntry must point to an HTML file.");
@@ -104,7 +104,7 @@ function validateResolvedPluginPackage(resolvedDirectory) {
         errors
     };
 }
-function validateEntry(rootDirectory, fieldName, relativePath, errors) {
+function validateEntry(rootDirectory, fieldName, relativePath, errors, requireExistingFile = true) {
     if (!relativePath) {
         return;
     }
@@ -118,7 +118,9 @@ function validateEntry(rootDirectory, fieldName, relativePath, errors) {
         return;
     }
     if (!fs.existsSync(entryPath)) {
-        errors.push(fieldName + " does not exist: " + relativePath);
+        if (requireExistingFile) {
+            errors.push(fieldName + " does not exist: " + relativePath);
+        }
         return;
     }
     const entryStat = fs.lstatSync(entryPath);

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import * as http from "http";
+import { type PluginDebugSelection, type PluginDebugTarget, type PluginDevIo } from "./dev";
+export interface PluginWebDevOptions extends PluginDebugSelection {
+    build: boolean;
+    openBrowser: boolean;
+    port: number;
+}
+export declare function runPluginWebDev(options: PluginWebDevOptions, io: PluginDevIo): number;
+export declare function createPluginWebDevServer(target: PluginDebugTarget, io: PluginDevIo): http.Server;
+export declare function pluginWebDevServerUrl(server: http.Server): string;