@bobfrankston/msger 0.1.128 → 0.1.130

package/cruft/clean.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=clean.d.ts.map

package/cruft/clean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["clean.js"],"names":[],"mappings":""}

package/cruft/clean.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform clean script
+ * Removes build artifacts
+ */
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+const rootDir = process.cwd();
+console.log('🧹 Cleaning build artifacts...\n');
+// Files to delete in root directory
+const rootPatterns = [
+    '*.js',
+    '*.d.ts',
+    '*.d.ts.map',
+    '*.js.map'
+];
+// Directories to exclude
+const excludeDirs = ['node_modules', '.git', 'msger-native'];
+function deleteFile(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function matchesPattern(filename, pattern) {
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\./g, '\\.') + '$');
+    return regex.test(filename);
+}
+// Clean root directory
+let deletedCount = 0;
+const files = fs.readdirSync(rootDir);
+for (const file of files) {
+    const filePath = path.join(rootDir, file);
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory())
+        continue;
+    for (const pattern of rootPatterns) {
+        if (matchesPattern(file, pattern)) {
+            if (deleteFile(filePath)) {
+                console.log(`  ✓ Deleted: ${file}`);
+                deletedCount++;
+            }
+            break;
+        }
+    }
+}
+console.log(`\n📁 Cleaned ${deletedCount} files from root directory`);
+// Clean Rust build artifacts
+console.log('\n🦀 Cleaning Rust build artifacts...');
+const nativeDir = path.join(rootDir, 'msger-native');
+if (fs.existsSync(nativeDir)) {
+    try {
+        execSync('cargo clean', {
+            cwd: nativeDir,
+            stdio: 'inherit'
+        });
+        console.log('  ✓ Rust artifacts cleaned');
+    }
+    catch (error) {
+        console.error('  ✗ Failed to run cargo clean');
+    }
+}
+else {
+    console.log('  ⚠️  msger-native directory not found');
+}
+console.log('\n✨ Clean complete!\n');
+//# sourceMappingURL=clean.js.map

package/cruft/clean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.js","sourceRoot":"","sources":["clean.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;AAE9B,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAEhD,oCAAoC;AACpC,MAAM,YAAY,GAAG;IACjB,MAAM;IACN,QAAQ;IACR,YAAY;IACZ,UAAU;CACb,CAAC;AAEF,yBAAyB;AACzB,MAAM,WAAW,GAAG,CAAC,cAAc,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D,SAAS,UAAU,CAAC,QAAgB;IAChC,IAAI,CAAC;QACD,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,KAAK,CAAC;IACjB,CAAC;AACL,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB,EAAE,OAAe;IACrD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC;IACzF,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED,uBAAuB;AACvB,IAAI,YAAY,GAAG,CAAC,CAAC;AACrB,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;AAEtC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;IACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC1C,MAAM,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAEnC,IAAI,IAAI,CAAC,WAAW,EAAE;QAAE,SAAS;IAEjC,KAAK,MAAM,OAAO,IAAI,YAAY,EAAE,CAAC;QACjC,IAAI,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;YAChC,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACvB,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;gBACpC,YAAY,EAAE,CAAC;YACnB,CAAC;YACD,MAAM;QACV,CAAC;IACL,CAAC;AACL,CAAC;AAED,OAAO,CAAC,GAAG,CAAC,gBAAgB,YAAY,4BAA4B,CAAC,CAAC;AAEtE,6BAA6B;AAC7B,OAAO,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;AACrD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;AAErD,IAAI,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;IAC3B,IAAI,CAAC;QACD,QAAQ,CAAC,aAAa,EAAE;YACpB,GAAG,EAAE,SAAS;YACd,KAAK,EAAE,SAAS;SACnB,CAAC,CAAC;QACH,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;AACL,CAAC;KAAM,CAAC;IACJ,OAAO,CAAC,GAAG,CAAC,wCAAwC,CAAC,CAAC;AAC1D,CAAC;AAED,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC"}

package/docs/README.md

