@aiot-nexus/plugin-sdk 2.0.2 → 2.1.1

package/dist/internal/src-electron/shared/plugin-electron-facade.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeMemberName = exports.unwrapElectronFacadeResult = exports.isElectronFacadeRequest = exports.decodeElectronFacadeValue = exports.encodeElectronFacadeValue = exports.ElectronFacadeRemoteError = exports.ElectronFacadeCodecError = exports.ElectronFacadeErrorCodes = void 0;
+exports.ElectronFacadeErrorCodes = {
+    InvalidRequest: "ElectronFacadeInvalidRequest",
+    ModuleUnavailable: "ElectronFacadeModuleUnavailable",
+    MemberUnavailable: "ElectronFacadeMemberUnavailable",
+    HandleReleased: "ElectronFacadeHandleReleased",
+    SerializationUnsupported: "ElectronFacadeSerializationUnsupported",
+    ProcessUnavailable: "ElectronFacadeProcessUnavailable",
+    SynchronousCallbackUnsupported: "ElectronFacadeSynchronousCallbackUnsupported",
+    LifecycleUnavailable: "ElectronFacadeLifecycleUnavailable",
+    InvocationFailed: "ElectronFacadeInvocationFailed"
+};
+class ElectronFacadeCodecError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = exports.ElectronFacadeErrorCodes.SerializationUnsupported;
+        this.name = "ElectronFacadeCodecError";
+    }
+}
+exports.ElectronFacadeCodecError = ElectronFacadeCodecError;
+class ElectronFacadeRemoteError extends Error {
+    constructor(error) {
+        super(error.message);
+        this.name = "ElectronFacadeRemoteError";
+        this.code = error.code;
+        this.details = error.details;
+    }
+}
+exports.ElectronFacadeRemoteError = ElectronFacadeRemoteError;
+function encodeElectronFacadeValue(value, hooks = {}) {
+    return encodeValue(value, hooks, new WeakSet());
+}
+exports.encodeElectronFacadeValue = encodeElectronFacadeValue;
+function decodeElectronFacadeValue(value, hooks = {}) {
+    if (Array.isArray(value)) {
+        return value.map((item) => decodeElectronFacadeValue(item, hooks));
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const tag = typeof value.$nexusElectron === "string" ? value.$nexusElectron : undefined;
+    if (!tag) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, decodeElectronFacadeValue(item, hooks)]));
+    }
+    switch (tag) {
+        case "undefined":
+            return undefined;
+        case "bigint": {
+            const encoded = readTagString(value, "value");
+            if (!/^-?(?:0|[1-9][0-9]*)$/.test(encoded)) {
+                throw new ElectronFacadeCodecError("Electron facade bigint tag is invalid.");
+            }
+            return BigInt(encoded);
+        }
+        case "number": {
+            const encoded = readTagString(value, "value");
+            if (encoded === "NaN") {
+                return Number.NaN;
+            }
+            if (encoded === "Infinity") {
+                return Number.POSITIVE_INFINITY;
+            }
+            if (encoded === "-Infinity") {
+                return Number.NEGATIVE_INFINITY;
+            }
+            throw new ElectronFacadeCodecError("Electron facade number tag is invalid.");
+        }
+        case "buffer": {
+            const encoded = readTagString(value, "base64");
+            if (encoded.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)) {
+                throw new ElectronFacadeCodecError("Electron facade buffer tag is invalid.");
+            }
+            return Buffer.from(encoded, "base64");
+        }
+        case "date": {
+            const decoded = new Date(readTagString(value, "value"));
+            if (!Number.isFinite(decoded.getTime())) {
+                throw new ElectronFacadeCodecError("Electron facade date tag is invalid.");
+            }
+            return decoded;
+        }
+        case "error": {
+            const error = new Error(readTagString(value, "message"));
+            error.name = typeof value.name === "string" ? value.name : "Error";
+            if (typeof value.stack === "string") {
+                error.stack = value.stack;
+            }
+            return error;
+        }
+        case "callback": {
+            const callbackId = readTagString(value, "callbackId");
+            if (!hooks.decodeFunction) {
+                throw new ElectronFacadeCodecError("Electron callback values are not supported in this context.");
+            }
+            return hooks.decodeFunction(callbackId);
+        }
+        case "handle": {
+            const handleId = readTagString(value, "handleId");
+            const typeName = readTagString(value, "typeName");
+            const callbackId = value.callbackId === undefined ? undefined : readTagString(value, "callbackId");
+            if (!hooks.decodeHandle) {
+                throw new ElectronFacadeCodecError("Electron handle values are not supported in this context.");
+            }
+            return hooks.decodeHandle(handleId, typeName, callbackId);
+        }
+        case "object": {
+            if (!isPlainObject(value.value)) {
+                throw new ElectronFacadeCodecError("Electron facade object tag is invalid.");
+            }
+            return Object.fromEntries(Object.entries(value.value).map(([key, item]) => [key, decodeElectronFacadeValue(item, hooks)]));
+        }
+        default:
+            throw new ElectronFacadeCodecError("Unknown Electron facade wire tag: " + tag + ".");
+    }
+}
+exports.decodeElectronFacadeValue = decodeElectronFacadeValue;
+function isElectronFacadeRequest(value) {
+    if (!isPlainObject(value) || !isElectronFacadeOperation(value.operation)) {
+        return false;
+    }
+    const hasModule = typeof value.module === "string" && isSafeMemberName(value.module);
+    const hasHandle = typeof value.handleId === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value.handleId);
+    if (value.operation === "release") {
+        return hasHandle && value.module === undefined && value.member === undefined && value.args === undefined;
+    }
+    if (value.operation === "construct") {
+        return hasModule && !hasHandle && value.member === undefined && (value.args === undefined || Array.isArray(value.args));
+    }
+    if (hasModule === hasHandle || typeof value.member !== "string" || !isSafeMemberName(value.member)) {
+        return false;
+    }
+    if (value.operation === "get") {
+        return value.args === undefined;
+    }
+    if (value.operation === "set" || value.operation === "on" || value.operation === "once") {
+        return Array.isArray(value.args) && value.args.length === 1;
+    }
+    return value.args === undefined || Array.isArray(value.args);
+}
+exports.isElectronFacadeRequest = isElectronFacadeRequest;
+function unwrapElectronFacadeResult(result, hooks = {}) {
+    if (!result.ok) {
+        throw new ElectronFacadeRemoteError(result.error);
+    }
+    return decodeElectronFacadeValue(result.value, hooks);
+}
+exports.unwrapElectronFacadeResult = unwrapElectronFacadeResult;
+function isSafeMemberName(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$-]{0,79}$/.test(value)
+        && value !== "constructor"
+        && value !== "prototype"
+        && value !== "__proto__";
+}
+exports.isSafeMemberName = isSafeMemberName;
+function encodeValue(value, hooks, seen) {
+    if (value === undefined) {
+        return tag("undefined");
+    }
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (Number.isFinite(value)) {
+            return value;
+        }
+        return tag("number", { value: Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity" });
+    }
+    if (typeof value === "bigint") {
+        return tag("bigint", { value: value.toString(10) });
+    }
+    if (typeof value === "function") {
+        if (!hooks.encodeFunction) {
+            throw new ElectronFacadeCodecError("Electron callback values are not supported in this context.");
+        }
+        return hooks.encodeFunction(value);
+    }
+    if (typeof value !== "object") {
+        throw new ElectronFacadeCodecError("Electron facade value cannot be serialized.");
+    }
+    if (Buffer.isBuffer(value)) {
+        return tag("buffer", { base64: value.toString("base64") });
+    }
+    if (value instanceof Date) {
+        return tag("date", { value: value.toISOString() });
+    }
+    if (value instanceof Error) {
+        return tag("error", {
+            name: value.name,
+            message: value.message,
+            ...(value.stack ? { stack: value.stack } : {})
+        });
+    }
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        if (!hooks.encodeObject) {
+            throw new ElectronFacadeCodecError("Electron native object requires a remote handle.");
+        }
+        return hooks.encodeObject(value);
+    }
+    if (seen.has(value)) {
+        throw new ElectronFacadeCodecError("Electron facade values cannot contain cycles.");
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => encodeValue(item, hooks, seen));
+        }
+        const encoded = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, encodeValue(item, hooks, seen)]));
+        return Object.prototype.hasOwnProperty.call(value, "$nexusElectron")
+            ? tag("object", { value: encoded })
+            : encoded;
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+function tag(type, values = {}) {
+    return { $nexusElectron: type, ...values };
+}
+function readTagString(value, key) {
+    const result = value[key];
+    if (typeof result !== "string") {
+        throw new ElectronFacadeCodecError("Electron facade wire tag is missing " + key + ".");
+    }
+    return result;
+}
+function isElectronFacadeOperation(value) {
+    return value === "call"
+        || value === "construct"
+        || value === "get"
+        || value === "set"
+        || value === "on"
+        || value === "once"
+        || value === "release";
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/internal/src-electron/shared/plugin-rpc.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginRpcMessage = exports.isPluginRpcJsonValue = exports.sanitizePluginRpcValue = exports.isPluginRpcOperationName = exports.createPluginRpcRequestId = exports.PluginRpcErrorCodes = exports.PLUGIN_RPC_REQUEST_ID_MAX_LENGTH = exports.PLUGIN_RPC_PROTOCOL_VERSION = void 0;
+exports.PLUGIN_RPC_PROTOCOL_VERSION = 3;
+exports.PLUGIN_RPC_REQUEST_ID_MAX_LENGTH = 128;
+exports.PluginRpcErrorCodes = {
+    InvalidMessage: "PluginRpcInvalidMessage",
+    UnsupportedProtocol: "PluginRpcUnsupportedProtocol",
+    NotReady: "PluginProcessNotReady",
+    ProcessExited: "PluginProcessExited",
+    ActivationTimeout: "PluginActivationTimeout",
+    OperationTimeout: "PluginOperationTimeout",
+    ShutdownTimeout: "PluginShutdownTimeout"
+};
+function createPluginRpcRequestId(prefix, sequence) {
+    const normalizedPrefix = prefix.trim().replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 110);
+    const normalizedSequence = Number.isSafeInteger(sequence) && sequence >= 0 ? sequence : 0;
+    return `${normalizedPrefix || "rpc"}-${normalizedSequence}`;
+}
+exports.createPluginRpcRequestId = createPluginRpcRequestId;
+function isPluginRpcOperationName(value) {
+    if (typeof value !== "string" || value.length > 80 || !/^[a-z][A-Za-z0-9]*(?:\.[a-z][A-Za-z0-9]*){1,4}$/.test(value)) {
+        return false;
+    }
+    return value.split(".").every((part) => part !== "constructor" && part !== "prototype" && part !== "__proto__");
+}
+exports.isPluginRpcOperationName = isPluginRpcOperationName;
+function sanitizePluginRpcValue(value) {
+    return sanitizeValue(value, new WeakSet());
+}
+exports.sanitizePluginRpcValue = sanitizePluginRpcValue;
+function isPluginRpcJsonValue(value) {
+    return isJsonValue(value, new WeakSet());
+}
+exports.isPluginRpcJsonValue = isPluginRpcJsonValue;
+function isPluginRpcMessage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.protocolVersion !== exports.PLUGIN_RPC_PROTOCOL_VERSION || typeof value.type !== "string") {
+        return false;
+    }
+    switch (value.type) {
+        case "initialize":
+            return isRequestId(value.requestId) && isInitializePayload(value.payload);
+        case "ready":
+            return isRequestId(value.requestId) && isReadyPayload(value.payload);
+        case "invoke":
+            return isRequestId(value.requestId) && isInvokePayload(value.payload);
+        case "result":
+            return isRequestId(value.requestId) && isPluginRpcResult(value.result);
+        case "hostRequest":
+            return isRequestId(value.requestId) && isHostRequestPayload(value.payload);
+        case "hostResult":
+            return isRequestId(value.requestId) && isPluginRpcResult(value.result);
+        case "electronCallback":
+            return isRequestId(value.requestId) && isElectronCallbackPayload(value.payload);
+        case "electronCallbackResult":
+            return isRequestId(value.requestId) && isPluginRpcResult(value.result);
+        case "electronEvent":
+            return isElectronCallbackPayload(value.payload);
+        case "shutdown":
+            return isRequestId(value.requestId)
+                && isRecord(value.payload)
+                && isShutdownReason(value.payload.reason);
+        case "fatal":
+            return isFatalPayload(value.payload);
+        default:
+            return false;
+    }
+}
+exports.isPluginRpcMessage = isPluginRpcMessage;
+function sanitizeValue(value, seen) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value !== "object") {
+        return null;
+    }
+    if (seen.has(value)) {
+        return null;
+    }
+    if (!isPlainObject(value) && !Array.isArray(value)) {
+        return null;
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => sanitizeValue(item, seen));
+        }
+        return Object.fromEntries(Object.entries(value)
+            .map(([key, item]) => [key, sanitizeValue(item, seen)]));
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+function isJsonValue(value, seen) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return true;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (typeof value !== "object") {
+        return false;
+    }
+    if (seen.has(value)) {
+        return false;
+    }
+    if (!isPlainObject(value) && !Array.isArray(value)) {
+        return false;
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.every((item) => isJsonValue(item, seen));
+        }
+        return Object.values(value).every((item) => isJsonValue(item, seen));
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+function isRecord(value) {
+    return isPlainObject(value);
+}
+function isRequestId(value) {
+    return typeof value === "string" && value.length <= exports.PLUGIN_RPC_REQUEST_ID_MAX_LENGTH && /^[A-Za-z0-9._:-]{1,128}$/.test(value);
+}
+function isInitializePayload(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return isNonEmptyString(value.pluginId)
+        && isNonEmptyString(value.pluginDirectory)
+        && isNonEmptyString(value.pluginDataDirectory)
+        && isPluginManifestPayload(value.manifest)
+        && value.pluginId === value.manifest.pluginId
+        && isNonEmptyString(value.hostVersion)
+        && isNonEmptyString(value.hostApiVersion);
+}
+function isReadyPayload(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Array.isArray(value.operations)
+        && value.operations.every((item) => isPluginRpcOperationName(item))
+        && new Set(value.operations).size === value.operations.length
+        && isNonEmptyString(value.activatedAtUtc);
+}
+function isInvokePayload(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return isRendererSurface(value.surface)
+        && isNonEmptyString(value.contributionId)
+        && isPluginRpcOperationName(value.operation)
+        && (value.input === undefined || isJsonObject(value.input));
+}
+function isHostRequestPayload(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return isHostMethod(value.method)
+        && (value.params === undefined || isJsonObject(value.params));
+}
+function isFatalPayload(value) {
+    return isRecord(value)
+        && isNonEmptyString(value.message)
+        && (value.details === undefined || isPluginRpcJsonValue(value.details));
+}
+function isElectronCallbackPayload(value) {
+    return isRecord(value)
+        && typeof value.callbackId === "string"
+        && /^[A-Za-z0-9._:-]{1,128}$/.test(value.callbackId)
+        && Array.isArray(value.args)
+        && value.args.every((item) => isPluginRpcJsonValue(item));
+}
+function isPluginRpcResult(value) {
+    if (!isRecord(value) || typeof value.ok !== "boolean") {
+        return false;
+    }
+    if (value.ok) {
+        return isPluginRpcJsonValue(value.value);
+    }
+    return isNexusError(value.error)
+        && (value.error.details === undefined || isPluginRpcJsonValue(value.error.details));
+}
+function isNexusError(value) {
+    return isRecord(value)
+        && typeof value.code === "string"
+        && typeof value.message === "string";
+}
+function isJsonObject(value) {
+    return isRecord(value) && isPluginRpcJsonValue(value);
+}
+function isRendererSurface(value) {
+    return value === "business" || value === "tool" || value === "settings";
+}
+function isPluginManifestPayload(value) {
+    if (!isJsonObject(value)) {
+        return false;
+    }
+    return typeof value.schemaVersion === "number"
+        && Number.isSafeInteger(value.schemaVersion)
+        && typeof value.pluginId === "string"
+        && isPluginId(value.pluginId)
+        && isNonEmptyString(value.displayNameKey)
+        && isNonEmptyString(value.descriptionKey)
+        && isNonEmptyString(value.pluginVersion)
+        && isNonEmptyString(value.hostApiVersion)
+        && isNonEmptyString(value.minHostVersion)
+        && Array.isArray(value.supportedCultures)
+        && value.supportedCultures.every((item) => isNonEmptyString(item))
+        && Array.isArray(value.permissions)
+        && value.permissions.every((item) => isNonEmptyString(item));
+}
+function isPluginId(value) {
+    return /^[a-z0-9][a-z0-9._-]{1,63}$/.test(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isHostMethod(value) {
+    return value === "getCapabilityStatus"
+        || value === "unsupportedCapability"
+        || value === "log"
+        || value === "getSettings"
+        || value === "updateSettings"
+        || value === "electronFacade";
+}
+function isShutdownReason(value) {
+    return value === "reload" || value === "disable" || value === "quit" || value === "crash-recovery";
+}

package/dist/src/electron-facade.d.ts

@@ -0,0 +1,4 @@
+export declare function createPluginElectronIpcChannel(pluginId: string, channel: string): string;
+export declare function createPluginElectronProtocolScheme(pluginId: string, scheme: string): string;
+export declare function isPluginElectronIpcChannel(pluginId: string, value: unknown): value is string;
+export declare function isPluginElectronProtocolScheme(pluginId: string, value: unknown): value is string;

package/dist/src/electron-facade.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginElectronProtocolScheme = exports.isPluginElectronIpcChannel = exports.createPluginElectronProtocolScheme = exports.createPluginElectronIpcChannel = void 0;
+const ipcPrefix = "nexus-plugin:";
+const protocolPrefix = "nexus-plugin-";
+const pluginIdPattern = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const channelPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/;
+const schemePattern = /^[a-z][a-z0-9+.-]{0,62}$/;
+function createPluginElectronIpcChannel(pluginId, channel) {
+    return ipcPrefix + requirePluginId(pluginId) + ":" + requireLogicalName(channel, channelPattern, "IPC channel");
+}
+exports.createPluginElectronIpcChannel = createPluginElectronIpcChannel;
+function createPluginElectronProtocolScheme(pluginId, scheme) {
+    const result = protocolPrefix + requirePluginId(pluginId) + "-" + requireLogicalName(scheme, schemePattern, "protocol scheme");
+    if (result.length > 40) {
+        throw new TypeError("Namespaced protocol scheme must be 40 characters or fewer.");
+    }
+    return result;
+}
+exports.createPluginElectronProtocolScheme = createPluginElectronProtocolScheme;
+function isPluginElectronIpcChannel(pluginId, value) {
+    const normalizedPluginId = normalizePluginId(pluginId);
+    if (!normalizedPluginId || typeof value !== "string") {
+        return false;
+    }
+    const prefix = ipcPrefix + normalizedPluginId + ":";
+    return value.startsWith(prefix) && channelPattern.test(value.slice(prefix.length));
+}
+exports.isPluginElectronIpcChannel = isPluginElectronIpcChannel;
+function isPluginElectronProtocolScheme(pluginId, value) {
+    const normalizedPluginId = normalizePluginId(pluginId);
+    if (!normalizedPluginId || typeof value !== "string" || value.length > 40) {
+        return false;
+    }
+    const prefix = protocolPrefix + normalizedPluginId + "-";
+    return value.startsWith(prefix) && schemePattern.test(value.slice(prefix.length));
+}
+exports.isPluginElectronProtocolScheme = isPluginElectronProtocolScheme;
+function requirePluginId(value) {
+    const normalized = normalizePluginId(value);
+    if (!normalized) {
+        throw new TypeError("Plugin id must match the Nexus manifest pluginId format.");
+    }
+    return normalized;
+}
+function normalizePluginId(value) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    return pluginIdPattern.test(normalized) ? normalized : undefined;
+}
+function requireLogicalName(value, pattern, label) {
+    const normalized = String(value).trim();
+    if (!pattern.test(normalized) || normalized.includes("__proto__")) {
+        throw new TypeError(label + " contains unsupported characters.");
+    }
+    return normalized;
+}

package/dist/src/index.d.ts

@@ -1,7 +1,8 @@
 import pluginManifestSchema from "../.generated/plugin-manifest.schema.json";
-export declare const PLUGIN_SDK_VERSION = "2.0.2";
+export declare const PLUGIN_SDK_VERSION = "2.1.1";
 export { pluginManifestSchema };
 export * from "../.generated/plugin-framework-version";
 export * from "./types";
+export * from "./electron-facade";
 export * from "./browser/frame-client";
 export * from "./validation";

package/dist/src/index.js

@@ -20,8 +20,9 @@ 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 = "2.0.2";
+exports.PLUGIN_SDK_VERSION = "2.1.1";
 __exportStar(require("../.generated/plugin-framework-version"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./electron-facade"), exports);
 __exportStar(require("./browser/frame-client"), exports);
 __exportStar(require("./validation"), exports);

package/dist/src/nexus-dev.js

@@ -30,6 +30,7 @@ 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");
+const processSignals = process;
 async function runPluginNexusDev(options, io) {
     return new PluginNexusDevSession(options, io).run();
 }
@@ -223,12 +224,12 @@ class PluginNexusDevSession {
         return this.watcher ? this.watcher.runBuild(operation) : operation();
     }
     installSignalHandlers() {
-        process.on("SIGINT", this.handleSignal);
-        process.on("SIGTERM", this.handleSignal);
+        processSignals.on("SIGINT", this.handleSignal);
+        processSignals.on("SIGTERM", this.handleSignal);
     }
     removeSignalHandlers() {
-        process.removeListener("SIGINT", this.handleSignal);
-        process.removeListener("SIGTERM", this.handleSignal);
+        processSignals.removeListener("SIGINT", this.handleSignal);
+        processSignals.removeListener("SIGTERM", this.handleSignal);
     }
     requireTarget() {
         if (!this.target) {

package/dist/src/scaffold.js

@@ -235,10 +235,10 @@ function createManifest(options) {
     const displayNameKey = "plugin.displayName";
     const descriptionKey = "plugin.description";
     const englishDescription = isSqlite
-        ? "Plugin-owned SQLite CRUD example generated by nexus-plugin."
+        ? "SQLite database browser with schema-aware CRUD generated by nexus-plugin."
         : "PluginFrame echo example generated by nexus-plugin.";
     const chineseDescription = isSqlite
-        ? "由 nexus-plugin 生成的插件独立 SQLite CRUD 示例。"
+        ? "由 nexus-plugin 生成的 SQLite 数据库浏览器与动态 CRUD 示例。"
         : "由 nexus-plugin 生成的 PluginFrame 回显示例。";
     return {
         schemaVersion: index_1.PLUGIN_MANIFEST_SCHEMA_VERSION,