@liquidmetal-ai/raindrop-code 0.0.1-alpha20 → 0.0.1

package/bin/raindrop-code

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+/**
+ * This is a shim that loads the platform-specific binary.
+ * During postinstall, this file may be replaced with the actual binary
+ * for performance optimization (except on Windows and when using Yarn).
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Determine platform and arch
+const platformKey = `${process.platform}-${process.arch}`;
+
+// Map to package names
+const PACKAGES = {
+  'darwin-x64': '@liquidmetal-ai/raindrop-code-darwin-universal',
+  'darwin-arm64': '@liquidmetal-ai/raindrop-code-darwin-universal',
+  'linux-x64': '@liquidmetal-ai/raindrop-code-linux-x64',
+  'linux-arm64': '@liquidmetal-ai/raindrop-code-linux-arm64',
+  'win32-x64': '@liquidmetal-ai/raindrop-code-win32-x64',
+};
+
+const packageName = PACKAGES[platformKey];
+
+if (!packageName) {
+  console.error(`Unsupported platform: ${platformKey}`);
+  console.error(`Supported platforms: ${Object.keys(PACKAGES).join(', ')}`);
+  process.exit(1);
+}
+
+// Determine binary name
+const binaryName = process.platform === 'win32' ? 'raindrop-code.exe' : 'raindrop-code';
+
+// Try to resolve the binary from the optional dependency
+let binaryPath;
+try {
+  // First try to resolve from the optional dependency
+  const packagePath = require.resolve(`${packageName}/package.json`);
+  binaryPath = path.join(path.dirname(packagePath), 'bin', binaryName);
+  
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath}`);
+  }
+} catch (error) {
+  console.error(`Error: Could not find ${packageName}`);
+  console.error('');
+  console.error('This usually means the package was installed with --no-optional or --ignore-scripts.');
+  console.error('Please reinstall raindrop-code without these flags:');
+  console.error('');
+  console.error('  npm install -g @liquidmetal-ai/raindrop-code');
+  console.error('');
+  process.exit(1);
+}
+
+// Execute the binary with all arguments
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  windowsHide: false,
+});
+
+if (result.error) {
+  console.error(`Failed to execute binary: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status || 0);

package/install.js

@@ -3,10 +3,10 @@
 /**
  * Postinstall script for @liquidmetal-ai/raindrop-code
  * 
- * This script ensures the correct platform-specific binary is available.
- * It follows a two-tier approach:
- * 1. First, check if a platform-specific optional dependency was installed
- * 2. If not, download the binary from npm as a fallback
+ * Approach inspired by esbuild's npm distribution:
+ * 1. A JavaScript shim exists at bin/raindrop-code that loads the binary from optional dependencies
+ * 2. On non-Windows, non-Yarn platforms, optimize by replacing the shim with the actual binary
+ * 3. If optional dependencies weren't installed, attempt to download as fallback
  */
 
 const fs = require('fs');