@@ -0,0 +1,26 @@
+# msger Documentation
+
+## User Documentation
+- [README.md](../README.md) - Main project README (in root)
+- [MSGER-API.md](MSGER-API.md) - JavaScript API for message box content
+- [MSGER-API-SUMMARY.md](MSGER-API-SUMMARY.md) - Quick API reference
+- [CLOSE-API.md](CLOSE-API.md) - Programmatic close API
+
+## Release Information
+- [CHANGELOG.md](CHANGELOG.md) - Version history and changes
+- [RELEASE-NOTES.md](RELEASE-NOTES.md) - User-facing release notes
+- [KNOWN-BUGS.md](KNOWN-BUGS.md) - Known issues and limitations
+
+## Features
+- [DETACH-FEATURE.md](DETACH-FEATURE.md) - Detached window mode
+- [FULLSCREEN-FEATURE.md](FULLSCREEN-FEATURE.md) - Fullscreen mode
+- [MOUSE-ZOOM-FEATURE.md](MOUSE-ZOOM-FEATURE.md) - Mouse wheel zoom
+
+## Developer Documentation
+- [DEVELOPERS.md](DEVELOPERS.md) - Developer guide
+- [IMPLEMENTATION-SUMMARY.md](IMPLEMENTATION-SUMMARY.md) - Implementation details
+- [PI-RENDERING-NOTES.md](PI-RENDERING-NOTES.md) - Raspberry Pi specific notes
+- [TODO.md](TODO.md) - Future plans and tasks
+
+## Session Notes
+Development session notes are in [sessions/](sessions/)

package/msger-native/builder/README.md

@@ -0,0 +1,69 @@
+# msger-native Builder
+
+Unified build system for msger-native that uses JSON configuration to control which platforms to build.
+
+## Usage
+
+```bash
+cd msger-native
+npm run build
+```
+
+## Configuration
+
+Edit `builder/build-config.json` to control which platforms are built:
+
+```json
+{
+    "platforms": {
+        "windows": true,    // Build Windows x64 binary
+        "wsl": false,       // Build Linux x64 binary (via WSL)
+        "pi": false,        // Build Raspberry Pi ARM64 binary (remote build on Pi)
+        "arm64": false      // Build Linux ARM64 binary (cross-compile via WSL)
+    },
+    "options": {
+        "release": true,    // Use release mode (optimized)
+        "verbose": false,   // Show detailed cargo output
+        "piHost": "pi4c",   // Raspberry Pi hostname for SSH
+        "piProjectPath": "/home/pi/dev/msger/msger-native"  // Project path on Pi
+    }
+}
+```
+
+## Build Targets
+
+| Platform | Output | Method | Requirements |
+|----------|--------|--------|--------------|
+| `windows` | `bin/msgernative.exe` | Native build on Windows | Windows, Visual Studio Build Tools |
+| `wsl` | `bin/msgernative` | Native build in WSL | WSL with Rust toolchain |
+| `pi` | `bin/msgernative-linux-aarch64` | **Remote build on Pi** (slower, guaranteed compatible) | SSH access to Raspberry Pi |
+| `arm64` | `bin/msgernative-linux-aarch64` | **Cross-compile on WSL** (faster, requires setup) | WSL with ARM64 cross-compilation toolchain |
+
+**Pi vs ARM64:**
+- **`pi`**: Builds on the actual Raspberry Pi via SSH - slower but guaranteed to work
+- **`arm64`**: Cross-compiles locally using WSL - faster but requires cross-toolchain setup
+
+## Features
+
+- **JSON-driven configuration**: Simply edit JSON file to enable/disable platforms
+- **Build summary**: Shows which builds succeeded/failed
+- **Size reporting**: Displays binary size for each platform
+- **TypeScript**: Uses Node's native TypeScript support (no compilation needed)
+- **Conservative defaults**: Only builds Windows by default
+
+## Legacy Scripts
+
+The old individual build scripts are still available:
+- `npm run build:legacy` - Original Windows build script
+- `npm run build:wsl` - WSL Linux build
+- `npm run build:pi` - Raspberry Pi build
+- `npm run build:arm64` - ARM64 cross-compile
+
+## Future Enhancements
+
+Potential additions:
+- Custom Cargo features/flags configuration
+- Parallel builds
+- Post-build verification/testing
+- Binary signing/notarization
+- Deployment automation

package/msger-native/builder/build-config.json

@@ -0,0 +1,14 @@
+{
+    "platforms": {
+        "windows": true,
+        "wsl": false,
+        "pi": false,
+        "arm64": false
+    },
+    "options": {
+        "release": true,
+        "verbose": false,
+        "piHost": "pi4c",
+        "piProjectPath": "/home/pi/dev/msger/msger-native"
+    }
+}

