@tgrv/void-cli 1.1.0 → 1.1.1

package/bin/void.js

@@ -72,6 +72,14 @@ function ensureDir(dir) {
   }
 }
 
+function toJsFriendlyName(name) {
+  let clean = name.includes('/') ? name.split('/').pop() : name;
+  clean = clean.replace(/^[^a-zA-Z_$]+|[^a-zA-Z0-9_$]+$/g, '');
+  return clean.replace(/[-_]([a-z0-9])/gi, (match, group1) => {
+    return group1.toUpperCase();
+  });
+}
+
 function copyFolderRecursive(src, dest, replacements = {}) {
   ensureDir(dest);
   const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -100,44 +108,44 @@ function copyFolderRecursive(src, dest, replacements = {}) {
   }
 }
 
-function copyNonSourceFiles(src, dest, buildOutputDir, filesConfig, wasmFilename) {
-  if (!filesConfig || !Array.isArray(filesConfig) || filesConfig.length === 0) {
-    return;
-  }
+function matchGlob(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
 
-  function matchGlob(filePath, pattern) {
-    const normalizedPath = filePath.replace(/\\/g, "/");
-    const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (normalizedPath === normalizedPattern) {
+    return true;
+  }
+  const prefix = normalizedPattern.endsWith('/') ? normalizedPattern : normalizedPattern + '/';
+  if (normalizedPath.startsWith(prefix)) {
+    return true;
+  }
 
-    if (normalizedPath === normalizedPattern) {
+  const globToRegex = (glob) => {
+    return '^' + glob
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '___DOUBLE_STAR___')
+      .replace(/\*/g, '___SINGLE_STAR___')
+      .replace(/\?/g, '___QUESTION___')
+      .replace(/___DOUBLE_STAR___/g, '.*')
+      .replace(/___SINGLE_STAR___/g, '[^/]*')
+      .replace(/___QUESTION___/g, '.') + '$';
+  };
+
+  const regex = new RegExp(globToRegex(normalizedPattern));
+  
+  if (!normalizedPattern.includes('/')) {
+    const baseName = path.basename(normalizedPath);
+    if (regex.test(baseName)) {
       return true;
     }
-    const prefix = normalizedPattern.endsWith('/') ? normalizedPattern : normalizedPattern + '/';
-    if (normalizedPath.startsWith(prefix)) {
-      return true;
-    }
-
-    const globToRegex = (glob) => {
-      return '^' + glob
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '___DOUBLE_STAR___')
-        .replace(/\*/g, '___SINGLE_STAR___')
-        .replace(/\?/g, '___QUESTION___')
-        .replace(/___DOUBLE_STAR___/g, '.*')
-        .replace(/___SINGLE_STAR___/g, '[^/]*')
-        .replace(/___QUESTION___/g, '.') + '$';
-    };
+  }
 
-    const regex = new RegExp(globToRegex(normalizedPattern));
-    
-    if (!normalizedPattern.includes('/')) {
-      const baseName = path.basename(normalizedPath);
-      if (regex.test(baseName)) {
-        return true;
-      }
-    }
+  return regex.test(normalizedPath);
+}
 
-    return regex.test(normalizedPath);
+function copyNonSourceFiles(src, dest, buildOutputDir, filesConfig, wasmFilename) {
+  if (!filesConfig || !Array.isArray(filesConfig) || filesConfig.length === 0) {
+    return;
   }
 
   function traverse(currentDir) {
@@ -178,6 +186,62 @@ function copyNonSourceFiles(src, dest, buildOutputDir, filesConfig, wasmFilename
   traverse(src);
 }
 
+function cleanupOutputDirectory(pluginDir, buildOutputDir, filesConfig, wasmFilename, typesFilename) {
+  if (!fs.existsSync(buildOutputDir)) return;
+
+  function traverse(currentDir) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = path.relative(buildOutputDir, fullPath);
+
+      if (entry.isDirectory()) {
+        traverse(fullPath);
+        // Clean up empty directories
+        if (fs.readdirSync(fullPath).length === 0) {
+          try {
+            fs.rmdirSync(fullPath);
+          } catch (e) {}
+        }
+      } else {
+        // Skip core files
+        if (entry.name === "index.js" || 
+            entry.name === "package.json" || 
+            entry.name === wasmFilename || 
+            (typesFilename && entry.name === typesFilename)) {
+          continue;
+        }
+
+        // Check if the file still exists in the source plugin root
+        const sourcePath = path.join(pluginDir, relativePath);
+        if (!fs.existsSync(sourcePath)) {
+          try {
+            fs.unlinkSync(fullPath);
+          } catch (e) {}
+          continue;
+        }
+
+        // Check if the file still matches the files configuration
+        if (!filesConfig || !Array.isArray(filesConfig) || filesConfig.length === 0) {
+          try {
+            fs.unlinkSync(fullPath);
+          } catch (e) {}
+          continue;
+        }
+
+        const matches = filesConfig.some(pattern => matchGlob(relativePath, pattern));
+        if (!matches) {
+          try {
+            fs.unlinkSync(fullPath);
+          } catch (e) {}
+        }
+      }
+    }
+  }
+
+  traverse(buildOutputDir);
+}
+
 const args = process.argv.slice(2);
 const command = args[0];
 
@@ -198,7 +262,7 @@ ${colors.bold}Usage:${colors.reset}
   process.exit(0);
 }
 
