@aiot-nexus/plugin-sdk 1.0.0

package/dist/src/dev.js

@@ -0,0 +1,224 @@
+"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.preparePluginDev = exports.runPluginDev = exports.PluginDevError = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const module_1 = require("module");
+const path = __importStar(require("path"));
+const validation_1 = require("./validation");
+class PluginDevError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PluginDevError";
+        this.exitCode = 1;
+    }
+}
+exports.PluginDevError = PluginDevError;
+const requiredElectronVersion = "22.3.27";
+function runPluginDev(options, io) {
+    const projectDirectory = path.resolve(options.projectDirectory);
+    assertPluginProject(projectDirectory);
+    if (options.build) {
+        io.stdout("Building plugin with development source maps: " + projectDirectory);
+        runProjectBuild(projectDirectory);
+    }
+    const target = preparePluginDev({ ...options, projectDirectory });
+    io.stdout("Starting plugin dev host: " + target.pluginId
+        + "\nPlugin package: " + target.packageDirectory
+        + "\nContribution: " + target.surface + ":" + target.contributionId);
+    if (options.inspectorMode) {
+        io.stdout("Main process debugger: " + options.inspectorMode
+            + " on 127.0.0.1:" + String(options.inspectorPort || 9229));
+    }
+    const electronArgs = [];
+    if (options.inspectorMode) {
+        electronArgs.push("--" + options.inspectorMode + "=" + String(options.inspectorPort || 9229));
+    }
+    electronArgs.push(target.devHostMainPath, "--plugin-package=" + target.packageDirectory, "--project-directory=" + target.projectDirectory, "--surface=" + target.surface, "--contribution-id=" + target.contributionId, "--language=" + target.language, "--theme=" + target.themeMode);
+    if (!options.openDevTools) {
+        electronArgs.push("--no-devtools");
+    }
+    if (options.smoke) {
+        electronArgs.push("--smoke");
+    }
+    const result = (0, child_process_1.spawnSync)(target.electronExecutable, electronArgs, {
+        cwd: target.projectDirectory,
+        env: process.env,
+        stdio: "inherit"
+    });
+    if (result.error) {
+        throw new PluginDevError("Plugin dev host could not start: " + result.error.message);
+    }
+    if (result.status === null) {
+        throw new PluginDevError("Plugin dev host stopped without an exit code" + (result.signal ? " (" + result.signal + ")" : "") + ".");
+    }
+    return result.status;
+}
+exports.runPluginDev = runPluginDev;
+function preparePluginDev(options) {
+    const projectDirectory = path.resolve(options.projectDirectory);
+    assertPluginProject(projectDirectory);
+    const sourceManifest = readManifest(path.join(projectDirectory, "src", "manifest.json"), "Plugin source manifest");
+    const packageDirectory = path.join(projectDirectory, "dist", sourceManifest.pluginId);
+    const validation = (0, validation_1.validatePluginPackage)(packageDirectory);
+    if (!validation.valid) {
+        throw new PluginDevError("Plugin package is not ready for debugging: " + packageDirectory
+            + "\n" + validation.errors.map((error) => "  - " + error).join("\n"));
+    }
+    const manifest = readManifest(path.join(packageDirectory, "manifest.json"), "Built plugin manifest");
+    if (manifest.pluginId !== sourceManifest.pluginId) {
+        throw new PluginDevError("Built plugin id does not match src/manifest.json.");
+    }
+    const contribution = resolveContribution(manifest, options.surface, options.contributionId);
+    const electronExecutable = resolveElectronExecutable(projectDirectory);
+    const devHostMainPath = path.join(resolvePackageRoot(), "dev-host", "main.js");
+    if (!fs.existsSync(devHostMainPath) || !fs.statSync(devHostMainPath).isFile()) {
+        throw new PluginDevError("Plugin SDK dev host is missing: " + devHostMainPath);
+    }
+    return {
+        projectDirectory,
+        packageDirectory,
+        pluginId: manifest.pluginId,
+        manifest,
+        electronExecutable,
+        devHostMainPath,
+        surface: contribution.surface,
+        contributionId: contribution.contributionId,
+        language: normalizeLanguage(options.language, manifest),
+        themeMode: options.themeMode || "system"
+    };
+}
+exports.preparePluginDev = preparePluginDev;
+function assertPluginProject(projectDirectory) {
+    if (!fs.existsSync(projectDirectory) || !fs.statSync(projectDirectory).isDirectory()) {
+        throw new PluginDevError("Plugin project directory does not exist: " + projectDirectory);
+    }
+    const packageJsonPath = path.join(projectDirectory, "package.json");
+    if (!fs.existsSync(packageJsonPath) || !fs.statSync(packageJsonPath).isFile()) {
+        throw new PluginDevError("Plugin project package.json is missing: " + packageJsonPath);
+    }
+}
+function runProjectBuild(projectDirectory) {
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const result = (0, child_process_1.spawnSync)(command, ["run", "build"], {
+        cwd: projectDirectory,
+        env: { ...process.env, NEXUS_PLUGIN_DEV: "1" },
+        stdio: "inherit"
+    });
+    if (result.error) {
+        throw new PluginDevError("Plugin development build could not start: " + result.error.message);
+    }
+    if (result.status !== 0) {
+        throw new PluginDevError("Plugin development build failed with exit code " + String(result.status === null ? 1 : result.status) + ".");
+    }
+}
+function readManifest(filePath, label) {
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        throw new PluginDevError(label + " is missing: " + filePath);
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new PluginDevError(label + " is not valid JSON: " + errorMessage(error));
+    }
+}
+function resolveContribution(manifest, requestedSurface, requestedContributionId) {
+    const contributions = pluginFrameContributions(manifest);
+    const matches = contributions.filter((contribution) => {
+        return (!requestedSurface || contribution.surface === requestedSurface)
+            && (!requestedContributionId || contribution.contributionId === requestedContributionId);
+    });
+    if (matches.length === 0) {
+        const selection = [requestedSurface, requestedContributionId].filter(Boolean).join(":") || "default";
+        throw new PluginDevError("No PluginFrame contribution matches the debug selection: " + selection + ".");
+    }
+    return matches[0];
+}
+function pluginFrameContributions(manifest) {
+    const contributions = [];
+    for (const entry of manifest.businessEntries || []) {
+        if (entry.component === "PluginFrame") {
+            contributions.push({ surface: "business", contributionId: entry.businessId });
+        }
+    }
+    for (const entry of manifest.tools || []) {
+        if (entry.component === "PluginFrame") {
+            contributions.push({ surface: "tool", contributionId: entry.toolId });
+        }
+    }
+    for (const entry of manifest.settingsSections || []) {
+        if (entry.component === "PluginFrame") {
+            contributions.push({ surface: "settings", contributionId: entry.sectionId });
+        }
+    }
+    return contributions;
+}
+function resolveElectronExecutable(projectDirectory) {
+    const projectRequire = (0, module_1.createRequire)(path.join(projectDirectory, "package.json"));
+    let electronPackagePath;
+    try {
+        electronPackagePath = projectRequire.resolve("electron/package.json");
+    }
+    catch {
+        throw new PluginDevError("electron@" + requiredElectronVersion + " is not installed in the plugin project. Run npm install.");
+    }
+    const electronPackage = readJsonRecord(electronPackagePath, "Electron package metadata");
+    if (electronPackage.version !== requiredElectronVersion) {
+        throw new PluginDevError("Plugin debugging requires electron@" + requiredElectronVersion
+            + ", found " + String(electronPackage.version || "unknown") + ".");
+    }
+    const electronValue = projectRequire("electron");
+    if (typeof electronValue !== "string" || !fs.existsSync(electronValue)) {
+        throw new PluginDevError("Electron executable is unavailable. Reinstall electron@" + requiredElectronVersion + ".");
+    }
+    return electronValue;
+}
+function readJsonRecord(filePath, label) {
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new Error("expected an object");
+        }
+        return value;
+    }
+    catch (error) {
+        throw new PluginDevError(label + " is invalid: " + errorMessage(error));
+    }
+}
+function normalizeLanguage(language, manifest) {
+    const value = language?.trim() || manifest.supportedCultures[0] || "en-US";
+    if (value.length > 40 || !/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/.test(value)) {
+        throw new PluginDevError("Plugin debug language is invalid: " + value);
+    }
+    return value;
+}
+function resolvePackageRoot() {
+    return path.resolve(__dirname, "..", "..");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManifestSchema = exports.PLUGIN_SDK_VERSION = void 0;
+const plugin_manifest_schema_json_1 = __importDefault(require("../.generated/plugin-manifest.schema.json"));
+exports.pluginManifestSchema = plugin_manifest_schema_json_1.default;
+exports.PLUGIN_SDK_VERSION = "1.0.0";
+__exportStar(require("../.generated/plugin-framework-version"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./browser/frame-client"), exports);
+__exportStar(require("./validation"), exports);

package/dist/src/scaffold.d.ts

@@ -0,0 +1,23 @@
+export type PluginTemplateName = "minimal" | "sqlite";
+export interface CreatePluginScaffoldOptions {
+    pluginId: string;
+    template: PluginTemplateName;
+    workingDirectory: string;
+    outputDirectory: string;
+    displayName: string;
+    sdkSource: string;
+    install: boolean;
+}
+export interface CreatePluginScaffoldResult {
+    pluginId: string;
+    template: PluginTemplateName;
+    pluginDirectory: string;
+    sdkSource: string;
+    installed: boolean;
+}
+export declare class PluginScaffoldError extends Error {
+    readonly exitCode: 1 | 2;
+    constructor(message: string, exitCode: 1 | 2);
+}
+export declare function createPluginScaffold(options: CreatePluginScaffoldOptions): CreatePluginScaffoldResult;
+export declare function defaultPluginDisplayName(pluginId: string): string;

package/dist/src/scaffold.js

@@ -0,0 +1,306 @@
+"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.defaultPluginDisplayName = exports.createPluginScaffold = exports.PluginScaffoldError = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const index_1 = require("./index");
+class PluginScaffoldError extends Error {
+    constructor(message, exitCode) {
+        super(message);
+        this.name = "PluginScaffoldError";
+        this.exitCode = exitCode;
+    }
+}
+exports.PluginScaffoldError = PluginScaffoldError;
+const pluginIdPattern = /^[a-z0-9][a-z0-9._-]{1,63}$/;
+const strictVersionPattern = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+const sdkPackageName = "@aiot-nexus/plugin-sdk";
+const vendoredSdkDirectory = "vendor";
+const vendoredSdkArchiveName = "aiot-nexus-plugin-sdk.tgz";
+const vendoredSdkDependency = "file:" + vendoredSdkDirectory + "/" + vendoredSdkArchiveName;
+function createPluginScaffold(options) {
+    validateOptions(options);
+    const outputDirectory = path.resolve(options.outputDirectory);
+    const pluginDirectory = path.join(outputDirectory, options.pluginId);
+    assertWritableTarget(pluginDirectory);
+    const sdkSource = normalizeSdkSource(options.sdkSource, options.workingDirectory);
+    const templateDirectory = path.join(resolvePackageRoot(), "templates", options.template);
+    if (!fs.existsSync(templateDirectory) || !fs.statSync(templateDirectory).isDirectory()) {
+        throw new PluginScaffoldError("Plugin template is missing: " + options.template, 1);
+    }
+    const targetExisted = fs.existsSync(pluginDirectory);
+    try {
+        fs.mkdirSync(pluginDirectory, { recursive: true });
+        copyTemplateDirectory(templateDirectory, pluginDirectory, {
+            "__PLUGIN_ID__": options.pluginId,
+            "__DISPLAY_NAME_MARKDOWN__": escapeMarkdown(options.displayName)
+        });
+        if (sdkSource.localArchivePath) {
+            vendorSdkArchive(pluginDirectory, sdkSource.localArchivePath);
+        }
+        writeJson(path.join(pluginDirectory, "package.json"), createPackageJson(options, sdkSource.dependencySpec));
+        writeJson(path.join(pluginDirectory, "src", "manifest.json"), createManifest(options));
+    }
+    catch (error) {
+        cleanupFailedTarget(pluginDirectory, targetExisted);
+        if (error instanceof PluginScaffoldError) {
+            throw error;
+        }
+        throw new PluginScaffoldError("Plugin scaffold could not be created: " + errorMessage(error), 1);
+    }
+    if (options.install) {
+        runNpmInstall(pluginDirectory);
+    }
+    return {
+        pluginId: options.pluginId,
+        template: options.template,
+        pluginDirectory,
+        sdkSource: sdkSource.dependencySpec,
+        installed: options.install
+    };
+}
+exports.createPluginScaffold = createPluginScaffold;
+function defaultPluginDisplayName(pluginId) {
+    return pluginId
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+exports.defaultPluginDisplayName = defaultPluginDisplayName;
+function validateOptions(options) {
+    if (!pluginIdPattern.test(options.pluginId)) {
+        throw new PluginScaffoldError("plugin-id must match " + pluginIdPattern.source + ".", 2);
+    }
+    if (options.template !== "minimal" && options.template !== "sqlite") {
+        throw new PluginScaffoldError("template must be minimal or sqlite.", 2);
+    }
+    if (!options.displayName || options.displayName.length > 120 || /[\u0000-\u001f\u007f]/.test(options.displayName)) {
+        throw new PluginScaffoldError("display-name must contain 1 to 120 printable characters.", 2);
+    }
+    if (!options.sdkSource.trim()) {
+        throw new PluginScaffoldError("sdk-source cannot be empty.", 2);
+    }
+}
+function assertWritableTarget(pluginDirectory) {
+    if (!fs.existsSync(pluginDirectory)) {
+        return;
+    }
+    const stat = fs.lstatSync(pluginDirectory);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new PluginScaffoldError("Target path must be an empty directory: " + pluginDirectory, 2);
+    }
+    if (fs.readdirSync(pluginDirectory).length > 0) {
+        throw new PluginScaffoldError("Target directory is not empty: " + pluginDirectory, 2);
+    }
+}
+function normalizeSdkSource(value, cwd) {
+    const source = value.trim();
+    const packagePrefix = sdkPackageName + "@";
+    const version = source.startsWith(packagePrefix) ? source.slice(packagePrefix.length) : source;
+    if (strictVersionPattern.test(version)) {
+        return { dependencySpec: version };
+    }
+    let localPath;
+    if (source.startsWith("file:")) {
+        try {
+            localPath = (0, url_1.fileURLToPath)(source);
+        }
+        catch (error) {
+            throw new PluginScaffoldError("sdk-source file URL is invalid: " + errorMessage(error), 2);
+        }
+    }
+    else if (isPathLike(source)) {
+        localPath = path.resolve(cwd, source);
+    }
+    if (!localPath) {
+        throw new PluginScaffoldError("sdk-source must be an X.Y.Z version or a local .tgz path.", 2);
+    }
+    if (path.extname(localPath).toLowerCase() !== ".tgz" || !fs.existsSync(localPath)) {
+        throw new PluginScaffoldError("Local sdk-source .tgz does not exist: " + localPath, 2);
+    }
+    const stat = fs.lstatSync(localPath);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new PluginScaffoldError("Local sdk-source must be a regular .tgz file: " + localPath, 2);
+    }
+    return {
+        dependencySpec: vendoredSdkDependency,
+        localArchivePath: path.resolve(localPath)
+    };
+}
+function isPathLike(value) {
+    return path.isAbsolute(value)
+        || value.startsWith(".")
+        || value.includes("/")
+        || value.includes("\\")
+        || value.toLowerCase().endsWith(".tgz");
+}
+function resolvePackageRoot() {
+    return path.resolve(__dirname, "..", "..");
+}
+function copyTemplateDirectory(sourceDirectory, targetDirectory, substitutions) {
+    for (const entry of fs.readdirSync(sourceDirectory, { withFileTypes: true })) {
+        if (entry.isSymbolicLink()) {
+            throw new PluginScaffoldError("Template entries cannot be symbolic links: " + entry.name, 1);
+        }
+        const isTemplateFile = entry.isFile() && entry.name.endsWith(".tmpl");
+        const targetName = isTemplateFile ? entry.name.slice(0, -".tmpl".length) : entry.name;
+        const sourcePath = path.join(sourceDirectory, entry.name);
+        const targetPath = path.join(targetDirectory, targetName);
+        if (entry.isDirectory()) {
+            fs.mkdirSync(targetPath, { recursive: true });
+            copyTemplateDirectory(sourcePath, targetPath, substitutions);
+            continue;
+        }
+        if (!entry.isFile()) {
+            throw new PluginScaffoldError("Unsupported template entry: " + sourcePath, 1);
+        }
+        if (!isTemplateFile) {
+            fs.copyFileSync(sourcePath, targetPath);
+            continue;
+        }
+        let content = fs.readFileSync(sourcePath, "utf8");
+        for (const token of Object.keys(substitutions)) {
+            content = content.split(token).join(substitutions[token]);
+        }
+        fs.writeFileSync(targetPath, content, "utf8");
+    }
+}
+function vendorSdkArchive(pluginDirectory, sourcePath) {
+    const vendorDirectory = path.join(pluginDirectory, vendoredSdkDirectory);
+    fs.mkdirSync(vendorDirectory, { recursive: true });
+    fs.copyFileSync(sourcePath, path.join(vendorDirectory, vendoredSdkArchiveName));
+}
+function createPackageJson(options, sdkSource) {
+    const scripts = {
+        build: "node scripts/build.js && npm run validate",
+        dev: "nexus-plugin dev .",
+        "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
+    };
+    const devDependencies = {
+        [sdkPackageName]: sdkSource,
+        "@types/node": "16.18.126",
+        electron: "22.3.27",
+        typescript: "4.9.4"
+    };
+    const packageJson = {
+        name: options.pluginId,
+        version: "0.1.0",
+        private: true,
+        description: options.displayName + " independent plugin for AIoT Nexus.",
+        scripts
+    };
+    if (options.template === "sqlite") {
+        scripts.build = "npm run rebuild:native && node scripts/build.js && npm run validate";
+        scripts["rebuild:native"] = "electron-rebuild -v 22.3.27 -m . -w better-sqlite3";
+        packageJson.dependencies = { "better-sqlite3": "8.7.0" };
+        devDependencies["@electron/rebuild"] = "3.7.2";
+    }
+    packageJson.devDependencies = devDependencies;
+    packageJson.engines = { node: ">=16.20.0 <17" };
+    return packageJson;
+}
+function createManifest(options) {
+    const isSqlite = options.template === "sqlite";
+    const displayNameKey = "plugin.displayName";
+    const descriptionKey = "plugin.description";
+    const englishDescription = isSqlite
+        ? "Plugin-owned SQLite CRUD example generated by nexus-plugin."
+        : "PluginFrame echo example generated by nexus-plugin.";
+    const chineseDescription = isSqlite
+        ? "由 nexus-plugin 生成的插件独立 SQLite CRUD 示例。"
+        : "由 nexus-plugin 生成的 PluginFrame 回显示例。";
+    return {
+        schemaVersion: index_1.PLUGIN_MANIFEST_SCHEMA_VERSION,
+        pluginId: options.pluginId,
+        displayNameKey,
+        descriptionKey,
+        pluginVersion: "0.1.0",
+        hostApiVersion: index_1.PLUGIN_FRAMEWORK_VERSION,
+        minHostVersion: "0.0.0",
+        supportedCultures: ["zh-CN", "en-US"],
+        resources: {
+            "zh-CN": {
+                [displayNameKey]: options.displayName,
+                [descriptionKey]: chineseDescription
+            },
+            "en-US": {
+                [displayNameKey]: options.displayName,
+                [descriptionKey]: englishDescription
+            }
+        },
+        permissions: ["businessLog"],
+        mainEntry: "main.cjs",
+        rendererEntry: "renderer/index.html",
+        businessEntries: [
+            {
+                businessId: options.pluginId,
+                titleKey: displayNameKey,
+                descriptionKey,
+                iconKey: isSqlite ? "storage" : "extension",
+                section: "home.main",
+                order: 50,
+                component: "PluginFrame",
+                pageRoute: options.pluginId,
+                isFullBleed: true,
+                showBusinessLogToggle: true
+            }
+        ]
+    };
+}
+function writeJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function runNpmInstall(pluginDirectory) {
+    runCommand(pluginDirectory, ["install"], "npm install");
+}
+function runCommand(pluginDirectory, args, label) {
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const result = (0, child_process_1.spawnSync)(command, args, { cwd: pluginDirectory, stdio: "inherit" });
+    if (result.error) {
+        throw new PluginScaffoldError(label + " could not start: " + result.error.message, 1);
+    }
+    if (result.status !== 0) {
+        throw new PluginScaffoldError(label + " failed with exit code " + String(result.status) + ".", 1);
+    }
+}
+function cleanupFailedTarget(pluginDirectory, targetExisted) {
+    fs.rmSync(pluginDirectory, { recursive: true, force: true });
+    if (targetExisted) {
+        fs.mkdirSync(pluginDirectory, { recursive: true });
+    }
+}
+function escapeMarkdown(value) {
+    return value.replace(/([\\`*_[\]<>])/g, "\\$1");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}