chore: wip

chrisbbreuer · chrisbbreuer · commit 8b3f5fa524b5 · 2025-08-05T09:23:37.000-07:00
diff --git a/.github/workflows/build-binaries.yml b/.github/workflows/build-binaries.yml
@@ -254,6 +254,10 @@ jobs:
           INSTALL_PREFIX="${{ env.OUTPUT_DIR }}/${{ env.BINARY_NAME }}"
           mkdir -p "$INSTALL_PREFIX"
 
+          # Set up launchpad build environment
+          echo "Setting up launchpad build environment..."
+          source "$HOME/.local/share/launchpad/global/build-env.sh"
+
           # Configure with platform-specific options
           if [[ "${{ matrix.platform }}" == "darwin" ]]; then
             # On macOS, point to Homebrew iconv installation
@@ -267,19 +271,52 @@ jobs:
           echo "  Extensions: ${{ env.CONFIGURE_EXTENSIONS }}"
           echo "  Prefix: $INSTALL_PREFIX"
           echo "  Extra config: $EXTRA_CONFIG"
+          echo "  PKG_CONFIG_PATH: $PKG_CONFIG_PATH"
+          echo "  LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
+
+          # Debug: Show available pkg-config files
+          echo "Available pkg-config files:"
+          pkg-config --list-all | grep -i curl || echo "No curl pkg-config found"
+          echo "libcurl pkg-config info:"
+          pkg-config --exists libcurl && pkg-config --modversion libcurl || echo "libcurl not found via pkg-config"
+
+          # Show all available pkg-config files for debugging
+          echo "All available pkg-config files:"
+          pkg-config --list-all | head -20
+          echo "... (showing first 20)"
+
+          # Check if libcurl is found via pkg-config
+          if pkg-config --exists libcurl; then
+            echo "libcurl found via pkg-config"
+            CURL_CONFIG=""
+          else
+            echo "libcurl not found via pkg-config, using manual configuration"
+            CURL_CONFIG="--with-curl=$HOME/.local/share/launchpad/global/curl.se/v8.15.0"
+          fi
+
+          # Check for other common libraries
+          echo "Checking for other required libraries:"
+          pkg-config --exists openssl && echo "✓ openssl found" || echo "✗ openssl not found"
+          pkg-config --exists zlib && echo "✓ zlib found" || echo "✗ zlib not found"
+          pkg-config --exists libxml-2.0 && echo "✓ libxml-2.0 found" || echo "✗ libxml-2.0 not found"
+          pkg-config --exists sqlite3 && echo "✓ sqlite3 found" || echo "✗ sqlite3 not found"
 
           ./configure \
             --prefix="$INSTALL_PREFIX" \
             --disable-debug \
             --enable-shared \
             --with-pic \
             ${{ env.CONFIGURE_EXTENSIONS }} \
-            $EXTRA_CONFIG
+            $EXTRA_CONFIG \
+                        $CURL_CONFIG
 
       - name: Build PHP
         run: |
           cd ${{ env.PHP_SOURCE_DIR }}
 
+          # Set up launchpad build environment for compilation
+          source "$HOME/.local/share/launchpad/global/build-env.sh"
+
           # Use all available CPU cores for faster builds
           if [[ "${{ matrix.platform }}" == "darwin" ]]; then
             JOBS=$(sysctl -n hw.ncpu)
diff --git a/packages/launchpad/bin/cli.ts b/packages/launchpad/bin/cli.ts
@@ -3348,6 +3348,43 @@ cli
     }
   })
 
