windowpp 0.1.1

package/lib/build.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// cli/lib/build.js — WindowPP production build
+//
+// Called for any WindowPP app directory.  Detects the app's cmake target
+// name from the directory's package.json ("cmakeTarget" field, or falls back
+// to the npm package name with hyphens swapped for underscores).
+//
+// Usage (via CLI or directly):
+//   windowpp build [--clean] [--app-dir <path>]
+
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+function build(options = {}) {
+    const {
+        appDir = process.cwd(),
+        clean = false,
+        config = 'Release',
+    } = options;
+
+    const rootDir = findRootDir(appDir);
+    const IS_WINDOWS = process.platform === 'win32';
+    const IS_MAC = process.platform === 'darwin';
+    const platformDir = IS_WINDOWS ? 'windows' : IS_MAC ? 'macos' : 'linux';
+    const buildDir = path.join(rootDir, 'build', platformDir);
+    const frontendDir = path.join(appDir, 'frontend');
+    const target = resolveTarget(appDir);
+
+    console.log(`\n=== WindowPP Build — ${target} (${platformDir}) ===\n`);
+
+    if (clean && fs.existsSync(buildDir)) {
+        console.log(`Cleaning ${buildDir} ...`);
+        fs.rmSync(buildDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(buildDir, { recursive: true });
+
+    // Frontend
+    if (fs.existsSync(frontendDir)) {
+        console.log('Building frontend with Vite...');
+        execSync('npm install', { cwd: frontendDir, stdio: 'inherit' });
+        execSync('npm run build', { cwd: frontendDir, stdio: 'inherit' });
+    }
+
+    // CMake configure (force re-configure when cache exists but generated dir is missing)
+    forceReconfigureIfNeeded(rootDir, buildDir);
+
+    const embedScript   = path.join(__dirname, '../cmake/embed_assets.py').replace(/\\/g, '/');
+    const frameworkDir  = path.join(__dirname, '../framework').replace(/\\/g, '/');
+    console.log('Configuring CMake...');
+    execSync(
+        `cmake -S "${rootDir}" -B "${buildDir}"` +
+        ` -DWPP_EMBED_SCRIPT="${embedScript}"` +
+        ` -DWPP_FRAMEWORK_DIR="${frameworkDir}"`,
+        { cwd: rootDir, stdio: 'inherit' }
+    );
+
+    // CMake build
+    console.log(`\nBuilding ${target} (${config})...`);
+    const buildCmd = IS_WINDOWS
+        ? `cmake --build "${buildDir}" --target ${target} --config ${config}`
+        : `cmake --build "${buildDir}" --target ${target} -- -j$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)`;
+    execSync(buildCmd, { cwd: rootDir, stdio: 'inherit' });
+
+    const exePath = exePathFor(buildDir, target, config, IS_WINDOWS);
+    console.log(`\n✓ Build complete: ${exePath}\n`);
+    return { exePath, buildDir, rootDir, target };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function findRootDir(appDir) {
+    // Walk up from appDir to find the directory containing CMakeLists.txt.
+    // This lets the CLI work whether invoked from the app dir or the repo root.
+    let dir = appDir;
+    for (let i = 0; i < 5; i++) {
+        if (fs.existsSync(path.join(dir, 'CMakeLists.txt'))) return dir;
+        dir = path.dirname(dir);
+    }
+    throw new Error(`Cannot find CMakeLists.txt above ${appDir}`);
+}
+
+function resolveTarget(appDir) {
+    const pkgPath = path.join(appDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (pkg.cmakeTarget) return pkg.cmakeTarget;
+        if (pkg.name) return pkg.name.replace(/-/g, '_');
+    }
+    // Fallback: use the directory name
+    return path.basename(appDir).replace(/-/g, '_');
+}
+
+function forceReconfigureIfNeeded(rootDir, buildDir) {
+    const cacheFile = path.join(buildDir, 'CMakeCache.txt');
+    // Check for any generated* directory
+    const generatedExists = fs.readdirSync(buildDir).some(n => n.startsWith('generated'));
+    if (fs.existsSync(cacheFile) && !generatedExists) {
+        console.log('Stale cache detected — forcing re-configure...');
+        fs.rmSync(cacheFile, { force: true });
+    }
+}
+
+function exePathFor(buildDir, target, config, isWindows) {
+    return isWindows
+        ? path.join(buildDir, config, `${target}.exe`)
+        : path.join(buildDir, target);
+}
+
+module.exports = { build, findRootDir, resolveTarget, exePathFor };

package/lib/create.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+// cli/lib/create.js — WindowPP app scaffolding
+//
+// Copies a template from cli/templates/<template>/ to <outDir>/<name>/,
+// substituting {{APP_NAME}}, {{APP_TITLE}}, and {{CMAKE_TARGET}} in all
+// text files.  Each created app is a self-contained project; it does NOT
+// need to live inside the framework repo.
+//
+// Usage (via CLI):
+//   windowpp create my-app [--template solid] [--out-dir .]
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+function create(name, options = {}) {
+    const {
+        template = 'solid',
+        outDir = process.cwd(),
+        installDeps = true,
+    } = options;
+
+    if (!name || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+        console.error('Error: app name must start with a letter and contain only letters, digits, hyphens or underscores.');
+        process.exit(1);
+    }
+
+    const appDir = path.join(outDir, name);
+    if (fs.existsSync(appDir)) {
+        console.error(`Error: directory "${appDir}" already exists.`);
+        process.exit(1);
+    }
+
+    const cliDir = path.resolve(__dirname, '..');
+    const templateDir = path.join(cliDir, 'templates', template);
+    if (!fs.existsSync(templateDir)) {
+        console.error(`Error: template "${template}" not found in ${path.join(cliDir, 'templates')}`);
+        process.exit(1);
+    }
+
+    const cmakeTarget = name.replace(/-/g, '_');
+    const appTitle = name
+        .split(/[-_]/)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+
+    const tokens = {
+        '{{APP_NAME}}':     name,
+        '{{APP_TITLE}}':    appTitle,
+        '{{CMAKE_TARGET}}': cmakeTarget,
+    };
+
+    console.log(`\n=== WindowPP Create — ${name} (template: ${template}) ===\n`);
+    console.log(`Scaffolding into: ${appDir}\n`);
+
+    // ── Copy template ─────────────────────────────────────────────────────────
+    copyDir(templateDir, appDir, tokens);
+
+    // ── Install frontend deps ─────────────────────────────────────────────────
+    const frontendDir = path.join(appDir, 'frontend');
+    if (installDeps && fs.existsSync(frontendDir)) {
+        console.log('Installing frontend dependencies...');
+        execSync('npm install', { cwd: frontendDir, stdio: 'inherit' });
+    }
+
+    console.log(`\n✓ Created "${name}"\n`);
+    console.log('Next steps:');
+    console.log(`  cd ${name}`);
+    console.log('  windowpp dev\n');
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function copyDir(src, dest, tokens) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath  = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, tokens);
+        } else {
+            copyFile(srcPath, destPath, tokens);
+        }
+    }
+}
+
+const TEXT_EXTENSIONS = new Set([
+    '.cpp', '.h', '.ts', '.tsx', '.js', '.json', '.html',
+    '.css', '.md', '.txt', '.cmake', '.sh', '.env',
+]);
+
+function copyFile(src, dest, tokens) {
+    const ext = path.extname(src).toLowerCase();
+    if (TEXT_EXTENSIONS.has(ext)) {
+        let content = fs.readFileSync(src, 'utf8');
+        for (const [token, value] of Object.entries(tokens)) {
+            content = content.split(token).join(value);
+        }
+        fs.writeFileSync(dest, content, 'utf8');
+    } else {
+        fs.copyFileSync(src, dest);
+    }
+}
+
+module.exports = { create };
+
+
+function create(name, options = {}) {
+    const {
+        template = 'solid',
+        outDir = process.cwd(),
+        installDeps = true,
+    } = options;
+
+    if (!name || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+        console.error('Error: app name must start with a letter and contain only letters, digits, hyphens or underscores.');
+        process.exit(1);
+    }
+
+    const appDir = path.join(outDir, name);
+    if (fs.existsSync(appDir)) {
+        console.error(`Error: directory "${appDir}" already exists.`);
+        process.exit(1);
+    }
+
+    const cliDir = path.resolve(__dirname, '..');
+    const templateDir = path.join(cliDir, 'templates', template);
+    if (!fs.existsSync(templateDir)) {
+        console.error(`Error: template "${template}" not found in ${path.join(cliDir, 'templates')}`);
+        process.exit(1);
+    }
+
+    const rootDir = findRootDir(outDir);
+
+    // cmake target name: replace hyphens with underscores
+    const cmakeTarget = name.replace(/-/g, '_');
+    const appTitle = name
+        .split(/[-_]/)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+
+    const tokens = {
+        '{{APP_NAME}}': name,
+        '{{APP_TITLE}}': appTitle,
+        '{{CMAKE_TARGET}}': cmakeTarget,
+        '{{REPO_ROOT}}': rootDir.replace(/\\/g, '/'),
+    };
+
+    console.log(`\n=== WindowPP Create — ${name} (template: ${template}) ===\n`);
+    console.log(`Scaffolding into: ${appDir}\n`);
+
+    // ── Copy template ─────────────────────────────────────────────────────────
+    copyDir(templateDir, appDir, tokens);
+
+    // ── Register in CMakeLists.txt ────────────────────────────────────────────
+    const appDirRelative = path.relative(rootDir, appDir).replace(/\\/g, '/');
+    addToCMake(rootDir, name, cmakeTarget, appDirRelative);
+
+    // ── Install frontend deps ─────────────────────────────────────────────────
+    const frontendDir = path.join(appDir, 'frontend');
+    if (installDeps && fs.existsSync(frontendDir)) {
+        console.log('Installing frontend dependencies...');
+        execSync('npm install', { cwd: frontendDir, stdio: 'inherit' });
+    }
+
+    console.log(`\n✓ Created "${name}"\n`);
+    console.log('Next steps:');
+    console.log(`  cd ${name}`);
+    console.log('  windowpp dev\n');
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function copyDir(src, dest, tokens) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, tokens);
+        } else {
+            copyFile(srcPath, destPath, tokens);
+        }
+    }
+}
+
+const TEXT_EXTENSIONS = new Set([
+    '.cpp', '.h', '.ts', '.tsx', '.js', '.json', '.html',
+    '.css', '.md', '.txt', '.cmake', '.sh', '.env',
+]);
+
+function copyFile(src, dest, tokens) {
+    const ext = path.extname(src).toLowerCase();
+    if (TEXT_EXTENSIONS.has(ext)) {
+        let content = fs.readFileSync(src, 'utf8');
+        for (const [token, value] of Object.entries(tokens)) {
+            content = content.split(token).join(value);
+        }
+        fs.writeFileSync(dest, content, 'utf8');
+    } else {
+        fs.copyFileSync(src, dest);
+    }
+}
+
+function addToCMake(rootDir, appName, cmakeTarget, appDirRelative) {
+    const cmakePath = path.join(rootDir, 'CMakeLists.txt');
+    let cmake = fs.readFileSync(cmakePath, 'utf8');
+
+    // Insert before the # ─── Install section
+    const installMarker = '# ─── Install ──';
+    if (!cmake.includes(installMarker)) {
+        console.warn('Warning: could not locate Install section in CMakeLists.txt — skipping auto-registration.');
+        return;
+    }
+
+    const appBlock = generateCMakeBlock(appName, cmakeTarget, appDirRelative);
+    cmake = cmake.replace(installMarker, appBlock + '\n' + installMarker);
+    fs.writeFileSync(cmakePath, cmake, 'utf8');
+    console.log(`Registered ${cmakeTarget} in CMakeLists.txt`);
+}
+
+function generateCMakeBlock(appName, cmakeTarget, appDirRelative) {
+    const generatedVar = cmakeTarget.toUpperCase() + '_GENERATED_DIR';
+    const embeddedCppVar = cmakeTarget.toUpperCase() + '_EMBEDDED_ASSETS_CPP';
+    const embeddedHVar = cmakeTarget.toUpperCase() + '_EMBEDDED_ASSETS_H';
+    const assetsTarget = cmakeTarget + '_frontend_assets';
+
+    return `# ─── ${appName} ──────────────────────────────────────────────────────────────────
+
+if(WPP_BUILD_EXAMPLES)
+    add_executable(${cmakeTarget} ${appDirRelative}/main.cpp)
+    target_link_libraries(${cmakeTarget} PRIVATE windowpp nlohmann_json::nlohmann_json)
+    if(WIN32 AND WEBVIEW2_INCLUDE_DIR)
+        target_include_directories(${cmakeTarget} PRIVATE \${WEBVIEW2_INCLUDE_DIR})
+        if(WEBVIEW2_STATIC)
+            target_link_libraries(${cmakeTarget} PRIVATE
+                \${CMAKE_CURRENT_SOURCE_DIR}/src/renderer/webview/x64/WebView2LoaderStatic.lib
+                version)
+        else()
+            target_link_libraries(${cmakeTarget} PRIVATE
+                \${CMAKE_CURRENT_SOURCE_DIR}/src/renderer/webview/x64/WebView2Loader.lib)
+        endif()
+    endif()
+
+    set(${generatedVar}        \${CMAKE_BINARY_DIR}/generated_${cmakeTarget})
+    set(${embeddedCppVar}  \${${generatedVar}}/embedded_assets.cpp)
+    set(${embeddedHVar}    \${${generatedVar}}/embedded_assets.h)
+
+    add_custom_command(
+        OUTPUT  \${${embeddedCppVar}} \${${embeddedHVar}}
+        COMMAND \${CMAKE_COMMAND} -E make_directory \${${generatedVar}}
+        COMMAND \${Python3_EXECUTABLE}
+                \${WPP_EMBED_SCRIPT}
+                \${CMAKE_CURRENT_SOURCE_DIR}/${appDirRelative}/frontend/dist
+                \${${embeddedCppVar}}
+                \${${embeddedHVar}}
+        DEPENDS \${CMAKE_CURRENT_SOURCE_DIR}/${appDirRelative}/frontend/dist/index.html
+        COMMENT "Embedding ${appName} frontend assets into C++ byte arrays..."
+        VERBATIM
+    )
+
+    set_source_files_properties(
+        \${${embeddedCppVar}}
+        \${${embeddedHVar}}
+        PROPERTIES GENERATED TRUE
+    )
+
+    add_custom_target(${assetsTarget} ALL
+        DEPENDS \${${embeddedCppVar}} \${${embeddedHVar}}
+    )
+
+    target_sources(${cmakeTarget} PRIVATE \${${embeddedCppVar}})
+    target_include_directories(${cmakeTarget} PRIVATE \${${generatedVar}})
+    target_compile_definitions(${cmakeTarget} PRIVATE WPP_EMBEDDED_ASSETS)
+    add_dependencies(${cmakeTarget} ${assetsTarget})
+endif()
+
+`;
+}
+
+module.exports = { create };

