Added a new public CLI command: `limactl start-at-login INSTANCE

--enabled`.
This command facilitates the generation of unit files for `launchd/systemd`,
providing users with a straightforward way to control `limactl` autostart behavior.

Signed-off-by: roman-kiselenko <roman.kiselenko.dev@gmail.com>

Author: roman-kiselenko

cmd/limactl/delete.go

@@ -5,7 +5,9 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"runtime"
 
+	"github.com/lima-vm/lima/pkg/autostart"
 	networks "github.com/lima-vm/lima/pkg/networks/reconcile"
 	"github.com/lima-vm/lima/pkg/stop"
 	"github.com/lima-vm/lima/pkg/store"
@@ -44,6 +46,14 @@ func deleteAction(cmd *cobra.Command, args []string) error {
 		if err := deleteInstance(cmd.Context(), inst, force); err != nil {
 			return fmt.Errorf("failed to delete instance %q: %w", instName, err)
 		}
+		if runtime.GOOS != "windows" {
+			deleted, err := autostart.DeleteStartAtLoginEntry(runtime.GOOS, instName)
+			if err != nil {
+				logrus.WithError(err)
+			} else if deleted {
+				logrus.Infof("The autostart file (%q) has been deleted", autostart.GetStartAtLoginEntryPath(runtime.GOOS, instName))
+			}
+		}
 		logrus.Infof("Deleted %q (%q)", instName, inst.Dir)
 	}
 	return networks.Reconcile(cmd.Context(), "")

cmd/limactl/edit.go

@@ -30,6 +30,7 @@ func newEditCommand() *cobra.Command {
 		GroupID:           basicCommand,
 	}
 	editflags.RegisterEdit(editCommand)
+
 	return editCommand
 }
 
@@ -51,12 +52,13 @@ func editAction(cmd *cobra.Command, args []string) error {
 		return errors.New("Cannot edit a running instance")
 	}
 
+	flags := cmd.Flags()
+
 	filePath := filepath.Join(inst.Dir, filenames.LimaYAML)
 	yContent, err := os.ReadFile(filePath)
 	if err != nil {
 		return err
 	}
-	flags := cmd.Flags()
 	tty, err := flags.GetBool("tty")
 	if err != nil {
 		return err

cmd/limactl/main.go

@@ -123,6 +123,10 @@ func newApp() *cobra.Command {
 		newProtectCommand(),
 		newUnprotectCommand(),
 	)
+	if runtime.GOOS != "windows" {
+		rootCmd.AddCommand(startAtLoginCommand())
+	}
+
 	return rootCmd
 }
 

cmd/limactl/start-at-login.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"runtime"
+
+	"github.com/lima-vm/lima/pkg/autostart"
+	"github.com/lima-vm/lima/pkg/store"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+func startAtLoginCommand() *cobra.Command {
+	resetCommand := &cobra.Command{
+		Use:               "start-at-login INSTANCE",
+		Short:             "Register/Unregister the unit file for instance",
+		Args:              WrapArgsError(cobra.MaximumNArgs(1)),
+		RunE:              startAtLoginAction,
+		ValidArgsFunction: startAtLoginComplete,
+		GroupID:           advancedCommand,
+	}
+
+	resetCommand.Flags().Bool(
+		"enabled", true,
+		"--enabled=true/false the "+map[string]string{"darwin": "launchd", "linux": "systemd"}[runtime.GOOS]+" unit file for instance",
+	)
+
+	return resetCommand
+}
+
+func startAtLoginAction(cmd *cobra.Command, args []string) error {
+	instName := DefaultInstanceName
+	if len(args) > 0 {
+		instName = args[0]
+	}
+
+	inst, err := store.Inspect(instName)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			logrus.Infof("Instance %q not found", instName)
+			return nil
+		}
+		return err
+	}
+
+	flags := cmd.Flags()
+	startAtLogin, err := flags.GetBool("enabled")
+	if err != nil {
+		return err
+	}
+	if startAtLogin {
+		if err := autostart.CreateStartAtLoginEntry(runtime.GOOS, inst.Name, inst.Dir); err != nil {
+			logrus.WithError(err)
+		} else {
+			logrus.Infof("The autostart file (%q) has been created", autostart.GetStartAtLoginEntryPath(runtime.GOOS, inst.Name))
+		}
+	} else {
+		deleted, err := autostart.DeleteStartAtLoginEntry(runtime.GOOS, instName)
+		if err != nil {
+			logrus.WithError(err)
+		} else if deleted {
+			logrus.Infof("The autostart file (%q) has been deleted", autostart.GetStartAtLoginEntryPath(runtime.GOOS, instName))
+		}
+	}
+
+	return nil
+}
+
+func startAtLoginComplete(cmd *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+	return bashCompleteInstanceNames(cmd)
+}

