@openvcs/sdk 0.2.1 → 0.2.3

package/src/lib/dist.ts

@@ -1,7 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { spawnSync } from "node:child_process";
 import tar = require("tar");
+import {
+  buildPluginAssets,
+  hasPackageJson,
+  ManifestInfo,
+  npmExecutable,
+  readManifest,
+  runCommand,
+  validateDeclaredModuleExec,
+} from "./build";
 import {
   copyDirectoryRecursiveStrict,
   copyFileStrict,
@@ -19,27 +27,11 @@ interface DistArgs {
   outDir: string;
   verbose: boolean;
   noNpmDeps: boolean;
-}
-
-interface ManifestInfo {
-  pluginId: string;
-  moduleExec: string | undefined;
-  manifestPath: string;
-}
-
-interface CommandResult {
-  status: number | null;
-  error?: Error;
-  stdout?: string | null;
-  stderr?: string | null;
-}
-
-function npmExecutable(): string {
-  return process.platform === "win32" ? "npm.cmd" : "npm";
+  noBuild: boolean;
 }
 
 export function distUsage(commandName = "openvcs"): string {
-  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`;
 }
 
 export function parseDistArgs(args: string[]): DistArgs {
@@ -47,6 +39,7 @@ export function parseDistArgs(args: string[]): DistArgs {
   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];
@@ -70,6 +63,10 @@ export function parseDistArgs(args: string[]): DistArgs {
       noNpmDeps = true;
       continue;
     }
+    if (arg === "--no-build") {
+      noBuild = true;
+      continue;
+    }
     if (arg === "-V" || arg === "--verbose") {
       verbose = true;
       continue;
@@ -87,105 +84,34 @@ export function parseDistArgs(args: string[]): DistArgs {
     outDir: path.resolve(outDir),
     verbose,
     noNpmDeps,
+    noBuild,
   };
 }
 
-function readManifest(pluginDir: string): ManifestInfo {
-  const manifestPath = path.join(pluginDir, "openvcs.plugin.json");
-  if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile()) {
-    throw new Error(`missing openvcs.plugin.json at ${manifestPath}`);
-  }
-
-  let manifest: unknown;
-  try {
-    manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  } catch (error: unknown) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`parse ${manifestPath}: ${detail}`);
-  }
-
-  const pluginId =
-    typeof (manifest as { id?: unknown }).id === "string"
-      ? ((manifest as { id: string }).id.trim() as string)
-      : "";
-  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 as { module?: { exec?: unknown } }).module;
-  const moduleExec = typeof moduleValue?.exec === "string" ? moduleValue.exec.trim() : undefined;
-
-  return {
-    pluginId,
-    moduleExec,
-    manifestPath,
-  };
-}
-
-function validateDeclaredModuleExec(pluginDir: string, moduleExec: string | undefined): void {
-  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: string, entry: string): void {
+  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 (!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 (!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: string): boolean {
-  const packageJsonPath = path.join(pluginDir, "package.json");
-  return fs.existsSync(packageJsonPath) && fs.lstatSync(packageJsonPath).isFile();
-}
-
-function runCommand(program: string, args: string[], cwd: string, verbose: boolean): void {
-  if (verbose) {
-    process.stderr.write(`Running command in ${cwd}: ${program} ${args.join(" ")}\n`);
-  }
-
-  const result = spawnSync(program, args, {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  }) as CommandResult;
-
-  if (result.error) {
-    throw new Error(`failed to spawn '${program}' in ${cwd}: ${result.error.message}`);
-  }
-  if (result.status === 0) {
-    if (verbose) {
-      if (result.stdout?.trim()) {
-        process.stderr.write(`${result.stdout.trim()}\n`);
-      }
-      if (result.stderr?.trim()) {
-        process.stderr.write(`${result.stderr.trim()}\n`);
-      }
-    }
-    return;
-  }
-
-  throw new Error(
-    `command failed (${program} ${args.join(" ")}), exit code ${result.status}, stdout='${(result.stdout || "").trim()}', stderr='${(result.stderr || "").trim()}'`
-  );
+function copyEntryDirectory(pluginDir: string, bundleDir: string, entry: string): void {
+  const normalized = entry.trim();
+  const entryDir = path.dirname(normalized);
+  const sourceDir = path.join(pluginDir, entryDir);
+  const destDir = path.join(bundleDir, entryDir);
+  copyDirectoryRecursiveStrict(sourceDir, destDir);
 }
 
-function ensurePackageLock(pluginDir: string, verbose: boolean): void {
+function ensurePackageLock(pluginDir: string, bundleDir: string, verbose: boolean): void {
   if (!hasPackageJson(pluginDir)) {
     return;
   }
@@ -194,13 +120,16 @@ function ensurePackageLock(pluginDir: string, verbose: boolean): void {
     return;
   }
 
+  const packageJsonPath = path.join(pluginDir, "package.json");
+  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,
+    bundleDir,
     verbose
   );
 }
@@ -212,12 +141,17 @@ function copyNpmFilesToStaging(pluginDir: string, bundleDir: string): void {
   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}`);
-  }
 
   copyFileStrict(packageJsonPath, path.join(bundleDir, "package.json"));
