deployer (#4654)

Adds launch plan subcommands and refactors launch flow to support deployer integration. Includes scanner improvements, framework detection fixes, and enhanced managed Postgres functionality.

Launch Plan Commands

  - Support for manifest-based configuration via --from-manifest flag
  - Added --force-name and --no-create-app flags for programmatic app creation
  - Improved flag precedence handling for --app, --region, and --org in
  generate step
  - Fixed compute override application across all configurations with nil
  checks

Scanner Improvements

  - Deno: Fixed malformed regex, better main.ts fallback detection, upgraded
  default version to 2.0.4
  - Rails: Fixed SQLite Dockerfile generation, improved ruby version
  detection, fixed binrails edge case in multi-test runs
  - Python/Django: Added WSGI/Gunicorn warnings, improved Python version
  detection from Pipfile
  - JS Frameworks: Fixed port detection (now respects specified ports instead
  of always defaulting to 3000)
  - Go: Better handling when go.sum is missing
  - PHP: Added composer.json scanning for version detection

Managed Postgres (MPG)

  - Improved retry logic with network error handling and progress logging
  during provisioning

Configuration

  - Fixed extension name prompting when using --yes flag
  - Better handling of internal port overrides
  - Fixed compute validation with isComputeValid helper

Author: jphenow

.github/workflows/build.yml

@@ -3,6 +3,7 @@ on:
   schedule:
     - cron: '21 */2 * * *'
   push:
+  pull_request:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -36,6 +37,8 @@ jobs:
           overwrite: true
 
   preflight:
+    # Only run preflight on master pushes, scheduled runs, or pull requests
+    if: ${{ github.event_name == 'schedule' || github.ref == 'refs/heads/master' || github.event_name == 'pull_request' }}
     needs: test_build
     uses: ./.github/workflows/preflight.yml
     secrets: inherit

.github/workflows/preflight.yml

@@ -24,7 +24,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-go@v6
         with:
-          go-version-file: "go.mod"
+          go-version-file: 'go.mod'
           check-latest: true
       - name: Get go version
         id: go-version
@@ -49,8 +49,8 @@ jobs:
           FLY_PREFLIGHT_TEST_ACCESS_TOKEN: ${{ secrets.FLYCTL_PREFLIGHT_CI_FLY_API_TOKEN }}
           FLY_PREFLIGHT_TEST_FLY_ORG: flyctl-ci-preflight
           FLY_PREFLIGHT_TEST_FLY_REGIONS: ${{ inputs.region }}
-          FLY_PREFLIGHT_TEST_NO_PRINT_HISTORY_ON_FAIL: "true"
-          FLY_FORCE_TRACE: "true"
+          FLY_PREFLIGHT_TEST_NO_PRINT_HISTORY_ON_FAIL: 'true'
+          FLY_FORCE_TRACE: 'true'
         run: |
           (test -e master-build/flyctl) && mv master-build/flyctl bin/flyctl
           chmod +x bin/flyctl

.gitignore

@@ -42,4 +42,6 @@ out
 # generated release meta
 release.json
 
+.fly
 CLAUDE.md
+.claude/settings.local.json

internal/command/deploy/deploy_build.go

@@ -146,7 +146,12 @@ func determineImage(ctx context.Context, app *flaps.App, appConfig *appconfig.Co
 		img, err = resolver.ResolveReference(ctx, io, opts)
 		if err != nil {
 			tracing.RecordError(span, err, "failed to resolve reference for prebuilt docker image")
-			return
+			img = &imgsrc.DeploymentImage{
+				ID:  imageRef,
+				Tag: imageRef,
+			}
+			terminal.Debugf("Failed to resolve reference for prebuilt docker image, using imageRef %s: %v\n", img.String(), err)
+			err = nil
 		}
 
 		span.AddEvent("using pre-built docker image")

internal/command/extensions/core/core.go

@@ -102,17 +102,17 @@ func ProvisionExtension(ctx context.Context, params ExtensionParams) (extension
 		if override := params.OverrideName; override != nil {
 			name = *override
 		} else {
-			if name == "" {
-				name = flag.GetString(ctx, "name")
-			}
+			name = flag.GetString(ctx, "name")
 
 			if name == "" {
 				if provider.NameSuffix != "" && targetApp.Name != "" {
 					name = targetApp.Name + "-" + provider.NameSuffix
 				}
-				err = prompt.String(ctx, &name, "Choose a name, use the default, or leave blank to generate one:", name, false)
-				if err != nil {
-					return
+				if !flag.GetYes(ctx) {
+					err = prompt.String(ctx, &name, "Choose a name, use the default, or leave blank to generate one:", name, false)
+					if err != nil {
+						return
+					}
 				}
 			}
 		}

internal/command/launch/cmd.go

@@ -144,9 +144,20 @@ func New() (cmd *cobra.Command) {
 			Name:        "yaml",
 			Description: "Generate configuration in YAML format",
 		},
+		// don't try to generate a name
 		flag.Bool{
-			Name:        "no-create",
-			Description: "Do not create an app, only generate configuration files",
+			Name:        "force-name",
+			Description: "Force app name supplied by --name",
+			Default:     false,
+			Hidden:      true,
+		},
+		// like reuse-app, but non-legacy!
+		flag.Bool{
+			Name:        "no-create-app",
+			Description: "Do not create an app",
+			Default:     false,
+			Hidden:      true,
+			Aliases:     []string{"no-create"},
 		},
 		flag.String{
 			Name:        "auto-stop",
@@ -337,6 +348,46 @@ func run(ctx context.Context) (err error) {
 		return err
 	}
 
+	planStep := plan.GetPlanStep(ctx)
+
+	if launchManifest != nil && planStep != "generate" {
+		// we loaded a manifest...
+		cache = &planBuildCache{
+			appConfig:        launchManifest.Config,
+			sourceInfo:       nil,
+			appNameValidated: true,
+			warnedNoCcHa:     true,
+		}
+	}
+
+	// For "generate" step, allow command-line flags to override manifest values.
+	// This is necessary because buildManifest() is skipped when loading a manifest from file.
+	// The "generate" step specifically needs this because it's called after propose/create steps,
+	// and the deployer wrapper needs to be able to override specific values without re-proposing.
+	if launchManifest != nil && planStep == "generate" {
+		// Override org if --org flag was provided
+		if orgRequested := flag.GetOrg(ctx); orgRequested != "" {
+			launchManifest.Plan.OrgSlug = orgRequested
+		}
+
+		// Override app name if --app flag was provided
+		// This allows explicit override while preserving manifest value by default
+		if appRequested := flag.GetApp(ctx); appRequested != "" && flag.IsSpecified(ctx, "app") {
+			launchManifest.Plan.AppName = appRequested
+		}
+
+		// Override region if --region flag was provided
+		if regionRequested := flag.GetRegion(ctx); regionRequested != "" && flag.IsSpecified(ctx, "region") {
+			launchManifest.Plan.RegionCode = regionRequested
+		}
+
+		// Initialize PlanSource if nil (happens when loading from JSON because fields are unexported)
+		// This prevents nil pointer dereference in PlanSummary and other code that accesses PlanSource
+		if launchManifest.PlanSource == nil {
+			launchManifest.PlanSource = newDefaultPlanSource("from manifest")
+		}
+	}
+
 	// "--from" arg handling
 	parentCtx := ctx
 	ctx, parentConfig, err := setupFromTemplate(ctx)
@@ -350,19 +401,20 @@ func run(ctx context.Context) (err error) {
 	recoverableErrors := recoverableErrorBuilder{canEnterUi: canEnterUi}
 
 	if launchManifest == nil {
-
 		launchManifest, cache, err = buildManifest(ctx, parentConfig, &recoverableErrors)
 		if err != nil {
 			var recoverableErr recoverableInUiError
-			if errors.As(err, &recoverableErr) && canEnterUi {
-			} else {
+			if !errors.As(err, &recoverableErr) || !canEnterUi {
 				return err
 			}
 		}
 
-		if flag.GetBool(ctx, "manifest") {
+		manifestFlag := flag.GetBool(ctx, "manifest")
+		manifestPath := flag.GetString(ctx, "manifest-path")
+
+		if manifestFlag {
 			var jsonEncoder *json.Encoder
-			if manifestPath := flag.GetString(ctx, "manifest-path"); manifestPath != "" {
+			if manifestPath != "" {
 				file, err := os.OpenFile(manifestPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
 				if err != nil {
 					return err
@@ -374,7 +426,8 @@ func run(ctx context.Context) (err error) {
 				jsonEncoder = json.NewEncoder(io.Out)
 			}
 			jsonEncoder.SetIndent("", "  ")
-			return jsonEncoder.Encode(launchManifest)
+			encodeErr := jsonEncoder.Encode(launchManifest)
+			return encodeErr
 		}
 	}
 
@@ -419,7 +472,6 @@ func run(ctx context.Context) (err error) {
 		family = state.sourceInfo.Family
 	}
 
-	planStep := plan.GetPlanStep(ctx)
 	if planStep == "" {
 		colorize := io.ColorScheme()
 

internal/command/launch/cmd_test.go

@@ -105,6 +105,21 @@ func TestValidatePostgresFlags(t *testing.T) {
 	}
 }
 
+func TestNewDefaultPlanSource(t *testing.T) {
+	source := "test source"
+	planSource := newDefaultPlanSource(source)
+
+	assert.NotNil(t, planSource)
+	assert.Equal(t, source, planSource.appNameSource)
+	assert.Equal(t, source, planSource.regionSource)
+	assert.Equal(t, source, planSource.orgSource)
+	assert.Equal(t, source, planSource.computeSource)
+	assert.Equal(t, source, planSource.postgresSource)
+	assert.Equal(t, source, planSource.redisSource)
+	assert.Equal(t, source, planSource.tigrisSource)
+	assert.Equal(t, source, planSource.sentrySource)
+}
+
 func TestParseMountOptions(t *testing.T) {
 	tests := []struct {
 		name          string

internal/command/launch/launch.go

@@ -110,6 +110,13 @@ func (state *launchState) Launch(ctx context.Context) error {
 		}
 	}
 
+	if planStep != "generate" {
+		// Override internal port if requested using --internal-port flag
+		if n := flag.GetInt(ctx, "internal-port"); n > 0 {
+			state.appConfig.SetInternalPort(n)
+		}
+	}
+
 	// if the user specified a command, set it in the app config
 	if flag.GetString(ctx, "command") != "" {
 		if state.appConfig.Processes == nil {
@@ -276,17 +283,30 @@ func (state *launchState) updateComputeFromDeprecatedGuestFields(ctx context.Con
 	return nil
 }
 
+// isComputeValid checks if a compute configuration is valid and can be safely modified
+func isComputeValid(c *appconfig.Compute) bool {
+	return c != nil && c.MachineGuest != nil
+}
+
 // updateConfig populates the appConfig with the plan's values
 func (state *launchState) updateConfig(ctx context.Context) {
-	state.appConfig.AppName = state.Plan.AppName
-	state.appConfig.PrimaryRegion = state.Plan.RegionCode
-	if state.env != nil {
-		state.appConfig.SetEnvVariables(state.env)
+	appConfig := state.appConfig
+	env := state.env
+	plan := state.Plan
+
+	if plan == nil {
+		return
 	}
 
-	state.appConfig.Compute = state.Plan.Compute
+	appConfig.AppName = plan.AppName
+	appConfig.PrimaryRegion = plan.RegionCode
+	if env != nil {
+		appConfig.SetEnvVariables(env)
+	}
+
+	appConfig.Compute = plan.Compute
 
-	if state.Plan.HttpServicePort != 0 {
+	if plan.HttpServicePort != 0 {
 		autostop := fly.MachineAutostopStop
 		autostopFlag := flag.GetString(ctx, "auto-stop")
 
@@ -296,8 +316,11 @@ func (state *launchState) updateConfig(ctx context.Context) {
 			autostop = fly.MachineAutostopSuspend
 
 			// if any compute has a GPU or more than 2GB of memory, set autostop to stop
-			for _, compute := range state.appConfig.Compute {
-				if compute.MachineGuest != nil && compute.MachineGuest.GPUKind != "" {
+			for _, compute := range appConfig.Compute {
+				if !isComputeValid(compute) {
+					continue
+				}
+				if compute.MachineGuest.GPUKind != "" {
 					autostop = fly.MachineAutostopStop
 					break
 				}
@@ -312,18 +335,44 @@ func (state *launchState) updateConfig(ctx context.Context) {
 			}
 		}
 
-		if state.appConfig.HTTPService == nil {
-			state.appConfig.HTTPService = &appconfig.HTTPService{
+		if appConfig.HTTPService == nil {
+			appConfig.HTTPService = &appconfig.HTTPService{
 				ForceHTTPS:         true,
 				AutoStartMachines:  fly.Pointer(true),
 				AutoStopMachines:   fly.Pointer(autostop),
 				MinMachinesRunning: fly.Pointer(0),
 				Processes:          []string{"app"},
 			}
 		}
-		state.appConfig.HTTPService.InternalPort = state.Plan.HttpServicePort
+		appConfig.HTTPService.InternalPort = plan.HttpServicePort
 	} else {
-		state.appConfig.HTTPService = nil
+		appConfig.HTTPService = nil
+	}
+
+	// Apply plan-level compute overrides to all compute configurations
+	// Only set fields that haven't already been set (defensive against updateComputeFromDeprecatedGuestFields)
+	if plan.CPUKind != "" {
+		for i := range appConfig.Compute {
+			if isComputeValid(appConfig.Compute[i]) && appConfig.Compute[i].CPUKind == "" {
+				appConfig.Compute[i].CPUKind = plan.CPUKind
+			}
+		}
+	}
+
+	if plan.CPUs != 0 {
+		for i := range appConfig.Compute {
+			if isComputeValid(appConfig.Compute[i]) && appConfig.Compute[i].CPUs == 0 {
+				appConfig.Compute[i].CPUs = plan.CPUs
+			}
+		}
+	}
+
+	if plan.MemoryMB != 0 {
+		for i := range appConfig.Compute {
+			if isComputeValid(appConfig.Compute[i]) && appConfig.Compute[i].MemoryMB == 0 {
+				appConfig.Compute[i].MemoryMB = plan.MemoryMB
+			}
+		}
 	}
 }
 

internal/command/launch/launch_databases.go

@@ -285,6 +285,18 @@ func (state *launchState) createManagedPostgres(ctx context.Context) error {
 		retry.Delay(2*time.Second),
 		retry.MaxDelay(30*time.Second),
 		retry.DelayType(retry.BackOffDelay),
+		retry.OnRetry(func(n uint, err error) {
+			// Log network-related errors and periodic status updates
+			if containsNetworkError(err.Error()) {
+				s.Stop()
+				fmt.Fprintf(io.Out, "Retrying status check due to network issue: %v\n", err)
+				s = spinner.Run(io, colorize.Yellow("Provisioning your Managed Postgres cluster..."))
+			} else if n%10 == 0 && n > 0 { // Log every 10th attempt to show progress
+				s.Stop()
+				fmt.Fprintf(io.Out, "Still waiting for cluster to be ready (attempt %d)...\n", n+1)
+				s = spinner.Run(io, colorize.Yellow("Provisioning your Managed Postgres cluster..."))
+			}
+		}),
 	)
 
 	// Stop the spinner

internal/command/launch/launch_frameworks.go

@@ -16,6 +16,7 @@ import (
 	"github.com/superfly/flyctl/helpers"
 	"github.com/superfly/flyctl/internal/appconfig"
 	"github.com/superfly/flyctl/internal/appsecrets"
+	"github.com/superfly/flyctl/internal/command/launch/plan"
 	"github.com/superfly/flyctl/internal/flag"
 	"github.com/superfly/flyctl/internal/flapsutil"
 	"github.com/superfly/flyctl/internal/flyutil"
@@ -35,11 +36,13 @@ func (state *launchState) setupGitHubActions(ctx context.Context, appName string
 		gh, err := exec.LookPath("gh")
 
 		if err != nil {
-			io := iostreams.FromContext(ctx)
-			colorize := io.ColorScheme()
-			fmt.Fprintln(io.Out, "Run", colorize.Purple("`fly tokens create deploy -x 999999h`"), "to create a token and set it as the FLY_API_TOKEN secret in your GitHub repository settings")
-			fmt.Fprintln(io.Out, "See https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions")
-			fmt.Fprintln(io.Out)
+			if plan.GetPlanStep(ctx) == "" {
+				io := iostreams.FromContext(ctx)
+				colorize := io.ColorScheme()
+				fmt.Fprintln(io.Out, "Run", colorize.Purple("`fly tokens create deploy -x 999999h`"), "to create a token and set it as the FLY_API_TOKEN secret in your GitHub repository settings")
+				fmt.Fprintln(io.Out, "See https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions")
+				fmt.Fprintln(io.Out)
+			}
 		} else {
 			apiClient := flyutil.ClientFromContext(ctx)