-// Build core compilation wrapper function to resolve output directory using void.json manifest
+// Build core compilation wrapper
 function runBuild(pluginPathArg) {
   const absolutePluginDir = path.resolve(process.cwd(), pluginPathArg);
   if (!fs.existsSync(absolutePluginDir)) {
@@ -238,7 +302,8 @@ function runBuild(pluginPathArg) {
   const pluginType = manifest.type;
   const buildDir = manifest.buildDir;
   const buildOutputDir = path.join(absolutePluginDir, buildDir);
-  const exportName = manifest.export || "plugin";
+  const rawExport = manifest.export || "plugin";
+  const exportName = toJsFriendlyName(rawExport);
   const wasmFilename = `${exportName}.wasm`;
 
   if (pluginType === "sdk") {
@@ -282,6 +347,45 @@ function runBuild(pluginPathArg) {
       process.exit(1);
     }
     builtWasmPath = outputWasm;
+  }
+  // C++ plugin compilation
+  else if (pluginType === "cpp") {
+    console.log(`${info} Running: ${colors.blue}emcmake cmake -B build -DCMAKE_BUILD_TYPE=Release${colors.reset}`);
+    const configSuccess = runCommand("emcmake cmake -B build -DCMAKE_BUILD_TYPE=Release", { cwd: absolutePluginDir });
+    if (!configSuccess) {
+      console.error(`${cross} ${colors.red}Emscripten CMake configuration failed. Make sure emscripten SDK is active.${colors.reset}`);
+      process.exit(1);
+    }
+
+    console.log(`${info} Running: ${colors.blue}cmake --build build --config Release${colors.reset}`);
+    const buildSuccess = runCommand("cmake --build build --config Release", { cwd: absolutePluginDir });
+    if (!buildSuccess) {
+      console.error(`${cross} ${colors.red}C++ compilation failed.${colors.reset}`);
+      process.exit(1);
+    }
+
+    const buildPath = path.join(absolutePluginDir, "build");
+    function findWasm(dir) {
+      if (!fs.existsSync(dir)) return null;
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const found = findWasm(fullPath);
+          if (found) return found;
+        } else if (entry.name.endsWith(".wasm")) {
+          return fullPath;
+        }
+      }
+      return null;
+    }
+
+    const wasmFile = findWasm(buildPath);
+    if (!wasmFile) {
+      console.error(`${cross} ${colors.red}Could not find compiled .wasm file in C++ build directory${colors.reset}`);
+      process.exit(1);
+    }
+    builtWasmPath = wasmFile;
   } else {
     console.error(`${cross} ${colors.red}Unsupported plugin type: '${pluginType}' in void.json${colors.reset}`);
     process.exit(1);
@@ -290,6 +394,18 @@ function runBuild(pluginPathArg) {
   console.log(`${info} Placing build output to local folder at ${colors.bold}${buildOutputDir}${colors.reset}...`);
   ensureDir(buildOutputDir);
 
+  // Remove past builds' .wasm files from the build output directory
+  if (fs.existsSync(buildOutputDir)) {
+    const files = fs.readdirSync(buildOutputDir);
+    for (const file of files) {
+      if (file.endsWith(".wasm")) {
+        try {
+          fs.unlinkSync(path.join(buildOutputDir, file));
+        } catch (e) {}
+      }
+    }
+  }
+
   // Copy WASM
   fs.copyFileSync(builtWasmPath, path.join(buildOutputDir, wasmFilename));
 
@@ -312,6 +428,7 @@ function runBuild(pluginPathArg) {
       main: "index.js",
       dependencies: {
         "@tgrv/void-runtime": "^1.0.0",
+        ...(manifest.dependencies || {})
       },
       publishConfig: {
         access: "public"
@@ -334,6 +451,13 @@ function runBuild(pluginPathArg) {
         existingPkg.types = manifest.types;
         changed = true;
       }
+      if (manifest.dependencies) {
+        existingPkg.dependencies = {
+          ...existingPkg.dependencies,
+          ...manifest.dependencies
+        };
+        changed = true;
+      }
       if (changed) {
         fs.writeFileSync(packageJsonPath, JSON.stringify(existingPkg, null, 2));
       }
@@ -366,6 +490,7 @@ export default ${exportName};
 `;
   fs.writeFileSync(path.join(buildOutputDir, "index.js"), indexJsContent);
   copyNonSourceFiles(absolutePluginDir, buildOutputDir, buildOutputDir, manifest.files, wasmFilename);
+  cleanupOutputDirectory(absolutePluginDir, buildOutputDir, manifest.files, wasmFilename, manifest.types);
   console.log(`${tick} ${colors.green}Successfully completed compilation & packaging!${colors.reset}`);
   return buildOutputDir;
 }
@@ -645,13 +770,13 @@ try {
       // Prompt for language
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
       const rawLanguage = await new Promise((resolve) => {
-        rl.question(`${info} Select plugin language (go/rust) [default: rust]: `, (ans) => {
+        rl.question(`${info} Select plugin language (go/rust/cpp) [default: rust]: `, (ans) => {
           resolve(ans.trim().toLowerCase() || "rust");
         });
       });
       rl.close();
 
-      if (rawLanguage !== "rust" && rawLanguage !== "go") {
+      if (rawLanguage !== "rust" && rawLanguage !== "go" && rawLanguage !== "cpp") {
         console.error(`${cross} ${colors.red}Error: Unsupported language: ${rawLanguage}${colors.reset}`);
         process.exit(1);
       }
@@ -673,7 +798,7 @@ try {
           "\\{\\{type\\}\\}": "rust",
           "\\{\\{workspace_dir\\}\\}": workspaceDir.replace(/\\/g, "/"),
         });
-      } else {
+      } else if (rawLanguage === "go") {
         // Verify Go
         const goCheck = runCommand("go version");
         if (!goCheck) {
@@ -690,6 +815,23 @@ try {
           "\\{\\{type\\}\\}": "go",
           "\\{\\{workspace_dir\\}\\}": workspaceDir.replace(/\\/g, "/"),
         });
+      } else {
+        // Verify CMake
+        const cmakeCheck = runCommand("cmake --version");
+        if (!cmakeCheck) {
+          console.error(`\n${cross} ${colors.red}Error: 'cmake' is not installed on your machine.${colors.reset}`);
+          console.error(`${colors.yellow}Please install CMake from https://cmake.org/ first.${colors.reset}\n`);
+          process.exit(1);
+        }
+
+        console.log(`${info} Creating C++ plugin template at ${colors.bold}${targetDir}${colors.reset}...`);
+        ensureDir(targetDir);
+        const templateSrc = path.join(cliRoot, "templates", "cpp");
+        copyFolderRecursive(templateSrc, targetDir, {
+          "\\{\\{name\\}\\}": folderName,
+          "\\{\\{type\\}\\}": "cpp",
+          "\\{\\{workspace_dir\\}\\}": workspaceDir.replace(/\\/g, "/"),
+        });
       }
 
       console.log(`${tick} ${colors.green}Plugin created successfully under '${pluginPathArg}'!${colors.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tgrv/void-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "bin": {
     "void": "./bin/void.js"

package/templates/cpp/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.14)
+project({{name}} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Configure output as a WebAssembly module
+set(CMAKE_EXECUTABLE_SUFFIX ".wasm")
+
+# Exclude entry point and export functions explicitly for Emscripten
+if (EMSCRIPTEN)
+  set(EXPORT_FUNCTIONS "-sEXPORTED_FUNCTIONS=_void_malloc,_void_free,_void_free_string,_void_invoke,_void_init")
+  set(EXPORT_METHODS "-sEXPORTED_RUNTIME_METHODS=ccall,cwrap")
+  add_link_options(
+    "${EXPORT_FUNCTIONS}"
+    "${EXPORT_METHODS}"
+    "--no-entry"
+    "-sALLOW_MEMORY_GROWTH=1"
+  )
+endif()
+
+# Reference Void C++ SDK
+add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@tgrv/void-sdk-cpp" void-sdk-cpp-build)
+
+
+add_executable({{name}} src/plugin.cpp)
+target_link_libraries({{name}} PRIVATE void-sdk-cpp)

package/templates/cpp/README.md

@@ -0,0 +1,57 @@
+# Void C++ Plugin Template
+
+A template for building WebAssembly (WASM) plugins for the **Void** framework using C++.
+
+## 🚀 Getting Started
+
+> [!IMPORTANT]
+> Before building your plugin, run **`npm install`** (or `npm i`) in this root directory to download the C++ SDK dependency (`@tgrv/void-sdk-cpp`). The `package.json` file in this root folder is only used for local development setup and resolving CMake dependencies; it is **not** the package that gets published. The final publishable package (with its own generated `package.json`) will be built inside your output directory (configured in `void.json` as `buildDir`).
+
+
+### 1. Where to Start
+Write your plugin logic inside [src/plugin.cpp](src/plugin.cpp). Define handlers matching the signature:
+```cpp
+nlohmann::json MyHandler(const void_sdk::ArgsMap& args)
+```
+And register them inside `init_handlers()`:
+```cpp
+void init_handlers() {
+    void_sdk::register_handler("hello", hello);
+}
+VOID_PLUGIN(init_handlers);
+```
+
+### 2. Build the Plugin
+Compile your plugin by running the build command in this directory:
+```bash
+npx void build
+```
+This runs `emcmake` to configure CMake and compiles the C++ code to a WebAssembly binary.
+
+### 3. Test/Install Locally
+To test the built plugin in a local Void application:
+1. Initialize your application project: `npx void init`
+2. Add your compiled local plugin build output folder path:
+   ```bash
+   npx void add ./path/to/plugin/@void/<plugin-name>
+   ```
+
+### 4. Publish
+To build and publish the plugin to the npm registry:
+```bash
+npx void publish
+```
+
+---
+
+## ⚙️ Configuration (`void.json`)
+
+Your plugin configuration is defined in `void.json`. Here are the available fields:
+
+- **`name`**: The package name of your plugin (e.g. `my-plugin`).
+- **`version`**: The current semantic version of the plugin.
+- **`type`**: The compilation target language. Set to `"cpp"`.
+- **`buildDir`**: The target directory where compilation and wrapping assets are generated (e.g. `@void/my-plugin`).
+- **`types`**: Path to the TypeScript declaration file (e.g. `"types.d.ts"`).
+- **`export`**: The name of the JavaScript variable used to load the WASM binary, which is also the default export name (e.g. `"myPlugin"`). **Note:** Ensure you use a JS-friendly name (e.g. alphanumeric/camelCase) to ensure the generated JS code does not contain syntax errors. The CLI will automatically sanitize special characters (like `-`, `_`, or `@scope/`) into camelCase/JS-friendly format for the variable and the generated WASM binary name.
+- **`files`**: An array of glob patterns of non-source files (such as `*.md` or `*.d.ts`) to copy from the plugin root into the build output folder.

package/templates/cpp/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "void-cpp-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "@tgrv/void-runtime": "^1.0.0",
+    "@tgrv/void-sdk-cpp": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "types.d.ts"
+}

package/templates/cpp/src/plugin.cpp

@@ -0,0 +1,17 @@
+#include <void/void.hpp>
+
+using json = nlohmann::json;
+
+// Define a starter function handler
+json hello(const void_sdk::ArgsMap& args) {
+    std::string name = void_sdk::get_string(args, "name");
+    return json{{"message", "Hello, " + name + " from C++!"}};
+}
+
+// Register function handlers
+void init_handlers() {
+    void_sdk::register_handler("hello", hello);
+}
+
+// Bind initialization entrypoint
+VOID_PLUGIN(init_handlers);

package/templates/cpp/types.d.ts

@@ -0,0 +1,7 @@
+declare module '{{name}}' {
+  interface CppPlugin {
+    hello(args: { name: string }): { message: string };
+  }
+  const plugin: CppPlugin;
+  export default plugin;
+}

package/templates/cpp/void.json

@@ -0,0 +1,15 @@
+{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "type": "cpp",
+  "buildDir": "@void/{{name}}",
+  "types": "types.d.ts",
+  "export": "{{name}}",
+  "dependencies": {
+    "@tgrv/void-sdk-cpp": "^1.0.0"
+  },
+  "files": [
+    "*.d.ts",
+    "*.md"  
+  ]
+}

package/templates/go/README.md

@@ -48,5 +48,5 @@ Your plugin configuration is defined in `void.json`. Here are the available fiel
 - **`type`**: The compilation target language. Set to `"go"`.
 - **`buildDir`**: The target directory where compilation and wrapping assets are generated (e.g. `@void/my-plugin`).
 - **`types`**: Path to the TypeScript declaration file (e.g. `"types.d.ts"`). During the build process, the CLI validates its existence, copies it to the build output, and automatically sets the `"types"` entry in `package.json` for autocomplete and editor support.
-- **`export`**: The name of the JavaScript variable used to load the WASM binary, which is also the default export name (e.g. `"myPlugin"`).
+- **`export`**: The name of the JavaScript variable used to load the WASM binary, which is also the default export name (e.g. `"myPlugin"`). **Note:** Ensure you use a JS-friendly name (e.g. alphanumeric/camelCase) to ensure the generated JS code does not contain syntax errors. The CLI will automatically sanitize special characters (like `-`, `_`, or `@scope/`) into camelCase/JS-friendly format for the variable and the generated WASM binary name.
 - **`files`**: An array of glob patterns of non-source files (such as `*.md` or `*.d.ts`) to copy from the plugin root into the build output folder.

package/templates/rust/README.md

@@ -40,5 +40,5 @@ Your plugin configuration is defined in `void.json`. Here are the available fiel
 - **`type`**: The compilation target language. Set to `"rust"`.
 - **`buildDir`**: The target directory where compilation and wrapping assets are generated (e.g. `@void/my-plugin`).
 - **`types`**: Path to the TypeScript declaration file (e.g. `"types.d.ts"`). During the build process, the CLI validates its existence, copies it to the build output, and automatically sets the `"types"` entry in `package.json` for autocomplete and editor support.
-- **`export`**: The name of the JavaScript variable used to load the WASM binary, which is also the default export name (e.g. `"myPlugin"`).
+- **`export`**: The name of the JavaScript variable used to load the WASM binary, which is also the default export name (e.g. `"myPlugin"`). **Note:** Ensure you use a JS-friendly name (e.g. alphanumeric/camelCase) to ensure the generated JS code does not contain syntax errors. The CLI will automatically sanitize special characters (like `-`, `_`, or `@scope/`) into camelCase/JS-friendly format for the variable and the generated WASM binary name.
 - **`files`**: An array of glob patterns of non-source files (such as `*.md` or `*.d.ts`) to copy from the plugin root into the build output folder.