chore: wip

Author: chrisbbreuer

packages/launchpad/launchpad.config.ts

@@ -64,10 +64,6 @@ export const defaultConfig: LaunchpadConfig = {
       password: 'password',
       authMethod: 'trust',
     },
-    php: {
-      enabled: true,
-      version: '8.4.11',
-    },
   },
 }
 

packages/launchpad/src/commands/install.ts

@@ -386,20 +386,18 @@ async function installGlobalDependencies(options: { dryRun?: boolean, quiet?: bo
     // Check for excluded dependencies configuration
     const excludedDeps = (config as any).excludeDependencies || []
     const globalExcludedDeps = (config as any).excludeGlobalDependencies || []
-    const phpExcludedDeps = (config.services?.php as any)?.excludeDependencies || []
 
     const allExcludedDeps = new Set([
       ...excludedDeps,
       ...globalExcludedDeps,
-      ...phpExcludedDeps,
     ])
 
     // Always install PHP dependencies by default - they are runtime dependencies, not build dependencies
     // Only exclude if explicitly configured to do so
     if (allExcludedDeps.size > 0) {
       try {
-        const { pantry } = await import('ts-pkgx')
-        const phpPackage = (pantry as any)?.phpnet
+        const { packages } = await import('ts-pkgx')
+        const phpPackage = (packages as any)?.phpnet
         const phpDeps: string[] = (phpPackage?.dependencies || []).map((dep: any) => {
           let name = ''
           if (typeof dep === 'string')

packages/launchpad/src/config.ts

@@ -4,8 +4,6 @@ import { homedir } from 'node:os'
 import path from 'node:path'
 import process from 'node:process'
 import { loadConfig } from 'bunfig'
-
-// Apply profile and validation
 import { getEffectiveConfig, validateConfig } from './config-validation'
 
 function getDefaultInstallPath(): string {
@@ -179,12 +177,7 @@ export const defaultConfig: LaunchpadConfig = {
     },
     frameworks: {
       enabled: process.env.LAUNCHPAD_FRAMEWORKS_ENABLED !== 'false',
-      laravel: {
-        enabled: process.env.LAUNCHPAD_LARAVEL_ENABLED !== 'false',
-        autoDetect: process.env.LAUNCHPAD_LARAVEL_AUTO_DETECT !== 'false',
-      },
       stacks: {
-        enabled: process.env.LAUNCHPAD_STACKS_ENABLED !== 'false',
         autoDetect: process.env.LAUNCHPAD_STACKS_AUTO_DETECT !== 'false',
       },
     },
@@ -195,6 +188,7 @@ export const defaultConfig: LaunchpadConfig = {
 // eslint-disable-next-line antfu/no-top-level-await
 const rawConfig = await loadConfig({
   name: 'launchpad',
+  alias: 'deps',
   defaultConfig,
 })
 

packages/launchpad/src/dev-setup.ts

@@ -111,7 +111,7 @@ export function getSupportedFrameworks(): ProjectFramework[] {
     })
   }
 
-  if (frameworksConfig.laravel?.enabled) {
+  if ((frameworksConfig as any).laravel?.enabled) {
     frameworks.push({
       name: 'Laravel',
       detectionFile: 'artisan',

packages/launchpad/src/dev/sniff.ts

@@ -893,15 +893,14 @@ function shouldInferServices(): boolean {
   // LAUNCHPAD_FRAMEWORKS_ENABLED and LAUNCHPAD_SERVICES_INFER
   const frameworksEnabled = process.env.LAUNCHPAD_FRAMEWORKS_ENABLED !== 'false'
   const inferServices = process.env.LAUNCHPAD_SERVICES_INFER !== 'false'
-  const laravelEnabled = process.env.LAUNCHPAD_LARAVEL_ENABLED !== 'false'
   const stacksEnabled = process.env.LAUNCHPAD_STACKS_ENABLED !== 'false'
 
   // Skip inference in shell integration mode for performance
   if (process.env.LAUNCHPAD_SHELL_INTEGRATION === '1') {
     return false
   }
 
-  return frameworksEnabled && inferServices && (laravelEnabled || stacksEnabled)
+  return frameworksEnabled && inferServices && stacksEnabled
 }
 
 async function inferServicesFromFramework(projectDir: string): Promise<{ autoStart: string[] }> {

packages/launchpad/src/install.ts

@@ -4,7 +4,7 @@ import { downloadPackage } from './install-core'
 import { install } from './install-main'
 import { cleanupSpinner, resetInstalledTracker } from './logging'
 import { getAllPackageAliases, getAllPackageDomains, getAllPackageNames, getAvailableVersions, getLatestVersion, getPackageInfo, isPackageAlias, isPackageDomain, isValidPackageName, isVersionAvailable, listAvailablePackages, parsePackageSpec, resolvePackageName, resolveVersion } from './package-resolution'
-import { buildSqliteFromSource, installDependenciesOnly, testPhpBinary } from './special-installers'
+import { buildSqliteFromSource, installDependenciesOnly } from './special-installers'
 import { DISTRIBUTION_CONFIG } from './types'
 import { install_prefix } from './utils'
 
@@ -35,5 +35,4 @@ export {
   resolveAllDependencies,
   resolvePackageName,
   resolveVersion,
-  testPhpBinary,
 }

packages/launchpad/src/special-installers.ts

@@ -247,30 +247,30 @@ export async function installDependenciesOnly(packages: string[], installPath?:
   let totalDepsAlreadyInstalled = 0
 
   try {
-    // Import pantry from ts-pkgx to get package dependencies
-    const { pantry } = await import('ts-pkgx')
+    // Import packages from ts-pkgx to get package dependencies
+    const { packages: pkgxPackages } = await import('ts-pkgx')
 
     for (const packageName of packages) {
       // Resolve package name to domain
       const domain = resolvePackageName(packageName)
 
-      // Try different ways to find the package in pantry
+      // Try different ways to find the package in packages
       let packageKey: string | undefined
 
       // First, try exact matches
-      packageKey = Object.keys(pantry).find(key => key === domain || key === packageName)
+      packageKey = Object.keys(pkgxPackages).find(key => key === domain || key === packageName)
 
       // Fallback to partial matches only if no exact match found
       if (!packageKey) {
-        packageKey = Object.keys(pantry).find(key =>
+        packageKey = Object.keys(pkgxPackages).find(key =>
           key.includes(packageName) || key.includes(domain.split('.')[0]),
         )
       }
 
-      const packageSpec = packageKey ? pantry[packageKey as keyof typeof pantry] : null
+      const packageSpec = packageKey ? pkgxPackages[packageKey as keyof typeof pkgxPackages] : null
 
       if (!packageSpec || !packageSpec.dependencies) {
-        console.warn(`⚠️ Package ${packageName} not found in pantry or has no dependencies`)
+        console.warn(`⚠️ Package ${packageName} not found in pkgxPackages or has no dependencies`)
         continue
       }
 

packages/launchpad/src/types.ts

@@ -1,17 +1,95 @@
-import type { aliases, packages } from 'ts-pkgx'
+import type {
+  PackageAlias,
+  PackageDomain,
+  PackageName,
+  Packages,
+  Dependencies
+} from 'ts-pkgx'
+import { createDependencies } from 'ts-pkgx'
 
-// Extract all package alias names from ts-pkgx
-export type PackageAlias = keyof typeof aliases
+// Re-export ts-pkgx types for internal use
+export type {
+  PackageAlias,
+  PackageDomain,
+  PackageName,
+  Packages,
+  Dependencies
+}
+
+// Re-export ts-pkgx utilities
+export { createDependencies }
 
-// Extract all package domain names from ts-pkgx packages
-export type PackageDomain = keyof typeof packages
+/**
+ * Helper function to create a fully typed dependencies configuration with version validation
+ * This provides IntelliSense and type safety for both package names AND versions!
+ */
+export function defineFullyTypedDependencies(deps: FullyTypedDependencies): FullyTypedDependencies {
+  return deps
+}
 
-// Union type of all valid package identifiers (aliases + domains)
-export type PackageName = PackageAlias | PackageDomain
+
+/**
+ * Helper function to create a typed dependencies configuration (backward compatible)
+ * This provides IntelliSense and type safety while maintaining flexibility
+ */
+export function definePackageDependencies(deps: TypedDependencies): TypedDependencies {
+  return deps
+}
+
+/**
+ * Helper function to create a fully typed dependencies array
+ */
+export function definePackageList<T extends readonly PackageName[]>(packages: T): T {
+  return packages
+}
 
 // Type for package with optional version (allowing string for flexibility)
 export type PackageSpec = string
 
+// Type for package dependency specification in config
+export interface PackageDependencySpec {
+  version?: string
+  global?: boolean
+}
+
+// Extract version types from ts-pkgx packages
+type PackageVersions<T extends PackageName> = T extends keyof Packages
+  ? Packages[T] extends { versions: readonly (infer V)[] }
+    ? V extends string
+      ? V
+      : never
+    : never
+  : never
+
+// Version constraint that allows valid versions or version ranges
+type VersionConstraint<T extends PackageName> =
+  | PackageVersions<T>
+  | `^${PackageVersions<T>}`
+  | `~${PackageVersions<T>}`
+  | `>=${PackageVersions<T>}`
+  | `<=${PackageVersions<T>}`
+  | `>${PackageVersions<T>}`
+  | `<${PackageVersions<T>}`
+  | 'latest'
+  | '*'
+
+// Enhanced dependency spec with typed versions
+export interface TypedPackageDependencySpec<T extends PackageName> {
+  version?: VersionConstraint<T>
+  global?: boolean
+}
+
+// Fully typed dependencies with version validation
+// Note: TypeScript will highlight property names for invalid versions (language limitation)
+export type FullyTypedDependencies = {
+  readonly [K in PackageName]?: VersionConstraint<K> | TypedPackageDependencySpec<K>
+}
+
+// Backward compatible typed dependencies (allows string versions for flexibility)
+export type TypedDependencies = {
+  [K in PackageName]?: string | PackageDependencySpec
+}
+
 // Supported distribution formats
 export type SupportedFormat = 'tar.xz' | 'tar.gz'
 export type SupportedPlatform = 'darwin' | 'linux' | 'windows'
@@ -65,6 +143,21 @@ export interface LaunchpadConfig {
    * - string | string[]: install only for the listed package name(s)
    */
   installBuildDeps?: boolean | string | string[]
+  /**
+   * Package dependencies to install (similar to deps.yaml)
+   * FULLY TYPED package names AND versions from ts-pkgx
+   *
+   * Supports both domain names ('bun.sh') and aliases ('bun')
+   * Invalid package names and versions will cause TypeScript errors
+   *
+   * Use createDependencies() helper for enhanced developer experience:
+   * dependencies: createDependencies({ 'bun': '^1.2.19' })
+   */
+  dependencies?: Dependencies
+  /**
+   * Global flag for dependencies - when true, all dependencies are installed globally
+   */
+  global?: boolean
   shellMessages?: {
     activation?: string
     deactivation?: string
@@ -209,7 +302,7 @@ export interface LaunchpadConfig {
     autoRestart?: boolean
     startupTimeout?: number
     shutdownTimeout?: number
-    /** Infer services to auto-start from framework config (e.g., Laravel/Stacks .env) */
+    /** Infer services to auto-start from framework config (e.g., Stacks .env) */
     infer?: boolean
     database?: {
       username?: string
@@ -218,10 +311,6 @@ export interface LaunchpadConfig {
     }
     frameworks?: {
       enabled?: boolean
-      laravel?: {
-        enabled?: boolean
-        autoDetect?: boolean
-      }
       stacks?: {
         enabled?: boolean
         autoDetect?: boolean