package/lib/dev.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// cli/lib/dev.js — WindowPP dev mode
+//
+// Builds the native binary (Debug), starts the Vite dev server, then launches
+// the binary with WPP_DEV_URL pointing at Vite.  Keeps both alive and cleans
+// up either when the app closes or Vite stops.
+//
+// Usage (via CLI or directly):
+//   windowpp dev [--clean] [--app-dir <path>] [--port 3000]
+
+'use strict';
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { build, findRootDir, resolveTarget, exePathFor } = require('./build');
+
+function dev(options = {}) {
+    const {
+        appDir = process.cwd(),
+        clean = false,
+        port = null,  // auto-detect from vite config; can be overridden
+    } = options;
+
+    const rootDir = findRootDir(appDir);
+    const IS_WINDOWS = process.platform === 'win32';
+    const IS_MAC = process.platform === 'darwin';
+    const platformDir = IS_WINDOWS ? 'windows' : IS_MAC ? 'macos' : 'linux';
+    const buildDir = path.join(rootDir, 'build', platformDir);
+    const frontendDir = path.join(appDir, 'frontend');
+    const target = resolveTarget(appDir);
+
+    console.log(`\n=== WindowPP Dev — ${target} (${platformDir}) ===\n`);
+
+    if (clean && fs.existsSync(buildDir)) {
+        console.log('Cleaning build directory...');
+        fs.rmSync(buildDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(buildDir, { recursive: true });
+
+    // ── Ensure a frontend dist exists for the embed step ─────────────────────
+    const hasDist = fs.existsSync(path.join(frontendDir, 'dist', 'index.html'));
+    if (fs.existsSync(frontendDir) && (!hasDist || clean)) {
+        console.log('Building frontend with Vite (for embed step)...');
+        execSync('npm install', { cwd: frontendDir, stdio: 'inherit' });
+        execSync('npm run build', { cwd: frontendDir, stdio: 'inherit' });
+    }
+
+    // ── CMake configure + Debug build ─────────────────────────────────────────
+    const cacheFile = path.join(buildDir, 'CMakeCache.txt');
+    const generatedExists = fs.existsSync(buildDir) &&
+        fs.readdirSync(buildDir).some(n => n.startsWith('generated'));
+    if (fs.existsSync(cacheFile) && !generatedExists) {
+        console.log('Stale cache detected — forcing re-configure...');
+        fs.rmSync(cacheFile, { force: true });
+    }
+
+    const embedScript   = path.join(__dirname, '../cmake/embed_assets.py').replace(/\\/g, '/');
+    const frameworkDir  = path.join(__dirname, '../framework').replace(/\\/g, '/');
+    console.log('Configuring CMake...');
+    execSync(
+        `cmake -S "${rootDir}" -B "${buildDir}"` +
+        ` -DWPP_EMBED_SCRIPT="${embedScript}"` +
+        ` -DWPP_FRAMEWORK_DIR="${frameworkDir}"`,
+        { cwd: rootDir, stdio: 'inherit' }
+    );
+
+    console.log(`\nBuilding ${target} (Debug)...`);
+    const buildArgs = ['cmake', '--build', `"${buildDir}"`, '--target', target];
+    if (IS_WINDOWS) buildArgs.push('--config', 'Debug');
+    execSync(buildArgs.join(' '), { cwd: rootDir, stdio: 'inherit' });
+
+    const exePath = exePathFor(buildDir, target, 'Debug', IS_WINDOWS);
+    console.log(`\nBuilt: ${exePath}\n`);
+
+    // ── Detect Vite port from vite.config or fallback ─────────────────────────
+    const devPort = port || detectVitePort(frontendDir) || 3000;
+    const devUrl = `http://localhost:${devPort}`;
+
+    // ── Start Vite dev server ─────────────────────────────────────────────────
+    console.log(`Starting Vite dev server on port ${devPort}...`);
+    const vite = spawn('npm', ['run', 'dev'], {
+        cwd: frontendDir,
+        stdio: 'inherit',
+        shell: IS_WINDOWS,
+    });
+
+    let app = null;
+
+    function killProc(proc, name) {
+        if (!proc) return;
+        if (IS_WINDOWS) {
+            try { spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t'], { shell: true }); } catch {}
+        } else {
+            try { proc.kill('SIGTERM'); } catch {}
+        }
+    }
+
+    function cleanup(signal) {
+        console.log(`\n${signal || 'Exit'} — cleaning up...`);
+        killProc(app, 'app');  app = null;
+        killProc(vite, 'vite');
+    }
+
+    process.on('SIGINT',  () => { cleanup('SIGINT');  process.exit(0); });
+    process.on('SIGTERM', () => { cleanup('SIGTERM'); process.exit(0); });
+
+    // Launch app 2 s after Vite starts (gives the dev server time to bind)
+    setTimeout(() => {
+        console.log(`\nLaunching ${target}...\n`);
+        app = spawn(exePath, [], {
+            stdio: 'inherit',
+            shell: IS_WINDOWS,
+            detached: false,
+            env: { ...process.env, WPP_DEV_URL: devUrl },
+        });
+
+        app.on('close', (code) => {
+            console.log(`\nApp exited (code ${code})`);
+            killProc(vite, 'vite');
+            process.exit(code ?? 0);
+        });
+
+        app.on('error', (err) => {
+            console.error(`\nApp error: ${err.message}`);
+            cleanup();
+            process.exit(1);
+        });
+    }, 2000);
+
+    vite.on('close', (code) => {
+        console.log(`Vite stopped (code ${code})`);
+        if (app) {
+            console.log('Vite closed — killing app...');
+            killProc(app, 'app');
+            app = null;
+        }
+        process.exit(code ?? 0);
+    });
+}
+
+function detectVitePort(frontendDir) {
+    // Try to read the port from vite.config.ts/js
+    const candidates = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'];
+    for (const c of candidates) {
+        const file = path.join(frontendDir, c);
+        if (!fs.existsSync(file)) continue;
+        const text = fs.readFileSync(file, 'utf8');
+        const m = text.match(/port\s*:\s*(\d+)/);
+        if (m) return parseInt(m[1], 10);
+    }
+    return null;
+}
+
+module.exports = { dev };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "windowpp",
+  "version": "0.1.1",
+  "description": "WindowPP CLI — build, dev, and scaffold for WindowPP apps",
+  "type": "commonjs",
+  "bin": {
+    "windowpp": "./bin/windowpp.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "cmake/",
+    "framework/",
+    "scripts/"
+  ],
+  "scripts": {
+    "sync": "node scripts/sync-framework.js",
+    "prepublishOnly": "node scripts/sync-framework.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/publish.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// cli/scripts/publish.js
+//
+// Syncs framework source, bumps the patch version in cli/package.json,
+// then runs `npm publish` from the cli/ directory.
+//
+// Prerequisites:  npm login   (once per machine)
+//
+// Run from repo root:  npm run package
+// Or directly:         node cli/scripts/publish.js [--minor] [--major]
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const CLI_DIR  = path.join(__dirname, '..');
+const PKG_PATH = path.join(CLI_DIR, 'package.json');
+
+// ── Check npm login ───────────────────────────────────────────────────────────
+try {
+    execSync('npm whoami', { stdio: 'pipe' });
+} catch {
+    console.error('\nError: not logged in to npm. Run:\n\n  npm login\n\nthen try again.\n');
+    process.exit(1);
+}
+
+// ── Parse bump type ───────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const bumpType = args.includes('--major') ? 'major'
+               : args.includes('--minor') ? 'minor'
+               : 'patch';
+
+// ── Read current version ──────────────────────────────────────────────────────
+const pkg = JSON.parse(fs.readFileSync(PKG_PATH, 'utf8'));
+const [major, minor, patch] = pkg.version.split('.').map(Number);
+
+let nextVersion;
+if (bumpType === 'major') nextVersion = `${major + 1}.0.0`;
+else if (bumpType === 'minor') nextVersion = `${major}.${minor + 1}.0`;
+else nextVersion = `${major}.${minor}.${patch + 1}`;
+
+console.log(`\n=== windowpp publish: ${pkg.version} → ${nextVersion} (${bumpType}) ===\n`);
+
+// ── Sync framework source ─────────────────────────────────────────────────────
+console.log('Syncing framework source...');
+execSync('node scripts/sync-framework.js', { cwd: CLI_DIR, stdio: 'inherit' });
+
+// ── Publish with the new version (without writing it yet) ─────────────────────
+// Temporarily write the new version so npm publish picks it up, then revert on failure.
+pkg.version = nextVersion;
+fs.writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+
+try {
+    console.log('\nPublishing to npm...\n');
+    execSync('npm publish', { cwd: CLI_DIR, stdio: 'inherit' });
+} catch (err) {
+    // Revert the version bump so the file stays clean
+    pkg.version = `${major}.${minor}.${patch}`;
+    fs.writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+    console.error(`\nPublish failed — reverted version back to ${pkg.version}\n`);
+    process.exit(1);
+}
+
+console.log(`\n✓ Published windowpp@${nextVersion}\n`);
+