ewvjs-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miukyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# ewvjs-cli
+
+CLI tool for packaging ewvjs applications into standalone executables.
+
+## Installation
+
+```bash
+npm install -g ewvjs-cli
+```
+
+Or use with npx:
+
+```bash
+npx ewvjs-cli ewv --help
+```
+
+## Usage
+
+### List available templates
+
+```bash
+ewv init --list-templates
+```
+
+### Initialize a new ewvjs project
+
+```bash
+ewv init my-app
+```
+
+With a specific template:
+
+```bash
+# Minimal template (simple Hello World)
+ewv init my-app --template minimal
+
+# Basic template (default - interactive with APIs)
+ewv init my-app --template basic
+
+# Advanced template (multiple windows, file operations)
+ewv init my-app --template advanced
+```
+
+### Package your application
+
+```bash
+ewv package app.js -o myapp -n "My Application"
+```
+
+#### Options
+
+- `-o, --output <name>` - Output executable name (default: "app")
+- `-a, --assets <dir>` - Assets directory to include (default: "./assets")
+- `-i, --icon <file>` - Application icon (.ico file)
+- `-n, --name <name>` - Application name (default: "My App")
+- `-t, --target <target>` - Target platform (default: "node18-win-x64")
+- `-m, --modules <modules>` - Additional node modules to bundle (comma-separated)
+- `--compress` - Compress the executable with UPX
+- `--no-native` - Skip bundling native DLLs
+
+### Example
+
+```bash
+# Create a new project
+ewv init my-awesome-app
+cd my-awesome-app
+
+# Install dependencies
+npm install
+
+# Run in development
+npm start
+
+# Create with a specific template
+ewv init simple-app --template minimal
+
+# Create an advanced app
+ewv init pro-app --template advanced
+
+# Package for distribution
+ewv package app.js -o MyAwesomeApp -n "My Awesome App" -i icon.ico --compress
+```
+
+## Templates
+
+ewvjs-cli includes three project templates:
+
+### minimal
+A simple "Hello World" template - perfect for quick testing.
+
+### basic (default)
+Interactive application with exposed Node.js functions and a polished UI.
+
+### advanced
+Comprehensive template with multiple windows, file operations, and external assets.
+
+Use `ewv init --list-templates` to see all available templates.
+
+## License
+
+MIT

