v1.0.9: fix PullImage on host, wait health none, push fallback to local image

Author: parv68

cli/cmd/push.go

@@ -73,13 +73,21 @@ func runPush(cmd *cobra.Command, args []string) error {
 		if err != nil {
 			return fmt.Errorf("list containers for %s: %w", name, err)
 		}
+		var sourceImage string
 		if len(containers) == 0 {
-			fmt.Fprintf(os.Stderr, "  Warning: no container found for service %s\n", name)
-			continue
+			// No running container — try to find a local image built by devbox build/start
+			sourceImage, _ = findLocalImage(ctx, dockerClient, "devbox-"+name+":latest")
+			if sourceImage == "" {
+				sourceImage, _ = findLocalImage(ctx, dockerClient, "devboxos-"+name+":latest")
+			}
+			if sourceImage == "" {
+				fmt.Fprintf(os.Stderr, "  Warning: no container or local image found for %s (run 'devbox build %s' first)\n", name, name)
+				continue
+			}
+		} else {
+			sourceImage = containers[0].Image
 		}
 
-		sourceImage := containers[0].Image
-
 		fmt.Printf("  Tagging %s -> %s...\n", sourceImage, pushTag)
 		if err := dockerClient.ImageTag(ctx, sourceImage, pushTag); err != nil {
 			return fmt.Errorf("tag image %s: %w", sourceImage, err)
@@ -127,3 +135,17 @@ func runPush(cmd *cobra.Command, args []string) error {
 	fmt.Println("✓ Push complete")
 	return nil
 }
+
+// findLocalImage checks if a Docker image exists locally by tag.
+func findLocalImage(ctx context.Context, dockerClient *client.Client, tag string) (string, error) {
+	images, err := dockerClient.ImageList(ctx, image.ListOptions{
+		Filters: filters.NewArgs(filters.Arg("reference", tag)),
+	})
+	if err != nil {
+		return "", err
+	}
+	if len(images) > 0 {
+		return tag, nil
+	}
+	return "", nil
+}

cli/cmd/restart.go

@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/devboxos/devboxos/cli/internal/client"
+	"github.com/devboxos/devboxos/cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+var restartCmd = &cobra.Command{
+	Use:   "restart",
+	Short: "Stop and restart all services",
+	Long:  `Stop all running services and start them again fresh from devbox.yml.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		dir, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("get working directory: %w", err)
+		}
+
+		conn, err := client.New()
+		if err != nil {
+			return fmt.Errorf("connect to engine: %w", err)
+		}
+		defer conn.Close()
+
+		output.Info("Stopping services...")
+		if err := conn.Stop(dir, ""); err != nil {
+			output.Warning("Stop failed: %v", err)
+		}
+
+		output.Info("Starting services...")
+		err = conn.Start(dir, func(status, msg string) {
+			switch status {
+			case "info":
+				output.Info("%s", msg)
+			case "error":
+				output.Error("%s", msg)
+			case "warning":
+				output.Warning("%s", msg)
+			default:
+				fmt.Println(msg)
+			}
+		})
+		if err != nil {
+			return fmt.Errorf("restart: %w", err)
+		}
+		output.Success("Environment restarted successfully")
+
+		printServiceURLs(dir)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(restartCmd)
+}

cli/cmd/start.go

@@ -3,9 +3,11 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"sort"
 
 	"github.com/devboxos/devboxos/cli/internal/client"
 	"github.com/devboxos/devboxos/cli/internal/output"
+	"github.com/devboxos/devboxos/shared/config"
 	"github.com/spf13/cobra"
 )
 
@@ -58,5 +60,51 @@ func runStart(cmd *cobra.Command, args []string) error {
 	}
 
 	output.Success("Environment started successfully")
+
+	printServiceURLs(dir)
 	return nil
 }
+
+func printServiceURLs(dir string) {
+	parser := config.NewParser()
+	cfg, err := parser.Parse(dir)
+	if err != nil {
+		return
+	}
+
+	names := make([]string, 0, len(cfg.Services))
+	for name := range cfg.Services {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	hasURLs := false
+	for _, name := range names {
+		svc := cfg.Services[name]
+		portStr := svc.Port
+		if portStr == "" && len(svc.Ports) > 0 {
+			portStr = svc.Ports[0]
+		}
+		if portStr == "" {
+			continue
+		}
+
+		hostPort := extractHostPort(portStr)
+		if hostPort == "" {
+			continue
+		}
+
+		protocol := svc.Protocol
+		if protocol == "" {
+			protocol = "http"
+		}
+
+		if !hasURLs {
+			fmt.Println()
+			output.Title("Access URLs")
+			hasURLs = true
+		}
+
+		fmt.Printf("  %-15s → %s://localhost:%s\n", name, protocol, hostPort)
+	}
+}

cli/cmd/upgrade.go

@@ -79,12 +79,11 @@ func runUpgrade(cmd *cobra.Command, args []string) error {
 }
 
 func getVersion() string {
-	// This would normally come from build-time ldflags
-	return "0.1.0-dev"
+	return version
 }
 
 func getLatestRelease() (*GitHubRelease, error) {
-	url := "https://api.github.com/repos/devboxos/devboxos/releases/latest"
+	url := "https://api.github.com/repos/parv68/DevBoxOS/releases/latest"
 	if upgradeVersion != "latest" {
 		url = fmt.Sprintf("https://api.github.com/repos/devboxos/devboxos/releases/tags/%s", upgradeVersion)
 	}

cli/cmd/validate.go

@@ -55,8 +55,8 @@ func runValidate(cmd *cobra.Command, args []string) error {
 	}
 
 	for name, svc := range cfg.Services {
-		if svc.Image == "" && (svc.Build == nil || svc.Build.Context == "") {
-			issues = append(issues, fmt.Sprintf("Service %q: must specify 'image' or 'build'", name))
+		if svc.Image == "" && (svc.Build == nil || svc.Build.Context == "") && svc.Command == "" && svc.Runtime == "" {
+			issues = append(issues, fmt.Sprintf("Service %q: must specify 'image', 'build', 'command', or 'runtime'", name))
 		}
 
 		if svc.Port != "" && svc.Ports != nil && len(svc.Ports) > 0 {

cli/cmd/wait.go

@@ -80,7 +80,7 @@ func waitForServiceViaEngine(ctx context.Context, cl *devboxclient.Client, servi
 
 		for _, svc := range resp.Services {
 			if svc.Name == serviceName {
-				if svc.Health == "healthy" || (svc.Health == "" && svc.Status == "running") {
+				if svc.Health == "healthy" || (svc.Health == "" || svc.Health == "none") && svc.Status == "running" {
 					return nil
 				}
 			}

engine/cmd/daemon.go

@@ -440,9 +440,12 @@ func (s *server) SnapshotList(ctx context.Context, req *pb.SnapshotListRequest)
 }
 
 func (s *server) SnapshotDelete(ctx context.Context, req *pb.SnapshotDeleteRequest) (*pb.StatusResponse, error) {
-	// Delete only needs filesystem access, not Docker
 	mgr := snapshot.NewManager(host.NewHostRuntime(), req.ProjectPath)
-	if err := mgr.Delete(req.SnapshotId); err != nil {
+	id, err := resolveSnapshotID(mgr, req.SnapshotId)
+	if err != nil {
+		return &pb.StatusResponse{Status: "error", Error: err.Error()}, nil
+	}
+	if err := mgr.Delete(id); err != nil {
 		return &pb.StatusResponse{Status: "error", Error: err.Error()}, nil
 	}
 	return &pb.StatusResponse{Status: "ok"}, nil
@@ -451,7 +454,6 @@ func (s *server) SnapshotDelete(ctx context.Context, req *pb.SnapshotDeleteReque
 func (s *server) SnapshotExport(req *pb.SnapshotExportRequest, stream pb.EngineService_SnapshotExportServer) error {
 	mgr := snapshot.NewManager(host.NewHostRuntime(), req.ProjectPath)
 
-	// If no snapshot ID provided, find the latest
 	snapshotID := req.SnapshotId
 	if snapshotID == "" {
 		infos, err := mgr.List()
@@ -460,6 +462,13 @@ func (s *server) SnapshotExport(req *pb.SnapshotExportRequest, stream pb.EngineS
 			return nil
 		}
 		snapshotID = infos[len(infos)-1].ID
+	} else {
+		id, err := resolveSnapshotID(mgr, snapshotID)
+		if err != nil {
+			stream.Send(&pb.StreamResponse{Status: "error", Error: err.Error(), Done: true})
+			return nil
+		}
+		snapshotID = id
 	}
 
 	statusChan := make(chan string, 64)
@@ -1009,3 +1018,27 @@ func main() {
 		log.Fatalf("Failed to serve: %v", err)
 	}
 }
+
+// resolveSnapshotID resolves a snapshot name or ID to a snapshot directory ID.
+func resolveSnapshotID(mgr *snapshot.Manager, input string) (string, error) {
+	// Try as ID first (fast path — directory exists)
+	infos, err := mgr.List()
+	if err != nil {
+		return "", fmt.Errorf("list snapshots: %w", err)
+	}
+
+	for _, info := range infos {
+		if info.ID == input || strings.HasPrefix(info.ID, input) {
+			return info.ID, nil
+		}
+	}
+
+	// Try as name
+	for _, info := range infos {
+		if info.Name == input {
+			return info.ID, nil
+		}
+	}
+
+	return "", fmt.Errorf("snapshot %q not found", input)
+}

engine/internal/orchestrator/lifecycle.go

@@ -4,9 +4,10 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	goruntime "runtime"
 	"time"
 
-	"github.com/devboxos/devboxos/shared/runtime"
+	sharedRuntime "github.com/devboxos/devboxos/shared/runtime"
 	"github.com/devboxos/devboxos/shared/secrets"
 	"github.com/devboxos/devboxos/shared/types"
 )
@@ -22,9 +23,9 @@ func NewLifecycle(resolver *secrets.Resolver) *Lifecycle {
 }
 
 // StartService starts a single service using the given runtime.
-func (l *Lifecycle) StartService(ctx context.Context, rt runtime.Runtime, name string, svc types.Service, networkName string, projectPath string, statusChan chan<- string) (string, error) {
+func (l *Lifecycle) StartService(ctx context.Context, rt sharedRuntime.Runtime, name string, svc types.Service, networkName string, projectPath string, statusChan chan<- string) (string, error) {
 	// Build container config
-	cfg := runtime.ContainerConfig{
+	cfg := sharedRuntime.ContainerConfig{
 		Name:       fmt.Sprintf("devbox-%s", name),
 		Image:      svc.Image,
 		Command:    parseCommand(svc.Command),
@@ -108,7 +109,7 @@ func (l *Lifecycle) StartService(ctx context.Context, rt runtime.Runtime, name s
 			contextDir = filepath.Join(projectPath, contextDir)
 		}
 
-		buildCfg := runtime.BuildConfig{
+		buildCfg := sharedRuntime.BuildConfig{
 			ContextDir: contextDir,
 			Dockerfile: svc.Build.Dockerfile,
 			BuildArgs:  svc.Build.Args,
@@ -120,8 +121,8 @@ func (l *Lifecycle) StartService(ctx context.Context, rt runtime.Runtime, name s
 			return "", fmt.Errorf("build image for %s: %w", name, err)
 		}
 		cfg.Image = builtImage
-	} else if svc.Image != "" {
-		// Pull image if no build config
+	} else if svc.Image != "" && svc.Command == "" {
+		// Pull image only for pure Docker services (image without command override)
 		if err := rt.PullImage(ctx, svc.Image); err != nil {
 			return "", fmt.Errorf("pull image %s: %w", svc.Image, err)
 		}
@@ -150,20 +151,20 @@ func (l *Lifecycle) StartService(ctx context.Context, rt runtime.Runtime, name s
 }
 
 // StopService stops a single service.
-func (l *Lifecycle) StopService(ctx context.Context, rt runtime.Runtime, containerID string, gracePeriod int) error {
+func (l *Lifecycle) StopService(ctx context.Context, rt sharedRuntime.Runtime, containerID string, gracePeriod int) error {
 	if err := rt.StopContainer(ctx, containerID, gracePeriod); err != nil {
 		return fmt.Errorf("stop container %s: %w", containerID, err)
 	}
 	return nil
 }
 
 // RemoveService removes a service container.
-func (l *Lifecycle) RemoveService(ctx context.Context, rt runtime.Runtime, containerID string) error {
+func (l *Lifecycle) RemoveService(ctx context.Context, rt sharedRuntime.Runtime, containerID string) error {
 	return rt.RemoveContainer(ctx, containerID, true)
 }
 
 // WaitForHealthy waits for a service to become healthy.
-func (l *Lifecycle) WaitForHealthy(ctx context.Context, rt runtime.Runtime, containerID string, svc types.Service) error {
+func (l *Lifecycle) WaitForHealthy(ctx context.Context, rt sharedRuntime.Runtime, containerID string, svc types.Service) error {
 	if svc.Healthcheck == nil {
 		// No health check defined, assume healthy after brief delay
 		time.Sleep(2 * time.Second)
@@ -217,6 +218,8 @@ func parseCommand(cmd string) []string {
 	if cmd == "" {
 		return nil
 	}
-	// Simple split — a real implementation would handle quotes
+	if goruntime.GOOS == "windows" {
+		return []string{"cmd", "/C", cmd}
+	}
 	return []string{"sh", "-c", cmd}
 }

engine/internal/orchestrator/lifecycle_test.go

@@ -1,6 +1,7 @@
 package orchestrator
 
 import (
+	goruntime "runtime"
 	"reflect"
 	"testing"
 )
@@ -12,25 +13,32 @@ func TestParseCommand_Empty(t *testing.T) {
 	}
 }
 
+func platformCommand(cmd string) []string {
+	if goruntime.GOOS == "windows" {
+		return []string{"cmd", "/C", cmd}
+	}
+	return []string{"sh", "-c", cmd}
+}
+
 func TestParseCommand_Simple(t *testing.T) {
 	result := parseCommand("npm start")
-	expected := []string{"sh", "-c", "npm start"}
+	expected := platformCommand("npm start")
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("parseCommand() = %v, want %v", result, expected)
 	}
 }
 
 func TestParseCommand_WithArgs(t *testing.T) {
 	result := parseCommand("node server.js --port 3000")
-	expected := []string{"sh", "-c", "node server.js --port 3000"}
+	expected := platformCommand("node server.js --port 3000")
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("parseCommand() = %v, want %v", result, expected)
 	}
 }
 
 func TestParseCommand_MultiWord(t *testing.T) {
 	result := parseCommand("echo hello world && sleep 10")
-	expected := []string{"sh", "-c", "echo hello world && sleep 10"}
+	expected := platformCommand("echo hello world && sleep 10")
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("parseCommand() = %v, want %v", result, expected)
 	}