@bobfrankston/msger 0.1.129 → 0.1.131

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/cruft/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/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

@@ -7,6 +7,8 @@
     },
     "options": {
         "release": true,
-        "verbose": false
+        "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();