package/bin/ewvjs-cli.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs');
+const { input, select } = require('@inquirer/prompts');
+const packageApp = require('../lib/packager');
+const { setIcon } = require('../lib/icon');
+const { getAvailableTemplates, copyTemplate, isValidTemplate } = require('../lib/templates');
+
+const program = new Command();
+
+program
+  .name('ewv')
+  .description('CLI tool for packaging ewvjs applications')
+  .version(require('../package.json').version);
+
+program
+  .command('package')
+  .description('Package your ewvjs application into a standalone executable')
+  .argument('<entry>', 'Entry point JavaScript file (e.g., app.js)')
+  .option('-o, --output <name>', 'Output executable name', 'app')
+  .option('-a, --assets <dir>', 'Assets directory to include (e.g., ./assets)', './assets')
+  .option('-i, --icon <file>', 'Application icon (.ico file)')
+  .option('-n, --name <name>', 'Application name', 'My App')
+  .option('-t, --target <target>', 'Target platform', 'node18-win-x64')
+  .option('-m, --modules <modules>', 'Additional node modules to bundle (comma-separated, e.g., "axios,lodash")')
+  .option('--compress', 'Compress the executable with UPX', false)
+  .option('--no-native', 'Skip bundling native DLLs (use if already included)')
+  .action(async (entry, options) => {
+    try {
+      console.log('📦 Packaging ewvjs application...\n');
+
+      // Validate entry file exists
+      const entryPath = path.resolve(process.cwd(), entry);
+      if (!fs.existsSync(entryPath)) {
+        console.error(`❌ Error: Entry file not found: ${entry}`);
+        process.exit(1);
+      }
+
+      // Validate icon if provided
+      if (options.icon) {
+        const iconPath = path.resolve(process.cwd(), options.icon);
+        if (!fs.existsSync(iconPath)) {
+          console.error(`❌ Error: Icon file not found: ${options.icon}`);
+          process.exit(1);
+        }
+        if (!iconPath.endsWith('.ico')) {
+          console.error('❌ Error: Icon must be a .ico file');
+          process.exit(1);
+        }
+      }
+
+      // Parse additional modules if provided
+      const additionalModules = options.modules
+        ? options.modules.split(',').map(m => m.trim()).filter(m => m)
+        : [];
+
+      const config = {
+        entry: entryPath,
+        output: options.output,
+        assets: options.assets ? path.resolve(process.cwd(), options.assets) : null,
+        icon: options.icon ? path.resolve(process.cwd(), options.icon) : null,
+        name: options.name,
+        target: options.target,
+        compress: options.compress,
+        includeNative: options.native,
+        additionalModules: additionalModules
+      };
+
+      await packageApp(config);
+
+      console.log('\n✅ Packaging complete!');
+      console.log(`📁 Output folder: ${path.join(process.cwd(), 'dist')}`);
+      console.log(`📦 Archive: ${path.join(process.cwd(), options.output + '.zip')}`);
+
+    } catch (error) {
+      console.error('\n❌ Packaging failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('init')
+  .description('Initialize a new ewvjs project')
+  .argument('[name]', 'Project name')
+  .option('-t, --template <template>', 'Template to use (minimal, basic, advanced)')
+  .option('-l, --list-templates', 'List available templates')
+  .action(async (name, options) => {
+    // Handle list templates option
+    if (options.listTemplates) {
+      console.log('📋 Available templates:\n');
+      const templates = getAvailableTemplates();
+      templates.forEach(t => {
+        const isDefault = t.name === 'basic' ? ' (default)' : '';
+        console.log(`  ${t.name}${isDefault}`);
+        console.log(`    ${t.description}\n`);
+      });
+      console.log('Usage: ewv init <project-name> --template <template-name>');
+      return;
+    }
+
+    const templates = getAvailableTemplates();
+    const answers = {};
+
+    // Prompt for project name if not provided
+    if (!name) {
+      answers.projectName = await input({
+        message: 'Project name:',
+        default: 'my-ewvjs-app',
+        validate: (value) => {
+          if (!value || value.trim() === '') {
+            return 'Project name is required';
+          }
+          if (fs.existsSync(path.join(process.cwd(), value))) {
+            return `Directory ${value} already exists`;
+          }
+          return true;
+        }
+      });
+    } else {
+      answers.projectName = name;
+    }
+
+    // Prompt for template if not provided
+    if (!options.template) {
+      answers.template = await select({
+        message: 'Select a template:',
+        choices: templates.map(t => ({
+          name: `${t.name} - ${t.description}`,
+          value: t.name
+        })),
+        default: 'basic'
+      });
+    } else {
+      answers.template = options.template;
+    }
+
+    const projectDir = path.join(process.cwd(), answers.projectName);
+
+    // Validate template
+    if (!isValidTemplate(answers.template)) {
+      console.error(`❌ Error: Template "${answers.template}" not found`);
+      console.log('\nAvailable templates:');
+      templates.forEach(t => {
+        console.log(`  - ${t.name}: ${t.description}`);
+      });
+      process.exit(1);
+    }
+
+    if (fs.existsSync(projectDir)) {
+      console.error(`❌ Error: Directory ${answers.projectName} already exists`);
+      process.exit(1);
+    }
+
+    console.log(`\n📂 Creating new ewvjs project: ${answers.projectName}`);
+    console.log(`📝 Using template: ${answers.template}\n`);
+
+    try {
+      // Copy template to project directory
+      copyTemplate(answers.template, answers.projectName, projectDir);
+
+      console.log('✅ Project created successfully!\n');
+      console.log('Next steps:');
+      console.log(`  cd ${answers.projectName}`);
+      console.log('  npm install');
+      console.log('  npm start\n');
+    } catch (error) {
+      console.error(`❌ Error creating project: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/lib/assets.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const path = require('path');
+const archiver = require('archiver');
+
+/**
+ * Bundle assets directory
+ * @param {string} assetsDir - Source assets directory
+ * @param {string} outputDir - Destination directory
+ * @returns {Promise<void>}
+ */
+async function bundleAssets(assetsDir, outputDir) {
+  if (!fs.existsSync(assetsDir)) {
+    throw new Error(`Assets directory not found: ${assetsDir}`);
+  }
+
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Copy assets directory
+  await copyDirectory(assetsDir, outputDir);
+
+  // Get stats
+  const stats = getDirectoryStats(outputDir);
+  console.log(`   Copied ${stats.files} files (${formatBytes(stats.size)})`);
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+async function copyDirectory(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Create a zip archive of assets (alternative to direct copy)
+ * @param {string} assetsDir - Source assets directory
+ * @param {string} outputPath - Output zip file path
+ * @returns {Promise<void>}
+ */
+async function createAssetsArchive(assetsDir, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 } // Maximum compression
+    });
+
+    output.on('close', () => {
+      console.log(`   Created archive: ${formatBytes(archive.pointer())}`);
+      resolve();
+    });
+
+    archive.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+    archive.directory(assetsDir, false);
+    archive.finalize();
+  });
+}
+
+/**
+ * Get directory statistics
+ * @param {string} dirPath - Directory path
+ * @returns {{files: number, size: number}}
+ */
+function getDirectoryStats(dirPath) {
+  let fileCount = 0;
+  let totalSize = 0;
+
+  function traverse(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        traverse(fullPath);
+      } else {
+        fileCount++;
+        totalSize += fs.statSync(fullPath).size;
+      }
+    }
+  }
+
+  traverse(dirPath);
+  return { files: fileCount, size: totalSize };
+}
+
+/**
+ * Format bytes to human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+
+module.exports = {
+  bundleAssets,
+  createAssetsArchive,
+  copyDirectory,
+  formatBytes
+};

package/lib/icon.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const NtExecutable = require('resedit').NtExecutable;
+const NtExecutableResource = require('resedit').NtExecutableResource;
+const Resource = require('resedit').Resource;
+
+/**
+ * Set icon and metadata for Windows executable
+ * @param {string} exePath - Path to the executable
+ * @param {string} iconPath - Path to the .ico file
+ * @param {string} appName - Application name
+ * @param {Object} options - Additional metadata options
+ * @returns {Promise<void>}
+ */
+async function setIcon(exePath, iconPath, appName, options = {}) {
+  try {
+    // Read the executable
+    const exeBuffer = fs.readFileSync(exePath);
+    const exe = NtExecutable.from(exeBuffer);
+    const res = NtExecutableResource.from(exe);
+
+    // Read the icon file
+    if (iconPath && fs.existsSync(iconPath)) {
+      const iconBuffer = fs.readFileSync(iconPath);
+      
+      // Parse icon data
+      const iconFile = Resource.IconFile.from(iconBuffer);
+      
+      // Replace icon in executable
+      Resource.IconGroupEntry.replaceIconsForResource(
+        res.entries,
+        1, // Icon group ID
+        1033, // Language (English - United States)
+        iconFile.icons.map((icon) => icon.data)
+      );
+      
+      console.log(`   Applied icon: ${path.basename(iconPath)}`);
+    }
+
+    // Set version info
+    const viList = Resource.VersionInfo.fromEntries(res.entries);
+    const vi = viList[0] || Resource.VersionInfo.createEmpty();
+
+    const {
+      version = '1.0.0.0',
+      companyName = '',
+      fileDescription = appName,
+      copyright = `Copyright © ${new Date().getFullYear()}`,
+      productName = appName,
+      internalName = appName.replace(/\s+/g, ''),
+    } = options;
+
+    // Parse version string
+    const [major = 1, minor = 0, patch = 0, build = 0] = version.split('.').map(Number);
+
+    // Set version numbers
+    vi.setFileVersion(major, minor, patch, build, 1033);
+    vi.setProductVersion(major, minor, patch, build, 1033);
+
+    // Set string values
+    vi.setStringValues(
+      { lang: 1033, codepage: 1200 },
+      {
+        ProductName: productName,
+        FileDescription: fileDescription,
+        CompanyName: companyName,
+        LegalCopyright: copyright,
+        FileVersion: version,
+        ProductVersion: version,
+        InternalName: internalName,
+        OriginalFilename: path.basename(exePath)
+      }
+    );
+
+    vi.outputToResourceEntries(res.entries);
+
+    // Write back to executable
+    res.outputResource(exe);
+    const newBuffer = exe.generate();
+    fs.writeFileSync(exePath, Buffer.from(newBuffer));
+
+    console.log(`   Applied metadata: ${appName} v${version}`);
+  } catch (error) {
+    console.warn(`   ⚠ Warning: Could not set icon/metadata: ${error.message}`);
+    console.warn('   The executable was created but icon/metadata may be missing.');
+  }
+}
+
+/**
+ * Validate icon file
+ * @param {string} iconPath - Path to icon file
+ * @returns {boolean}
+ */
+function validateIcon(iconPath) {
+  if (!fs.existsSync(iconPath)) {
+    throw new Error(`Icon file not found: ${iconPath}`);
+  }
+
+  if (!iconPath.toLowerCase().endsWith('.ico')) {
+    throw new Error('Icon file must be in .ico format');
+  }
+
+  const stats = fs.statSync(iconPath);
+  if (stats.size === 0) {
+    throw new Error('Icon file is empty');
+  }
+
+  if (stats.size > 1024 * 1024) {
+    console.warn('Warning: Icon file is larger than 1MB, consider optimizing it');
+  }
+
+  return true;
+}
+
+/**
+ * Extract icon from executable
+ * @param {string} exePath - Path to executable
+ * @param {string} outputPath - Output path for icon file
+ * @returns {Promise<void>}
+ */
+async function extractIcon(exePath, outputPath) {
+  try {
+    const exeBuffer = fs.readFileSync(exePath);
+    const exe = NtExecutable.from(exeBuffer);
+    const res = NtExecutableResource.from(exe);
+
+    // Find icon group
+    const iconGroups = Resource.IconGroupEntry.fromEntries(res.entries);
+    
+    if (iconGroups.length === 0) {
+      throw new Error('No icon found in executable');
+    }
+
+    // Get first icon group
+    const iconGroup = iconGroups[0];
+    const iconFile = Resource.IconFile.from(iconGroup, res.entries);
+
+    // Write icon file
+    fs.writeFileSync(outputPath, Buffer.from(iconFile.data));
+    console.log(`Extracted icon to: ${outputPath}`);
+  } catch (error) {
+    throw new Error(`Failed to extract icon: ${error.message}`);
+  }
+}
+
+module.exports = {
+  setIcon,
+  validateIcon,
+  extractIcon
+};

package/lib/packager.js

@@ -0,0 +1,397 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const archiver = require('archiver');
+const { bundleAssets } = require('./assets');
+const { setIcon } = require('./icon');
+
+/**
+ * Convert console application to GUI application (hide console window)
+ * @param {string} exePath - Path to the executable
+ */
+function convertToGuiApp(exePath) {
+  try {
+    // Read the executable as a buffer
+    const exeBuffer = fs.readFileSync(exePath);
+    
+    // Get PE signature offset (at 0x3C in DOS header)
+    const peOffset = exeBuffer.readUInt32LE(0x3C);
+    
+    // PE signature is 4 bytes ("PE\0\0")
+    // COFF header is 20 bytes
+    // Optional header starts at peOffset + 24
+    // Subsystem is at offset 68 (0x44) in optional header
+    const subsystemOffset = peOffset + 24 + 68;
+    
+    // Read current subsystem value
+    const currentSubsystem = exeBuffer.readUInt16LE(subsystemOffset);
+    console.log(`   Current subsystem: ${currentSubsystem} (3=CONSOLE, 2=GUI)`);
+    
+    // Set to IMAGE_SUBSYSTEM_WINDOWS_GUI (2) instead of CONSOLE (3)
+    if (currentSubsystem === 3) {
+      exeBuffer.writeUInt16LE(2, subsystemOffset);
+      console.log(`   Changed subsystem to GUI (2)`);
+      
+      // Write the modified executable
+      fs.writeFileSync(exePath, exeBuffer);
+    }
+  } catch (error) {
+    console.warn(`   ⚠ Warning: Could not convert to GUI app: ${error.message}`);
+    console.warn('   The executable will show a console window.');
+  }
+}
+
+/**
+ * Run pkg command using spawn
+ * @param {string[]} args - Arguments for pkg
+ * @returns {Promise<void>}
+ */
+function runPkg(args) {
+  return new Promise((resolve, reject) => {
+    // Try to find pkg binary in node_modules
+    let pkgBin;
+    try {
+      const pkgPackageJson = require.resolve('@yao-pkg/pkg/package.json');
+      const pkgDir = path.dirname(pkgPackageJson);
+      
+      // Check for different possible bin locations
+      const possibleBins = [
+        path.join(pkgDir, 'lib-es5', 'bin.js'),
+        path.join(pkgDir, 'lib', 'bin.js'),
+        path.join(pkgDir, 'bin', 'pkg.js')
+      ];
+      
+      for (const bin of possibleBins) {
+        if (fs.existsSync(bin)) {
+          pkgBin = bin;
+          break;
+        }
+      }
+      
+      if (!pkgBin) {
+        throw new Error('pkg binary not found');
+      }
+    } catch (error) {
+      reject(new Error(`Cannot find @yao-pkg/pkg installation: ${error.message}`));
+      return;
+    }
+    
+    console.log(`   Running: node ${pkgBin} ${args.join(' ')}`);
+    
+    // Spawn pkg process
+    let stdout = '';
+    let stderr = '';
+    
+    const pkgProcess = spawn(process.execPath, [pkgBin, ...args], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      shell: false
+    });
+    
+    pkgProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      stdout += output;
+      process.stdout.write(output);
+    });
+    
+    pkgProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      stderr += output;
+      process.stderr.write(output);
+    });
+
+    pkgProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const errorMsg = stderr || stdout || `pkg exited with code ${code}`;
+        reject(new Error(errorMsg));
+      }
+    });
+
+    pkgProcess.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Package an ewvjs application into a standalone executable
+ * @param {Object} config - Packaging configuration
+ * @param {string} config.entry - Entry point file path
+ * @param {string} config.output - Output executable name (without .exe)
+ * @param {string} config.assets - Assets directory path
+ * @param {string} config.icon - Icon file path (.ico)
+ * @param {string} config.name - Application name
+ * @param {string} config.target - Target platform (e.g., node18-win-x64)
+ * @param {boolean} config.compress - Whether to compress with UPX
+ * @param {boolean} config.includeNative - Whether to include native DLLs
+ * @param {string[]} config.additionalModules - Additional node modules to bundle
+ */
+async function packageApp(config) {
+  const {
+    entry,
+    output,
+    assets,
+    icon,
+    name,
+    target,
+    compress,
+    includeNative = true,
+    additionalModules = []
+  } = config;
+
+  const outputDir = path.join(process.cwd(), 'dist');
+  const outputPath = path.join(outputDir, `${output}.exe`);
+
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  console.log('📝 Configuration:');
+  console.log(`   Entry: ${entry}`);
+  console.log(`   Output: ${outputPath}`);
+  console.log(`   Target: ${target}`);
+  console.log(`   Compress: ${compress ? 'Yes' : 'No'}`);
+  if (assets && fs.existsSync(assets)) {
+    console.log(`   Assets: ${assets}`);
+  }
+  if (icon) {
+    console.log(`   Icon: ${icon}`);
+  }
+  if (additionalModules.length > 0) {
+    console.log(`   Additional Modules: ${additionalModules.join(', ')}`);
+  }
+  console.log('');
+
+  // Step 1: Package with @yao-pkg/pkg
+  console.log('🔨 Step 1: Creating executable with pkg...');
+  
+  const pkgArgs = [
+    entry,
+    '--target', target,
+    '--output', outputPath,
+    '--public',  // Faster, includes sources
+    '--no-bytecode',  // Skip bytecode generation for faster packaging
+  ];
+
+  if (compress) {
+    pkgArgs.push('--compress', 'GZip');
+  }
+
+  // Add pkg configuration for native modules
+  const pkgConfig = {
+    assets: []
+  };
+
+  // Include native DLLs if requested
+  if (includeNative) {
+    const ewvjsPath = require.resolve('ewvjs');
+    const ewvjsRoot = path.dirname(path.dirname(ewvjsPath));
+    const nativePath = path.join(ewvjsRoot, 'native');
+    
+    if (fs.existsSync(nativePath)) {
+      console.log('   Including native DLLs from ewvjs...');
+      pkgConfig.assets.push(`${nativePath}/**/*`);
+    }
+  }
+
+  // Write temporary pkg config
+  const pkgConfigPath = path.join(process.cwd(), '.pkg-config.json');
+  fs.writeFileSync(pkgConfigPath, JSON.stringify(pkgConfig, null, 2));
+
+  try {
+    // Execute pkg using spawn
+    await runPkg(pkgArgs);
+    console.log('   ✓ Executable created');
+    
+    // Convert to GUI application (hide console window)
+    console.log('   Converting to GUI application...');
+    convertToGuiApp(outputPath);
+    console.log('   ✓ Converted to GUI app (no console window)');
+    
+    // Clean up temp config
+    if (fs.existsSync(pkgConfigPath)) {
+      fs.unlinkSync(pkgConfigPath);
+    }
+  } catch (error) {
+    // Clean up temp config on error
+    if (fs.existsSync(pkgConfigPath)) {
+      fs.unlinkSync(pkgConfigPath);
+    }
+    throw new Error(`pkg failed: ${error.message}`);
+  }
+
+  // Step 2: Copy native DLLs next to executable
+  if (includeNative) {
+    console.log('\n🔧 Step 2: Copying native dependencies...');
+    const ewvjsPath = require.resolve('ewvjs');
+    const ewvjsRoot = path.dirname(path.dirname(ewvjsPath));
+    const nativePath = path.join(ewvjsRoot, 'native');
+    
+    if (fs.existsSync(nativePath)) {
+      const targetNativePath = path.join(outputDir, 'native');
+      
+      // Copy directory recursively
+      copyRecursive(nativePath, targetNativePath);
+      console.log(`   ✓ Native DLLs copied to ${targetNativePath}`);
+      
+      // Copy additional node modules if specified
+      if (additionalModules.length > 0) {
+        console.log('\n   📦 Copying additional node modules...');
+        const targetNodeModulesPath = path.join(targetNativePath, 'node_modules');
+        const copiedModules = new Set();
+        
+        /**
+         * Recursively copy module and its dependencies
+         */
+        function copyModuleWithDependencies(moduleName, depth = 0) {
+          const indent = '      ' + '  '.repeat(depth);
+          
+          // Avoid copying the same module twice
+          if (copiedModules.has(moduleName)) {
+            return;
+          }
+          
+          try {
+            // Try to resolve the module from the current project
+            const modulePath = require.resolve(moduleName + '/package.json', {
+              paths: [process.cwd()]
+            });
+            const moduleRoot = path.dirname(modulePath);
+            const moduleDestPath = path.join(targetNodeModulesPath, moduleName);
+            
+            // Mark as copied before processing to avoid circular dependencies
+            copiedModules.add(moduleName);
+            
+            // Copy the module
+            copyRecursive(moduleRoot, moduleDestPath);
+            console.log(`${indent}✓ Copied ${moduleName}`);
+            
+            // Read package.json to get dependencies
+            const packageJsonPath = path.join(moduleRoot, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+              const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+              const dependencies = {
+                ...packageJson.dependencies,
+                ...packageJson.optionalDependencies
+              };
+              
+              // Recursively copy dependencies
+              if (dependencies && Object.keys(dependencies).length > 0) {
+                for (const depName of Object.keys(dependencies)) {
+                  copyModuleWithDependencies(depName, depth + 1);
+                }
+              }
+            }
+          } catch (error) {
+            if (depth === 0) {
+              // Only warn for top-level modules
+              console.warn(`${indent}⚠ Warning: Could not find module "${moduleName}": ${error.message}`);
+            }
+            // Skip missing optional dependencies silently
+          }
+        }
+        
+        // Copy each requested module with its dependencies
+        for (const moduleName of additionalModules) {
+          copyModuleWithDependencies(moduleName, 0);
+        }
+        
+        console.log(`      Total modules copied: ${copiedModules.size}`);
+      }
+    } else {
+      console.warn('   ⚠ Warning: Native DLLs not found in ewvjs installation');
+    }
+  }
+
+  // Step 3: Bundle assets if provided
+  if (assets && fs.existsSync(assets)) {
+    console.log('\n📦 Step 3: Bundling assets...');
+    const assetsOutput = path.join(outputDir, 'assets');
+    await bundleAssets(assets, assetsOutput);
+    console.log(`   ✓ Assets bundled to ${assetsOutput}`);
+  }
+
+  // Step 4: Set icon if provided
+  if (icon && fs.existsSync(icon)) {
+    console.log('\n🎨 Step 4: Setting application icon...');
+    await setIcon(outputPath, icon, name);
+    console.log('   ✓ Icon applied');
+  }
+
+  // Step 5: Create ZIP archive
+  console.log('\n📦 Step 5: Creating archive...');
+  const archivePath = path.join(outputDir, `${output}.zip`);
+  await createArchive(outputDir, archivePath);
+  console.log(`   ✓ Archive saved to ${archivePath}`);
+
+  return outputPath;
+}
+
+/**
+ * Copy directory recursively
+ */
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Create a ZIP archive of the dist folder
+ * @param {string} sourceDir - Source directory to archive
+ * @param {string} outputPath - Output ZIP file path
+ * @returns {Promise<void>}
+ */
+function createArchive(sourceDir, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 } // Maximum compression
+    });
+
+    output.on('close', () => {
+      const sizeMB = (archive.pointer() / 1024 / 1024).toFixed(2);
+      console.log(`   ✓ Archive created: ${sizeMB} MB`);
+      resolve();
+    });
+
+    archive.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.on('warning', (err) => {
+      if (err.code === 'ENOENT') {
+        console.warn(`   ⚠ Warning: ${err.message}`);
+      } else {
+        reject(err);
+      }
+    });
+
+    archive.pipe(output);
+
+    // Add all files from the source directory, excluding the output archive
+    const outputFileName = path.basename(outputPath);
+    archive.directory(sourceDir, false, (entry) => {
+      return entry.name !== outputFileName ? entry : false;
+    });
+
+    archive.finalize();
+  });
+}
+
+module.exports = packageApp;

package/lib/templates.js

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get available templates
+ * @returns {Array<{name: string, description: string}>}
+ */
+function getAvailableTemplates() {
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  
+  const templates = [
+    {
+      name: 'basic',
+      description: 'Basic template - Interactive app with exposed functions (default)'
+    },
+  ];
+  
+  // Filter to only existing templates
+  return templates.filter(t => {
+    return fs.existsSync(path.join(templatesDir, t.name));
+  });
+}
+
+/**
+ * Copy template to destination
+ * @param {string} templateName - Template name
+ * @param {string} projectName - Project name
+ * @param {string} destination - Destination directory
+ */
+function copyTemplate(templateName, projectName, destination) {
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  const templatePath = path.join(templatesDir, templateName);
+  
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Template "${templateName}" not found`);
+  }
+  
+  // Create destination directory
+  if (!fs.existsSync(destination)) {
+    fs.mkdirSync(destination, { recursive: true });
+  }
+  
+  // Copy template files recursively
+  copyTemplateRecursive(templatePath, destination, projectName);
+}
+
+/**
+ * Copy template directory recursively and process template files
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @param {string} projectName - Project name for replacements
+ */
+function copyTemplateRecursive(src, dest, projectName) {
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      // Create directory and recurse
+      if (!fs.existsSync(destPath)) {
+        fs.mkdirSync(destPath, { recursive: true });
+      }
+      copyTemplateRecursive(srcPath, destPath, projectName);
+    } else {
+      // Copy and process file
+      let content = fs.readFileSync(srcPath, 'utf-8');
+      
+      // Replace template variables
+      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+      
+      fs.writeFileSync(destPath, content, 'utf-8');
+    }
+  }
+}
+
+/**
+ * Validate template name
+ * @param {string} templateName - Template name
+ * @returns {boolean}
+ */
+function isValidTemplate(templateName) {
+  const templates = getAvailableTemplates();
+  return templates.some(t => t.name === templateName);
+}
+
+module.exports = {
+  getAvailableTemplates,
+  copyTemplate,
+  isValidTemplate
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "ewvjs-cli",
+  "version": "1.0.0",
+  "description": "CLI tool for packaging ewvjs applications",
+  "main": "./index.js",
+  "bin": {
+    "ewvjs": "./bin/ewvjs-cli.js"
+  },
+  "files": [
+    "bin/**/*",
+    "lib/**/*",
+    "templates/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "ewvjs",
+    "webview",
+    "webview2",
+    "cli",
+    "packaging",
+    "electron-alternative"
+  ],
+  "author": "miukyo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miukyo/ewvjs",
+    "directory": "packages/cli"
+  },
+  "type": "commonjs",
+  "os": [
+    "win32"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "@yao-pkg/pkg": "^6.12.0",
+    "archiver": "^7.0.1",
+    "commander": "^12.1.0",
+    "resedit": "^2.0.2"
+  },
+  "peerDependencies": {
+    "ewvjs": "^1.0.3"
+  }
+}

package/templates/basic/README.md

@@ -0,0 +1,30 @@
+# {{PROJECT_NAME}}
+
+A ewvjs application.
+
+## Getting Started
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Run the application:
+```bash
+npm start
+```
+
+3. Package the application:
+```bash
+npm run package
+```
+
+## Project Structure
+
+- `app.js` - Main application entry point
+- `assets/` - Static assets (images, fonts, etc.)
+- `package.json` - Project configuration
+
+## Documentation
+
+Visit [ewvjs documentation](https://github.com/miukyo/ewvjs) for more information.

package/templates/basic/app.js

@@ -0,0 +1,28 @@
+const { create_window, start, expose } = require('ewvjs');
+const path = require('path');
+
+expose('greet', (name) => {
+  return `Hello, ${name}! This is from Node.js 🚀`;
+});
+
+expose('getSystemInfo', () => {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    uptime: process.uptime()
+  };
+});
+
+// Create main window
+const window = create_window('Hello ewvjs', `file://${path.resolve('index.html')}`, {
+  width: 800,
+  height: 600,
+  vibrancy: true,
+  debug: true
+});
+
+window.run();
+
+// Start the event loop
+start();

package/templates/basic/assets/.gitkeep

@@ -0,0 +1,9 @@
+# Assets Directory
+
+Place your static assets here:
+- Images
+- Fonts
+- Additional CSS files
+- Additional JavaScript files
+
+These assets will be included when you package your application.

package/templates/basic/index.html

@@ -0,0 +1,126 @@
+
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Hello ewvjs</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    
+    body {
+      font-family: sans-serif;
+      color: white;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 20px;
+    }
+    
+    .container {
+      text-align: center;
+      max-width: 600px;
+    }
+    
+    h1 {
+      font-size: 3em;
+      margin-bottom: 20px;
+      text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);
+    }
+    
+    p {
+      font-size: 1.2em;
+      margin-bottom: 30px;
+      opacity: 0.9;
+    }
+    
+    input {
+      width: 100%;
+      padding: 15px;
+      font-size: 16px;
+      border: none;
+      margin-bottom: 15px;
+      background: rgba(255, 255, 255, 0.9);
+      color: #333;
+    }
+    
+    button {
+      background: white;
+      color: #000000;
+      border: none;
+      padding: 15px 30px;
+      font-size: 18px;
+      font-weight: bold;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      margin: 5px;
+    }
+    
+    button:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.3);
+    }
+    
+    button:active {
+      transform: translateY(0);
+    }
+    
+    .result {
+      margin-top: 20px;
+      padding: 20px;
+      background: rgba(255, 255, 255, 0.15);
+      min-height: 60px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    
+    .info {
+      text-align: left;
+      font-size: 0.9em;
+      line-height: 1.6;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>🚀 Hello ewvjs!</h1>
+    <p>A lightweight WebView2 application for Windows</p>
+    
+    <input type="text" id="nameInput" placeholder="Enter your name..." value="World">
+    
+    <div>
+      <button onclick="sayHello()">Greet Me</button>
+      <button onclick="showSystemInfo()">System Info</button>
+    </div>
+    
+    <div class="result" id="result">
+      Click a button to see the result...
+    </div>
+  </div>
+  
+  <script>
+    async function sayHello() {
+      const name = document.getElementById('nameInput').value || 'World';
+      const result = await window.ewvjs.api.greet(name);
+      document.getElementById('result').innerHTML = '<strong>' + result + '</strong>';
+    }
+    
+    async function showSystemInfo() {
+      const info = await window.ewvjs.api.getSystemInfo();
+      document.getElementById('result').innerHTML = 
+        '<div class="info">' +
+        '<strong>System Information:</strong><br>' +
+        'Platform: ' + info.platform + '<br>' +
+        'Architecture: ' + info.arch + '<br>' +
+        'Node.js: ' + info.nodeVersion + '<br>' +
+        'Uptime: ' + Math.floor(info.uptime) + ' seconds' +
+        '</div>';
+    }
+  </script>
+</body>
+</html>

package/templates/basic/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "description": "My ewvjs application",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "package": "ewvjs package app.js -o myapp -n \"My App\""
+  },
+  "dependencies": {
+    "ewvjs": "^1.0.0",
+    "ewvjs-cli": "^1.0.0"
+  }
+}