@openvcs/sdk 0.2.2 → 0.2.3

package/README.md

@@ -44,6 +44,7 @@ Run the local CLI through npm scripts:
 
 ```bash
 npm run openvcs -- --help
+npm run openvcs -- build --help
 npm run openvcs -- init --help
 npm run openvcs -- dist --help
 ```
@@ -66,23 +67,60 @@ Interactive theme plugin scaffold:
 openvcs init --theme my-theme
 ```
 
+## Build plugin assets
+
+In a generated code plugin folder:
+
+```bash
+npm run build
+```
+
+This runs `openvcs build`, which executes `scripts["build:plugin"]` and verifies
+that `bin/<module.exec>` now exists.
+
+Theme-only plugins can also run `npm run build`; the command exits successfully
+without producing `bin/` output.
+
 ## Build a `.ovcsp` bundle
 
 In a generated plugin folder:
 
 ```bash
-npm run build
+npm run dist
 ```
 
 This produces `dist/<plugin-id>.ovcsp`.
 
+`openvcs dist` runs `openvcs build` first unless `--no-build` is provided.
+Use `--no-build` when packaging prebuilt plugin assets.
+
+Generated code plugin scripts use this split by default:
+
+```json
+{
+  "scripts": {
+    "build:plugin": "tsc -p tsconfig.json",
+    "build": "openvcs build",
+    "dist": "openvcs dist --plugin-dir . --out dist"
+  }
+}
+```
+
 `.ovcsp` is a gzip-compressed tar archive (`tar.gz`) that contains a top-level
 `<plugin-id>/` directory with `openvcs.plugin.json` and plugin runtime assets.
 
+Bundle contents:
+- `openvcs.plugin.json` (required)
+- `icon.*` (optional, first found by extension priority)
+- `bin/` (required for code plugins with `module.exec`)
+- `entry` directory (required for UI plugins with top-level `entry` field; the entire directory containing the entry file is bundled)
+- `themes/` (required for theme plugins)
+- `node_modules/` (if npm dependencies are bundled)
+
 Dependency behavior while packaging:
 
 - npm dependency bundling is enabled by default when `package.json` exists.
-- If `package-lock.json` is missing, SDK generates it in the plugin worktree.
+- If `package-lock.json` is missing, SDK generates it in the staging area (not the plugin worktree).
 - Dependencies are installed into the bundle staging dir with:
   - `npm ci --omit=dev --ignore-scripts --no-bin-links --no-audit --no-fund`
 - Disable npm dependency processing with `--no-npm-deps`.
@@ -93,15 +131,17 @@ Dependency behavior while packaging:
 Package a plugin manually:
 
 ```bash
-openvcs dist --plugin-dir /path/to/plugin --out /path/to/dist
+npx openvcs build --plugin-dir /path/to/plugin
+npx openvcs dist --plugin-dir /path/to/plugin --out /path/to/dist
 ```
 
 Show command help:
 
 ```bash