+// Build environment command
+cli
+  .command('build-env', 'Set up build environment for launchpad-installed packages')
+  .alias('env')
+  .option('--path <path>', 'Custom installation path')
+  .option('--shell', 'Output shell code for evaluation (use with eval)')
+  .example('launchpad build-env')
+  .example('launchpad build-env --path ~/.local/share/launchpad/global')
+  .example('launchpad build-env --shell | source /dev/stdin')
+  .action(async (options?: { path?: string, shell?: boolean }) => {
+    try {
+      const defaultInstallPath = path.join(homedir(), '.local', 'share', 'launchpad', 'global')
+      const installPath = options?.path || defaultInstallPath
+      const buildEnvScript = path.join(installPath, 'build-env.sh')
+
+      if (!fs.existsSync(buildEnvScript)) {
+        console.error('❌ Build environment script not found. Please install some packages first.')
+        console.error(`   Expected location: ${buildEnvScript}`)
+        process.exit(1)
+      }
+
+      if (options?.shell) {
+        // Output the script content for shell evaluation
+        const scriptContent = fs.readFileSync(buildEnvScript, 'utf-8')
+        console.log(scriptContent)
+      } else {
+        // Execute the script directly
+        const { execSync } = await import('node:child_process')
+        execSync(`source "${buildEnvScript}"`, { stdio: 'inherit', shell: '/bin/sh' })
+      }
+    }
+    catch (error) {
+      console.error('Failed to set up build environment:', error instanceof Error ? error.message : String(error))
+      process.exit(1)
+    }
+  })
+
 // Parse CLI arguments
 try {
   cli.version(version)
diff --git a/packages/launchpad/src/install-core.ts b/packages/launchpad/src/install-core.ts
@@ -7,7 +7,7 @@ import process from 'node:process'
 import { install_bun } from './bun'
 import { getCachedPackagePath, savePackageToCache } from './cache'
 import { config } from './config'
-import { createShims, createVersionCompatibilitySymlinks, createVersionSymlinks, validatePackageInstallation } from './install-helpers'
+import { createShims, createVersionCompatibilitySymlinks, createVersionSymlinks, validatePackageInstallation, createBuildEnvironmentScript } from './install-helpers'
 import { cleanupSpinner, logUniqueMessage } from './logging'
 import { getLatestVersion, parsePackageSpec, resolvePackageName, resolveVersion } from './package-resolution'
 import { installMeilisearch } from './special-installers'
@@ -888,6 +888,9 @@ export async function downloadPackage(
     // Find binaries and create shims
     const installedBinaries = await createShims(packageDir, installPath, domain, version)
 
+    // Create comprehensive build environment script
+    await createBuildEnvironmentScript(installPath)
+
     // Create package metadata for tracking
     const metadata = {
       domain,
diff --git a/packages/launchpad/src/install-helpers.ts b/packages/launchpad/src/install-helpers.ts
@@ -118,7 +118,80 @@ export async function createShims(packageDir: string, installPath: string, domai
     return libraryPaths
   }
 
+  // Helper function to build pkg-config paths for all installed packages
+  function buildPkgConfigPaths(installPath: string): string[] {
+    const pkgConfigPaths: string[] = []
+
+    try {
+      const domains = fs.readdirSync(installPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory()
+          && !['bin', 'sbin', 'lib', 'lib64', 'share', 'include', 'etc', 'pkgs', '.tmp', '.cache'].includes(dirent.name))
+
+      for (const domainEntry of domains) {
+        const domainPath = path.join(installPath, domainEntry.name)
+        if (fs.existsSync(domainPath)) {
+          const versions = fs.readdirSync(domainPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory() && dirent.name.startsWith('v'))
+
+          for (const versionEntry of versions) {
+            const versionPath = path.join(domainPath, versionEntry.name)
+            const pkgConfigDirs = [
+              path.join(versionPath, 'lib', 'pkgconfig'),
+              path.join(versionPath, 'lib64', 'pkgconfig'),
+            ]
+
+            for (const pkgConfigDir of pkgConfigDirs) {
+              if (fs.existsSync(pkgConfigDir) && !pkgConfigPaths.includes(pkgConfigDir)) {
+                pkgConfigPaths.push(pkgConfigDir)
+              }
+            }
+          }
+        }
+      }
+    }
+    catch {
+      // Ignore errors reading directories
+    }
+
+    return pkgConfigPaths
+  }
+
+  // Helper function to build include paths for all installed packages
+  function buildIncludePaths(installPath: string): string[] {
+    const includePaths: string[] = []
+
+    try {
+      const domains = fs.readdirSync(installPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory()
+          && !['bin', 'sbin', 'lib', 'lib64', 'share', 'include', 'etc', 'pkgs', '.tmp', '.cache'].includes(dirent.name))
+
+      for (const domainEntry of domains) {
+        const domainPath = path.join(installPath, domainEntry.name)
+        if (fs.existsSync(domainPath)) {
+          const versions = fs.readdirSync(domainPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory() && dirent.name.startsWith('v'))
+
+          for (const versionEntry of versions) {
+            const versionPath = path.join(domainPath, versionEntry.name)
+            const includeDir = path.join(versionPath, 'include')
+
+            if (fs.existsSync(includeDir) && !includePaths.includes(includeDir)) {
+              includePaths.push(includeDir)
+            }
+          }
+        }
+      }
+    }
+    catch {
+      // Ignore errors reading directories
+    }
+
+    return includePaths
+  }
+
   const libraryPaths = buildLibraryPaths(packageDir, installPath)
+  const pkgConfigPaths = buildPkgConfigPaths(installPath)
+  const includePaths = buildIncludePaths(installPath)
 
   for (const { sourceDir, shimDir: targetShimDir } of binaryDirs) {
     if (!fs.existsSync(sourceDir)) {
@@ -139,9 +212,10 @@ export async function createShims(packageDir: string, installPath: string, domai
         let shimContent = `#!/bin/sh
 # Launchpad shim for ${binary} (${domain} v${version})
 
-# Set up library paths for dynamic linking
+# Set up comprehensive build environment for launchpad-installed packages
 `
 
+        // Set up library paths for dynamic linking
         if (libraryPaths.length > 0) {
           const libraryPathString = libraryPaths.join(':')
           shimContent += `# macOS dynamic library paths
@@ -164,6 +238,39 @@ else
   export LD_LIBRARY_PATH="${libraryPathString}"
 fi
 
+`
+        }
+
+        // Set up pkg-config paths for build tools
+        if (pkgConfigPaths.length > 0) {
+          const pkgConfigPathString = pkgConfigPaths.join(':')
+          shimContent += `# Set up pkg-config to find launchpad-installed libraries
+if [ -n "$PKG_CONFIG_PATH" ]; then
+  export PKG_CONFIG_PATH="${pkgConfigPathString}:$PKG_CONFIG_PATH"
+else
+  export PKG_CONFIG_PATH="${pkgConfigPathString}"
+fi
+
+`
+        }
+
+        // Set up include paths for compilation
+        if (includePaths.length > 0) {
+          const includePathString = includePaths.join(' ')
+          shimContent += `# Set up include paths for compilation
+if [ -n "$CPPFLAGS" ]; then
+  export CPPFLAGS="-I${includePathString} $CPPFLAGS"
+else
+  export CPPFLAGS="-I${includePathString}"
+fi
+
+# Set up library paths for linking
+if [ -n "$LDFLAGS" ]; then
+  export LDFLAGS="-L${libraryPaths.join(' -L')} $LDFLAGS"
+else
+  export LDFLAGS="-L${libraryPaths.join(' -L')}"
+fi
+
 `
         }
 
@@ -444,3 +551,133 @@ export async function validatePackageInstallation(packageDir: string, domain: st
     return true // Assume valid if we can't check
   }
 }
+
+/**
+ * Create a comprehensive environment setup script for build tools
+ * This script can be sourced to set up all launchpad-installed packages for building
+ */
+export async function createBuildEnvironmentScript(installPath: string): Promise<void> {
+  const scriptPath = path.join(installPath, 'build-env.sh')
+
+  // Build all the paths
+  const libraryPaths: string[] = []
+  const pkgConfigPaths: string[] = []
+  const includePaths: string[] = []
+  const binPaths: string[] = []
+
+  try {
+    const domains = fs.readdirSync(installPath, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory()
+        && !['bin', 'sbin', 'lib', 'lib64', 'share', 'include', 'etc', 'pkgs', '.tmp', '.cache'].includes(dirent.name))
+
+    for (const domainEntry of domains) {
+      const domainPath = path.join(installPath, domainEntry.name)
+      if (fs.existsSync(domainPath)) {
+        const versions = fs.readdirSync(domainPath, { withFileTypes: true })
+          .filter(dirent => dirent.isDirectory() && dirent.name.startsWith('v'))
+
+        for (const versionEntry of versions) {
+          const versionPath = path.join(domainPath, versionEntry.name)
+
+          // Add library paths
+          const libDirs = [
+            path.join(versionPath, 'lib'),
+            path.join(versionPath, 'lib64'),
+          ]
+          for (const libDir of libDirs) {
+            if (fs.existsSync(libDir) && !libraryPaths.includes(libDir)) {
+              libraryPaths.push(libDir)
+            }
+          }
+
+          // Add pkg-config paths
+          const pkgConfigDirs = [
+            path.join(versionPath, 'lib', 'pkgconfig'),
+            path.join(versionPath, 'lib64', 'pkgconfig'),
+          ]
+          for (const pkgConfigDir of pkgConfigDirs) {
+            if (fs.existsSync(pkgConfigDir) && !pkgConfigPaths.includes(pkgConfigDir)) {
+              pkgConfigPaths.push(pkgConfigDir)
+            }
+          }
+
+          // Add include paths
+          const includeDir = path.join(versionPath, 'include')
+          if (fs.existsSync(includeDir) && !includePaths.includes(includeDir)) {
+            includePaths.push(includeDir)
+          }
+
+          // Add bin paths
+          const binDir = path.join(versionPath, 'bin')
+          if (fs.existsSync(binDir) && !binPaths.includes(binDir)) {
+            binPaths.push(binDir)
+          }
+        }
+      }
+    }
+  }
+  catch {
+    // Ignore errors reading directories
+  }
+
+  // Create the environment setup script
+  let scriptContent = `#!/bin/sh
+# Launchpad Build Environment Setup Script
+# Source this script to set up environment for building with launchpad-installed packages
+
+# Set up PATH to include launchpad binaries
+if [ -n "$PATH" ]; then
+  export PATH="${binPaths.join(':')}:$PATH"
+else
+  export PATH="${binPaths.join(':')}"
+fi
+
+`
+
+  // Set up library paths
+  if (libraryPaths.length > 0) {
+    const libraryPathString = libraryPaths.join(':')
+    scriptContent += `# Set up library paths for dynamic linking
+export LD_LIBRARY_PATH="${libraryPathString}${process.platform === 'darwin' ? ':$LD_LIBRARY_PATH' : ''}"
+export DYLD_LIBRARY_PATH="${libraryPathString}${process.platform === 'darwin' ? ':$DYLD_LIBRARY_PATH' : ''}"
+export DYLD_FALLBACK_LIBRARY_PATH="${libraryPathString}:/usr/local/lib:/lib:/usr/lib"
+
+`
+  }
+
+  // Set up pkg-config paths
+  if (pkgConfigPaths.length > 0) {
+    const pkgConfigPathString = pkgConfigPaths.join(':')
+    scriptContent += `# Set up pkg-config to find launchpad-installed libraries
+export PKG_CONFIG_PATH="${pkgConfigPathString}${process.env.PKG_CONFIG_PATH ? ':' + process.env.PKG_CONFIG_PATH : ''}"
+
+`
+  }
+
+  // Set up include and library paths for compilation
+  if (includePaths.length > 0 || libraryPaths.length > 0) {
+    scriptContent += `# Set up include paths for compilation
+export CPPFLAGS="-I${includePaths.join(' -I')}${process.env.CPPFLAGS ? ' ' + process.env.CPPFLAGS : ''}"
+
+# Set up library paths for linking
+export LDFLAGS="-L${libraryPaths.join(' -L')}${process.env.LDFLAGS ? ' ' + process.env.LDFLAGS : ''}"
+
+`
+  }
+
+  scriptContent += `# Print environment info
+echo "Launchpad build environment activated:"
+echo "  PATH: $PATH"
+echo "  LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
+echo "  PKG_CONFIG_PATH: $PKG_CONFIG_PATH"
+echo "  CPPFLAGS: $CPPFLAGS"
+echo "  LDFLAGS: $LDFLAGS"
+`
+
+  await fs.promises.writeFile(scriptPath, scriptContent)
+  await fs.promises.chmod(scriptPath, 0o755)
+
+  if (config.verbose) {
+    console.warn(`Created build environment script: ${scriptPath}`)
+  }
+}