@@ -31,8 +31,7 @@ const BINARY_DISTRIBUTION_PACKAGES = {
 const binaryName = process.platform === 'win32' ? 'raindrop-code.exe' : 'raindrop-code';
 
 // Paths
-const binDir = path.join(__dirname, 'bin');
-const fallbackBinaryPath = path.join(binDir, binaryName);
+const shimPath = path.join(__dirname, 'bin', binaryName);
 
 // Determine the platform-specific package name
 const platformKey = `${process.platform}-${process.arch}`;
@@ -45,46 +44,115 @@ if (!platformSpecificPackageName) {
 }
 
 /**
- * Check if the optional dependency was installed successfully
+ * Check if Yarn is being used
  */
-function checkOptionalDependency() {
+function isYarn() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    return /\byarn\//.test(npm_config_user_agent);
+  }
+  return false;
+}
+
+/**
+ * Try to find the binary from the optional dependency
+ */
+function findBinaryFromOptionalDependency() {
   try {
-    const optionalDepPath = path.join(__dirname, 'node_modules', platformSpecificPackageName);
-    const binaryPath = path.join(optionalDepPath, 'bin', binaryName);
+    // Try to resolve the package
+    const packageJsonPath = require.resolve(`${platformSpecificPackageName}/package.json`);
+    const packageDir = path.dirname(packageJsonPath);
+    const binaryPath = path.join(packageDir, 'bin', binaryName);
     
     if (fs.existsSync(binaryPath)) {
-      console.log(`✓ Platform-specific package installed: ${platformSpecificPackageName}`);
-      
-      // Create bin directory if it doesn't exist
-      if (!fs.existsSync(binDir)) {
-        fs.mkdirSync(binDir, { recursive: true });
-      }
-      
-      // Create a symlink or copy to the expected location
-      if (process.platform === 'win32') {
-        // Windows doesn't handle symlinks well, so copy
-        fs.copyFileSync(binaryPath, fallbackBinaryPath);
-      } else {
-        // Unix: create symlink
-        const relativePath = path.relative(binDir, binaryPath);
-        if (fs.existsSync(fallbackBinaryPath)) {
-          fs.unlinkSync(fallbackBinaryPath);
-        }
-        fs.symlinkSync(relativePath, fallbackBinaryPath);
-      }
-      
-      // Ensure executable
-      if (process.platform !== 'win32') {
-        fs.chmodSync(fallbackBinaryPath, 0o755);
-      }
-      
-      return true;
+      return binaryPath;
     }
   } catch (error) {
-    // Ignore errors, fall through to download
+    // Package not found
   }
   
-  return false;
+  return null;
+}
+
+/**
+ * Verify the binary works
+ */
+function verifyBinary(binaryPath) {
+  try {
+    const output = execSync(`"${binaryPath}" --version`, { 
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    const version = output.trim();
+    console.log(`✓ Binary verified: ${version}`);
+    
+    // Check version matches
+    if (!version.includes(VERSION.split('-')[0])) {
+      console.warn(`Warning: Binary version (${version}) may not match package version (${VERSION})`);
+    }
+    
+    return true;
+  } catch (error) {
+    console.error(`✗ Binary verification failed: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Optimize by replacing the shim with the actual binary.
+ * This is an optional optimization that improves startup time by avoiding an extra Node.js process.
+ * 
+ * Only done on Unix-like systems (not Windows) and not when using Yarn.
+ * - Windows requires .exe extension for binaries, so we keep the shim
+ * - Yarn may run install scripts multiple times from different platforms (e.g., in Docker)
+ */
+function maybeOptimizePackage(binaryPath) {
+  // Skip optimization on Windows
+  if (process.platform === 'win32') {
+    console.log('ℹ Using JavaScript shim (Windows)');
+    return false;
+  }
+  
+  // Skip optimization when using Yarn to avoid idempotency issues
+  if (isYarn()) {
+    console.log('ℹ Using JavaScript shim (Yarn detected)');
+    return false;
+  }
+  
+  const tempPath = path.join(__dirname, 'bin', `${binaryName}-temp`);
+  
+  try {
+    // Create a hard link to the binary with a temporary name
+    // This avoids taking up additional space on the file system
+    fs.linkSync(binaryPath, tempPath);
+    
+    // Atomically replace the shim with the binary using rename
+    // If this fails, we just leave the temporary file (harmless)
+    fs.renameSync(tempPath, shimPath);
+    
+    console.log('✓ Optimized: Replaced shim with binary for faster startup');
+    
+    // Clean up the temp file if it still exists
+    // (renameSync may return without doing anything if inodes are the same)
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+      // Ignore - file may not exist
+    }
+    
+    return true;
+  } catch (error) {
+    console.log('ℹ Using JavaScript shim (optimization not possible)');
+    
+    // Clean up temp file if it exists
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+      // Ignore
+    }
+    
+    return false;
+  }
 }
 
 /**
@@ -132,11 +200,10 @@ function extractFileFromTarball(tarballBuffer, filepath) {
 }
 
 /**
- * Download the platform-specific binary from npm
+ * Download and install the binary from npm registry as a fallback
  */
-async function downloadBinary() {
-  console.log(`Downloading binary for ${platformKey}...`);
-  console.log(`Package: ${platformSpecificPackageName}@${VERSION}`);
+async function downloadBinaryFromNPM() {
+  console.log(`Downloading ${platformSpecificPackageName}@${VERSION}...`);
   
   try {
     // Construct npm registry URL
@@ -156,19 +223,40 @@ async function downloadBinary() {
     const binaryPathInTar = `package/bin/${binaryName}`;
     const binaryBuffer = extractFileFromTarball(tarBuffer, binaryPathInTar);
     
-    // Write binary to disk
-    if (!fs.existsSync(binDir)) {
-      fs.mkdirSync(binDir, { recursive: true });
+    // Create a temporary directory to extract to
+    const tempDir = path.join(__dirname, '.tmp-install');
+    const tempBinaryPath = path.join(tempDir, binaryName);
+    
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
     }
     
-    fs.writeFileSync(fallbackBinaryPath, binaryBuffer);
+    // Write binary to temp location
+    fs.writeFileSync(tempBinaryPath, binaryBuffer);
     
     // Make executable on Unix
     if (process.platform !== 'win32') {
-      fs.chmodSync(fallbackBinaryPath, 0o755);
+      fs.chmodSync(tempBinaryPath, 0o755);
+    }
+    
+    console.log(`✓ Binary extracted to temporary location`);
+    
+    // Verify it works before installing
+    if (!verifyBinary(tempBinaryPath)) {
+      throw new Error('Downloaded binary failed verification');
+    }
+    
+    // Try to optimize (replace shim with binary)
+    maybeOptimizePackage(tempBinaryPath);
+    
+    // Clean up temp directory
+    try {
+      fs.unlinkSync(tempBinaryPath);
+      fs.rmdirSync(tempDir);
+    } catch {
+      // Ignore cleanup errors
     }
     
-    console.log(`✓ Binary installed to ${fallbackBinaryPath}`);
     return true;
   } catch (error) {
     console.error(`✗ Failed to download binary: ${error.message}`);
@@ -177,54 +265,160 @@ async function downloadBinary() {
 }
 
 /**
- * Verify the binary works
+ * Install using npm as a fallback
  */
-function verifyBinary() {
+function installUsingNPM() {
+  console.log('Attempting to install using npm...');
+  
   try {
-    const output = execSync(`"${fallbackBinaryPath}" --version`, { 
-      encoding: 'utf-8',
-      stdio: ['ignore', 'pipe', 'ignore']
-    });
-    console.log(`✓ Binary verified: ${output.trim()}`);
-    return true;
+    // Erase npm_config_global to prevent deadlock in global installs
+    const env = { ...process.env, npm_config_global: undefined };
+    
+    // Create temporary directory for installation
+    const tempDir = path.join(__dirname, '.tmp-npm-install');
+    fs.mkdirSync(tempDir, { recursive: true });
+    
+    try {
+      // Create empty package.json
+      fs.writeFileSync(path.join(tempDir, 'package.json'), '{}');
+      
+      // Install the platform-specific package
+      console.log(`Running: npm install ${platformSpecificPackageName}@${VERSION}`);
+      execSync(
+        `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${platformSpecificPackageName}@${VERSION}`,
+        { cwd: tempDir, stdio: 'pipe', env }
+      );
+      
+      // Find the installed binary
+      const installedBinaryPath = path.join(
+        tempDir,
+        'node_modules',
+        platformSpecificPackageName,
+        'bin',
+        binaryName
+      );
+      
+      if (!fs.existsSync(installedBinaryPath)) {
+        throw new Error('Binary not found after npm install');
+      }
+      
+      console.log('✓ Package installed via npm');
+      
+      // Verify the binary
+      if (!verifyBinary(installedBinaryPath)) {
+        throw new Error('Installed binary failed verification');
+      }
+      
+      // Try to optimize
+      maybeOptimizePackage(installedBinaryPath);
+      
+      return true;
+    } finally {
+      // Clean up temp directory
+      try {
+        removeRecursive(tempDir);
+      } catch {
+        // Ignore cleanup errors (especially on Windows where files may be locked)
+      }
+    }
   } catch (error) {
-    console.error(`✗ Binary verification failed`);
+    console.error(`✗ Failed to install using npm: ${error.message}`);
     return false;
   }
 }
 
+/**
+ * Recursively remove directory
+ */
+function removeRecursive(dir) {
+  for (const entry of fs.readdirSync(dir)) {
+    const entryPath = path.join(dir, entry);
+    let stats;
+    try {
+      stats = fs.lstatSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      removeRecursive(entryPath);
+    } else {
+      fs.unlinkSync(entryPath);
+    }
+  }
+  fs.rmdirSync(dir);
+}
+
 /**
  * Main installation logic
  */
 async function main() {
   console.log('raindrop-code postinstall');
   console.log('========================');
+  console.log(`Platform: ${platformKey}`);
+  console.log(`Package: ${platformSpecificPackageName}`);
+  console.log('');
   
   // Strategy 1: Check if optional dependency was installed
-  if (checkOptionalDependency()) {
-    console.log('✓ Installation complete (via optional dependency)');
+  const binaryPath = findBinaryFromOptionalDependency();
+  
+  if (binaryPath) {
+    console.log(`✓ Found binary from optional dependency: ${platformSpecificPackageName}`);
+    
+    // Verify the binary works
+    if (!verifyBinary(binaryPath)) {
+      console.error('✗ Binary verification failed');
+      process.exit(1);
+    }
+    
+    // Try to optimize by replacing shim with binary
+    maybeOptimizePackage(binaryPath);
+    
+    console.log('');
+    console.log('✓ Installation complete');
     return;
   }
   
-  console.log('Optional dependency not found, downloading binary...');
+  // Strategy 2: Try to install using npm
+  console.log('Optional dependency not found.');
+  console.log('This can happen if you used --no-optional or --ignore-scripts.');
+  console.log('');
   
-  // Strategy 2: Download binary from npm
-  const downloadSuccess = await downloadBinary();
-  
-  if (!downloadSuccess) {
-    console.error('\n⚠ Installation incomplete');
-    console.error('Please report this issue: https://github.com/ianschenck/raindrop-code/issues');
-    process.exit(1);
+  const npmSuccess = installUsingNPM();
+  if (npmSuccess) {
+    console.log('');
+    console.log('✓ Installation complete (via npm)');
+    return;
   }
   
-  // Verify the binary
-  verifyBinary();
+  // Strategy 3: Download directly from npm registry
+  console.log('');
+  console.log('npm install failed, attempting direct download...');
+  console.log('');
+  
+  const downloadSuccess = await downloadBinaryFromNPM();
+  if (downloadSuccess) {
+    console.log('');
+    console.log('✓ Installation complete (via direct download)');
+    return;
+  }
   
-  console.log('✓ Installation complete (via download)');
+  // All strategies failed
+  console.error('');
+  console.error('✗ Installation failed');
+  console.error('');
+  console.error('All installation strategies failed. Please try:');
+  console.error('  1. Reinstall without --no-optional or --ignore-scripts');
+  console.error('  2. Check your internet connection');
+  console.error('  3. Check npm registry access');
+  console.error('');
+  console.error('If the problem persists, please report an issue:');
+  console.error('  https://github.com/ianschenck/raindrop-code/issues');
+  console.error('');
+  process.exit(1);
 }
 
 // Run installation
 main().catch((error) => {
-  console.error('Installation failed:', error);
+  console.error('Installation error:', error);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquidmetal-ai/raindrop-code",
-  "version": "0.0.1-alpha20",
+  "version": "0.0.1",
   "description": "AI-powered terminal coding assistant with deep code understanding, file operations, and extensible tools",
   "keywords": [
     "ai",
@@ -41,9 +41,9 @@
     "bin/"
   ],
   "optionalDependencies": {
-    "@liquidmetal-ai/raindrop-code-darwin-universal": "0.0.1-alpha20",
-    "@liquidmetal-ai/raindrop-code-linux-x64": "0.0.1-alpha20",
-    "@liquidmetal-ai/raindrop-code-linux-arm64": "0.0.1-alpha20",
-    "@liquidmetal-ai/raindrop-code-win32-x64": "0.0.1-alpha20"
+    "@liquidmetal-ai/raindrop-code-darwin-universal": "0.0.1",
+    "@liquidmetal-ai/raindrop-code-linux-x64": "0.0.1",
+    "@liquidmetal-ai/raindrop-code-linux-arm64": "0.0.1",
+    "@liquidmetal-ai/raindrop-code-win32-x64": "0.0.1"
   }
 }