-  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()) {
+    copyFileStrict(lockPath, path.join(bundleDir, "package-lock.json"));
+  }
 }
 
 function rejectNativeAddonsRecursive(dirPath: string): void {
@@ -261,14 +195,21 @@ function installNpmDependencies(pluginDir: string, bundleDir: string, verbose: b
 }
 
 function copyIcon(pluginDir: string, bundleDir: string): void {
-  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) {
+      copyFileStrict(
+        path.join(pluginDir, found.name),
+        path.join(bundleDir, found.name)
+      );
+      return;
     }
-    copyFileStrict(sourcePath, path.join(bundleDir, fileName));
-    return;
   }
 }
 
@@ -294,16 +235,21 @@ async function writeTarGz(outPath: string, baseDir: string, folderName: string):
 }
 
 export async function bundlePlugin(parsedArgs: DistArgs): Promise<string> {
-  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
+    ? readManifest(pluginDir)
+    : 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);
+  }
+  if (!moduleExec && !hasThemes && !entry) {
+    throw new Error("manifest has no module.exec, entry, or themes/");
   }
   validateDeclaredModuleExec(pluginDir, moduleExec);
 
@@ -317,6 +263,10 @@ export async function bundlePlugin(parsedArgs: DistArgs): Promise<string> {
     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()) {
       copyDirectoryRecursiveStrict(sourceBinDir, path.join(bundleDir, "bin"));
@@ -326,7 +276,7 @@ export async function bundlePlugin(parsedArgs: DistArgs): Promise<string> {
     }
 
     if (!noNpmDeps && hasPackageJson(pluginDir)) {
-      ensurePackageLock(pluginDir, verbose);
+      ensurePackageLock(pluginDir, bundleDir, verbose);
       installNpmDependencies(pluginDir, bundleDir, verbose);
     }
 
@@ -349,5 +299,6 @@ export const __private = {
   rejectNativeAddonsRecursive,
   uniqueStagingDir,
   validateDeclaredModuleExec,
+  validateManifestEntry,
   writeTarGz,
 };

package/src/lib/init.ts

@@ -23,6 +23,12 @@ interface CollectAnswersOptions {
   targetHint?: string;
 }
 
+interface PromptDriver {
+  promptText(label: string, defaultValue?: string): Promise<string>;
+  promptBoolean(label: string, defaultValue: boolean): Promise<boolean>;
+  close(): void;
+}
+
 interface InitCommandError {
   code?: string;
 }
@@ -68,37 +74,49 @@ function defaultPluginNameFromId(pluginId: string): string {
   return words.length > 0 ? words.join(" ") : "OpenVCS Plugin";
 }
 
-async function promptText(
-  rl: readline.Interface,
-  label: string,
-  defaultValue = ""
-): Promise<string> {
-  const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  const answer = await rl.question(`${label}${suffix}: `);
-  const trimmed = answer.trim();
-  return trimmed || defaultValue;
+function validatePluginId(pluginId: string): string | undefined {
+  if (!pluginId) {
+    return "Plugin id is required.";
+  }
+  if (pluginId === "." || pluginId === "..") {
+    return "Plugin id must not be '.' or '..'.";
+  }
+  if (pluginId.includes("/") || pluginId.includes("\\")) {
+    return "Plugin id must not contain path separators (/ or \\).";
+  }
+  return undefined;
 }
 
-async function promptBoolean(
-  rl: readline.Interface,
-  label: string,
-  defaultValue: boolean
-): Promise<boolean> {
-  const suffix = defaultValue ? "Y/n" : "y/N";
-  while (true) {
-    const answer = await rl.question(`${label} (${suffix}): `);
-    const normalized = answer.trim().toLowerCase();
-    if (!normalized) {
-      return defaultValue;
-    }
-    if (normalized === "y" || normalized === "yes") {
-      return true;
-    }
-    if (normalized === "n" || normalized === "no") {
-      return false;
-    }
-    process.stderr.write("Please answer yes or no.\n");
-  }
+function createReadlinePromptDriver(output: NodeJS.WritableStream = process.stderr): PromptDriver {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  return {
+    async promptText(label: string, defaultValue = ""): Promise<string> {
+      const suffix = defaultValue ? ` [${defaultValue}]` : "";
+      const answer = await rl.question(`${label}${suffix}: `);
+      const trimmed = answer.trim();
+      return trimmed || defaultValue;
+    },
+    async promptBoolean(label: string, defaultValue: boolean): Promise<boolean> {
+      const suffix = defaultValue ? "Y/n" : "y/N";
+      while (true) {
+        const answer = await rl.question(`${label} (${suffix}): `);
+        const normalized = answer.trim().toLowerCase();
+        if (!normalized) {
+          return defaultValue;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          return true;
+        }
+        if (normalized === "n" || normalized === "no") {
+          return false;
+        }
+        output.write("Please answer yes or no.\n");
+      }
+    },
+    close(): void {
+      rl.close();
+    },
+  };
 }
 
 function writeJson(filePath: string, value: unknown): void {
@@ -116,11 +134,14 @@ function directoryHasEntries(targetDir: string): boolean {
   return entries.length > 0;
 }
 
-async function collectAnswers({ forceTheme, targetHint }: CollectAnswersOptions): Promise<InitAnswers> {
+async function collectAnswers(
+  { forceTheme, targetHint }: CollectAnswersOptions,
+  promptDriver: PromptDriver = createReadlinePromptDriver(),
+  output: NodeJS.WritableStream = process.stderr
+): Promise<InitAnswers> {
   const defaultTarget = targetHint || path.join(process.cwd(), "openvcs-plugin");
-  const rl = readline.createInterface({ input: stdin, output: stdout });
   try {
-    const targetText = await promptText(rl, "Target directory", defaultTarget);
+    const targetText = await promptDriver.promptText("Target directory", defaultTarget);
     const targetDir = path.resolve(targetText);
 
     let kind: "module" | "theme" = "module";
@@ -128,7 +149,7 @@ async function collectAnswers({ forceTheme, targetHint }: CollectAnswersOptions)
       kind = "theme";
     } else {
       while (true) {
-        const value = (await promptText(rl, "Template type (module/theme)", "module"))
+        const value = (await promptDriver.promptText("Template type (module/theme)", "module"))
           .trim()
           .toLowerCase();
         if (value === "module" || value === "m") {
@@ -139,29 +160,35 @@ async function collectAnswers({ forceTheme, targetHint }: CollectAnswersOptions)
           kind = "theme";
           break;
         }
-        process.stderr.write("Please choose 'module' or 'theme'.\n");
+        output.write("Please choose 'module' or 'theme'.\n");
       }
     }
 
     const defaultId = defaultPluginIdFromDir(targetDir);
-    let pluginId = "";
+    let pluginId: string | undefined;
     while (!pluginId) {
-      pluginId = (await promptText(rl, "Plugin id", defaultId)).trim();
+      const candidateId = (await promptDriver.promptText("Plugin id", defaultId)).trim();
+      const validationError = validatePluginId(candidateId);
+      if (!validationError) {
+        pluginId = candidateId;
+        break;
+      }
+      output.write(`${validationError}\n`);
     }
 
     const defaultName = defaultPluginNameFromId(pluginId);
     let pluginName = "";
     while (!pluginName) {
-      pluginName = (await promptText(rl, "Plugin name", defaultName)).trim();
+      pluginName = (await promptDriver.promptText("Plugin name", defaultName)).trim();
     }
 
     let pluginVersion = "";
     while (!pluginVersion) {
-      pluginVersion = (await promptText(rl, "Version", "0.1.0")).trim();
+      pluginVersion = (await promptDriver.promptText("Version", "0.1.0")).trim();
     }
 
-    const defaultEnabled = await promptBoolean(rl, "Default enabled", true);
-    const runNpmInstall = await promptBoolean(rl, "Run npm install now", true);
+    const defaultEnabled = await promptDriver.promptBoolean("Default enabled", true);
+    const runNpmInstall = await promptDriver.promptBoolean("Run npm install now", true);
 
     return {
       targetDir,
@@ -173,7 +200,7 @@ async function collectAnswers({ forceTheme, targetHint }: CollectAnswersOptions)
       runNpmInstall,
     };
   } finally {
-    rl.close();
+    promptDriver.close();
   }
 }
 
@@ -209,9 +236,10 @@ function writeModuleTemplate(answers: InitAnswers): void {
     private: true,
     type: "module",
     scripts: {
-      "build:ts": "tsc -p tsconfig.json",
-      build: "npm run build:ts && openvcs dist --plugin-dir . --out dist",
-      test: "openvcs dist --plugin-dir . --out dist --no-npm-deps",
+      "build:plugin": "tsc -p tsconfig.json",
+      build: "openvcs build",
+      dist: "openvcs dist --plugin-dir . --out dist",
+      test: "openvcs dist --plugin-dir . --out dist --no-build --no-npm-deps",
     },
     devDependencies: {
       "@openvcs/sdk": `^${packageJson.version}`,
@@ -245,8 +273,9 @@ function writeThemeTemplate(answers: InitAnswers): void {
     version: answers.pluginVersion,
     private: true,
     scripts: {
-      build: "openvcs dist --plugin-dir . --out dist",
-      test: "openvcs dist --plugin-dir . --out dist --no-npm-deps",
+      build: "openvcs build",
+      dist: "openvcs dist --plugin-dir . --out dist",
+      test: "openvcs dist --plugin-dir . --out dist --no-build --no-npm-deps",
     },
     devDependencies: {
       "@openvcs/sdk": `^${packageJson.version}`,
@@ -292,10 +321,9 @@ export async function runInitCommand(args: string[]): Promise<string> {
   } else if (!fs.lstatSync(answers.targetDir).isDirectory()) {
     throw new Error(`target path exists but is not a directory: ${answers.targetDir}`);
   } else if (directoryHasEntries(answers.targetDir)) {
-    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const promptDriver = createReadlinePromptDriver();
     try {
-      const proceed = await promptBoolean(
-        rl,
+      const proceed = await promptDriver.promptBoolean(
         `Directory ${answers.targetDir} is not empty. Continue and overwrite known files`,
         false
       );
@@ -303,7 +331,7 @@ export async function runInitCommand(args: string[]): Promise<string> {
         throw new Error("aborted by user");
       }
     } finally {
-      rl.close();
+      promptDriver.close();
     }
   }
 
@@ -328,3 +356,11 @@ export function isUsageError(error: unknown): error is InitCommandError {
     typeof (error as InitCommandError).code === "string"
   );
 }
+
+export const __private = {
+  collectAnswers,
+  createReadlinePromptDriver,
+  defaultPluginIdFromDir,
+  sanitizeIdToken,
+  validatePluginId,
+};

package/test/build.test.js

@@ -0,0 +1,95 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+const { buildPluginAssets, parseBuildArgs, readManifest, validateDeclaredModuleExec } = require("../lib/build");
+const { cleanupTempDir, makeTempDir, writeJson, writeText } = require("./helpers");
+
+test("parseBuildArgs uses defaults", () => {
+  const parsed = parseBuildArgs([]);
+  assert.equal(parsed.pluginDir, process.cwd());
+  assert.equal(parsed.verbose, false);
+});
+
+test("parseBuildArgs parses known flags", () => {
+  const parsed = parseBuildArgs(["--plugin-dir", "some/plugin", "--verbose"]);
+  assert.equal(parsed.pluginDir, path.resolve("some/plugin"));
+  assert.equal(parsed.verbose, true);
+});
+
+test("parseBuildArgs help returns usage error", () => {
+  assert.throws(() => parseBuildArgs(["--help"]), /openvcs build \[args\]/);
+});
+
+test("buildPluginAssets no-ops for theme-only plugins", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+
+  writeJson(path.join(pluginDir, "openvcs.plugin.json"), { id: "theme-only" });
+  const manifest = buildPluginAssets({ pluginDir, verbose: false });
+
+  assert.equal(manifest.pluginId, "theme-only");
+  cleanupTempDir(root);
+});
+
+test("buildPluginAssets requires package.json for code plugins", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+
+  writeJson(path.join(pluginDir, "openvcs.plugin.json"), {
+    id: "missing-package",
+    module: { exec: "plugin.js" },
+  });
+
+  assert.throws(
+    () => buildPluginAssets({ pluginDir, verbose: false }),
+    /code plugins must include package\.json/
+  );
+
+  cleanupTempDir(root);
+});
+
+test("buildPluginAssets runs build:plugin and validates output", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+
+  writeJson(path.join(pluginDir, "openvcs.plugin.json"), {
+    id: "builder",
+    module: { exec: "plugin.js" },
+  });
+  writeJson(path.join(pluginDir, "package.json"), {
+    name: "builder",
+    private: true,
+    scripts: {
+      "build:plugin": "node ./scripts/build-plugin.js",
+    },
+  });
+  writeText(
+    path.join(pluginDir, "scripts", "build-plugin.js"),
+    "const fs = require('node:fs');\nconst path = require('node:path');\nconst out = path.join(process.cwd(), 'bin', 'plugin.js');\nfs.mkdirSync(path.dirname(out), { recursive: true });\nfs.writeFileSync(out, 'export {};\\n', 'utf8');\n"
+  );
+
+  const manifest = buildPluginAssets({ pluginDir, verbose: false });
+
+  assert.equal(manifest.pluginId, "builder");
+  assert.equal(fs.existsSync(path.join(pluginDir, "bin", "plugin.js")), true);
+  cleanupTempDir(root);
+});
+
+test("readManifest and validateDeclaredModuleExec stay reusable", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+
+  writeJson(path.join(pluginDir, "openvcs.plugin.json"), {
+    id: "reusable",
+    module: { exec: "plugin.js" },
+  });
+  writeText(path.join(pluginDir, "bin", "plugin.js"), "export {};\n");
+
+  const manifest = readManifest(pluginDir);
+  assert.equal(manifest.moduleExec, "plugin.js");
+  assert.doesNotThrow(() => validateDeclaredModuleExec(pluginDir, manifest.moduleExec));
+
+  cleanupTempDir(root);
+});