rskim 0.7.0 → 0.9.4

package/bin/skim

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+const { spawnSync, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Cached result for musl detection (null = not yet computed)
+ */
+let _muslCached = null;
+
+/**
+ * Detect if running on musl-based Linux (Alpine, Void, etc.)
+ * Result is cached at module level since it cannot change during execution.
+ *
+ * ARCHITECTURE NOTE: This function is intentionally duplicated in scripts/postinstall.js.
+ * Postinstall scripts run before node_modules is fully available, so that script
+ * must be self-contained with no external dependencies. Do not extract to a shared
+ * module - it would break postinstall execution.
+ */
+function isMusl() {
+  if (_muslCached !== null) {
+    return _muslCached;
+  }
+  _muslCached = detectMusl();
+  return _muslCached;
+}
+
+/**
+ * Internal musl detection logic
+ */
+function detectMusl() {
+  if (process.platform !== 'linux') {
+    return false;
+  }
+
+  // Check for Alpine Linux (most common musl distro)
+  try {
+    const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+    if (osRelease.includes('Alpine')) {
+      return true;
+    }
+  } catch {
+    // File doesn't exist, continue checking
+  }
+
+  // Check ldd output for musl
+  try {
+    const lddOutput = execSync('ldd --version 2>&1 || true', { encoding: 'utf8' });
+    if (lddOutput.includes('musl')) {
+      return true;
+    }
+  } catch {
+    // ldd not available, continue checking
+  }
+
+  // Check for musl dynamic linker
+  try {
+    const files = fs.readdirSync('/lib');
+    if (files.some(f => f.startsWith('ld-musl'))) {
+      return true;
+    }
+  } catch {
+    // /lib doesn't exist or not readable
+  }
+
+  return false;
+}
+
+/**
+ * Get the platform-specific package name
+ */
+function getPlatformPackage() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const musl = isMusl();
+
+  const packages = {
+    'darwin-arm64': '@rskim/cli-darwin-arm64',
+    'darwin-x64': '@rskim/cli-darwin-x64',
+    'linux-arm64': musl ? '@rskim/cli-linux-arm64-musl' : '@rskim/cli-linux-arm64',
+    'linux-x64': musl ? '@rskim/cli-linux-x64-musl' : '@rskim/cli-linux-x64',
+    'win32-x64': '@rskim/cli-win32-x64',
+  };
+
+  const key = `${platform}-${arch}`;
+  return packages[key];
+}
+
+/**
+ * Find installed platform package binary using walktree algorithm.
+ *
+ * Walks up the directory tree looking for node_modules containing the platform package.
+ * This approach is package-manager agnostic and works with npm, pnpm, yarn (classic & berry),
+ * bun, and arbitrary monorepo nesting depths.
+ */
+function findPlatformBinary(packageName) {
+  if (!packageName) {
+    return null;
+  }
+
+  const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+  let currentDir = __dirname;
+
+  // Walk up the directory tree looking for node_modules
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(currentDir, 'node_modules', packageName, binaryName);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break; // Hit filesystem root
+    currentDir = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Find fallback binary in local bin directory (from postinstall)
+ */
+function findFallbackBinary() {
+  const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+  const fallbackPath = path.join(__dirname, binaryName);
+
+  if (fs.existsSync(fallbackPath)) {
+    return fallbackPath;
+  }
+
+  return null;
+}
+
+/**
+ * Get the binary path, with helpful error messages
+ */
+function getBinaryPath() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const musl = isMusl();
+
+  // Get the platform-specific package
+  const packageName = getPlatformPackage();
+
+  if (!packageName) {
+    console.error(`ERROR: Platform ${platform}-${arch} is not supported.`);
+    console.error('');
+    console.error('Supported platforms:');
+    console.error('  - darwin-arm64 (macOS Apple Silicon)');
+    console.error('  - darwin-x64 (macOS Intel)');
+    console.error('  - linux-arm64 (Linux ARM64, glibc)');
+    console.error('  - linux-arm64-musl (Linux ARM64, Alpine/musl)');
+    console.error('  - linux-x64 (Linux x64, glibc)');
+    console.error('  - linux-x64-musl (Linux x64, Alpine/musl)');
+    console.error('  - win32-x64 (Windows x64)');
+    console.error('');
+    console.error('Workaround: Install via Cargo instead:');
+    console.error('  cargo install rskim');
+    console.error('');
+    console.error('Report issues: https://github.com/dean0x/skim/issues');
+    process.exit(1);
+  }
+
+  // Try to find the platform package binary
+  let binaryPath = findPlatformBinary(packageName);
+
+  // Fallback to local binary (from postinstall)
+  if (!binaryPath) {
+    binaryPath = findFallbackBinary();
+  }
+
+  if (!binaryPath) {
+    console.error(`ERROR: Could not find skim binary.`);
+    console.error('');
+    console.error(`Expected platform package: ${packageName}`);
+    if (musl) {
+      console.error('Detected: musl-based Linux (Alpine, Void, etc.)');
+    }
+    console.error('');
+    console.error('The platform-specific package may have failed to install.');
+    console.error('This can happen with npm\'s optional dependencies.');
+    console.error('');
+    console.error('Try reinstalling:');
+    console.error('  npm uninstall -g rskim && npm install -g rskim');
+    console.error('');
+    console.error('Or install via Cargo:');
+    console.error('  cargo install rskim');
+    console.error('');
+    console.error('Report issues: https://github.com/dean0x/skim/issues');
+    process.exit(1);
+  }
+
+  // Verify binary is executable
+  try {
+    const testResult = spawnSync(binaryPath, ['--version'], {
+      timeout: 5000,
+      stdio: 'pipe',
+    });
+
+    if (testResult.error) {
+      const errorMsg = testResult.error.message || '';
+
+      console.error('ERROR: Binary exists but cannot be executed.');
+      console.error(`Path: ${binaryPath}`);
+      console.error(`Error: ${errorMsg}`);
+      console.error('');
+
+      if (errorMsg.includes('ENOENT') || errorMsg.includes('libc') || errorMsg.includes('GLIBC')) {
+        console.error('This appears to be a C library compatibility issue.');
+        if (musl) {
+          console.error('You are on musl-based Linux but may have a glibc binary.');
+        } else {
+          console.error('You may be on Alpine/musl but have a glibc binary.');
+        }
+        console.error('');
+        console.error('For Alpine Linux:');
+        console.error('  apk add cargo');
+        console.error('  cargo install rskim');
+      } else {
+        console.error('Workaround: Install via Cargo:');
+        console.error('  cargo install rskim');
+      }
+      console.error('');
+      console.error('Report issues: https://github.com/dean0x/skim/issues');
+      process.exit(1);
+    }
+  } catch {
+    // Non-fatal, proceed with execution
+  }
+
+  return binaryPath;
+}
+
+// Main execution
+const binaryPath = getBinaryPath();
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+});
+
+if (result.error) {
+  console.error(`ERROR: Failed to execute skim: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status || 0);

package/package.json

@@ -1,14 +1,7 @@
 {
   "name": "rskim",
-  "version": "0.7.0",
+  "version": "0.9.4",
   "description": "Smart code reader - streaming code transformation for AI agents",
-  "bin": {
-    "skim": "./bin/skim.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dean0x/skim.git"
-  },
   "keywords": [
     "code",
     "ast",
@@ -18,17 +11,35 @@
   ],
   "author": "Skim Contributors",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dean0x/skim.git"
+  },
   "bugs": {
     "url": "https://github.com/dean0x/skim/issues"
   },
   "homepage": "https://github.com/dean0x/skim#readme",
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
+  "bin": {
+    "skim": "bin/skim",
+    "rskim": "bin/skim"
+  },
+  "files": [
+    "bin",
+    "scripts"
   ],
-  "cpu": [
-    "x64",
-    "arm64"
-  ]
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "optionalDependencies": {
+    "@rskim/cli-darwin-arm64": "0.9.4",
+    "@rskim/cli-darwin-x64": "0.9.4",
+    "@rskim/cli-linux-arm64": "0.9.4",
+    "@rskim/cli-linux-x64": "0.9.4",
+    "@rskim/cli-linux-arm64-musl": "0.9.4",
+    "@rskim/cli-linux-x64-musl": "0.9.4",
+    "@rskim/cli-win32-x64": "0.9.4"
+  }
 }

package/scripts/postinstall.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script for rskim npm package.
+ *
+ * This script runs after `npm install` to ensure the binary is available.
+ * It downloads the platform-specific binary as a fallback if the optional
+ * dependency failed to install (common with npm's optional deps).
+ *
+ * IMPORTANT: This script only uses Node.js built-in modules (no dependencies).
+ */
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const os = require('os');
+
+/**
+ * Detect if running on musl-based Linux
+ *
+ * ARCHITECTURE NOTE: This function is intentionally duplicated in bin/skim.
+ * Postinstall scripts run before node_modules is fully available, so this script
+ * must be self-contained with no external dependencies. Do not extract to a shared
+ * module - it would break postinstall execution.
+ */
+function isMusl() {
+  if (process.platform !== 'linux') {
+    return false;
+  }
+
+  try {
+    const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+    if (osRelease.includes('Alpine')) {
+      return true;
+    }
+  } catch {
+    // Continue checking
+  }
+
+  try {
+    const lddOutput = execSync('ldd --version 2>&1 || true', { encoding: 'utf8' });
+    if (lddOutput.includes('musl')) {
+      return true;
+    }
+  } catch {
+    // Continue checking
+  }
+
+  try {
+    const files = fs.readdirSync('/lib');
+    if (files.some(f => f.startsWith('ld-musl'))) {
+      return true;
+    }
+  } catch {
+    // Not musl
+  }
+
+  return false;
+}
+
+/**
+ * Get platform-specific package name
+ */
+function getPlatformPackage() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const musl = isMusl();
+
+  const packages = {
+    'darwin-arm64': '@rskim/cli-darwin-arm64',
+    'darwin-x64': '@rskim/cli-darwin-x64',
+    'linux-arm64': musl ? '@rskim/cli-linux-arm64-musl' : '@rskim/cli-linux-arm64',
+    'linux-x64': musl ? '@rskim/cli-linux-x64-musl' : '@rskim/cli-linux-x64',
+    'win32-x64': '@rskim/cli-win32-x64',
+  };
+
+  return packages[`${platform}-${arch}`];
+}
+
+/**
+ * Check if platform package is already installed using walktree algorithm.
+ *
+ * Walks up the directory tree looking for node_modules containing the platform package.
+ * This approach is package-manager agnostic and works with npm, pnpm, yarn (classic & berry),
+ * bun, and arbitrary monorepo nesting depths.
+ */
+function isPlatformPackageInstalled(packageName) {
+  const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+  let currentDir = __dirname;
+
+  // Walk up the directory tree looking for node_modules
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(currentDir, 'node_modules', packageName, binaryName);
+    if (fs.existsSync(candidate)) {
+      return true;
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break; // Hit filesystem root
+    currentDir = parent;
+  }
+
+  return false;
+}
+
+/**
+ * Check if fallback binary already exists
+ */
+function isFallbackInstalled() {
+  const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+  const fallbackPath = path.join(__dirname, '..', 'bin', binaryName);
+  return fs.existsSync(fallbackPath);
+}
+
+/**
+ * Trusted domains for redirect validation.
+ * Only follow redirects to these domains to prevent redirect attacks.
+ */
+const TRUSTED_DOMAINS = [
+  'registry.npmjs.org',
+  'registry.yarnpkg.com',
+  'registry.npmmirror.com',
+];
+
+/**
+ * Validate that a URL is within trusted domains
+ */
+function isUrlTrusted(urlString) {
+  try {
+    const url = new URL(urlString);
+    return TRUSTED_DOMAINS.some(domain => url.hostname === domain || url.hostname.endsWith('.' + domain));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Download file with redirect handling
+ */
+function downloadToFile(url, destPath, maxRedirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      reject(new Error('Too many redirects'));
+      return;
+    }
+
+    const file = fs.createWriteStream(destPath);
+
+    https.get(url, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        file.close();
+        fs.unlinkSync(destPath);
+
+        // Validate redirect URL stays within trusted domains
+        const redirectUrl = response.headers.location;
+        if (!isUrlTrusted(redirectUrl)) {
+          reject(new Error(`Redirect to untrusted domain blocked: ${redirectUrl}`));
+          return;
+        }
+
+        downloadToFile(redirectUrl, destPath, maxRedirects - 1)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(destPath);
+        reject(new Error(`HTTP ${response.statusCode}: ${url}`));
+        return;
+      }
+
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+      file.on('error', (err) => {
+        file.close();
+        fs.unlinkSync(destPath);
+        reject(err);
+      });
+    }).on('error', (err) => {
+      file.close();
+      try { fs.unlinkSync(destPath); } catch {}
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Get the npm registry tarball URL for a package
+ * Uses the abbreviated metadata endpoint (/{package}/{version}) for efficiency.
+ */
+async function getPackageTarballUrl(packageName, version) {
+  return new Promise((resolve, reject) => {
+    // Use abbreviated metadata endpoint - returns only the specific version data
+    const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}`;
+
+    https.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to fetch package info: HTTP ${response.statusCode}`));
+        return;
+      }
+
+      let data = '';
+      response.on('data', chunk => data += chunk);
+      response.on('end', () => {
+        try {
+          const versionData = JSON.parse(data);
+          if (!versionData.dist || !versionData.dist.tarball) {
+            reject(new Error(`Tarball URL not found for ${packageName}@${version}`));
+            return;
+          }
+          resolve(versionData.dist.tarball);
+        } catch (e) {
+          reject(new Error(`Failed to parse package info: ${e.message}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Extract binary from npm tarball using system tar command
+ */
+async function extractBinaryFromTarball(tarballUrl, destPath) {
+  const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+
+  // Create a temporary directory for extraction
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rskim-'));
+  const tarballPath = path.join(tempDir, 'package.tgz');
+
+  try {
+    // Download the tarball
+    await downloadToFile(tarballUrl, tarballPath);
+
+    // Extract using system tar command
+    // The tarball contains: package/<binaryName>
+    await new Promise((resolve, reject) => {
+      const tarArgs = ['-xzf', tarballPath, '-C', tempDir];
+      const tar = spawn('tar', tarArgs, { stdio: 'inherit' });
+      tar.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`tar exited with code ${code}`));
+        }
+      });
+      tar.on('error', reject);
+    });
+
+    // Find the extracted binary (it will be in package/<binaryName>)
+    const extractedBinary = path.join(tempDir, 'package', binaryName);
+    if (!fs.existsSync(extractedBinary)) {
+      throw new Error(`Binary not found in tarball: ${binaryName}`);
+    }
+
+    // Ensure destination directory exists
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+
+    // Copy to destination
+    fs.copyFileSync(extractedBinary, destPath);
+
+    // Make executable (Unix only)
+    if (process.platform !== 'win32') {
+      fs.chmodSync(destPath, 0o755);
+    }
+  } finally {
+    // Cleanup temp directory
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Main postinstall logic
+ */
+async function main() {
+  const packageName = getPlatformPackage();
+
+  if (!packageName) {
+    // Unsupported platform, wrapper will show error at runtime
+    return;
+  }
+
+  // Check if platform package is already installed
+  if (isPlatformPackageInstalled(packageName)) {
+    // Already installed via optional dependency
+    return;
+  }
+
+  // Check if fallback binary already exists
+  if (isFallbackInstalled()) {
+    return;
+  }
+
+  // Read our version from package.json
+  const pkgJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+  const version = pkgJson.version;
+
+  console.log(`rskim: Downloading ${packageName}@${version}...`);
+
+  try {
+    const tarballUrl = await getPackageTarballUrl(packageName, version);
+    const binaryName = process.platform === 'win32' ? 'skim.exe' : 'skim';
+    const destPath = path.join(__dirname, '..', 'bin', binaryName);
+
+    await extractBinaryFromTarball(tarballUrl, destPath);
+    console.log('rskim: Binary downloaded successfully');
+  } catch (error) {
+    // Non-fatal - wrapper will show helpful error at runtime
+    console.warn(`rskim: Failed to download binary: ${error.message}`);
+    console.warn('rskim: You may need to install via: cargo install rskim');
+  }
+}
+
+// Run main and handle errors gracefully
+main().catch(error => {
+  // Non-fatal - wrapper will handle missing binary
+  console.warn(`rskim postinstall: ${error.message}`);
+});

package/bin/skim.js

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-function getBinaryPath() {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  // Define supported platforms and their binary paths
-  const supportedPlatforms = {
-    'linux-x64': 'bin/linux/x64/skim',
-    'linux-arm64': 'bin/linux/arm64/skim',
-    'darwin-x64': 'bin/darwin/x64/skim',
-    'darwin-arm64': 'bin/darwin/arm64/skim',
-    'win32-x64': 'bin/win32/x64/skim.exe',
-  };
-
-  const platformKey = `${platform}-${arch}`;
-  const binaryRelativePath = supportedPlatforms[platformKey];
-
-  // Check if platform is supported
-  if (!binaryRelativePath) {
-    console.error(`ERROR: Platform ${platform}-${arch} is not supported by the npm package.`);
-    console.error('');
-    console.error('Supported platforms:');
-    Object.keys(supportedPlatforms).forEach(p => {
-      console.error(`  - ${p}`);
-    });
-    console.error('');
-    console.error('Workaround: Install via Cargo instead:');
-    console.error('  cargo install rskim');
-    console.error('');
-    console.error('If you believe this platform should be supported, please report:');
-    console.error('  https://github.com/dean0x/skim/issues');
-    process.exit(1);
-  }
-
-  // Check if binary exists in package
-  const binaryPath = path.join(__dirname, '..', binaryRelativePath);
-  if (!fs.existsSync(binaryPath)) {
-    console.error('ERROR: Binary missing from npm package');
-    console.error(`Expected location: ${binaryPath}`);
-    console.error(`Platform: ${platformKey}`);
-    console.error('');
-    console.error('This is a packaging bug. Please report:');
-    console.error('  https://github.com/dean0x/skim/issues');
-    console.error('');
-    console.error('Workaround: Install via Cargo instead:');
-    console.error('  cargo install rskim');
-    process.exit(1);
-  }
-
-  // Quick check if binary is executable (catches glibc/musl issues)
-  try {
-    const testResult = spawnSync(binaryPath, ['--version'], {
-      timeout: 5000,
-      stdio: 'pipe'
-    });
-
-    if (testResult.error) {
-      console.error('ERROR: Binary exists but cannot be executed');
-      console.error(`Reason: ${testResult.error.message}`);
-      console.error('');
-
-      if (testResult.error.code === 'ENOENT' || testResult.error.message.includes('libc')) {
-        console.error('This may be a C library incompatibility issue.');
-        console.error('Common cause: Alpine Linux (musl) vs glibc binary mismatch');
-        console.error('');
-        console.error('If you are using Alpine Linux, install via Cargo instead:');
-        console.error('  apk add cargo');
-        console.error('  cargo install rskim');
-      } else {
-        console.error('Workaround: Install via Cargo instead:');
-        console.error('  cargo install rskim');
-      }
-      console.error('');
-      console.error('For more help, see: https://github.com/dean0x/skim/issues');
-      process.exit(1);
-    }
-  } catch (e) {
-    // Non-fatal, just proceed
-  }
-
-  return binaryPath;
-}
-
-const binary = getBinaryPath();
-const result = spawnSync(binary, process.argv.slice(2), {
-  stdio: 'inherit',
-});
-
-process.exit(result.status || 0);