add progress tracking flag to monitor VM startup state using cloud-init

cmd/limactl/clone.go

@@ -109,7 +109,7 @@ func cloneAction(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	return instance.Start(ctx, newInst, "", false)
+	return instance.Start(ctx, newInst, "", false, false)
 }
 
 func cloneBashComplete(cmd *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {

cmd/limactl/edit.go

@@ -160,7 +160,7 @@ func editAction(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	return instance.Start(ctx, inst, "", false)
+	return instance.Start(ctx, inst, "", false, false)
 }
 
 func askWhetherToStart() (bool, error) {

cmd/limactl/hostagent.go

@@ -35,6 +35,7 @@ func newHostagentCommand() *cobra.Command {
 	hostagentCommand.Flags().Bool("run-gui", false, "Run GUI synchronously within hostagent")
 	hostagentCommand.Flags().String("guestagent", "", "Local file path (not URL) of lima-guestagent.OS-ARCH[.gz]")
 	hostagentCommand.Flags().String("nerdctl-archive", "", "Local file path (not URL) of nerdctl-full-VERSION-GOOS-GOARCH.tar.gz")
+	hostagentCommand.Flags().Bool("progress", false, "Show provision script progress by monitoring cloud-init logs")
 	return hostagentCommand
 }
 
@@ -94,6 +95,13 @@ func hostagentAction(cmd *cobra.Command, args []string) error {
 	if nerdctlArchive != "" {
 		opts = append(opts, hostagent.WithNerdctlArchive(nerdctlArchive))
 	}
+	showProgress, err := cmd.Flags().GetBool("progress")
+	if err != nil {
+		return err
+	}
+	if showProgress {
+		opts = append(opts, hostagent.WithCloudInitProgress(showProgress))
+	}
 	ha, err := hostagent.New(instName, stdout, signalCh, opts...)
 	if err != nil {
 		return err

cmd/limactl/shell.go

@@ -101,7 +101,7 @@ func shellAction(cmd *cobra.Command, args []string) error {
 			return err
 		}
 
-		err = instance.Start(ctx, inst, "", false)
+		err = instance.Start(ctx, inst, "", false, false)
 		if err != nil {
 			return err
 		}

cmd/limactl/start.go

@@ -99,6 +99,7 @@ See the examples in 'limactl create --help'.
 		startCommand.Flags().Bool("foreground", false, "Run the hostagent in the foreground")
 	}
 	startCommand.Flags().Duration("timeout", instance.DefaultWatchHostAgentEventsTimeout, "Duration to wait for the instance to be running before timing out")
+	startCommand.Flags().Bool("progress", false, "Show provision script progress by tailing cloud-init logs")
 	return startCommand
 }
 
@@ -493,7 +494,12 @@ func startAction(cmd *cobra.Command, args []string) error {
 		ctx = instance.WithWatchHostAgentTimeout(ctx, timeout)
 	}
 
-	return instance.Start(ctx, inst, "", launchHostAgentForeground)
+	progress, err := cmd.Flags().GetBool("progress")
+	if err != nil {
+		return err
+	}
+
+	return instance.Start(ctx, inst, "", launchHostAgentForeground, progress)
 }
 
 func createBashComplete(cmd *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {

pkg/hostagent/events/events.go

@@ -17,6 +17,18 @@ type Status struct {
 	Errors []string `json:"errors,omitempty"`
 
 	SSHLocalPort int `json:"sshLocalPort,omitempty"`
+
+	// Cloud-init progress information
+	CloudInitProgress *CloudInitProgress `json:"cloudInitProgress,omitempty"`
+}
+
+type CloudInitProgress struct {
+	// Current log line from cloud-init
+	LogLine string `json:"logLine,omitempty"`
+	// Whether cloud-init has completed
+	Completed bool `json:"completed,omitempty"`
+	// Whether cloud-init monitoring is active
+	Active bool `json:"active,omitempty"`
 }
 
 type Event struct {

pkg/hostagent/hostagent.go

@@ -4,6 +4,7 @@
 package hostagent
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -72,11 +73,14 @@ type HostAgent struct {
 
 	guestAgentAliveCh     chan struct{} // closed on establishing the connection
 	guestAgentAliveChOnce sync.Once
+
+	showProgress bool // whether to show cloud-init progress
 }
 
 type options struct {
 	guestAgentBinary string
 	nerdctlArchive   string // local path, not URL
+	showProgress     bool
 }
 
 type Opt func(*options) error
@@ -95,6 +99,13 @@ func WithNerdctlArchive(s string) Opt {
 	}
 }
 
+func WithCloudInitProgress(enabled bool) Opt {
+	return func(o *options) error {
+		o.showProgress = enabled
+		return nil
+	}
+}
+
 // New creates the HostAgent.
 //
 // stdout is for emitting JSON lines of Events.
@@ -214,6 +225,7 @@ func New(instName string, stdout io.Writer, signalCh chan os.Signal, opts ...Opt
 		vSockPort:         vSockPort,
 		virtioPort:        virtioPort,
 		guestAgentAliveCh: make(chan struct{}),
+		showProgress:      o.showProgress,
 	}
 	return a, nil
 }
@@ -480,6 +492,18 @@ sudo chown -R "${USER}" /run/host-services`
 	}
 	if !*a.instConfig.Plain {
 		go a.watchGuestAgentEvents(ctx)
+		if a.showProgress {
+			cloudInitDone := make(chan struct{})
+			go func() {
+				a.watchCloudInitProgress(ctx)
+				close(cloudInitDone)
+			}()
+
+			go func() {
+				<-cloudInitDone
+				logrus.Debug("Cloud-init monitoring completed, VM is fully ready")
+			}()
+		}
 	}
 	if err := a.waitForRequirements("optional", a.optionalRequirements()); err != nil {
 		errs = append(errs, err)
@@ -777,6 +801,141 @@ func forwardSSH(ctx context.Context, sshConfig *ssh.SSHConfig, port int, local,
 	return nil
 }
 
+func (a *HostAgent) watchCloudInitProgress(ctx context.Context) {
+	logrus.Debug("Starting cloud-init progress monitoring")
+
+	a.emitEvent(ctx, events.Event{
+		Status: events.Status{
+			SSHLocalPort: a.sshLocalPort,
+			CloudInitProgress: &events.CloudInitProgress{
+				Active: true,
+			},
+		},
+	})
+
+	maxRetries := 30
+	retryDelay := time.Second
+	var sshReady bool
+
+	for i := 0; i < maxRetries && !sshReady; i++ {
+		if i > 0 {
+			time.Sleep(retryDelay)
+		}
+
+		// Test SSH connectivity
+		args := a.sshConfig.Args()
+		args = append(args,
+			"-p", strconv.Itoa(a.sshLocalPort),
+			"127.0.0.1",
+			"echo 'SSH Ready'",
+		)
+
+		cmd := exec.CommandContext(ctx, a.sshConfig.Binary(), args...)
+		if err := cmd.Run(); err == nil {
+			sshReady = true
+			logrus.Debug("SSH ready for cloud-init monitoring")
+		}
+	}
+
+	if !sshReady {
+		logrus.Warn("SSH not ready for cloud-init monitoring, proceeding anyway")
+	}
+
+	args := a.sshConfig.Args()
+	args = append(args,
+		"-p", strconv.Itoa(a.sshLocalPort),
+		"127.0.0.1",
+		"sudo", "tail", "-n", "+1", "-f", "/var/log/cloud-init-output.log",
+	)
+
+	cmd := exec.CommandContext(ctx, a.sshConfig.Binary(), args...)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		logrus.WithError(err).Warn("Failed to create stdout pipe for cloud-init monitoring")
+		return
+	}
+
+	if err := cmd.Start(); err != nil {
+		logrus.WithError(err).Warn("Failed to start cloud-init monitoring command")
+		return
+	}
+
+	scanner := bufio.NewScanner(stdout)
+	cloudInitFinished := false
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+
+		if strings.Contains(line, "Cloud-init") && strings.Contains(line, "finished") {
+			cloudInitFinished = true
+		}
+
+		a.emitEvent(ctx, events.Event{
+			Status: events.Status{
+				SSHLocalPort: a.sshLocalPort,
+				CloudInitProgress: &events.CloudInitProgress{
+					Active:    !cloudInitFinished,
+					LogLine:   line,
+					Completed: cloudInitFinished,
+				},
+			},
+		})
+	}
+
+	if err := cmd.Wait(); err != nil {
+		logrus.WithError(err).Debug("SSH command finished (expected when cloud-init completes)")
+	}
+
+	if !cloudInitFinished {
+		logrus.Debug("Connection dropped, checking for any remaining cloud-init logs")
+
+		finalArgs := a.sshConfig.Args()
+		finalArgs = append(finalArgs,
+			"-p", strconv.Itoa(a.sshLocalPort),
+			"127.0.0.1",
+			"sudo", "tail", "-n", "20", "/var/log/cloud-init-output.log",
+		)
+
+		finalCmd := exec.CommandContext(ctx, a.sshConfig.Binary(), finalArgs...)
+		if finalOutput, err := finalCmd.Output(); err == nil {
+			lines := strings.Split(string(finalOutput), "\n")
+			for _, line := range lines {
+				if strings.TrimSpace(line) != "" {
+					if strings.Contains(line, "Cloud-init") && strings.Contains(line, "finished") {
+						cloudInitFinished = true
+					}
+
+					a.emitEvent(ctx, events.Event{
+						Status: events.Status{
+							SSHLocalPort: a.sshLocalPort,
+							CloudInitProgress: &events.CloudInitProgress{
+								Active:    !cloudInitFinished,
+								LogLine:   line,
+								Completed: cloudInitFinished,
+							},
+						},
+					})
+				}
+			}
+		}
+	}
+
+	a.emitEvent(ctx, events.Event{
+		Status: events.Status{
+			SSHLocalPort: a.sshLocalPort,
+			CloudInitProgress: &events.CloudInitProgress{
+				Active:    false,
+				Completed: true,
+			},
+		},
+	})
+
+	logrus.Debug("Cloud-init progress monitoring completed")
+}
+
 func copyToHost(ctx context.Context, sshConfig *ssh.SSHConfig, port int, local, remote string) error {
 	args := sshConfig.Args()
 	args = append(args,

pkg/instance/restart.go

@@ -12,7 +12,10 @@ import (
 	"github.com/lima-vm/lima/v2/pkg/store"
 )
 
-const launchHostAgentForeground = false
+const (
+	launchHostAgentForeground = false
+	showProgress              = false
+)
 
 func Restart(ctx context.Context, inst *store.Instance) error {
 	if err := StopGracefully(ctx, inst, true); err != nil {
@@ -23,7 +26,7 @@ func Restart(ctx context.Context, inst *store.Instance) error {
 		return err
 	}
 
-	if err := Start(ctx, inst, "", launchHostAgentForeground); err != nil {
+	if err := Start(ctx, inst, "", launchHostAgentForeground, showProgress); err != nil {
 		return err
 	}
 
@@ -38,7 +41,7 @@ func RestartForcibly(ctx context.Context, inst *store.Instance) error {
 		return err
 	}
 
-	if err := Start(ctx, inst, "", launchHostAgentForeground); err != nil {
+	if err := Start(ctx, inst, "", launchHostAgentForeground, showProgress); err != nil {
 		return err
 	}