package/msger-native/builder/build-under-wsl.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Build script to run natively inside WSL
+ * Handles both x64 and ARM64 builds
+ * Reads configuration from build-config.json
+ *
+ * Usage from WSL:
+ *   node builder/build-under-wsl.ts
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface BuildConfig {
+    platforms: {
+        windows?: boolean;
+        wsl?: boolean;
+        pi?: boolean;
+        arm64?: boolean;
+    };
+    options?: {
+        release?: boolean;
+        verbose?: boolean;
+        piHost?: string;
+        piProjectPath?: string;
+    };
+}
+
+function timestamp(): string {
+    const now = new Date();
+    return now.toTimeString().split(' ')[0];
+}
+
+interface BuildTarget {
+    name: string;
+    rustTarget: string;
+    outputName: string;
+    description: string;
+}
+
+const targets: Record<string, BuildTarget> = {
+    x64: {
+        name: 'x64',
+        rustTarget: 'x86_64-unknown-linux-gnu',
+        outputName: 'msgernative',
+        description: 'Linux x64'
+    },
+    arm64: {
+        name: 'arm64',
+        rustTarget: 'aarch64-unknown-linux-gnu',
+        outputName: 'msgernative-linux-aarch64',
+        description: 'Linux ARM64'
+    }
+};
+
+function checkToolchain(target: BuildTarget): boolean {
+    try {
+        const installed = execSync('rustup target list --installed', { encoding: 'utf-8' });
+        return installed.includes(target.rustTarget);
+    } catch {
+        return false;
+    }
+}
+
+function installToolchain(target: BuildTarget): boolean {
+    console.log(`  [${timestamp()}] 📦 Installing ${target.description} toolchain...`);
+
+    try {
+        // Add Rust target
+        execSync(`rustup target add ${target.rustTarget}`, { stdio: 'inherit' });
+
+        // For ARM64, also install cross-compiler
+        if (target.name === 'arm64') {
+            console.log(`  [${timestamp()}] 📦 Installing ARM64 cross-compiler...`);
+            execSync('sudo apt update && sudo apt install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu libc6-dev-arm64-cross', {
+                stdio: 'inherit'
+            });
+        }
+
+        console.log(`  [${timestamp()}] ✅ Toolchain installed`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ Failed to install toolchain: ${error.message}`);
+        return false;
+    }
+}
+
+function build(target: BuildTarget, verbose: boolean): boolean {
+    console.log(`\n[${timestamp()}] 📦 Building ${target.description} binary...`);
+
+    // Check toolchain
+    if (!checkToolchain(target)) {
+        console.log(`  [${timestamp()}] ⚙️  ${target.description} toolchain not found`);
+        if (!installToolchain(target)) {
+            return false;
+        }
+    }
+
+    const nativeDir = path.join(__dirname, '..');
+    const binDir = path.join(nativeDir, 'bin');
+    const binaryPath = path.join(binDir, target.outputName);
+
+    try {
+        console.log(`  [${timestamp()}] 🔨 Compiling with cargo...`);
+        execSync(`cargo build --release --target ${target.rustTarget}`, {
+            cwd: nativeDir,
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+
+        // Copy to bin directory
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        const sourcePath = path.join(nativeDir, 'target', target.rustTarget, 'release', 'msgernative');
+        fs.copyFileSync(sourcePath, binaryPath);
+        fs.chmodSync(binaryPath, 0o755);
+
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] ✅ ${target.description} binary completed`);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        console.log(`  [${timestamp()}] 📁 Output: ${binaryPath}`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ Build failed: ${error.message}`);
+        return false;
+    }
+}
+
+function loadConfig(): BuildConfig {
+    const configPath = path.join(__dirname, 'build-config.json');
+
+    if (!fs.existsSync(configPath)) {
+        console.error('❌ build-config.json not found');
+        process.exit(1);
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error: any) {
+        console.error(`❌ Failed to parse build-config.json: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+function main() {
+    console.log('🚀 WSL Native Builder\n');
+
+    const config = loadConfig();
+    const verboseFlag = config.options?.verbose ?? false;
+
+    // Determine which targets to build based on config
+    const requestedTargets: string[] = [];
+    if (config.platforms.wsl) requestedTargets.push('x64');
+    if (config.platforms.arm64) requestedTargets.push('arm64');
+
+    if (requestedTargets.length === 0) {
+        console.log('⚠️  No WSL platforms enabled in build-config.json');
+        console.log('   Enable "wsl" for x64 or "arm64" for ARM64 builds');
+        process.exit(0);
+    }
+
+    console.log(`📋 Configuration:`);
+    console.log(`   Mode: ${config.options?.release ? 'release' : 'debug'}`);
+    console.log(`   Targets: ${requestedTargets.join(', ')}`);
+    console.log(`   Verbose: ${verboseFlag}\n`);
+
+    const results: { target: string; success: boolean }[] = [];
+
+    for (const targetName of requestedTargets) {
+        const target = targets[targetName];
+        if (!target) {
+            console.error(`❌ Unknown target: ${targetName}`);
+            console.error(`   Available targets: x64, arm64, all`);
+            process.exit(1);
+        }
+
+        const success = build(target, verboseFlag);
+        results.push({ target: targetName, success });
+    }
+
+    // Summary
+    console.log('\n' + '='.repeat(50));
+    console.log('📊 Build Summary:');
+    console.log('='.repeat(50));
+
+    for (const result of results) {
+        const status = result.success ? '✅' : '❌';
+        console.log(`${status} ${result.target}`);
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    const totalCount = results.length;
+
+    console.log('='.repeat(50));
+    console.log(`\n🎉 Completed: ${successCount}/${totalCount} builds successful\n`);
+
+    if (successCount < totalCount) {
+        process.exit(1);
+    }
+}
+
+main();

package/msger-native/builder/builder.ts

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+/**
+ * Unified build system for msger-native
+ * Reads build-config.json to determine which platforms to build
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { platform } from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface BuildConfig {
+    platforms: {
+        windows?: boolean;
+        wsl?: boolean;
+        pi?: boolean;
+        arm64?: boolean;
+    };
+    options?: {
+        release?: boolean;
+        verbose?: boolean;
+        piHost?: string;
+        piProjectPath?: string;
+    };
+}
+
+function isWSL(): boolean {
+    try {
+        const release = fs.readFileSync('/proc/version', 'utf8');
+        return release.toLowerCase().includes('microsoft');
+    } catch {
+        return false;
+    }
+}
+
+function isWindows(): boolean {
+    return platform() === 'win32' && !isWSL();
+}
+
+function getCleanPathForWindows(): string {
+    // Remove Git's /usr/bin from PATH to avoid link.exe conflict with VS linker
+    const currentPath = process.env.PATH || '';
+    const pathParts = currentPath.split(';');
+    const filteredParts = pathParts.filter(part => {
+        const lower = part.toLowerCase();
+        return !lower.includes('git\\usr\\bin') && !lower.includes('git/usr/bin');
+    });
+    return filteredParts.join(';');
+}
+
+function needsRebuild(binaryPath: string, sourceDirs: string[]): boolean {
+    if (!fs.existsSync(binaryPath)) {
+        return true;
+    }
+
+    const binaryTime = fs.statSync(binaryPath).mtime.getTime();
+
+    function checkDir(dirPath: string): boolean {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isFile()) {
+                const fileTime = fs.statSync(fullPath).mtime.getTime();
+                if (fileTime > binaryTime) {
+                    console.log(`  📝 Source file changed: ${entry.name}`);
+                    return true;
+                }
+            } else if (entry.isDirectory()) {
+                if (checkDir(fullPath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    for (const sourcePath of sourceDirs) {
+        if (!fs.existsSync(sourcePath)) continue;
+
+        const stats = fs.statSync(sourcePath);
+        if (stats.isFile()) {
+            const fileTime = stats.mtime.getTime();
+            if (fileTime > binaryTime) {
+                console.log(`  📝 Source file changed: ${sourcePath}`);
+                return true;
+            }
+        } else if (stats.isDirectory()) {
+            if (checkDir(sourcePath)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Load build configuration from JSON file
+ */
+function loadConfig(): BuildConfig {
+    const configPath = path.join(__dirname, 'build-config.json');
+
+    if (!fs.existsSync(configPath)) {
+        console.error('❌ build-config.json not found');
+        process.exit(1);
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error: any) {
+        console.error(`❌ Failed to parse build-config.json: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+function timestamp(): string {
+    const now = new Date();
+    return now.toTimeString().split(' ')[0]; // HH:MM:SS
+}
+
+/**
+ * Build Windows binary
+ */
+function buildWindows(nativeDir: string, binDir: string, verbose: boolean): boolean {
+    console.log(`\n[${timestamp()}] 📦 Building Windows x64 binary...`);
+
+    const binaryPath = path.join(binDir, 'msgernative.exe');
+    const sourceDirs = [
+        path.join(nativeDir, 'src'),
+        path.join(nativeDir, 'Cargo.toml'),
+        path.join(nativeDir, 'build.rs')
+    ];
+
+    if (!needsRebuild(binaryPath, sourceDirs)) {
+        console.log(`  [${timestamp()}] ✅ Binary is up to date, skipping build`);
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        return true;
+    }
+
+    console.log(`  [${timestamp()}] 🔧 Fixing PATH to use VS linker instead of Git link.exe`);
+    const cleanPath = getCleanPathForWindows();
+
+    try {
+        execSync('cargo build --release', {
+            cwd: nativeDir,
+            stdio: verbose ? 'inherit' : 'pipe',
+            env: { ...process.env, PATH: cleanPath }
+        });
+
+        // Copy to bin directory
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        const sourcePath = path.join(nativeDir, 'target', 'release', 'msgernative.exe');
+        fs.copyFileSync(sourcePath, binaryPath);
+
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] ✅ Windows x64 binary completed`);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ Windows build failed: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Build WSL Linux binary
+ */
+function buildWSL(nativeDir: string, binDir: string, verbose: boolean): boolean {
+    console.log(`\n[${timestamp()}] 📦 Building WSL Linux x64 binary...`);
+
+    const binaryPath = path.join(binDir, 'msgernative');
+
+    try {
+        execSync('wsl bash -c "cd /mnt/y/dev/utils/msger/msger-native && cargo build --release --target x86_64-unknown-linux-gnu"', {
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+
+        // Copy to bin directory
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        const sourcePath = path.join(nativeDir, 'target', 'x86_64-unknown-linux-gnu', 'release', 'msgernative');
+        fs.copyFileSync(sourcePath, binaryPath);
+        fs.chmodSync(binaryPath, 0o755);
+
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] ✅ WSL Linux x64 binary completed`);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ WSL build failed: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Build Raspberry Pi ARM64 binary
+ */
+function buildPi(nativeDir: string, binDir: string, verbose: boolean, piHost: string, piProjectPath: string): boolean {
+    console.log(`\n[${timestamp()}] 📦 Building Raspberry Pi ARM64 binary...`);
+    console.log(`  Target: ${piHost}:${piProjectPath}`);
+
+    const binaryPath = path.join(binDir, 'msgernative-linux-aarch64');
+
+    try {
+        // Build remotely on Pi
+        console.log(`  [${timestamp()}] 🔗 Building on remote Raspberry Pi...`);
+        execSync(`ssh ${piHost} "cd ${piProjectPath} && cargo build --release"`, {
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+
+        // Copy from Pi
+        console.log(`  [${timestamp()}] 📥 Copying binary from Pi...`);
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        execSync(`scp ${piHost}:${piProjectPath}/target/release/msgernative "${binaryPath}"`, {
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+
+        fs.chmodSync(binaryPath, 0o755);
+
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] ✅ Raspberry Pi ARM64 binary completed`);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ Pi build failed: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Check if ARM64 toolchain is installed
+ */
+function checkARM64Toolchain(): boolean {
+    try {
+        // Check if Rust target is installed
+        const targets = execSync('wsl bash -c "rustup target list --installed"', { encoding: 'utf-8' });
+        if (!targets.includes('aarch64-unknown-linux-gnu')) {
+            return false;
+        }
+
+        // Check if cross-compiler is installed
+        const which = execSync('wsl bash -c "which aarch64-linux-gnu-gcc"', { encoding: 'utf-8' });
+        return which.trim().length > 0;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Install ARM64 toolchain
+ */
+function installARM64Toolchain(verbose: boolean): boolean {
+    console.log(`  [${timestamp()}] 📦 ARM64 toolchain not found, installing...`);
+
+    try {
+        execSync('wsl bash msger-native/pibuild/setup-arm64-toolchain.sh', {
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+        console.log(`  [${timestamp()}] ✅ ARM64 toolchain installed successfully`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ Failed to install ARM64 toolchain: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Build generic ARM64 binary via cross-compilation
+ */
+function buildARM64(nativeDir: string, binDir: string, verbose: boolean): boolean {
+    console.log(`\n[${timestamp()}] 📦 Building Linux ARM64 binary (cross-compile)...`);
+
+    // Check and install toolchain if needed
+    if (!checkARM64Toolchain()) {
+        console.log(`  [${timestamp()}] ⚙️  Checking ARM64 toolchain...`);
+        if (!installARM64Toolchain(verbose)) {
+            return false;
+        }
+    }
+
+    const binaryPath = path.join(binDir, 'msgernative-linux-aarch64');
+
+    try {
+        execSync('wsl bash -c "cd /mnt/y/dev/utils/msger/msger-native && cargo build --release --target aarch64-unknown-linux-gnu"', {
+            stdio: verbose ? 'inherit' : 'pipe'
+        });
+
+        // Copy to bin directory
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        const sourcePath = path.join(nativeDir, 'target', 'aarch64-unknown-linux-gnu', 'release', 'msgernative');
+        fs.copyFileSync(sourcePath, binaryPath);
+        fs.chmodSync(binaryPath, 0o755);
+
+        const stats = fs.statSync(binaryPath);
+        const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        console.log(`  [${timestamp()}] ✅ Linux ARM64 binary completed`);
+        console.log(`  [${timestamp()}] 📊 Binary size: ${sizeMB} MB`);
+        return true;
+    } catch (error: any) {
+        console.error(`  [${timestamp()}] ❌ ARM64 build failed: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Main build orchestrator
+ */
+function main() {
+    console.log('🚀 msger-native unified builder\n');
+
+    const config = loadConfig();
+    const verbose = config.options?.verbose ?? false;
+    const release = config.options?.release ?? true;
+
+    const nativeDir = path.join(__dirname, '..');
+    const binDir = path.join(nativeDir, 'bin');
+
+    const enabledPlatforms = Object.entries(config.platforms)
+        .filter(([_, enabled]) => enabled)
+        .map(([name]) => name);
+
+    console.log(`📋 Build configuration:`);
+    console.log(`   Mode: ${release ? 'release' : 'debug'}`);
+    console.log(`   Platforms: ${enabledPlatforms.join(', ') || 'none'}\n`);
+
+    if (enabledPlatforms.length === 0) {
+        console.log('⚠️  No platforms enabled in build-config.json');
+        process.exit(0);
+    }
+
+    const results: { platform: string; success: boolean }[] = [];
+
+    // Build each enabled platform
+    if (config.platforms.windows) {
+        results.push({ platform: 'windows', success: buildWindows(nativeDir, binDir, verbose) });
+    }
+
+    if (config.platforms.wsl) {
+        results.push({ platform: 'wsl', success: buildWSL(nativeDir, binDir, verbose) });
+    }
+
+    if (config.platforms.pi) {
+        const piHost = config.options?.piHost ?? 'pi4c';
+        const piProjectPath = config.options?.piProjectPath ?? '/home/pi/dev/msger/msger-native';
+        results.push({ platform: 'pi', success: buildPi(nativeDir, binDir, verbose, piHost, piProjectPath) });
+    }
+
+    if (config.platforms.arm64) {
+        results.push({ platform: 'arm64', success: buildARM64(nativeDir, binDir, verbose) });
+    }
+
+    // Summary
+    console.log('\n' + '='.repeat(50));
+    console.log('📊 Build Summary:');
+    console.log('='.repeat(50));
+
+    for (const result of results) {
+        const status = result.success ? '✅' : '❌';
+        console.log(`${status} ${result.platform}`);
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    const totalCount = results.length;
+
+    console.log('='.repeat(50));
+    console.log(`\n🎉 Completed: ${successCount}/${totalCount} builds successful\n`);
+
+    if (successCount < totalCount) {
+        process.exit(1);
+    }
+}
+
+main();

package/msger-native/builder/clean.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform clean script
+ * Removes build artifacts
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Navigate to project root (two levels up from builder/)
+const rootDir = path.join(__dirname, '../..');
+
+console.log('🧹 Cleaning build artifacts...\n');
+
+// Files to delete in root directory
+const rootPatterns = [
+    '*.js',
+    '*.d.ts',
+    '*.d.ts.map',
+    '*.js.map'
+];
+
+// Directories to exclude
+const excludeDirs = ['node_modules', '.git', 'msger-native'];
+
+function deleteFile(filePath: string): boolean {
+    try {
+        fs.unlinkSync(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function matchesPattern(filename: string, pattern: string): boolean {
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\./g, '\\.') + '$');
+    return regex.test(filename);
+}
+
+// Clean root directory
+let deletedCount = 0;
+const files = fs.readdirSync(rootDir);
+
+for (const file of files) {
+    const filePath = path.join(rootDir, file);
+    const stat = fs.statSync(filePath);
+
+    if (stat.isDirectory()) continue;
+
+    for (const pattern of rootPatterns) {
+        if (matchesPattern(file, pattern)) {
+            if (deleteFile(filePath)) {
+                console.log(`  ✓ Deleted: ${file}`);
+                deletedCount++;
+            }
+            break;
+        }
+    }
+}
+
+console.log(`\n📁 Cleaned ${deletedCount} files from root directory`);
+
+// Clean Rust build artifacts
+console.log('\n🦀 Cleaning Rust build artifacts...');
+const nativeDir = path.join(rootDir, 'msger-native');
+
+if (fs.existsSync(nativeDir)) {
+    try {
+        execSync('cargo clean', {
+            cwd: nativeDir,
+            stdio: 'inherit'
+        });
+        console.log('  ✓ Rust artifacts cleaned');
+    } catch (error) {
+        console.error('  ✗ Failed to run cargo clean');
+    }
+} else {
+    console.log('  ⚠️  msger-native directory not found');
+}
+
+console.log('\n✨ Clean complete!\n');

package/msger-native/builder/postinstall.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Post-install script to set executable permissions on Linux binaries
+ * and check for required system dependencies
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function detectDistro(): string {
+    if (!fs.existsSync('/etc/os-release')) {
+        return 'unknown';
+    }
+
+    try {
+        const osRelease = fs.readFileSync('/etc/os-release', 'utf8').toLowerCase();
+
+        if (osRelease.includes('ubuntu') || osRelease.includes('debian')) {
+            return 'debian';
+        }
+        if (osRelease.includes('fedora') || osRelease.includes('rhel') || osRelease.includes('centos')) {
+            return 'fedora';
+        }
+        if (osRelease.includes('arch')) {
+            return 'arch';
+        }
+
+        return 'unknown';
+    } catch {
+        return 'unknown';
+    }
+}
+
+function showDependencyInstallCommand(distro: string): void {
+    console.warn('\n⚠️  Missing system dependencies detected!');
+    console.warn('   Install required libraries with:\n');
+
+    switch (distro) {
+        case 'debian':
+            console.warn('   sudo apt update');
+            console.warn('   sudo apt install libwebkit2gtk-4.1-0 libgtk-3-0\n');
+            break;
+        case 'fedora':
+            console.warn('   sudo dnf install webkit2gtk4.1 gtk3\n');
+            break;
+        case 'arch':
+            console.warn('   sudo pacman -S webkit2gtk gtk3\n');
+            break;
+        default:
+            console.warn('   Install webkit2gtk and gtk3 for your distribution\n');
+    }
+}
+
+function checkSystemDependencies(binaryPath: string): void {
+    try {
+        const lddOutput = execSync(`ldd "${binaryPath}" 2>&1`, { encoding: 'utf8' });
+
+        if (lddOutput.includes('not found')) {
+            const distro = detectDistro();
+            showDependencyInstallCommand(distro);
+        }
+    } catch {
+        // ldd command failed or not installed - skip check
+    }
+}
+
+function setExecutePermissions(binaryPath: string, binaryName: string): void {
+    try {
+        fs.chmodSync(binaryPath, 0o755);
+        console.log(`✅ Set execute permissions on ${binaryName} binary`);
+    } catch (error: any) {
+        console.warn(`⚠️  Could not set execute permission on ${binaryPath}: ${error.message}`);
+        console.warn(`   You may need to run: sudo chmod +x ${binaryPath}`);
+    }
+}
+
+function main(): void {
+    // Windows doesn't need executable permissions
+    if (process.platform === 'win32') {
+        return;
+    }
+
+    // Determine binary name based on architecture
+    const arch = process.arch;
+    const binaryName = arch === 'arm64' ? 'msgernative-linux-aarch64' : 'msgernative';
+    const binaryPath = path.join(__dirname, '..', 'bin', binaryName);
+
+    // Binary doesn't exist - warn user
+    if (!fs.existsSync(binaryPath)) {
+        console.warn(`⚠️  Binary not found at ${binaryPath}`);
+        console.warn(`   The msger package may not support your platform (${process.platform} ${arch})`);
+        return;
+    }
+
+    // Set executable permissions
+    setExecutePermissions(binaryPath, binaryName);
+
+    // Check for required system libraries
+    checkSystemDependencies(binaryPath);
+}
+
+main();

package/msger-native/package.json

@@ -4,10 +4,7 @@
     "description": "Rust binary for msger - native message box implementation",
     "type": "module",
     "scripts": {
-        "build": "node build.ts",
-        "build:wsl": "node build-wsl.ts",
-        "build:arm64": "node build-arm64.ts",
-        "build:pi": "node  build-pi.ts"
+        "build": "node builder/builder.ts"
     },
     "keywords": [
         "message-box",

package/msger-native/pibuild/README.md

@@ -0,0 +1,42 @@
+# Raspberry Pi Build Utilities
+
+Utilities for building msger-native on Raspberry Pi (ARM64/aarch64).
+
+## Files
+
+### build-on-pi.sh
+Shell script to run on the Raspberry Pi itself to build the native binary.
+
+### build-pi.ps1
+PowerShell script to build remotely on Pi via SSH (called from Windows).
+
+### pi-diagnostics.ts
+TypeScript diagnostic script to check Pi build environment and dependencies.
+
+### setup-arm64-toolchain.sh
+Sets up ARM64 cross-compilation toolchain on WSL for local ARM64 builds.
+
+## Usage
+
+The main builder (`../builder/builder.ts`) handles Pi builds automatically when enabled in `build-config.json`. These utilities are for manual builds or troubleshooting.
+
+### Remote build on Pi (from Windows):
+```powershell
+.\build-pi.ps1
+```
+
+### Direct build on Pi:
+```bash
+ssh pi4c
+cd /home/pi/dev/msger/msger-native
+./pibuild/build-on-pi.sh
+```
+
+### Setup ARM64 cross-compilation:
+```bash
+wsl bash pibuild/setup-arm64-toolchain.sh
+```
+
+## Output
+
+Pi builds produce: `bin/msgernative-linux-aarch64`

package/msger-native/src/main.rs

@@ -170,15 +170,16 @@ fn default_title() -> String {
 }
 
 fn get_package_version() -> Option<String> {
-    // Read ../package.json relative to executable
+    // Read version from parent package.json (not msger-native/package.json)
     let exe_path = std::env::current_exe().ok()?;
     let exe_dir = exe_path.parent()?;
 
     // Try multiple possible locations for package.json
+    // NOTE: Check ../../package.json FIRST to skip msger-native/package.json
     let possible_paths = vec![
-        exe_dir.join("../package.json"),           // Development: bin/../package.json
-        exe_dir.join("../../package.json"),        // Installed globally: lib/node_modules/@bobfrankston/msger/package.json
-        exe_dir.join("../../../package.json"),     // node_modules structure
+        exe_dir.join("../../package.json"),        // Development: bin/../../package.json (parent of msger-native)
+        exe_dir.join("../../../package.json"),     // Installed globally: lib/node_modules/@bobfrankston/msger/package.json
+        exe_dir.join("../../../../package.json"),  // Deeply nested node_modules
     ];
 
     for path in possible_paths {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bobfrankston/msger",
-    "version": "0.1.128",
+    "version": "0.1.130",
     "description": "Fast, lightweight, cross-platform message box - Rust-powered alternative to msgview",
     "type": "module",
     "main": "./index.js",
@@ -16,19 +16,14 @@
     "scripts": {
         "build": "npm run build:ts && npm run build:native",
         "build:native": "cd msger-native && npm run build",
-        "build:native:wsl": "cd msger-native && npm run build:wsl",
-        "build:native:arm64": "cd msger-native && npm run build:arm64",
-        "build:native:pi": "cd msger-native && npm run build:pi",
-        "build:native:all": "npm run build:native && npm run build:native:wsl && (npm run build:native:pi || true)",
-        "setup:arm64": "wsl bash msger-native/setup-arm64-toolchain.sh",
         "build:ts": "tsc",
         "watch": "tsc -w",
-        "clean": "rm -rf *.js *.d.ts *.js.map bin && cd msger-native && cargo clean",
+        "clean": "node msger-native/builder/clean.ts",
         "test": "node test.js",
-        "postinstall": "node postinstall.js",
-        "prepublishOnly": "npm run build:ts && npm run build:native:all",
+        "postinstall": "node msger-native/builder/postinstall.ts",
+        "prepublishOnly": "npm run build:ts && npm run build:native",
         "prerelease:local": "git add -A && (git diff-index --quiet HEAD || git commit -m \"Pre-release commit\")",
-        "preversion": "npm run build:ts && npm run build:native:all && git add -A",
+        "preversion": "npm run build:ts && npm run build:native && git add -A",
         "postversion": "git push && git push --tags",
         "release": "npm run prerelease:local && npm version patch && npm publish",
         "installer": "npm run release && npm cache clean --force && npm install -g @bobfrankston/msger@latest && wsl npm cache clean --force && wsl npm install -g @bobfrankston/msger@latest"