emacs-lsp-proxy 0.1.1

package/bin/cli

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+const childProcess = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Platform-specific package mappings - same as install.js
+const platformPackages = {
+  'darwin-arm64': '@emacs-lsp-proxy/darwin-arm64',
+  'darwin-x64': '@emacs-lsp-proxy/darwin-x64', 
+  'linux-arm64': '@emacs-lsp-proxy/linux-arm64',
+  'linux-x64': '@emacs-lsp-proxy/linux-x64',
+  'win32-x64': '@emacs-lsp-proxy/win32-x64'
+};
+
+function getBinaryPath() {
+  // First try local bin directory (after install.js has run)
+  const platform = os.platform();
+  const binaryName = platform === 'win32' ? 'emacs-lsp-proxy.exe' : 'emacs-lsp-proxy';
+  const localBin = path.join(__dirname, '..', 'bin', binaryName);
+  
+  if (fs.existsSync(localBin)) {
+    return localBin;
+  }
+
+  // Fallback: try to resolve from platform package directly  
+  const platformKey = `${platform}-${os.arch()}`;
+  const packageName = platformPackages[platformKey];
+  
+  if (!packageName) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+
+  try {
+    const packageDir = path.dirname(require.resolve(packageName + '/package.json'));
+    const possiblePaths = [
+      path.join(packageDir, binaryName),
+      path.join(packageDir, 'bin', binaryName)
+    ];
+    
+    for (const binPath of possiblePaths) {
+      if (fs.existsSync(binPath)) {
+        return binPath;
+      }
+    }
+  } catch (e) {
+    // Package not found
+  }
+
+  throw new Error(`Binary not found for platform: ${platformKey}`);
+}
+
+try {
+  const binaryPath = getBinaryPath();
+  childProcess.execFileSync(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
+} catch (error) {
+  console.error('[emacs-lsp-proxy]', error.message);
+  process.exit(1);
+}

package/install.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Platform-specific package mappings
+const platformPackages = {
+  'darwin-arm64': '@emacs-lsp-proxy/darwin-arm64',
+  'darwin-x64': '@emacs-lsp-proxy/darwin-x64', 
+  'linux-arm64': '@emacs-lsp-proxy/linux-arm64',
+  'linux-x64': '@emacs-lsp-proxy/linux-x64',
+  'win32-x64': '@emacs-lsp-proxy/win32-x64'
+};
+
+function getPlatformKey() {
+  const platform = os.platform();
+  const arch = os.arch();
+  
+  // Normalize architecture names
+  const normalizedArch = arch === 'x64' ? 'x64' : 
+                        arch === 'arm64' ? 'arm64' : arch;
+  
+  return `${platform}-${normalizedArch}`;
+}
+
+function findBinary() {
+  const platformKey = getPlatformKey();
+  const packageName = platformPackages[platformKey];
+  
+  if (!packageName) {
+    console.error(`[emacs-lsp-proxy] Unsupported platform: ${platformKey}`);
+    process.exit(1);
+  }
+
+  try {
+    // Try to resolve the platform-specific package
+    const packagePath = require.resolve(packageName + '/package.json');
+    const packageDir = path.dirname(packagePath);
+    
+    // Look for binary in expected locations
+    const binaryName = platformKey.startsWith('win32') ? 'emacs-lsp-proxy.exe' : 'emacs-lsp-proxy';
+    const possiblePaths = [
+      path.join(packageDir, binaryName),
+      path.join(packageDir, 'bin', binaryName)
+    ];
+    
+    for (const binPath of possiblePaths) {
+      if (fs.existsSync(binPath)) {
+        // Create symlink or copy to expected location
+        const targetPath = path.join(__dirname, 'bin', 'emacs-lsp-proxy' + (platformKey.startsWith('win32') ? '.exe' : ''));
+        
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        
+        try {
+          // Try to create a hard link first (faster)
+          if (fs.existsSync(targetPath)) fs.unlinkSync(targetPath);
+          fs.linkSync(binPath, targetPath);
+        } catch (e) {
+          // Fall back to copying
+          fs.copyFileSync(binPath, targetPath);
+        }
+        
+        // Make executable on Unix systems
+        if (!platformKey.startsWith('win32')) {
+          fs.chmodSync(targetPath, 0o755);
+        }
+        
+        console.log(`[emacs-lsp-proxy] Binary installed successfully for ${platformKey}`);
+        return;
+      }
+    }
+    
+    console.error(`[emacs-lsp-proxy] Binary not found in package ${packageName}`);
+    process.exit(1);
+    
+  } catch (e) {
+    console.error(`[emacs-lsp-proxy] Platform package ${packageName} not found. This usually means the package wasn't installed properly.`);
+    console.error('Make sure your platform is supported and npm installed the optional dependencies.');
+    process.exit(1);
+  }
+}
+
+// Only run if this is the main package being installed
+if (require.main === module) {
+  findBinary();
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "emacs-lsp-proxy",
+  "version": "0.1.1",
+  "scripts": {
+    "postinstall": "node ./install.js"
+  },
+  "bin": {
+    "emacs-lsp-proxy": "./bin/cli"
+  },
+  "publicConfig": {
+    "access": "public"
+  },
+  "keywords": ["emacs", "lsp", "rust"],
+  "author": "jadestrong",
+  "optionalDependencies": {
+    "@emacs-lsp-proxy/darwin-x64": "0.1.0",
+    "@emacs-lsp-proxy/darwin-arm64": "0.1.0",
+    "@emacs-lsp-proxy/linux-x64": "0.1.0",
+    "@emacs-lsp-proxy/linux-arm64": "0.1.0",
+    "@emacs-lsp-proxy/win32-x64": "0.1.0"
+  },
+  "license": "ISC",
+  "description": "An LSP client for Emacs implemented in Rust."
+}