-openvcs --help
-openvcs dist --help
-openvcs init --help
+npx openvcs --help
+npx openvcs build --help
+npx openvcs dist --help
+npx openvcs init --help
 ```
 
 ## Releases

package/lib/build.d.ts

@@ -0,0 +1,28 @@
+/** CLI arguments for `openvcs build`. */
+export interface BuildArgs {
+    pluginDir: string;
+    verbose: boolean;
+}
+/** Trimmed manifest details used by build and dist flows. */
+export interface ManifestInfo {
+    pluginId: string;
+    moduleExec: string | undefined;
+    entry: string | undefined;
+    manifestPath: string;
+}
+/** Returns the npm executable name for the current platform. */
+export declare function npmExecutable(): string;
+/** Formats help text for the build command. */
+export declare function buildUsage(commandName?: string): string;
+/** Parses `openvcs build` arguments. */
+export declare function parseBuildArgs(args: string[]): BuildArgs;
+/** Reads and validates the plugin manifest. */
+export declare function readManifest(pluginDir: string): ManifestInfo;
+/** Verifies that a declared module entry resolves to a real file under `bin/`. */
+export declare function validateDeclaredModuleExec(pluginDir: string, moduleExec: string | undefined): void;
+/** Returns whether the plugin repository has a `package.json`. */
+export declare function hasPackageJson(pluginDir: string): boolean;
+/** Runs a command in the given directory with optional verbose logging. */
+export declare function runCommand(program: string, args: string[], cwd: string, verbose: boolean): void;
+/** Builds a plugin's runtime assets when it declares a code module. */
+export declare function buildPluginAssets(parsedArgs: BuildArgs): ManifestInfo;

package/lib/build.js

@@ -0,0 +1,188 @@
+"use strict";
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmExecutable = npmExecutable;
+exports.buildUsage = buildUsage;
+exports.parseBuildArgs = parseBuildArgs;
+exports.readManifest = readManifest;
+exports.validateDeclaredModuleExec = validateDeclaredModuleExec;
+exports.hasPackageJson = hasPackageJson;
+exports.runCommand = runCommand;
+exports.buildPluginAssets = buildPluginAssets;
+const fs = require("node:fs");
+const path = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const fs_utils_1 = require("./fs-utils");
+/** Returns the npm executable name for the current platform. */
+function npmExecutable() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+/** Formats help text for the build command. */
+function buildUsage(commandName = "openvcs") {
+    return `${commandName} build [args]\n\n  --plugin-dir <path>   Plugin repository root (contains openvcs.plugin.json)\n  -V, --verbose         Enable verbose output\n`;
+}
+/** Parses `openvcs build` arguments. */
+function parseBuildArgs(args) {
+    let pluginDir = process.cwd();
+    let verbose = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--plugin-dir") {
+            index += 1;
+            if (index >= args.length) {
+                throw new Error("missing value for --plugin-dir");
+            }
+            pluginDir = args[index];
+            continue;
+        }
+        if (arg === "-V" || arg === "--verbose") {
+            verbose = true;
+            continue;
+        }
+        if (arg === "--help") {
+            const error = new Error(buildUsage());
+            error.code = "USAGE";
+            throw error;
+        }
+        throw new Error(`unknown flag: ${arg}`);
+    }
+    return {
+        pluginDir: path.resolve(pluginDir),
+        verbose,
+    };
+}
+/** Reads and validates the plugin manifest. */
+function readManifest(pluginDir) {
+    const manifestPath = path.join(pluginDir, "openvcs.plugin.json");
+    let manifestRaw;
+    let manifestFd;
+    let manifest;
+    try {
+        manifestFd = fs.openSync(manifestPath, "r");
+        const manifestStat = fs.fstatSync(manifestFd);
+        if (!manifestStat.isFile()) {
+            throw new Error(`missing openvcs.plugin.json at ${manifestPath}`);
+        }
+        manifestRaw = fs.readFileSync(manifestFd, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`missing openvcs.plugin.json at ${manifestPath}`);
+        }
+        throw error;
+    }
+    finally {
+        if (typeof manifestFd === "number") {
+            fs.closeSync(manifestFd);
+        }
+    }
+    try {
+        manifest = JSON.parse(manifestRaw);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`parse ${manifestPath}: ${detail}`);
+    }
+    const pluginId = typeof manifest.id === "string"
+        ? manifest.id.trim()
+        : "";
+    if (!pluginId) {
+        throw new Error(`manifest ${manifestPath} is missing a string 'id'`);
+    }
+    if (pluginId === "." || pluginId === ".." || pluginId.includes("/") || pluginId.includes("\\")) {
+        throw new Error(`manifest id must not contain path separators: ${pluginId}`);
+    }
+    const moduleValue = manifest.module;
+    const moduleExec = typeof moduleValue?.exec === "string" ? moduleValue.exec.trim() : undefined;
+    const entryValue = manifest.entry;
+    const entry = typeof entryValue === "string" ? entryValue.trim() : undefined;
+    return {
+        pluginId,
+        moduleExec,
+        entry,
+        manifestPath,
+    };
+}
+/** Verifies that a declared module entry resolves to a real file under `bin/`. */
+function validateDeclaredModuleExec(pluginDir, moduleExec) {
+    if (!moduleExec) {
+        return;
+    }
+    const normalizedExec = moduleExec.trim();
+    const lowered = normalizedExec.toLowerCase();
+    if (!lowered.endsWith(".js") && !lowered.endsWith(".mjs") && !lowered.endsWith(".cjs")) {
+        throw new Error(`manifest exec must end with .js/.mjs/.cjs (Node runtime): ${moduleExec}`);
+    }
+    if (path.isAbsolute(normalizedExec)) {
+        throw new Error(`manifest module.exec must be a relative path under bin/: ${moduleExec}`);
+    }
+    const binDir = path.resolve(pluginDir, "bin");
+    const targetPath = path.resolve(binDir, normalizedExec);
+    if (!(0, fs_utils_1.isPathInside)(binDir, targetPath) || targetPath === binDir) {
+        throw new Error(`manifest module.exec must point to a file under bin/: ${moduleExec}`);
+    }
+    if (!fs.existsSync(targetPath) || !fs.lstatSync(targetPath).isFile()) {
+        throw new Error(`module entrypoint not found at ${targetPath}`);
+    }
+}
+/** Returns whether the plugin repository has a `package.json`. */
+function hasPackageJson(pluginDir) {
+    const packageJsonPath = path.join(pluginDir, "package.json");
+    return fs.existsSync(packageJsonPath) && fs.lstatSync(packageJsonPath).isFile();
+}
+/** Runs a command in the given directory with optional verbose logging. */
+function runCommand(program, args, cwd, verbose) {
+    if (verbose) {
+        process.stderr.write(`Running command in ${cwd}: ${program} ${args.join(" ")}\n`);
+    }
+    const result = (0, node_child_process_1.spawnSync)(program, args, {
+        cwd,
+        stdio: ["ignore", verbose ? "inherit" : "ignore", "inherit"],
+    });
+    if (result.error) {
+        throw new Error(`failed to spawn '${program}' in ${cwd}: ${result.error.message}`);
+    }
+    if (result.status === 0) {
+        return;
+    }
+    throw new Error(`command failed (${program} ${args.join(" ")}), exit code ${result.status}`);
+}
+/** Reads `package.json` scripts for the plugin, if present. */
+function readPackageScripts(pluginDir) {
+    const packageJsonPath = path.join(pluginDir, "package.json");
+    let packageData;
+    try {
+        packageData = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`code plugins must include package.json: ${packageJsonPath}`);
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`parse ${packageJsonPath}: ${detail}`);
+    }
+    const scripts = packageData.scripts;
+    if (typeof scripts !== "object" || scripts === null) {
+        return {};
+    }
+    return scripts;
+}
+/** Builds a plugin's runtime assets when it declares a code module. */
+function buildPluginAssets(parsedArgs) {
+    const manifest = readManifest(parsedArgs.pluginDir);
+    if (!manifest.moduleExec) {
+        return manifest;
+    }
+    if (!hasPackageJson(parsedArgs.pluginDir)) {
+        throw new Error(`code plugins must include package.json: ${path.join(parsedArgs.pluginDir, "package.json")}`);
+    }
+    const scripts = readPackageScripts(parsedArgs.pluginDir);
+    const buildScript = scripts["build:plugin"];
+    if (typeof buildScript !== "string" || buildScript.trim() === "") {
+        throw new Error(`code plugins must define scripts[\"build:plugin\"] in ${path.join(parsedArgs.pluginDir, "package.json")}`);
+    }
+    runCommand(npmExecutable(), ["run", "build:plugin"], parsedArgs.pluginDir, parsedArgs.verbose);
+    validateDeclaredModuleExec(parsedArgs.pluginDir, manifest.moduleExec);
+    return manifest;
+}