pkg/autostart/autostart.go

@@ -0,0 +1,125 @@
+// Package autostart manage start at login unit files for darwin/linux
+package autostart
+
+import (
+	_ "embed"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/lima-vm/lima/pkg/textutil"
+)
+
+//go:embed lima-vm@INSTANCE.service
+var systemdTemplate string
+
+//go:embed io.lima-vm.autostart.INSTANCE.plist
+var launchdTemplate string
+
+// CreateStartAtLoginEntry respect host OS arch and create unit file
+func CreateStartAtLoginEntry(hostOS, instName, workDir string) error {
+	unitPath := GetStartAtLoginEntryPath(hostOS, instName)
+	if _, err := os.Stat(unitPath); !errors.Is(err, os.ErrNotExist) {
+		return err
+	}
+	tmpl, err := renderTemplate(hostOS, workDir, instName, os.Executable)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(unitPath), os.ModePerm); err != nil {
+		return err
+	}
+	if err := os.WriteFile(unitPath, tmpl, 0o644); err != nil {
+		if !errors.Is(err, os.ErrExist) && !errors.Is(err, os.ErrNotExist) {
+			return err
+		}
+	}
+	return enableDisableService("enable", hostOS, GetStartAtLoginEntryPath(hostOS, instName))
+}
+
+// DeleteStartAtLoginEntry respect host OS arch and delete unit file
+// return true, nil if unit file has been deleted
+func DeleteStartAtLoginEntry(hostOS, instName string) (bool, error) {
+	unitPath := GetStartAtLoginEntryPath(hostOS, instName)
+	if _, err := os.Stat(unitPath); err != nil {
+		// Skip error log if file not present
+		if errors.Is(err, os.ErrNotExist) {
+			return false, nil
+		}
+		return false, err
+	}
+	if err := enableDisableService("disable", hostOS, GetStartAtLoginEntryPath(hostOS, instName)); err != nil {
+		return false, err
+	}
+	if err := os.Remove(unitPath); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+// GetFilePath returns the path to autostart file with respect of host
+func GetStartAtLoginEntryPath(hostOS, instName string) string {
+	var fileTmp string
+	if hostOS == "darwin" { // launchd plist
+		fileTmp = fmt.Sprintf("%s/Library/LaunchAgents/io.lima-vm.autostart.%s.plist", os.Getenv("HOME"), instName)
+	}
+	if hostOS == "linux" { // systemd service
+		// Use instance name as argument to systemd service
+		// Instance name available in unit file as %i
+		xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
+		if xdgConfigHome == "" {
+			xdgConfigHome = filepath.Join(os.Getenv("HOME"), ".config")
+		}
+		fileTmp = fmt.Sprintf("%s/systemd/user/lima-vm@%s.service", xdgConfigHome, instName)
+	}
+	return fileTmp
+}
+
+func enableDisableService(action, hostOS, serviceWithPath string) error {
+	// Get filename without extension
+	filename := strings.TrimSuffix(path.Base(serviceWithPath), filepath.Ext(path.Base(serviceWithPath)))
+
+	var args []string
+	if hostOS == "darwin" {
+		// man launchctl
+		args = append(args, []string{
+			"launchctl",
+			action,
+			fmt.Sprintf("gui/%s/%s", strconv.Itoa(os.Getuid()), filename),
+		}...)
+	} else {
+		args = append(args, []string{
+			"systemctl",
+			"--user",
+			action,
+			filename,
+		}...)
+	}
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func renderTemplate(hostOS, instName, workDir string, getExecutable func() (string, error)) ([]byte, error) {
+	selfExeAbs, err := getExecutable()
+	if err != nil {
+		return nil, err
+	}
+	tmpToExecute := systemdTemplate
+	if hostOS == "darwin" {
+		tmpToExecute = launchdTemplate
+	}
+	return textutil.ExecuteTemplate(
+		tmpToExecute,
+		map[string]string{
+			"Binary":   selfExeAbs,
+			"Instance": instName,
+			"WorkDir":  workDir,
+		})
+}

pkg/autostart/autostart_test.go

@@ -0,0 +1,124 @@
+package autostart
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestRenderTemplate(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skipping testing on windows host")
+	}
+	tests := []struct {
+		Name          string
+		InstanceName  string
+		HostOS        string
+		Expected      string
+		WorkDir       string
+		GetExecutable func() (string, error)
+	}{
+		{
+			Name:         "render darwin launchd plist",
+			InstanceName: "default",
+			HostOS:       "darwin",
+			Expected: `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>io.lima-vm.autostart.default</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/limactl</string>
+		<string>start</string>
+		<string>default</string>
+		<string>--foreground</string>
+	</array>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>StandardErrorPath</key>
+	<string>launchd.stderr.log</string>
+	<key>StandardOutPath</key>
+	<string>launchd.stdout.log</string>
+	<key>WorkingDirectory</key>
+	<string>/some/path</string>
+	<key>ProcessType</key>
+	<string>Background</string>
+</dict>
+</plist>`,
+			GetExecutable: func() (string, error) {
+				return "/limactl", nil
+			},
+			WorkDir: "/some/path",
+		},
+		{
+			Name:         "render linux systemd service",
+			InstanceName: "default",
+			HostOS:       "linux",
+			Expected: `[Unit]
+Description=Lima - Linux virtual machines, with a focus on running containers.
+Documentation=man:lima(1)
+
+[Service]
+ExecStart=/limactl start %i --foreground
+WorkingDirectory=%h
+Type=simple
+TimeoutSec=10
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target`,
+			GetExecutable: func() (string, error) {
+				return "/limactl", nil
+			},
+			WorkDir: "/some/path",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			tmpl, err := renderTemplate(tt.HostOS, tt.InstanceName, tt.WorkDir, tt.GetExecutable)
+			assert.NilError(t, err)
+			assert.Equal(t, string(tmpl), tt.Expected)
+		})
+	}
+}
+
+func TestGetFilePath(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skipping testing on windows host")
+	}
+	tests := []struct {
+		Name         string
+		HostOS       string
+		InstanceName string
+		HomeEnv      string
+		Expected     string
+	}{
+		{
+			Name:         "darwin with docker instance name",
+			HostOS:       "darwin",
+			InstanceName: "docker",
+			Expected:     "Library/LaunchAgents/io.lima-vm.autostart.docker.plist",
+		},
+		{
+			Name:         "linux with docker instance name",
+			HostOS:       "linux",
+			InstanceName: "docker",
+			Expected:     ".config/systemd/user/lima-vm@docker.service",
+		},
+		{
+			Name:         "empty with empty instance name",
+			HostOS:       "",
+			InstanceName: "",
+			Expected:     "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			assert.Check(t, strings.HasSuffix(GetStartAtLoginEntryPath(tt.HostOS, tt.InstanceName), tt.Expected))
+		})
+	}
+}