package/lib/cli.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
+const build_1 = require("./build");
 const dist_1 = require("./dist");
 const init_1 = require("./init");
 const packageJson = require("../package.json");
@@ -11,7 +12,7 @@ function hasCode(error, code) {
         error.code === code);
 }
 function usage() {
-    return "Usage: openvcs <command> [options]\n\nCommands:\n  dist [args]            Package plugin into .ovcsp\n  init [--theme] [dir]   Interactively scaffold a plugin project\n  -v, --version          Show version information\n\nDist args:\n  --plugin-dir <path>    Plugin root containing openvcs.plugin.json\n  --out <path>           Output directory (default: ./dist)\n  --no-npm-deps          Skip npm dependency bundling\n  -V, --verbose          Verbose output\n";
+    return "Usage: openvcs <command> [options]\n\nCommands:\n  build [args]           Build plugin runtime assets\n  dist [args]            Package plugin into .ovcsp\n  init [--theme] [dir]   Interactively scaffold a plugin project\n  -v, --version          Show version information\n\nBuild args:\n  --plugin-dir <path>    Plugin root containing openvcs.plugin.json\n  -V, --verbose          Verbose output\n\nDist args:\n  --plugin-dir <path>    Plugin root containing openvcs.plugin.json\n  --out <path>           Output directory (default: ./dist)\n  --no-build             Skip plugin build before packaging\n  --no-npm-deps          Skip npm dependency bundling\n  -V, --verbose          Verbose output\n";
 }
 async function runCli(args) {
     if (args.length === 0) {
@@ -19,7 +20,7 @@ async function runCli(args) {
         process.exitCode = 1;
         return;
     }
-    if (args.includes("-v") || args.includes("--version")) {
+    if (args[0] === "-v" || args[0] === "--version") {
         process.stdout.write(`openvcs ${packageJson.version}\n`);
         return;
     }
@@ -46,6 +47,24 @@ async function runCli(args) {
             throw error;
         }
     }
+    if (command === "build") {
+        if (rest.includes("--help")) {
+            process.stdout.write((0, build_1.buildUsage)());
+            return;
+        }
+        try {
+            const parsed = (0, build_1.parseBuildArgs)(rest);
+            const manifest = (0, build_1.buildPluginAssets)(parsed);
+            process.stdout.write(`${manifest.pluginId}\n`);
+            return;
+        }
+        catch (error) {
+            if (hasCode(error, "USAGE")) {
+                throw new Error((0, build_1.buildUsage)());
+            }
+            throw error;
+        }
+    }
     if (command === "init") {
         if (rest.includes("--help")) {
             process.stdout.write((0, init_1.initUsage)());

package/lib/dist.d.ts

@@ -1,18 +1,14 @@
+import { readManifest, validateDeclaredModuleExec } from "./build";
 interface DistArgs {
     pluginDir: string;
     outDir: string;
     verbose: boolean;
     noNpmDeps: boolean;
-}
-interface ManifestInfo {
-    pluginId: string;
-    moduleExec: string | undefined;
-    manifestPath: string;
+    noBuild: boolean;
 }
 export declare function distUsage(commandName?: string): string;
 export declare function parseDistArgs(args: string[]): DistArgs;
-declare function readManifest(pluginDir: string): ManifestInfo;
-declare function validateDeclaredModuleExec(pluginDir: string, moduleExec: string | undefined): void;
+declare function validateManifestEntry(pluginDir: string, entry: string): void;
 declare function rejectNativeAddonsRecursive(dirPath: string): void;
 declare function copyIcon(pluginDir: string, bundleDir: string): void;
 declare function uniqueStagingDir(outDir: string): string;
@@ -25,6 +21,7 @@ export declare const __private: {
     rejectNativeAddonsRecursive: typeof rejectNativeAddonsRecursive;
     uniqueStagingDir: typeof uniqueStagingDir;
     validateDeclaredModuleExec: typeof validateDeclaredModuleExec;
+    validateManifestEntry: typeof validateManifestEntry;
     writeTarGz: typeof writeTarGz;
 };
 export {};

package/lib/dist.js

@@ -6,21 +6,19 @@ exports.parseDistArgs = parseDistArgs;
 exports.bundlePlugin = bundlePlugin;
 const fs = require("node:fs");
 const path = require("node:path");
-const node_child_process_1 = require("node:child_process");
 const tar = require("tar");
+const build_1 = require("./build");
 const fs_utils_1 = require("./fs-utils");
 const ICON_EXTENSIONS = ["png", "jpg", "jpeg", "webp", "avif", "svg"];
-function npmExecutable() {
-    return process.platform === "win32" ? "npm.cmd" : "npm";
-}
 function distUsage(commandName = "openvcs") {
-    return `${commandName} dist [args]\n\n  --plugin-dir <path>   Plugin repository root (contains openvcs.plugin.json)\n  --out <path>          Output directory (default: ./dist)\n  --no-npm-deps         Disable npm dependency bundling (enabled by default)\n  -V, --verbose         Enable verbose output\n`;
+    return `${commandName} dist [args]\n\n  --plugin-dir <path>   Plugin repository root (contains openvcs.plugin.json)\n  --out <path>          Output directory (default: ./dist)\n  --no-build            Skip the plugin build step before packaging\n  --no-npm-deps         Disable npm dependency bundling (enabled by default)\n  -V, --verbose         Enable verbose output\n`;
 }
 function parseDistArgs(args) {
     let pluginDir = process.cwd();
     let outDir = "dist";
     let verbose = false;
     let noNpmDeps = false;
+    let noBuild = false;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--plugin-dir") {
@@ -43,6 +41,10 @@ function parseDistArgs(args) {
             noNpmDeps = true;
             continue;
         }
+        if (arg === "--no-build") {
+            noBuild = true;
+            continue;
+        }
         if (arg === "-V" || arg === "--verbose") {
             verbose = true;
             continue;
@@ -59,109 +61,44 @@ function parseDistArgs(args) {
         outDir: path.resolve(outDir),
         verbose,
         noNpmDeps,
+        noBuild,
     };
 }
-function readManifest(pluginDir) {
-    const manifestPath = path.join(pluginDir, "openvcs.plugin.json");
-    let manifestRaw;
-    let manifestFd;
-    let manifest;
-    try {
-        manifestFd = fs.openSync(manifestPath, "r");
-        const manifestStat = fs.fstatSync(manifestFd);
-        if (!manifestStat.isFile()) {
-            throw new Error(`missing openvcs.plugin.json at ${manifestPath}`);
-        }
-        manifestRaw = fs.readFileSync(manifestFd, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error(`missing openvcs.plugin.json at ${manifestPath}`);
-        }
-        throw error;
-    }
-    finally {
-        if (typeof manifestFd === "number") {
-            fs.closeSync(manifestFd);
-        }
-    }
-    try {
-        manifest = JSON.parse(manifestRaw);
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        throw new Error(`parse ${manifestPath}: ${detail}`);
-    }
-    const pluginId = typeof manifest.id === "string"
-        ? manifest.id.trim()
-        : "";
-    if (!pluginId) {
-        throw new Error(`manifest ${manifestPath} is missing a string 'id'`);
-    }
-    if (pluginId === "." || pluginId === ".." || pluginId.includes("/") || pluginId.includes("\\")) {
-        throw new Error(`manifest id must not contain path separators: ${pluginId}`);
-    }
-    const moduleValue = manifest.module;
-    const moduleExec = typeof moduleValue?.exec === "string" ? moduleValue.exec.trim() : undefined;
-    return {
-        pluginId,
-        moduleExec,
-        manifestPath,
-    };
-}
-function validateDeclaredModuleExec(pluginDir, moduleExec) {
-    if (!moduleExec) {
-        return;
-    }
-    const normalizedExec = moduleExec.trim();
-    const lowered = normalizedExec.toLowerCase();
-    if (!lowered.endsWith(".js") && !lowered.endsWith(".mjs") && !lowered.endsWith(".cjs")) {
-        throw new Error(`manifest exec must end with .js/.mjs/.cjs (Node runtime): ${moduleExec}`);
+function validateManifestEntry(pluginDir, entry) {
+    const normalized = entry.trim();
+    if (path.isAbsolute(normalized)) {
+        throw new Error(`manifest entry must be a relative path: ${entry}`);
     }
-    if (path.isAbsolute(normalizedExec)) {
-        throw new Error(`manifest module.exec must be a relative path under bin/: ${moduleExec}`);
-    }
-    const binDir = path.resolve(pluginDir, "bin");
-    const targetPath = path.resolve(binDir, normalizedExec);
-    if (!(0, fs_utils_1.isPathInside)(binDir, targetPath) || targetPath === binDir) {
-        throw new Error(`manifest module.exec must point to a file under bin/: ${moduleExec}`);
+    const targetPath = path.resolve(pluginDir, normalized);
+    const pluginDirResolved = path.resolve(pluginDir);
+    if (!(0, fs_utils_1.isPathInside)(pluginDirResolved, targetPath) || targetPath === pluginDirResolved) {
+        throw new Error(`manifest entry must point to a file under the plugin directory: ${entry}`);
     }
     if (!fs.existsSync(targetPath) || !fs.lstatSync(targetPath).isFile()) {
-        throw new Error(`module entrypoint not found at ${targetPath}`);
+        throw new Error(`manifest entry file not found: ${entry}`);
     }
 }
-function hasPackageJson(pluginDir) {
-    const packageJsonPath = path.join(pluginDir, "package.json");
-    return fs.existsSync(packageJsonPath) && fs.lstatSync(packageJsonPath).isFile();
+function copyEntryDirectory(pluginDir, bundleDir, entry) {
+    const normalized = entry.trim();
+    const entryDir = path.dirname(normalized);
+    const sourceDir = path.join(pluginDir, entryDir);
+    const destDir = path.join(bundleDir, entryDir);
+    (0, fs_utils_1.copyDirectoryRecursiveStrict)(sourceDir, destDir);
 }
-function runCommand(program, args, cwd, verbose) {
-    if (verbose) {
-        process.stderr.write(`Running command in ${cwd}: ${program} ${args.join(" ")}\n`);
-    }
-    const result = (0, node_child_process_1.spawnSync)(program, args, {
-        cwd,
-        stdio: ["ignore", verbose ? "inherit" : "ignore", "inherit"],
-    });
-    if (result.error) {
-        throw new Error(`failed to spawn '${program}' in ${cwd}: ${result.error.message}`);
-    }
-    if (result.status === 0) {
-        return;
-    }
-    throw new Error(`command failed (${program} ${args.join(" ")}), exit code ${result.status}`);
-}
-function ensurePackageLock(pluginDir, verbose) {
-    if (!hasPackageJson(pluginDir)) {
+function ensurePackageLock(pluginDir, bundleDir, verbose) {
+    if (!(0, build_1.hasPackageJson)(pluginDir)) {
         return;
     }
     const lockPath = path.join(pluginDir, "package-lock.json");
     if (fs.existsSync(lockPath) && fs.lstatSync(lockPath).isFile()) {
         return;
     }
+    const packageJsonPath = path.join(pluginDir, "package.json");
+    (0, fs_utils_1.copyFileStrict)(packageJsonPath, path.join(bundleDir, "package.json"));
     if (verbose) {
-        process.stderr.write(`Generating package-lock.json in ${pluginDir}\n`);
+        process.stderr.write(`Generating package-lock.json in staging\n`);
     }
-    runCommand(npmExecutable(), ["install", "--package-lock-only", "--ignore-scripts", "--no-audit", "--no-fund"], pluginDir, verbose);
+    (0, build_1.runCommand)((0, build_1.npmExecutable)(), ["install", "--package-lock-only", "--ignore-scripts", "--no-audit", "--no-fund"], bundleDir, verbose);
 }
 function copyNpmFilesToStaging(pluginDir, bundleDir) {
     const packageJsonPath = path.join(pluginDir, "package.json");
@@ -169,11 +106,14 @@ function copyNpmFilesToStaging(pluginDir, bundleDir) {
     if (!fs.existsSync(packageJsonPath) || !fs.lstatSync(packageJsonPath).isFile()) {
         throw new Error(`missing package.json at ${packageJsonPath}`);
     }
-    if (!fs.existsSync(lockPath) || !fs.lstatSync(lockPath).isFile()) {
-        throw new Error(`missing package-lock.json at ${lockPath}`);
-    }
     (0, fs_utils_1.copyFileStrict)(packageJsonPath, path.join(bundleDir, "package.json"));
-    (0, fs_utils_1.copyFileStrict)(lockPath, path.join(bundleDir, "package-lock.json"));
+    const stagedLockPath = path.join(bundleDir, "package-lock.json");
+    if (fs.existsSync(stagedLockPath) && fs.lstatSync(stagedLockPath).isFile()) {
+        return;
+    }
+    if (fs.existsSync(lockPath) && fs.lstatSync(lockPath).isFile()) {
+        (0, fs_utils_1.copyFileStrict)(lockPath, path.join(bundleDir, "package-lock.json"));
+    }
 }
 function rejectNativeAddonsRecursive(dirPath) {
     const entries = fs.readdirSync(dirPath, { withFileTypes: true });
@@ -197,7 +137,7 @@ function rejectNativeAddonsRecursive(dirPath) {
 }
 function installNpmDependencies(pluginDir, bundleDir, verbose) {
     copyNpmFilesToStaging(pluginDir, bundleDir);
-    runCommand(npmExecutable(), ["ci", "--omit=dev", "--ignore-scripts", "--no-bin-links", "--no-audit", "--no-fund"], bundleDir, verbose);
+    (0, build_1.runCommand)((0, build_1.npmExecutable)(), ["ci", "--omit=dev", "--ignore-scripts", "--no-bin-links", "--no-audit", "--no-fund"], bundleDir, verbose);
     const nodeModulesPath = path.join(bundleDir, "node_modules");
     if (!fs.existsSync(nodeModulesPath)) {
         return;
@@ -208,14 +148,19 @@ function installNpmDependencies(pluginDir, bundleDir, verbose) {
     rejectNativeAddonsRecursive(nodeModulesPath);
 }
 function copyIcon(pluginDir, bundleDir) {
-    for (const extension of ICON_EXTENSIONS) {
-        const fileName = `icon.${extension}`;
-        const sourcePath = path.join(pluginDir, fileName);
-        if (!fs.existsSync(sourcePath)) {
-            continue;
+    const entries = fs.readdirSync(pluginDir, { withFileTypes: true });
+    const iconEntries = entries.filter((e) => {
+        if (!e.isFile())
+            return false;
+        const name = e.name.toLowerCase();
+        return name.startsWith("icon.") && ICON_EXTENSIONS.includes(name.slice(5));
+    });
+    for (const ext of ICON_EXTENSIONS) {
+        const found = iconEntries.find((e) => e.name.toLowerCase() === `icon.${ext}`);
+        if (found) {
+            (0, fs_utils_1.copyFileStrict)(path.join(pluginDir, found.name), path.join(bundleDir, found.name));
+            return;
         }
-        (0, fs_utils_1.copyFileStrict)(sourcePath, path.join(bundleDir, fileName));
-        return;
     }
 }
 function uniqueStagingDir(outDir) {
@@ -235,17 +180,22 @@ async function writeTarGz(outPath, baseDir, folderName) {
     }, [folderName]);
 }
 async function bundlePlugin(parsedArgs) {
-    const { pluginDir, outDir, verbose, noNpmDeps } = parsedArgs;
+    const { pluginDir, outDir, verbose, noNpmDeps, noBuild } = parsedArgs;
     if (verbose) {
         process.stderr.write(`Bundling plugin from: ${pluginDir}\n`);
     }
-    const { pluginId, moduleExec, manifestPath } = readManifest(pluginDir);
+    const { pluginId, moduleExec, entry, manifestPath } = noBuild
+        ? (0, build_1.readManifest)(pluginDir)
+        : (0, build_1.buildPluginAssets)({ pluginDir, verbose });
     const themesPath = path.join(pluginDir, "themes");
     const hasThemes = fs.existsSync(themesPath) && fs.lstatSync(themesPath).isDirectory();
-    if (!moduleExec && !hasThemes) {
-        throw new Error("manifest has no module.exec or themes/");
+    if (entry) {
+        validateManifestEntry(pluginDir, entry);
     }
-    validateDeclaredModuleExec(pluginDir, moduleExec);
+    if (!moduleExec && !hasThemes && !entry) {
+        throw new Error("manifest has no module.exec, entry, or themes/");
+    }
+    (0, build_1.validateDeclaredModuleExec)(pluginDir, moduleExec);
     (0, fs_utils_1.ensureDirectory)(outDir);
     const stagingRoot = uniqueStagingDir(outDir);
     const bundleDir = path.join(stagingRoot, pluginId);
@@ -253,6 +203,9 @@ async function bundlePlugin(parsedArgs) {
     try {
         (0, fs_utils_1.copyFileStrict)(manifestPath, path.join(bundleDir, "openvcs.plugin.json"));
         copyIcon(pluginDir, bundleDir);
+        if (entry) {
+            copyEntryDirectory(pluginDir, bundleDir, entry);
+        }
         const sourceBinDir = path.join(pluginDir, "bin");
         if (fs.existsSync(sourceBinDir) && fs.lstatSync(sourceBinDir).isDirectory()) {
             (0, fs_utils_1.copyDirectoryRecursiveStrict)(sourceBinDir, path.join(bundleDir, "bin"));
@@ -260,8 +213,8 @@ async function bundlePlugin(parsedArgs) {
         if (hasThemes) {
             (0, fs_utils_1.copyDirectoryRecursiveStrict)(themesPath, path.join(bundleDir, "themes"));
         }
-        if (!noNpmDeps && hasPackageJson(pluginDir)) {
-            ensurePackageLock(pluginDir, verbose);
+        if (!noNpmDeps && (0, build_1.hasPackageJson)(pluginDir)) {
+            ensurePackageLock(pluginDir, bundleDir, verbose);
             installNpmDependencies(pluginDir, bundleDir, verbose);
         }
         const outPath = path.join(outDir, `${pluginId}.ovcsp`);
@@ -278,9 +231,10 @@ async function bundlePlugin(parsedArgs) {
 exports.__private = {
     ICON_EXTENSIONS,
     copyIcon,
-    readManifest,
+    readManifest: build_1.readManifest,
     rejectNativeAddonsRecursive,
     uniqueStagingDir,
-    validateDeclaredModuleExec,
+    validateDeclaredModuleExec: build_1.validateDeclaredModuleExec,
+    validateManifestEntry,
     writeTarGz,
 };