Merge pull request #1640 from ktock/monitor-invoke-mode-restore

monitor: add `debug-shell` and `on-error`

build/build.go

@@ -920,7 +920,12 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opt map[s
 							}
 							results.Set(resultKey(dp.driverIndex, k), res)
 							if resultHandleFunc != nil {
-								resultHandleFunc(dp.driverIndex, &ResultContext{cc, res})
+								resultCtx, err := NewResultContext(cc, so, res)
+								if err == nil {
+									resultHandleFunc(dp.driverIndex, resultCtx)
+								} else {
+									logrus.Warnf("failed to record result: %s", err)
+								}
 							}
 							return res, nil
 						}

build/invoke.go

@@ -3,110 +3,68 @@ package build
 import (
 	"context"
 	_ "crypto/sha256" // ensure digests can be computed
-	"encoding/json"
-	"fmt"
 	"io"
 	"sync"
 	"sync/atomic"
 	"syscall"
 
 	controllerapi "github.com/docker/buildx/controller/pb"
-	"github.com/moby/buildkit/client"
-	"github.com/moby/buildkit/exporter/containerimage/exptypes"
 	gateway "github.com/moby/buildkit/frontend/gateway/client"
-	"github.com/moby/buildkit/solver/pb"
-	specs "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-// ResultContext is a build result with the client that built it.
-type ResultContext struct {
-	Client *client.Client
-	Res    *gateway.Result
-}
-
 type Container struct {
 	cancelOnce      sync.Once
 	containerCancel func()
-
 	isUnavailable   atomic.Bool
-
 	initStarted     atomic.Bool
-
 	container       gateway.Container
-	image     *specs.Image
-
 	releaseCh       chan struct{}
+	resultCtx       *ResultContext
 }
 
-func NewContainer(ctx context.Context, resultCtx *ResultContext) (*Container, error) {
+func NewContainer(ctx context.Context, resultCtx *ResultContext, cfg *controllerapi.InvokeConfig) (*Container, error) {
-	c, res := resultCtx.Client, resultCtx.Res
-
 	mainCtx := ctx
 
 	ctrCh := make(chan *Container)
 	errCh := make(chan error)
 	go func() {
-		_, err := c.Build(context.TODO(), client.SolveOpt{}, "buildx", func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
+		err := resultCtx.build(func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
 			ctx, cancel := context.WithCancel(ctx)
 			go func() {
 				<-mainCtx.Done()
 				cancel()
 			}()
 
-			if res.Ref == nil {
+			containerCfg, err := resultCtx.getContainerConfig(ctx, c, cfg)
-				return nil, errors.Errorf("no reference is registered")
-			}
-			st, err := res.Ref.ToState()
-			if err != nil {
-				return nil, err
-			}
-			def, err := st.Marshal(ctx)
-			if err != nil {
-				return nil, err
-			}
-			imgRef, err := c.Solve(ctx, gateway.SolveRequest{
-				Definition: def.ToPB(),
-			})
 			if err != nil {
 				return nil, err
 			}
 			containerCtx, containerCancel := context.WithCancel(ctx)
 			defer containerCancel()
-			bkContainer, err := c.NewContainer(containerCtx, gateway.NewContainerRequest{
+			bkContainer, err := c.NewContainer(containerCtx, containerCfg)
-				Mounts: []gateway.Mount{
-					{
-						Dest:      "/",
-						MountType: pb.MountType_BIND,
-						Ref:       imgRef.Ref,
-					},
-				},
-			})
 			if err != nil {
 				return nil, err
 			}
-			imgData := res.Metadata[exptypes.ExporterImageConfigKey]
-			var img *specs.Image
-			if len(imgData) > 0 {
-				img = &specs.Image{}
-				if err := json.Unmarshal(imgData, img); err != nil {
-					fmt.Println(err)
-					return nil, err
-				}
-			}
 			releaseCh := make(chan struct{})
 			container := &Container{
 				containerCancel: containerCancel,
 				container:       bkContainer,
-				image:           img,
 				releaseCh:       releaseCh,
+				resultCtx:       resultCtx,
 			}
+			doneCh := make(chan struct{})
+			defer close(doneCh)
+			resultCtx.registerCleanup(func() {
+				container.Cancel()
+				<-doneCh
+			})
 			ctrCh <- container
 			<-container.releaseCh
 
 			return nil, bkContainer.Release(ctx)
-		}, nil)
+		})
 		if err != nil {
 			errCh <- err
 		}
@@ -146,7 +104,7 @@ func (c *Container) Exec(ctx context.Context, cfg *controllerapi.InvokeConfig, s
 			c.markUnavailable()
 		}()
 	}
-	err := exec(ctx, cfg, c.container, c.image, stdin, stdout, stderr)
+	err := exec(ctx, c.resultCtx, cfg, c.container, stdin, stdout, stderr)
 	if err != nil {
 		// Container becomes unavailable if one of the processes fails in it.
 		c.markUnavailable()
@@ -154,48 +112,12 @@ func (c *Container) Exec(ctx context.Context, cfg *controllerapi.InvokeConfig, s
 	return err
 }
 
-func exec(ctx context.Context, cfg *controllerapi.InvokeConfig, ctr gateway.Container, img *specs.Image, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) error {
+func exec(ctx context.Context, resultCtx *ResultContext, cfg *controllerapi.InvokeConfig, ctr gateway.Container, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) error {
-	user := ""
+	processCfg, err := resultCtx.getProcessConfig(cfg, stdin, stdout, stderr)
-	if !cfg.NoUser {
+	if err != nil {
-		user = cfg.User
+		return err
-	} else if img != nil {
-		user = img.Config.User
 	}
-
+	proc, err := ctr.Start(ctx, processCfg)
-	cwd := ""
-	if !cfg.NoCwd {
-		cwd = cfg.Cwd
-	} else if img != nil {
-		cwd = img.Config.WorkingDir
-	}
-
-	env := []string{}
-	if img != nil {
-		env = append(env, img.Config.Env...)
-	}
-	env = append(env, cfg.Env...)
-
-	args := []string{}
-	if cfg.Entrypoint != nil {
-		args = append(args, cfg.Entrypoint...)
-	}
-	if cfg.Cmd != nil {
-		args = append(args, cfg.Cmd...)
-	}
-	// caller should always set args
-	if len(args) == 0 {
-		return errors.Errorf("specify args to execute")
-	}
-	proc, err := ctr.Start(ctx, gateway.StartRequest{
-		Args:   args,
-		Env:    env,
-		User:   user,
-		Cwd:    cwd,
-		Tty:    cfg.Tty,
-		Stdin:  stdin,
-		Stdout: stdout,
-		Stderr: stderr,
-	})
 	if err != nil {
 		return errors.Errorf("failed to start container: %v", err)
 	}

build/result.go

@@ -0,0 +1,365 @@
+package build
+
+import (
+	"context"
+	_ "crypto/sha256" // ensure digests can be computed
+	"encoding/json"
+	"io"
+	"sync"
+	"sync/atomic"
+
+	controllerapi "github.com/docker/buildx/controller/pb"
+	"github.com/moby/buildkit/client"
+	"github.com/moby/buildkit/exporter/containerimage/exptypes"
+	gateway "github.com/moby/buildkit/frontend/gateway/client"
+	"github.com/moby/buildkit/solver/errdefs"
+	"github.com/moby/buildkit/solver/pb"
+	specs "github.com/opencontainers/image-spec/specs-go/v1"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+func NewResultContext(c *client.Client, solveOpt client.SolveOpt, res *gateway.Result) (*ResultContext, error) {
+	ctx := context.Background()
+	def, err := getDefinition(ctx, res)
+	if err != nil {
+		return nil, err
+	}
+	return getResultAt(ctx, c, solveOpt, def, nil)
+}
+
+func getDefinition(ctx context.Context, res *gateway.Result) (*pb.Definition, error) {
+	ref, err := res.SingleRef()
+	if err != nil {
+		return nil, err
+	}
+	st, err := ref.ToState()
+	if err != nil {
+		return nil, err
+	}
+	def, err := st.Marshal(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return def.ToPB(), nil
+}
+
+func getResultAt(ctx context.Context, c *client.Client, solveOpt client.SolveOpt, target *pb.Definition, statusChan chan *client.SolveStatus) (*ResultContext, error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	// forward SolveStatus
+	done := new(atomic.Bool)
+	defer done.Store(true)
+	ch := make(chan *client.SolveStatus)
+	go func() {
+		for {
+			s := <-ch
+			if s == nil {
+				return
+			}
+			if done.Load() {
+				// Do not forward if the function returned because statusChan is possibly closed
+				continue
+			}
+			select {
+			case statusChan <- s:
+			case <-ctx.Done():
+			}
+		}
+	}()
+
+	// get result
+	resultCtxCh := make(chan *ResultContext)
+	errCh := make(chan error)
+	go func() {
+		_, err := c.Build(context.Background(), solveOpt, "buildx", func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
+			ctx, cancel := context.WithCancel(ctx)
+			defer cancel()
+			resultCtx := ResultContext{}
+			res2, err := c.Solve(ctx, gateway.SolveRequest{
+				Evaluate:   true,
+				Definition: target,
+			})
+			if err != nil {
+				var se *errdefs.SolveError
+				if errors.As(err, &se) {
+					resultCtx.solveErr = se
+				} else {
+					return nil, err
+				}
+			}
+			// Record the client and ctx as well so that containers can be created from the SolveError.
+			resultCtx.res = res2
+			resultCtx.gwClient = c
+			resultCtx.gwCtx = ctx
+			resultCtx.gwDone = cancel
+			select {
+			case resultCtxCh <- &resultCtx:
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			}
+			<-ctx.Done()
+			return nil, nil
+		}, ch)
+		if err != nil {
+			errCh <- err
+		}
+	}()
+
+	select {
+	case resultCtx := <-resultCtxCh:
+		return resultCtx, nil
+	case err := <-errCh:
+		return nil, err
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+// ResultContext is a build result with the client that built it.
+type ResultContext struct {
+	res      *gateway.Result
+	solveErr *errdefs.SolveError
+
+	gwClient   gateway.Client
+	gwCtx      context.Context
+	gwDone     func()
+	gwDoneOnce sync.Once
+
+	cleanups   []func()
+	cleanupsMu sync.Mutex
+}
+
+func (r *ResultContext) Done() {
+	r.gwDoneOnce.Do(func() {
+		r.cleanupsMu.Lock()
+		cleanups := r.cleanups
+		r.cleanups = nil
+		r.cleanupsMu.Unlock()
+		for _, f := range cleanups {
+			f()
+		}
+		r.gwDone()
+	})
+}
+
+func (r *ResultContext) registerCleanup(f func()) {
+	r.cleanupsMu.Lock()
+	r.cleanups = append(r.cleanups, f)
+	r.cleanupsMu.Unlock()
+}
+
+func (r *ResultContext) build(buildFunc gateway.BuildFunc) (err error) {
+	_, err = buildFunc(r.gwCtx, r.gwClient)
+	return err
+}
+
+func (r *ResultContext) getContainerConfig(ctx context.Context, c gateway.Client, cfg *controllerapi.InvokeConfig) (containerCfg gateway.NewContainerRequest, _ error) {
+	if r.res != nil && r.solveErr == nil {
+		logrus.Debugf("creating container from successful build")
+		ccfg, err := containerConfigFromResult(ctx, r.res, c, *cfg)
+		if err != nil {
+			return containerCfg, err
+		}
+		containerCfg = *ccfg
+	} else {
+		logrus.Debugf("creating container from failed build %+v", cfg)
+		ccfg, err := containerConfigFromError(r.solveErr, *cfg)
+		if err != nil {
+			return containerCfg, errors.Wrapf(err, "no result nor error is available")
+		}
+		containerCfg = *ccfg
+	}
+	return containerCfg, nil
+}
+
+func (r *ResultContext) getProcessConfig(cfg *controllerapi.InvokeConfig, stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) (_ gateway.StartRequest, err error) {
+	processCfg := newStartRequest(stdin, stdout, stderr)
+	if r.res != nil && r.solveErr == nil {
+		logrus.Debugf("creating container from successful build")
+		if err := populateProcessConfigFromResult(&processCfg, r.res, *cfg); err != nil {
+			return processCfg, err
+		}
+	} else {
+		logrus.Debugf("creating container from failed build %+v", cfg)
+		if err := populateProcessConfigFromError(&processCfg, r.solveErr, *cfg); err != nil {
+			return processCfg, err
+		}
+	}
+	return processCfg, nil
+}
+
+func containerConfigFromResult(ctx context.Context, res *gateway.Result, c gateway.Client, cfg controllerapi.InvokeConfig) (*gateway.NewContainerRequest, error) {
+	if res.Ref == nil {
+		return nil, errors.Errorf("no reference is registered")
+	}
+	if cfg.Initial {
+		return nil, errors.Errorf("starting from the container from the initial state of the step is supported only on the failed steps")
+	}
+	st, err := res.Ref.ToState()
+	if err != nil {
+		return nil, err
+	}
+	def, err := st.Marshal(ctx)
+	if err != nil {
+		return nil, err
+	}
+	imgRef, err := c.Solve(ctx, gateway.SolveRequest{
+		Definition: def.ToPB(),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &gateway.NewContainerRequest{
+		Mounts: []gateway.Mount{
+			{
+				Dest:      "/",
+				MountType: pb.MountType_BIND,
+				Ref:       imgRef.Ref,
+			},
+		},
+	}, nil
+}
+
+func populateProcessConfigFromResult(req *gateway.StartRequest, res *gateway.Result, cfg controllerapi.InvokeConfig) error {
+	imgData := res.Metadata[exptypes.ExporterImageConfigKey]
+	var img *specs.Image
+	if len(imgData) > 0 {
+		img = &specs.Image{}
+		if err := json.Unmarshal(imgData, img); err != nil {
+			return err
+		}
+	}
+
+	user := ""
+	if !cfg.NoUser {
+		user = cfg.User
+	} else if img != nil {
+		user = img.Config.User
+	}
+
+	cwd := ""
+	if !cfg.NoCwd {
+		cwd = cfg.Cwd
+	} else if img != nil {
+		cwd = img.Config.WorkingDir
+	}
+
+	env := []string{}
+	if img != nil {
+		env = append(env, img.Config.Env...)
+	}
+	env = append(env, cfg.Env...)
+
+	args := []string{}
+	if cfg.Entrypoint != nil {
+		args = append(args, cfg.Entrypoint...)
+	} else if img != nil {
+		args = append(args, img.Config.Entrypoint...)
+	}
+	if cfg.Cmd != nil {
+		args = append(args, cfg.Cmd...)
+	} else if img != nil {
+		args = append(args, img.Config.Cmd...)
+	}
+
+	req.Args = args
+	req.Env = env
+	req.User = user
+	req.Cwd = cwd
+	req.Tty = cfg.Tty
+
+	return nil
+}
+
+func containerConfigFromError(solveErr *errdefs.SolveError, cfg controllerapi.InvokeConfig) (*gateway.NewContainerRequest, error) {
+	exec, err := execOpFromError(solveErr)
+	if err != nil {
+		return nil, err
+	}
+	var mounts []gateway.Mount
+	for i, mnt := range exec.Mounts {
+		rid := solveErr.Solve.MountIDs[i]
+		if cfg.Initial {
+			rid = solveErr.Solve.InputIDs[i]
+		}
+		mounts = append(mounts, gateway.Mount{
+			Selector:  mnt.Selector,
+			Dest:      mnt.Dest,
+			ResultID:  rid,
+			Readonly:  mnt.Readonly,
+			MountType: mnt.MountType,
+			CacheOpt:  mnt.CacheOpt,
+			SecretOpt: mnt.SecretOpt,
+			SSHOpt:    mnt.SSHOpt,
+		})
+	}
+	return &gateway.NewContainerRequest{
+		Mounts:  mounts,
+		NetMode: exec.Network,
+	}, nil
+}
+
+func populateProcessConfigFromError(req *gateway.StartRequest, solveErr *errdefs.SolveError, cfg controllerapi.InvokeConfig) error {
+	exec, err := execOpFromError(solveErr)
+	if err != nil {
+		return err
+	}
+	meta := exec.Meta
+	user := ""
+	if !cfg.NoUser {
+		user = cfg.User
+	} else {
+		user = meta.User
+	}
+
+	cwd := ""
+	if !cfg.NoCwd {
+		cwd = cfg.Cwd
+	} else {
+		cwd = meta.Cwd
+	}
+
+	env := append(meta.Env, cfg.Env...)
+
+	args := []string{}
+	if cfg.Entrypoint != nil {
+		args = append(args, cfg.Entrypoint...)
+	}
+	if cfg.Cmd != nil {
+		args = append(args, cfg.Cmd...)
+	}
+	if len(args) == 0 {
+		args = meta.Args
+	}
+
+	req.Args = args
+	req.Env = env
+	req.User = user
+	req.Cwd = cwd
+	req.Tty = cfg.Tty
+
+	return nil
+}
+
+func execOpFromError(solveErr *errdefs.SolveError) (*pb.ExecOp, error) {
+	if solveErr == nil {
+		return nil, errors.Errorf("no error is available")
+	}
+	switch op := solveErr.Solve.Op.GetOp().(type) {
+	case *pb.Op_Exec:
+		return op.Exec, nil
+	default:
+		return nil, errors.Errorf("invoke: unsupported error type")
+	}
+	// TODO: support other ops
+}
+
+func newStartRequest(stdin io.ReadCloser, stdout io.WriteCloser, stderr io.WriteCloser) gateway.StartRequest {
+	return gateway.StartRequest{
+		Stdin:  stdin,
+		Stdout: stdout,
+		Stderr: stderr,
+	}
+}

commands/build.go

@@ -18,6 +18,7 @@ import (
 	"github.com/docker/buildx/controller"
 	cbuild "github.com/docker/buildx/controller/build"
 	"github.com/docker/buildx/controller/control"
+	controllererrors "github.com/docker/buildx/controller/errdefs"
 	controllerapi "github.com/docker/buildx/controller/pb"
 	"github.com/docker/buildx/monitor"
 	"github.com/docker/buildx/store"
@@ -67,7 +68,8 @@ type buildOptions struct {
 	target         string
 	ulimits        *dockeropts.UlimitOpt
 
-	invoke string
+	invoke  *invokeConfig
+	noBuild bool
 
 	attests    []string
 	sbom       string
@@ -229,6 +231,7 @@ func runBuild(dockerCli command.Cli, in buildOptions) error {
 func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	options := buildOptions{}
 	cFlags := &commonFlags{}
+	var invokeFlag string
 
 	cmd := &cobra.Command{
 		Use:     "build [OPTIONS] PATH | URL | -",
@@ -250,6 +253,14 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 			options.progress = cFlags.progress
 			cmd.Flags().VisitAll(checkWarnedFlags)
 			if isExperimental() {
+				if invokeFlag != "" {
+					invokeConfig, err := parseInvokeConfig(invokeFlag)
+					if err != nil {
+						return err
+					}
+					options.invoke = &invokeConfig
+					options.noBuild = invokeFlag == "debug-shell"
+				}
 				return launchControllerAndRunBuild(dockerCli, options)
 			}
 			return runBuild(dockerCli, options)
@@ -324,7 +335,7 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	flags.StringVar(&options.provenance, "provenance", "", `Shortand for "--attest=type=provenance"`)
 
 	if isExperimental() {
-		flags.StringVar(&options.invoke, "invoke", "", "Invoke a command after the build [experimental]")
+		flags.StringVar(&invokeFlag, "invoke", "", "Invoke a command after the build [experimental]")
 		flags.StringVar(&options.Root, "root", "", "Specify root directory of server to connect [experimental]")
 		flags.BoolVar(&options.Detach, "detach", runtime.GOOS == "linux", "Detach buildx server (supported only on linux) [experimental]")
 		flags.StringVar(&options.ServerConfig, "server-config", "", "Specify buildx server config file (used only when launching new server) [experimental]")
@@ -486,18 +497,10 @@ func updateLastActivity(dockerCli command.Cli, ng *store.NodeGroup) error {
 func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) error {
 	ctx := context.TODO()
 
-	if options.invoke != "" && (options.dockerfileName == "-" || options.contextPath == "-") {
+	if options.invoke != nil && (options.dockerfileName == "-" || options.contextPath == "-") {
 		// stdin must be usable for monitor
 		return errors.Errorf("Dockerfile or context from stdin is not supported with invoke")
 	}
-	var invokeConfig controllerapi.InvokeConfig
-	if inv := options.invoke; inv != "" {
-		var err error
-		invokeConfig, err = parseInvokeConfig(inv)
-		if err != nil {
-			return err
-		}
-	}
 
 	c, err := controller.NewController(ctx, options.ControlOptions, dockerCli)
 	if err != nil {
@@ -509,15 +512,7 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 		}
 	}()
 
-	f := ioset.NewSingleForwarder()
+	// Start build
-	pr, pw := io.Pipe()
-	f.SetWriter(pw, func() io.WriteCloser {
-		pw.Close() // propagate EOF
-		logrus.Debug("propagating stdin close")
-		return nil
-	})
-	f.SetReader(os.Stdin)
-
 	opts, err := options.toControllerOptions()
 	if err != nil {
 		return err
@@ -527,14 +522,6 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 		return err
 	}
 
-	// Avoid leaving a stale file if we eventually fail
-	if options.imageIDFile != "" {
-		if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) {
-			return errors.Wrap(err, "removing image ID file")
-		}
-	}
-
-	// Start build
 	// NOTE: buildx server has the current working directory different from the client
 	// so we need to resolve paths to abosolute ones in the client.
 	optsP, err := resolvePaths(&opts)
@@ -542,9 +529,37 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 		return err
 	}
 	opts = *optsP
-	ref, resp, err := c.Build(ctx, opts, pr, os.Stdout, os.Stderr, progress)
+
+	var ref string
+	var retErr error
+	f := ioset.NewSingleForwarder()
+	f.SetReader(os.Stdin)
+	if !options.noBuild {
+		pr, pw := io.Pipe()
+		f.SetWriter(pw, func() io.WriteCloser {
+			pw.Close() // propagate EOF
+			logrus.Debug("propagating stdin close")
+			return nil
+		})
+
+		// Avoid leaving a stale file if we eventually fail
+		if options.imageIDFile != "" {
+			if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) {
+				return errors.Wrap(err, "removing image ID file")
+			}
+		}
+
+		var resp *client.SolveResponse
+		ref, resp, err = c.Build(ctx, opts, pr, os.Stdout, os.Stderr, progress)
 		if err != nil {
-		return errors.Wrapf(err, "failed to build") // TODO: allow invoke even on error
+			var be *controllererrors.BuildError
+			if errors.As(err, &be) {
+				ref = be.Ref
+				retErr = err
+				// We can proceed to monitor
+			} else {
+				return errors.Wrapf(err, "failed to build")
+			}
 		}
 		if err := pw.Close(); err != nil {
 			logrus.Debug("failed to close stdin pipe writer")
@@ -564,8 +579,10 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 			return os.WriteFile(options.imageIDFile, []byte(dgst), 0644)
 		}
 
+	}
+
 	// post-build operations
-	if options.invoke != "" {
+	if options.invoke != nil && options.invoke.needsMonitor(retErr) {
 		pr2, pw2 := io.Pipe()
 		f.SetWriter(pw2, func() io.WriteCloser {
 			pw2.Close() // propagate EOF
@@ -578,7 +595,7 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 			}
 			return errors.Errorf("failed to configure terminal: %v", err)
 		}
-		err = monitor.RunMonitor(ctx, ref, opts, invokeConfig, c, options.progress, pr2, os.Stdout, os.Stderr)
+		err = monitor.RunMonitor(ctx, ref, &opts, options.invoke.InvokeConfig, c, progress, pr2, os.Stdout, os.Stderr)
 		con.Reset()
 		if err := pw2.Close(); err != nil {
 			logrus.Debug("failed to close monitor stdin pipe reader")
@@ -594,9 +611,33 @@ func launchControllerAndRunBuild(dockerCli command.Cli, options buildOptions) er
 	return nil
 }
 
-func parseInvokeConfig(invoke string) (cfg controllerapi.InvokeConfig, err error) {
+type invokeConfig struct {
+	controllerapi.InvokeConfig
+	invokeFlag string
+}
+
+func (cfg *invokeConfig) needsMonitor(retErr error) bool {
+	switch cfg.invokeFlag {
+	case "debug-shell":
+		return true
+	case "on-error":
+		return retErr != nil
+	default:
+		return cfg.invokeFlag != ""
+	}
+}
+
+func parseInvokeConfig(invoke string) (cfg invokeConfig, err error) {
+	cfg.invokeFlag = invoke
 	cfg.Tty = true
-	if invoke == "default" {
+	switch invoke {
+	case "default", "debug-shell":
+		return cfg, nil
+	case "on-error":
+		// NOTE: we overwrite the command to run because the original one should fail on the failed step.
+		// TODO: make this configurable via flags or restorable from LLB.
+		// Discussion: https://github.com/docker/buildx/pull/1640#discussion_r1113295900
+		cfg.Cmd = []string{"/bin/sh"}
 		return cfg, nil
 	}
 

commands/debug-shell.go

@@ -0,0 +1,63 @@
+package commands
+
+import (
+	"context"
+	"os"
+	"runtime"
+
+	"github.com/containerd/console"
+	"github.com/docker/buildx/controller"
+	"github.com/docker/buildx/controller/control"
+	controllerapi "github.com/docker/buildx/controller/pb"
+	"github.com/docker/buildx/monitor"
+	"github.com/docker/cli/cli/command"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+func debugShellCmd(dockerCli command.Cli) *cobra.Command {
+	var options control.ControlOptions
+	var progress string
+
+	cmd := &cobra.Command{
+		Use:   "debug-shell",
+		Short: "Start a monitor",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := context.TODO()
+			c, err := controller.NewController(ctx, options, dockerCli)
+			if err != nil {
+				return err
+			}
+			defer func() {
+				if err := c.Close(); err != nil {
+					logrus.Warnf("failed to close server connection %v", err)
+				}
+			}()
+			con := console.Current()
+			if err := con.SetRaw(); err != nil {
+				return errors.Errorf("failed to configure terminal: %v", err)
+			}
+			err = monitor.RunMonitor(ctx, "", nil, controllerapi.InvokeConfig{
+				Tty: true,
+			}, c, progress, os.Stdin, os.Stdout, os.Stderr)
+			con.Reset()
+			return err
+		},
+	}
+
+	flags := cmd.Flags()
+
+	flags.StringVar(&options.Root, "root", "", "Specify root directory of server to connect [experimental]")
+	flags.BoolVar(&options.Detach, "detach", runtime.GOOS == "linux", "Detach buildx server (supported only on linux) [experimental]")
+	flags.StringVar(&options.ServerConfig, "server-config", "", "Specify buildx server config file (used only when launching new server) [experimental]")
+	flags.StringVar(&progress, "progress", "auto", `Set type of progress output ("auto", "plain", "tty"). Use plain to show container output`)
+
+	return cmd
+}
+
+func addDebugShellCommand(cmd *cobra.Command, dockerCli command.Cli) {
+	cmd.AddCommand(
+		debugShellCmd(dockerCli),
+	)
+}

commands/root.go

@@ -89,6 +89,7 @@ func addCommands(cmd *cobra.Command, dockerCli command.Cli) {
 	)
 	if isExperimental() {
 		remote.AddControllerCommands(cmd, dockerCli)
+		addDebugShellCommand(cmd, dockerCli)
 	}
 }
 

controller/build/build.go

@@ -41,6 +41,11 @@ import (
 
 const defaultTargetName = "default"
 
+// RunBuild runs the specified build and returns the result.
+//
+// NOTE: When an error happens during the build and this function acquires the debuggable *build.ResultContext,
+// this function returns it in addition to the error (i.e. it does "return nil, res, err"). The caller can
+// inspect the result and debug the cause of that error.
 func RunBuild(ctx context.Context, dockerCli command.Cli, in controllerapi.BuildOptions, inStream io.Reader, progressMode string, statusChan chan *client.SolveStatus) (*client.SolveResponse, *build.ResultContext, error) {
 	if in.NoCache && len(in.NoCacheFilter) > 0 {
 		return nil, nil, errors.Errorf("--no-cache and --no-cache-filter cannot currently be used together")
@@ -177,11 +182,17 @@ func RunBuild(ctx context.Context, dockerCli command.Cli, in controllerapi.Build
 	resp, res, err := buildTargets(ctx, dockerCli, b.NodeGroup, nodes, map[string]build.Options{defaultTargetName: opts}, progressMode, in.MetadataFile, statusChan)
 	err = wrapBuildError(err, false)
 	if err != nil {
-		return nil, nil, err
+		// NOTE: buildTargets can return *build.ResultContext even on error.
+		return nil, res, err
 	}
 	return resp, res, nil
 }
 
+// buildTargets runs the specified build and returns the result.
+//
+// NOTE: When an error happens during the build and this function acquires the debuggable *build.ResultContext,
+// this function returns it in addition to the error (i.e. it does "return nil, res, err"). The caller can
+// inspect the result and debug the cause of that error.
 func buildTargets(ctx context.Context, dockerCli command.Cli, ng *store.NodeGroup, nodes []builder.Node, opts map[string]build.Options, progressMode string, metadataFile string, statusChan chan *client.SolveStatus) (*client.SolveResponse, *build.ResultContext, error) {
 	ctx2, cancel := context.WithCancel(context.TODO())
 	defer cancel()
@@ -209,7 +220,7 @@ func buildTargets(ctx context.Context, dockerCli command.Cli, ng *store.NodeGrou
 		err = err1
 	}
 	if err != nil {
-		return nil, nil, err
+		return nil, res, err
 	}
 
 	if len(metadataFile) > 0 && resp != nil {

controller/control/controller.go

@@ -22,6 +22,7 @@ type BuildxController interface {
 	Disconnect(ctx context.Context, ref string) error
 	ListProcesses(ctx context.Context, ref string) (infos []*controllerapi.ProcessInfo, retErr error)
 	DisconnectProcess(ctx context.Context, ref, pid string) error
+	Inspect(ctx context.Context, ref string) (*controllerapi.InspectResponse, error)
 }
 
 type ControlOptions struct {

controller/errdefs/build.go

@@ -0,0 +1,34 @@
+package errdefs
+
+import (
+	"github.com/containerd/typeurl/v2"
+	"github.com/moby/buildkit/util/grpcerrors"
+)
+
+func init() {
+	typeurl.Register((*Build)(nil), "github.com/docker/buildx", "errdefs.Build+json")
+}
+
+type BuildError struct {
+	Build
+	error
+}
+
+func (e *BuildError) Unwrap() error {
+	return e.error
+}
+
+func (e *BuildError) ToProto() grpcerrors.TypedErrorProto {
+	return &e.Build
+}
+
+func WrapBuild(err error, ref string) error {
+	if err == nil {
+		return nil
+	}
+	return &BuildError{Build: Build{Ref: ref}, error: err}
+}
+
+func (b *Build) WrapError(err error) error {
+	return &BuildError{error: err, Build: *b}
+}

controller/errdefs/errdefs.pb.go

@@ -0,0 +1,77 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: errdefs.proto
+
+package errdefs
+
+import (
+	fmt "fmt"
+	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/moby/buildkit/solver/pb"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+type Build struct {
+	Ref                  string   `protobuf:"bytes,1,opt,name=Ref,proto3" json:"Ref,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Build) Reset()         { *m = Build{} }
+func (m *Build) String() string { return proto.CompactTextString(m) }
+func (*Build) ProtoMessage()    {}
+func (*Build) Descriptor() ([]byte, []int) {
+	return fileDescriptor_689dc58a5060aff5, []int{0}
+}
+func (m *Build) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Build.Unmarshal(m, b)
+}
+func (m *Build) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Build.Marshal(b, m, deterministic)
+}
+func (m *Build) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Build.Merge(m, src)
+}
+func (m *Build) XXX_Size() int {
+	return xxx_messageInfo_Build.Size(m)
+}
+func (m *Build) XXX_DiscardUnknown() {
+	xxx_messageInfo_Build.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Build proto.InternalMessageInfo
+
+func (m *Build) GetRef() string {
+	if m != nil {
+		return m.Ref
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Build)(nil), "errdefs.Build")
+}
+
+func init() { proto.RegisterFile("errdefs.proto", fileDescriptor_689dc58a5060aff5) }
+
+var fileDescriptor_689dc58a5060aff5 = []byte{
+	// 111 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0x2d, 0x2a, 0x4a,
+	0x49, 0x4d, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x87, 0x72, 0xa5, 0x74, 0xd2,
+	0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x73, 0xf3, 0x93, 0x2a, 0xf5, 0x93,
+	0x4a, 0x33, 0x73, 0x52, 0xb2, 0x33, 0x4b, 0xf4, 0x8b, 0xf3, 0x73, 0xca, 0x52, 0x8b, 0xf4, 0x0b,
+	0x92, 0xf4, 0xf3, 0x0b, 0xa0, 0xda, 0x94, 0x24, 0xb9, 0x58, 0x9d, 0x40, 0xf2, 0x42, 0x02, 0x5c,
+	0xcc, 0x41, 0xa9, 0x69, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x20, 0x66, 0x12, 0x1b, 0x58,
+	0x85, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x56, 0x52, 0x41, 0x91, 0x69, 0x00, 0x00, 0x00,
+}

controller/errdefs/errdefs.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+package errdefs;
+
+import "github.com/moby/buildkit/solver/pb/ops.proto";
+
+message Build {
+  string Ref = 1;
+}

controller/errdefs/generate.go

@@ -0,0 +1,3 @@
+package errdefs
+
+//go:generate protoc -I=. -I=../../vendor/ --gogo_out=plugins=grpc:. errdefs.proto

controller/local/controller.go

@@ -9,6 +9,7 @@ import (
 	"github.com/docker/buildx/build"
 	cbuild "github.com/docker/buildx/controller/build"
 	"github.com/docker/buildx/controller/control"
+	controllererrors "github.com/docker/buildx/controller/errdefs"
 	controllerapi "github.com/docker/buildx/controller/pb"
 	"github.com/docker/buildx/controller/processes"
 	"github.com/docker/buildx/util/ioset"
@@ -25,10 +26,17 @@ func NewLocalBuildxController(ctx context.Context, dockerCli command.Cli) contro
 	}
 }
 
+type buildConfig struct {
+	// TODO: these two structs should be merged
+	// Discussion: https://github.com/docker/buildx/pull/1640#discussion_r1113279719
+	resultCtx    *build.ResultContext
+	buildOptions *controllerapi.BuildOptions
+}
+
 type localController struct {
 	dockerCli   command.Cli
 	ref         string
-	resultCtx *build.ResultContext
+	buildConfig buildConfig
 	processes   *processes.Manager
 
 	buildOnGoing atomic.Bool
@@ -40,11 +48,20 @@ func (b *localController) Build(ctx context.Context, options controllerapi.Build
 	}
 	defer b.buildOnGoing.Store(false)
 
-	resp, res, err := cbuild.RunBuild(ctx, b.dockerCli, options, in, progressMode, nil)
+	resp, res, buildErr := cbuild.RunBuild(ctx, b.dockerCli, options, in, progressMode, nil)
-	if err != nil {
+	// NOTE: RunBuild can return *build.ResultContext even on error.
-		return "", nil, err
+	if res != nil {
+		b.buildConfig = buildConfig{
+			resultCtx:    res,
+			buildOptions: &options,
+		}
+		if buildErr != nil {
+			buildErr = controllererrors.WrapBuild(buildErr, b.ref)
+		}
+	}
+	if buildErr != nil {
+		return "", nil, buildErr
 	}
-	b.resultCtx = res
 	return b.ref, resp, nil
 }
 
@@ -74,11 +91,11 @@ func (b *localController) Invoke(ctx context.Context, ref string, pid string, cf
 	proc, ok := b.processes.Get(pid)
 	if !ok {
 		// Start a new process.
-		if b.resultCtx == nil {
+		if b.buildConfig.resultCtx == nil {
 			return errors.New("no build result is registered")
 		}
 		var err error
-		proc, err = b.processes.StartProcess(pid, b.resultCtx, &cfg)
+		proc, err = b.processes.StartProcess(pid, b.buildConfig.resultCtx, &cfg)
 		if err != nil {
 			return err
 		}
@@ -99,12 +116,15 @@ func (b *localController) Invoke(ctx context.Context, ref string, pid string, cf
 }
 
 func (b *localController) Kill(context.Context) error {
-	b.cancelRunningProcesses()
+	b.Close()
 	return nil
 }
 
 func (b *localController) Close() error {
 	b.cancelRunningProcesses()
+	if b.buildConfig.resultCtx != nil {
+		b.buildConfig.resultCtx.Done()
+	}
 	// TODO: cancel ongoing builds?
 	return nil
 }
@@ -114,6 +134,13 @@ func (b *localController) List(ctx context.Context) (res []string, _ error) {
 }
 
 func (b *localController) Disconnect(ctx context.Context, key string) error {
-	b.cancelRunningProcesses()
+	b.Close()
 	return nil
 }
+
+func (b *localController) Inspect(ctx context.Context, ref string) (*controllerapi.InspectResponse, error) {
+	if ref != b.ref {
+		return nil, errors.Errorf("unknown ref %q", ref)
+	}
+	return &controllerapi.InspectResponse{Options: b.buildConfig.buildOptions}, nil
+}

controller/pb/controller.pb.go

@@ -777,6 +777,82 @@ func (m *Secret) GetEnv() string {
 	return ""
 }
 
+type InspectRequest struct {
+	Ref                  string   `protobuf:"bytes,1,opt,name=Ref,proto3" json:"Ref,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InspectRequest) Reset()         { *m = InspectRequest{} }
+func (m *InspectRequest) String() string { return proto.CompactTextString(m) }
+func (*InspectRequest) ProtoMessage()    {}
+func (*InspectRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ed7f10298fa1d90f, []int{12}
+}
+func (m *InspectRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InspectRequest.Unmarshal(m, b)
+}
+func (m *InspectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InspectRequest.Marshal(b, m, deterministic)
+}
+func (m *InspectRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InspectRequest.Merge(m, src)
+}
+func (m *InspectRequest) XXX_Size() int {
+	return xxx_messageInfo_InspectRequest.Size(m)
+}
+func (m *InspectRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_InspectRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InspectRequest proto.InternalMessageInfo
+
+func (m *InspectRequest) GetRef() string {
+	if m != nil {
+		return m.Ref
+	}
+	return ""
+}
+
+type InspectResponse struct {
+	Options              *BuildOptions `protobuf:"bytes,1,opt,name=Options,proto3" json:"Options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *InspectResponse) Reset()         { *m = InspectResponse{} }
+func (m *InspectResponse) String() string { return proto.CompactTextString(m) }
+func (*InspectResponse) ProtoMessage()    {}
+func (*InspectResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ed7f10298fa1d90f, []int{13}
+}
+func (m *InspectResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InspectResponse.Unmarshal(m, b)
+}
+func (m *InspectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InspectResponse.Marshal(b, m, deterministic)
+}
+func (m *InspectResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InspectResponse.Merge(m, src)
+}
+func (m *InspectResponse) XXX_Size() int {
+	return xxx_messageInfo_InspectResponse.Size(m)
+}
+func (m *InspectResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_InspectResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InspectResponse proto.InternalMessageInfo
+
+func (m *InspectResponse) GetOptions() *BuildOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
 type UlimitOpt struct {
 	Values               map[string]*Ulimit `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
@@ -788,7 +864,7 @@ func (m *UlimitOpt) Reset()         { *m = UlimitOpt{} }
 func (m *UlimitOpt) String() string { return proto.CompactTextString(m) }
 func (*UlimitOpt) ProtoMessage()    {}
 func (*UlimitOpt) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{12}
+	return fileDescriptor_ed7f10298fa1d90f, []int{14}
 }
 func (m *UlimitOpt) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UlimitOpt.Unmarshal(m, b)
@@ -828,7 +904,7 @@ func (m *Ulimit) Reset()         { *m = Ulimit{} }
 func (m *Ulimit) String() string { return proto.CompactTextString(m) }
 func (*Ulimit) ProtoMessage()    {}
 func (*Ulimit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{13}
+	return fileDescriptor_ed7f10298fa1d90f, []int{15}
 }
 func (m *Ulimit) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Ulimit.Unmarshal(m, b)
@@ -880,7 +956,7 @@ func (m *BuildResponse) Reset()         { *m = BuildResponse{} }
 func (m *BuildResponse) String() string { return proto.CompactTextString(m) }
 func (*BuildResponse) ProtoMessage()    {}
 func (*BuildResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{14}
+	return fileDescriptor_ed7f10298fa1d90f, []int{16}
 }
 func (m *BuildResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BuildResponse.Unmarshal(m, b)
@@ -918,7 +994,7 @@ func (m *DisconnectRequest) Reset()         { *m = DisconnectRequest{} }
 func (m *DisconnectRequest) String() string { return proto.CompactTextString(m) }
 func (*DisconnectRequest) ProtoMessage()    {}
 func (*DisconnectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{15}
+	return fileDescriptor_ed7f10298fa1d90f, []int{17}
 }
 func (m *DisconnectRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DisconnectRequest.Unmarshal(m, b)
@@ -955,7 +1031,7 @@ func (m *DisconnectResponse) Reset()         { *m = DisconnectResponse{} }
 func (m *DisconnectResponse) String() string { return proto.CompactTextString(m) }
 func (*DisconnectResponse) ProtoMessage()    {}
 func (*DisconnectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{16}
+	return fileDescriptor_ed7f10298fa1d90f, []int{18}
 }
 func (m *DisconnectResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DisconnectResponse.Unmarshal(m, b)
@@ -986,7 +1062,7 @@ func (m *ListRequest) Reset()         { *m = ListRequest{} }
 func (m *ListRequest) String() string { return proto.CompactTextString(m) }
 func (*ListRequest) ProtoMessage()    {}
 func (*ListRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{17}
+	return fileDescriptor_ed7f10298fa1d90f, []int{19}
 }
 func (m *ListRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListRequest.Unmarshal(m, b)
@@ -1024,7 +1100,7 @@ func (m *ListResponse) Reset()         { *m = ListResponse{} }
 func (m *ListResponse) String() string { return proto.CompactTextString(m) }
 func (*ListResponse) ProtoMessage()    {}
 func (*ListResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{18}
+	return fileDescriptor_ed7f10298fa1d90f, []int{20}
 }
 func (m *ListResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListResponse.Unmarshal(m, b)
@@ -1065,7 +1141,7 @@ func (m *InputMessage) Reset()         { *m = InputMessage{} }
 func (m *InputMessage) String() string { return proto.CompactTextString(m) }
 func (*InputMessage) ProtoMessage()    {}
 func (*InputMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{19}
+	return fileDescriptor_ed7f10298fa1d90f, []int{21}
 }
 func (m *InputMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputMessage.Unmarshal(m, b)
@@ -1139,7 +1215,7 @@ func (m *InputInitMessage) Reset()         { *m = InputInitMessage{} }
 func (m *InputInitMessage) String() string { return proto.CompactTextString(m) }
 func (*InputInitMessage) ProtoMessage()    {}
 func (*InputInitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{20}
+	return fileDescriptor_ed7f10298fa1d90f, []int{22}
 }
 func (m *InputInitMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputInitMessage.Unmarshal(m, b)
@@ -1178,7 +1254,7 @@ func (m *DataMessage) Reset()         { *m = DataMessage{} }
 func (m *DataMessage) String() string { return proto.CompactTextString(m) }
 func (*DataMessage) ProtoMessage()    {}
 func (*DataMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{21}
+	return fileDescriptor_ed7f10298fa1d90f, []int{23}
 }
 func (m *DataMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DataMessage.Unmarshal(m, b)
@@ -1222,7 +1298,7 @@ func (m *InputResponse) Reset()         { *m = InputResponse{} }
 func (m *InputResponse) String() string { return proto.CompactTextString(m) }
 func (*InputResponse) ProtoMessage()    {}
 func (*InputResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{22}
+	return fileDescriptor_ed7f10298fa1d90f, []int{24}
 }
 func (m *InputResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputResponse.Unmarshal(m, b)
@@ -1258,7 +1334,7 @@ func (m *Message) Reset()         { *m = Message{} }
 func (m *Message) String() string { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()    {}
 func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{23}
+	return fileDescriptor_ed7f10298fa1d90f, []int{25}
 }
 func (m *Message) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Message.Unmarshal(m, b)
@@ -1360,7 +1436,7 @@ func (m *InitMessage) Reset()         { *m = InitMessage{} }
 func (m *InitMessage) String() string { return proto.CompactTextString(m) }
 func (*InitMessage) ProtoMessage()    {}
 func (*InitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{24}
+	return fileDescriptor_ed7f10298fa1d90f, []int{26}
 }
 func (m *InitMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InitMessage.Unmarshal(m, b)
@@ -1411,6 +1487,7 @@ type InvokeConfig struct {
 	NoCwd                bool     `protobuf:"varint,7,opt,name=NoCwd,proto3" json:"NoCwd,omitempty"`
 	Tty                  bool     `protobuf:"varint,8,opt,name=Tty,proto3" json:"Tty,omitempty"`
 	Rollback             bool     `protobuf:"varint,9,opt,name=Rollback,proto3" json:"Rollback,omitempty"`
+	Initial              bool     `protobuf:"varint,10,opt,name=Initial,proto3" json:"Initial,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1420,7 +1497,7 @@ func (m *InvokeConfig) Reset()         { *m = InvokeConfig{} }
 func (m *InvokeConfig) String() string { return proto.CompactTextString(m) }
 func (*InvokeConfig) ProtoMessage()    {}
 func (*InvokeConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{25}
+	return fileDescriptor_ed7f10298fa1d90f, []int{27}
 }
 func (m *InvokeConfig) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InvokeConfig.Unmarshal(m, b)
@@ -1503,6 +1580,13 @@ func (m *InvokeConfig) GetRollback() bool {
 	return false
 }
 
+func (m *InvokeConfig) GetInitial() bool {
+	if m != nil {
+		return m.Initial
+	}
+	return false
+}
+
 type FdMessage struct {
 	Fd                   uint32   `protobuf:"varint,1,opt,name=Fd,proto3" json:"Fd,omitempty"`
 	EOF                  bool     `protobuf:"varint,2,opt,name=EOF,proto3" json:"EOF,omitempty"`
@@ -1516,7 +1600,7 @@ func (m *FdMessage) Reset()         { *m = FdMessage{} }
 func (m *FdMessage) String() string { return proto.CompactTextString(m) }
 func (*FdMessage) ProtoMessage()    {}
 func (*FdMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{26}
+	return fileDescriptor_ed7f10298fa1d90f, []int{28}
 }
 func (m *FdMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FdMessage.Unmarshal(m, b)
@@ -1569,7 +1653,7 @@ func (m *ResizeMessage) Reset()         { *m = ResizeMessage{} }
 func (m *ResizeMessage) String() string { return proto.CompactTextString(m) }
 func (*ResizeMessage) ProtoMessage()    {}
 func (*ResizeMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{27}
+	return fileDescriptor_ed7f10298fa1d90f, []int{29}
 }
 func (m *ResizeMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResizeMessage.Unmarshal(m, b)
@@ -1616,7 +1700,7 @@ func (m *SignalMessage) Reset()         { *m = SignalMessage{} }
 func (m *SignalMessage) String() string { return proto.CompactTextString(m) }
 func (*SignalMessage) ProtoMessage()    {}
 func (*SignalMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{28}
+	return fileDescriptor_ed7f10298fa1d90f, []int{30}
 }
 func (m *SignalMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalMessage.Unmarshal(m, b)
@@ -1654,7 +1738,7 @@ func (m *StatusRequest) Reset()         { *m = StatusRequest{} }
 func (m *StatusRequest) String() string { return proto.CompactTextString(m) }
 func (*StatusRequest) ProtoMessage()    {}
 func (*StatusRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{29}
+	return fileDescriptor_ed7f10298fa1d90f, []int{31}
 }
 func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatusRequest.Unmarshal(m, b)
@@ -1695,7 +1779,7 @@ func (m *StatusResponse) Reset()         { *m = StatusResponse{} }
 func (m *StatusResponse) String() string { return proto.CompactTextString(m) }
 func (*StatusResponse) ProtoMessage()    {}
 func (*StatusResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{30}
+	return fileDescriptor_ed7f10298fa1d90f, []int{32}
 }
 func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatusResponse.Unmarshal(m, b)
@@ -1753,7 +1837,7 @@ func (m *InfoRequest) Reset()         { *m = InfoRequest{} }
 func (m *InfoRequest) String() string { return proto.CompactTextString(m) }
 func (*InfoRequest) ProtoMessage()    {}
 func (*InfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{31}
+	return fileDescriptor_ed7f10298fa1d90f, []int{33}
 }
 func (m *InfoRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoRequest.Unmarshal(m, b)
@@ -1784,7 +1868,7 @@ func (m *InfoResponse) Reset()         { *m = InfoResponse{} }
 func (m *InfoResponse) String() string { return proto.CompactTextString(m) }
 func (*InfoResponse) ProtoMessage()    {}
 func (*InfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{32}
+	return fileDescriptor_ed7f10298fa1d90f, []int{34}
 }
 func (m *InfoResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoResponse.Unmarshal(m, b)
@@ -1824,7 +1908,7 @@ func (m *BuildxVersion) Reset()         { *m = BuildxVersion{} }
 func (m *BuildxVersion) String() string { return proto.CompactTextString(m) }
 func (*BuildxVersion) ProtoMessage()    {}
 func (*BuildxVersion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{33}
+	return fileDescriptor_ed7f10298fa1d90f, []int{35}
 }
 func (m *BuildxVersion) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BuildxVersion.Unmarshal(m, b)
@@ -1883,6 +1967,8 @@ func init() {
 	proto.RegisterType((*Attest)(nil), "buildx.controller.v1.Attest")
 	proto.RegisterType((*SSH)(nil), "buildx.controller.v1.SSH")
 	proto.RegisterType((*Secret)(nil), "buildx.controller.v1.Secret")
+	proto.RegisterType((*InspectRequest)(nil), "buildx.controller.v1.InspectRequest")
+	proto.RegisterType((*InspectResponse)(nil), "buildx.controller.v1.InspectResponse")
 	proto.RegisterType((*UlimitOpt)(nil), "buildx.controller.v1.UlimitOpt")
 	proto.RegisterMapType((map[string]*Ulimit)(nil), "buildx.controller.v1.UlimitOpt.ValuesEntry")
 	proto.RegisterType((*Ulimit)(nil), "buildx.controller.v1.Ulimit")
@@ -1912,119 +1998,122 @@ func init() {
 func init() { proto.RegisterFile("controller.proto", fileDescriptor_ed7f10298fa1d90f) }
 
 var fileDescriptor_ed7f10298fa1d90f = []byte{
-	// 1779 bytes of a gzipped FileDescriptorProto
+	// 1832 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x5f, 0x73, 0x1b, 0x49,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x5f, 0x6f, 0xdb, 0xc8,
-	0x11, 0x67, 0x25, 0x59, 0x7f, 0x5a, 0x96, 0xcf, 0x19, 0x9c, 0x63, 0xa2, 0x84, 0x8b, 0xb3, 0x09,
+	0x11, 0x2f, 0x25, 0x59, 0x7f, 0x46, 0x96, 0xe3, 0x6c, 0x9d, 0xeb, 0x86, 0x49, 0x2f, 0x0e, 0x93,
-	0x87, 0x8a, 0x50, 0xf2, 0x9d, 0x8f, 0x23, 0x97, 0x4b, 0xa8, 0xc2, 0x96, 0xad, 0xb2, 0xaf, 0xe2,
+	0xbb, 0x0a, 0x4d, 0x21, 0xdf, 0xf9, 0x7a, 0xcd, 0xe5, 0x72, 0x05, 0x6a, 0xcb, 0x16, 0xec, 0x43,
-	0x3f, 0x35, 0x72, 0x72, 0x05, 0x54, 0x91, 0x5a, 0x49, 0x63, 0x79, 0x4b, 0xab, 0x1d, 0xb1, 0x33,
+	0xfc, 0x07, 0x94, 0x93, 0x43, 0x5b, 0xa0, 0x07, 0x4a, 0x5a, 0xcb, 0x84, 0x28, 0xae, 0xca, 0x5d,
-	0xb2, 0x2d, 0x9e, 0x78, 0xe1, 0x95, 0xef, 0x41, 0xf1, 0xca, 0x1b, 0x4f, 0x7c, 0x07, 0x3e, 0x08,
+	0xd9, 0x56, 0x9f, 0xfa, 0xd2, 0xb7, 0xa2, 0xdf, 0xa3, 0xe8, 0x47, 0xe8, 0x53, 0xbf, 0x50, 0xd1,
-	0x8f, 0x3c, 0x52, 0xd3, 0x33, 0x2b, 0xad, 0x2c, 0xad, 0x6c, 0xc3, 0x93, 0xa6, 0x7b, 0x7f, 0xbf,
+	0xc7, 0x3e, 0x16, 0x3b, 0xbb, 0xa4, 0x28, 0x4b, 0x94, 0xed, 0xde, 0x93, 0x76, 0x86, 0xbf, 0xdf,
-	0x9e, 0xe9, 0xde, 0x9e, 0xee, 0x5e, 0xc1, 0x7a, 0x47, 0x84, 0x2a, 0x12, 0x41, 0xc0, 0xa3, 0xfa,
+	0xec, 0xce, 0x70, 0x76, 0x66, 0x44, 0x58, 0xef, 0xf2, 0x50, 0x46, 0x3c, 0x08, 0x58, 0xd4, 0x18,
-	0x30, 0x12, 0x4a, 0x90, 0x8d, 0xf6, 0xc8, 0x0f, 0xba, 0xd7, 0xf5, 0xc4, 0x83, 0xcb, 0x2f, 0xab,
+	0x45, 0x5c, 0x72, 0xb2, 0xd1, 0x19, 0xfb, 0x41, 0xef, 0xba, 0x91, 0x7a, 0x70, 0xf9, 0xb9, 0xfd,
-	0x6f, 0x7a, 0xbe, 0xba, 0x18, 0xb5, 0xeb, 0x1d, 0x31, 0xd8, 0x1a, 0x88, 0xf6, 0x78, 0x0b, 0x51,
+	0xb6, 0xef, 0xcb, 0x8b, 0x71, 0xa7, 0xd1, 0xe5, 0xc3, 0xad, 0x21, 0xef, 0x4c, 0xb6, 0x10, 0x35,
-	0x7d, 0x5f, 0x6d, 0x79, 0x43, 0x7f, 0x4b, 0xf2, 0xe8, 0xd2, 0xef, 0x70, 0xb9, 0x65, 0x49, 0xf1,
+	0xf0, 0xe5, 0x96, 0x37, 0xf2, 0xb7, 0x04, 0x8b, 0x2e, 0xfd, 0x2e, 0x13, 0x5b, 0x86, 0x14, 0xff,
-	0xaf, 0x31, 0xe9, 0xd6, 0x60, 0xe3, 0x9d, 0x2f, 0xd5, 0x69, 0x24, 0x3a, 0x5c, 0x4a, 0x2e, 0x19,
+	0x6a, 0x93, 0x4e, 0x1d, 0x36, 0xde, 0xf9, 0x42, 0x9e, 0x46, 0xbc, 0xcb, 0x84, 0x60, 0xc2, 0x65,
-	0xff, 0xc3, 0x88, 0x4b, 0x45, 0xd6, 0x21, 0xcb, 0xf8, 0x39, 0x75, 0x36, 0x9d, 0x5a, 0x89, 0xe9,
+	0x7f, 0x1c, 0x33, 0x21, 0xc9, 0x3a, 0xe4, 0x5d, 0x76, 0x4e, 0xad, 0x4d, 0xab, 0x5e, 0x71, 0xd5,
-	0xa5, 0x7b, 0x0a, 0x0f, 0x6f, 0x20, 0xe5, 0x50, 0x84, 0x92, 0x93, 0x57, 0xb0, 0x72, 0x18, 0x9e,
+	0xd2, 0x39, 0x85, 0x47, 0x37, 0x90, 0x62, 0xc4, 0x43, 0xc1, 0xc8, 0x6b, 0x58, 0x39, 0x0c, 0xcf,
-	0x0b, 0x49, 0x9d, 0xcd, 0x6c, 0xad, 0xbc, 0xfd, 0xac, 0xbe, 0xe8, 0x94, 0x75, 0xcb, 0xd3, 0x48,
+	0xb9, 0xa0, 0xd6, 0x66, 0xbe, 0x5e, 0xdd, 0x7e, 0xde, 0x58, 0x74, 0xca, 0x86, 0xe1, 0x29, 0xa4,
-	0x66, 0xf0, 0xae, 0x84, 0x72, 0x42, 0x4b, 0x9e, 0x40, 0x29, 0x16, 0xf7, 0xec, 0xc6, 0x53, 0x05,
+	0xab, 0xf1, 0x8e, 0x80, 0x6a, 0x4a, 0x4b, 0x9e, 0x42, 0x25, 0x16, 0xf7, 0xcc, 0xc6, 0x53, 0x05,
-	0x69, 0xc2, 0xea, 0x61, 0x78, 0x29, 0xfa, 0xbc, 0x21, 0xc2, 0x73, 0xbf, 0x47, 0x33, 0x9b, 0x4e,
+	0x69, 0xc1, 0xea, 0x61, 0x78, 0xc9, 0x07, 0xac, 0xc9, 0xc3, 0x73, 0xbf, 0x4f, 0x73, 0x9b, 0x56,
-	0xad, 0xbc, 0xed, 0x2e, 0xde, 0x2c, 0x89, 0x64, 0x33, 0x3c, 0xf7, 0x3b, 0xa0, 0x7b, 0xbe, 0xec,
+	0xbd, 0xba, 0xed, 0x2c, 0xde, 0x2c, 0x8d, 0x74, 0x67, 0x78, 0xce, 0xb7, 0x40, 0xf7, 0x7c, 0xd1,
-	0x88, 0x30, 0xe4, 0x9d, 0xd8, 0x99, 0x54, 0xa7, 0x67, 0xcf, 0x94, 0xb9, 0x71, 0x26, 0xf7, 0x31,
+	0xe5, 0x61, 0xc8, 0xba, 0xb1, 0x33, 0x99, 0x4e, 0xcf, 0x9e, 0x29, 0x77, 0xe3, 0x4c, 0xce, 0x13,
-	0x3c, 0x5a, 0x60, 0xcb, 0x84, 0xc5, 0xfd, 0x3d, 0xac, 0xee, 0xea, 0xb3, 0xa5, 0x1b, 0x7f, 0x0b,
+	0x78, 0xbc, 0xc0, 0x96, 0x0e, 0x8b, 0xf3, 0x07, 0x58, 0xdd, 0x55, 0x67, 0xcb, 0x36, 0xfe, 0x0d,
-	0x85, 0x93, 0xa1, 0xf2, 0x45, 0x28, 0x97, 0x7b, 0x83, 0x66, 0x2c, 0x92, 0xc5, 0x14, 0xf7, 0x3f,
+	0x94, 0x4e, 0x46, 0xd2, 0xe7, 0xa1, 0x58, 0xee, 0x0d, 0x9a, 0x31, 0x48, 0x37, 0xa6, 0x38, 0xff,
-	0x60, 0x37, 0xb0, 0x0a, 0xb2, 0x09, 0xe5, 0x86, 0x08, 0x15, 0xbf, 0x56, 0xa7, 0x9e, 0xba, 0xb0,
+	0x05, 0xb3, 0x81, 0x51, 0x90, 0x4d, 0xa8, 0x36, 0x79, 0x28, 0xd9, 0xb5, 0x3c, 0xf5, 0xe4, 0x85,
-	0x1b, 0x25, 0x55, 0xe4, 0x73, 0x58, 0xdb, 0x13, 0x9d, 0x3e, 0x8f, 0xce, 0xfd, 0x80, 0x1f, 0x7b,
+	0xd9, 0x28, 0xad, 0x22, 0x9f, 0xc2, 0xda, 0x1e, 0xef, 0x0e, 0x58, 0x74, 0xee, 0x07, 0xec, 0xd8,
-	0x03, 0x6e, 0x5d, 0xba, 0xa1, 0x35, 0x5e, 0xfb, 0xa1, 0x6a, 0x8e, 0xc2, 0x0e, 0xcd, 0xc6, 0x5e,
+	0x1b, 0x32, 0xe3, 0xd2, 0x0d, 0xad, 0xf6, 0xda, 0x0f, 0x65, 0x6b, 0x1c, 0x76, 0x69, 0x3e, 0xf6,
-	0x5b, 0x05, 0xf9, 0x1d, 0x54, 0x34, 0xaa, 0x6b, 0x2d, 0x4b, 0x9a, 0xc3, 0xf7, 0xfe, 0xf5, 0xed,
+	0xda, 0x28, 0xc8, 0xef, 0xa1, 0xa6, 0x50, 0x3d, 0x63, 0x59, 0xd0, 0x02, 0xbe, 0xf7, 0x2f, 0x6f,
-	0x87, 0xaf, 0xcf, 0xf0, 0xf6, 0x43, 0x15, 0x8d, 0xd9, 0xac, 0x2d, 0xb2, 0x01, 0x2b, 0x3b, 0x41,
+	0x3f, 0x7c, 0x63, 0x86, 0xb7, 0x1f, 0xca, 0x68, 0xe2, 0xce, 0xda, 0x22, 0x1b, 0xb0, 0xb2, 0x13,
-	0x20, 0xae, 0xe8, 0xca, 0x66, 0xb6, 0x56, 0x62, 0x46, 0x20, 0xbf, 0x84, 0xc2, 0x8e, 0x52, 0x5c,
+	0x04, 0xfc, 0x8a, 0xae, 0x6c, 0xe6, 0xeb, 0x15, 0x57, 0x0b, 0xe4, 0x57, 0x50, 0xda, 0x91, 0x92,
-	0x2a, 0x49, 0xf3, 0xb8, 0xd9, 0x93, 0xc5, 0x9b, 0x19, 0x10, 0x8b, 0xc1, 0xe4, 0x04, 0x4a, 0xb8,
+	0x09, 0x29, 0x68, 0x11, 0x37, 0x7b, 0xba, 0x78, 0x33, 0x0d, 0x72, 0x63, 0x30, 0x39, 0x81, 0x0a,
-	0xff, 0x4e, 0xd4, 0x93, 0xb4, 0x80, 0xcc, 0x2f, 0xef, 0x70, 0xcc, 0x09, 0xc7, 0x1c, 0x71, 0x6a,
+	0xee, 0xbf, 0x13, 0xf5, 0x05, 0x2d, 0x21, 0xf3, 0xf3, 0x3b, 0x1c, 0x33, 0xe1, 0xe8, 0x23, 0x4e,
-	0x83, 0xec, 0x43, 0xa9, 0xe1, 0x75, 0x2e, 0x78, 0x33, 0x12, 0x03, 0x5a, 0x44, 0x83, 0x3f, 0x5d,
+	0x6d, 0x90, 0x7d, 0xa8, 0x34, 0xbd, 0xee, 0x05, 0x6b, 0x45, 0x7c, 0x48, 0xcb, 0x68, 0xf0, 0x67,
-	0x6c, 0x10, 0x61, 0xd6, 0xa0, 0x35, 0x33, 0x61, 0x92, 0x1d, 0x28, 0xa0, 0x70, 0x26, 0x68, 0xe9,
+	0x8b, 0x0d, 0x22, 0xcc, 0x18, 0x34, 0x66, 0x12, 0x26, 0xd9, 0x81, 0x12, 0x0a, 0x67, 0x9c, 0x56,
-	0x7e, 0x46, 0x62, 0x1e, 0x71, 0x61, 0xb5, 0xd1, 0x8b, 0xc4, 0x68, 0x78, 0xea, 0x45, 0x3c, 0x54,
+	0xee, 0x67, 0x24, 0xe6, 0x11, 0x07, 0x56, 0x9b, 0xfd, 0x88, 0x8f, 0x47, 0xa7, 0x5e, 0xc4, 0x42,
-	0x14, 0xf0, 0x35, 0xcd, 0xe8, 0xc8, 0x1b, 0x28, 0xec, 0x5f, 0x0f, 0x45, 0xa4, 0x24, 0x2d, 0x2f,
+	0x49, 0x01, 0x5f, 0xd3, 0x8c, 0x8e, 0xbc, 0x85, 0xd2, 0xfe, 0xf5, 0x88, 0x47, 0x52, 0xd0, 0xea,
-	0xbb, 0x9b, 0x06, 0x64, 0x37, 0xb0, 0x0c, 0xf2, 0x19, 0xc0, 0xfe, 0xb5, 0x8a, 0xbc, 0x03, 0xa1,
+	0xb2, 0xbb, 0xa9, 0x41, 0x66, 0x03, 0xc3, 0x20, 0x1f, 0x03, 0xec, 0x5f, 0xcb, 0xc8, 0x3b, 0xe0,
-	0xc3, 0xbe, 0x8a, 0xaf, 0x23, 0xa1, 0x21, 0x4d, 0xc8, 0xbf, 0xf3, 0xda, 0x3c, 0x90, 0xb4, 0x82,
+	0x2a, 0xec, 0xab, 0xf8, 0x3a, 0x52, 0x1a, 0xd2, 0x82, 0xe2, 0x3b, 0xaf, 0xc3, 0x02, 0x41, 0x6b,
-	0xb6, 0xeb, 0x77, 0x08, 0xac, 0x21, 0x98, 0x8d, 0x2c, 0x5b, 0xa7, 0xed, 0x31, 0x57, 0x57, 0x22,
+	0x68, 0xbb, 0x71, 0x87, 0xc0, 0x6a, 0x82, 0xde, 0xc8, 0xb0, 0x55, 0xda, 0x1e, 0x33, 0x79, 0xc5,
-	0xea, 0x1f, 0x89, 0x2e, 0xa7, 0x6b, 0x26, 0x6d, 0x13, 0x2a, 0xf2, 0x02, 0x2a, 0xc7, 0xc2, 0x04,
+	0xa3, 0xc1, 0x11, 0xef, 0x31, 0xba, 0xa6, 0xd3, 0x36, 0xa5, 0x22, 0x2f, 0xa1, 0x76, 0xcc, 0x75,
-	0xcf, 0x0f, 0x14, 0x8f, 0xe8, 0x27, 0x78, 0x98, 0x59, 0x25, 0x26, 0x6d, 0xe0, 0xa9, 0x73, 0x11,
+	0xf0, 0xfc, 0x40, 0xb2, 0x88, 0x3e, 0xc0, 0xc3, 0xcc, 0x2a, 0x31, 0x69, 0x03, 0x4f, 0x9e, 0xf3,
-	0x0d, 0x24, 0x5d, 0x47, 0xc4, 0x54, 0xa1, 0x33, 0xa8, 0xc5, 0x3b, 0x11, 0x57, 0x92, 0x3e, 0x58,
+	0x68, 0x28, 0xe8, 0x3a, 0x22, 0xa6, 0x0a, 0x95, 0x41, 0x6d, 0xd6, 0x8d, 0x98, 0x14, 0xf4, 0xe1,
-	0x96, 0x41, 0x06, 0xc4, 0x62, 0x30, 0xa1, 0x50, 0x68, 0x5d, 0x0c, 0x5a, 0xfe, 0x1f, 0x39, 0x25,
+	0xb2, 0x0c, 0xd2, 0x20, 0x37, 0x06, 0x13, 0x0a, 0xa5, 0xf6, 0xc5, 0xb0, 0xed, 0xff, 0x89, 0x51,
-	0x9b, 0x4e, 0x2d, 0xcb, 0x62, 0x91, 0xbc, 0x84, 0x6c, 0xab, 0x75, 0x40, 0x7f, 0x88, 0xd6, 0x1e,
+	0xb2, 0x69, 0xd5, 0xf3, 0x6e, 0x2c, 0x92, 0x57, 0x90, 0x6f, 0xb7, 0x0f, 0xe8, 0x8f, 0xd1, 0xda,
-	0xa5, 0x58, 0x6b, 0x1d, 0x30, 0x8d, 0x22, 0x04, 0x72, 0x67, 0x5e, 0x4f, 0xd2, 0x0d, 0x3c, 0x17,
+	0xe3, 0x0c, 0x6b, 0xed, 0x03, 0x57, 0xa1, 0x08, 0x81, 0xc2, 0x99, 0xd7, 0x17, 0x74, 0x03, 0xcf,
-	0xae, 0xc9, 0xa7, 0x90, 0x3f, 0xf3, 0xa2, 0x1e, 0x57, 0xf4, 0x21, 0xfa, 0x6c, 0x25, 0xf2, 0x1a,
+	0x85, 0x6b, 0xf2, 0x11, 0x14, 0xcf, 0xbc, 0xa8, 0xcf, 0x24, 0x7d, 0x84, 0x3e, 0x1b, 0x89, 0xbc,
-	0x0a, 0xef, 0x03, 0x7f, 0xe0, 0x2b, 0x49, 0x3f, 0xc5, 0xb2, 0xf0, 0x74, 0xb1, 0x71, 0x03, 0x3a,
+	0x81, 0xd2, 0xfb, 0xc0, 0x1f, 0xfa, 0x52, 0xd0, 0x8f, 0xb0, 0x2c, 0x3c, 0x5b, 0x6c, 0x5c, 0x83,
-	0x19, 0x2a, 0x16, 0xe3, 0xf5, 0x69, 0x31, 0xde, 0x3c, 0xa2, 0x3f, 0x42, 0x9b, 0xb1, 0xa8, 0xd3,
+	0x4e, 0x46, 0xd2, 0x8d, 0xf1, 0xea, 0xb4, 0x18, 0x6f, 0x16, 0xd1, 0x9f, 0xa0, 0xcd, 0x58, 0x54,
-	0xe5, 0x88, 0x2b, 0xaf, 0xeb, 0x29, 0xaf, 0xe9, 0x07, 0x9c, 0x52, 0x93, 0x2e, 0x49, 0x9d, 0x66,
+	0xe9, 0x72, 0xc4, 0xa4, 0xd7, 0xf3, 0xa4, 0xd7, 0xf2, 0x03, 0x46, 0xa9, 0x4e, 0x97, 0xb4, 0x4e,
-	0xdb, 0x90, 0xd2, 0x47, 0x9b, 0x4e, 0xad, 0xc8, 0x62, 0x51, 0x1f, 0xff, 0x74, 0x14, 0x04, 0xb4,
+	0xb1, 0x4d, 0x48, 0xe9, 0xe3, 0x4d, 0xab, 0x5e, 0x76, 0x63, 0x51, 0x1d, 0xff, 0x74, 0x1c, 0x04,
-	0x8a, 0x6a, 0x5c, 0x9b, 0xfc, 0xd0, 0xa9, 0x72, 0x3a, 0x92, 0x17, 0xf4, 0x31, 0x3e, 0x49, 0x68,
+	0xd4, 0x46, 0x35, 0xae, 0x75, 0x7e, 0xa8, 0x54, 0x39, 0x1d, 0x8b, 0x0b, 0xfa, 0x04, 0x9f, 0xa4,
-	0xa6, 0xcf, 0xdf, 0x09, 0xaf, 0x4b, 0x9f, 0x24, 0x9f, 0x6b, 0x4d, 0xf5, 0xd7, 0x40, 0xe6, 0xcb,
+	0x34, 0xd3, 0xe7, 0xef, 0xb8, 0xd7, 0xa3, 0x4f, 0xd3, 0xcf, 0x95, 0xc6, 0xfe, 0x0d, 0x90, 0xf9,
-	0x81, 0xae, 0x92, 0x7d, 0x3e, 0x8e, 0xab, 0x64, 0x9f, 0x8f, 0x75, 0x45, 0xb8, 0xf4, 0x82, 0x51,
+	0x72, 0xa0, 0xaa, 0xe4, 0x80, 0x4d, 0xe2, 0x2a, 0x39, 0x60, 0x13, 0x55, 0x11, 0x2e, 0xbd, 0x60,
-	0x5c, 0xab, 0x8c, 0xf0, 0x6d, 0xe6, 0x1b, 0xa7, 0xfa, 0x16, 0xd6, 0x66, 0x6f, 0xea, 0xbd, 0xd8,
+	0x1c, 0xd7, 0x2a, 0x2d, 0x7c, 0x9d, 0xfb, 0xca, 0xb2, 0xbf, 0x81, 0xb5, 0xd9, 0x9b, 0x7a, 0x2f,
-	0xaf, 0xa1, 0x9c, 0x48, 0xc7, 0xfb, 0x50, 0xdd, 0x7f, 0x3a, 0x50, 0x4e, 0xdc, 0x19, 0x7c, 0xbb,
+	0xf6, 0x1b, 0xa8, 0xa6, 0xd2, 0xf1, 0x3e, 0x54, 0xe7, 0x5f, 0x16, 0x54, 0x53, 0x77, 0x06, 0xdf,
-	0xe3, 0x21, 0xb7, 0x64, 0x5c, 0x93, 0x5d, 0x58, 0xd9, 0x51, 0x2a, 0xd2, 0xa5, 0x5d, 0x27, 0xc8,
+	0xee, 0x64, 0xc4, 0x0c, 0x19, 0xd7, 0x64, 0x17, 0x56, 0x76, 0xa4, 0x8c, 0x54, 0x69, 0x57, 0x09,
-	0xcf, 0x6f, 0xbd, 0x79, 0x75, 0x84, 0x9b, 0xbb, 0x61, 0xa8, 0xfa, 0x6a, 0xec, 0x71, 0xa9, 0xfc,
+	0xf2, 0x8b, 0x5b, 0x6f, 0x5e, 0x03, 0xe1, 0xfa, 0x6e, 0x68, 0xaa, 0xba, 0x1a, 0x7b, 0x4c, 0x48,
-	0xd0, 0xd3, 0xd7, 0xc7, 0x56, 0xe2, 0xa4, 0xaa, 0xfa, 0x0d, 0xc0, 0x94, 0x76, 0x2f, 0x1f, 0xfe,
+	0x3f, 0xf4, 0xd4, 0xf5, 0x31, 0x95, 0x38, 0xad, 0xb2, 0xbf, 0x02, 0x98, 0xd2, 0xee, 0xe5, 0xc3,
-	0xe6, 0xc0, 0x83, 0xb9, 0xf2, 0xb2, 0xd0, 0x93, 0x83, 0x59, 0x4f, 0xb6, 0xef, 0x58, 0xaa, 0xe6,
+	0x3f, 0x2c, 0x78, 0x38, 0x57, 0x5e, 0x16, 0x7a, 0x72, 0x30, 0xeb, 0xc9, 0xf6, 0x1d, 0x4b, 0xd5,
-	0xfd, 0xf9, 0x3f, 0x4e, 0x7b, 0x0c, 0x79, 0x53, 0xd3, 0x17, 0x9e, 0xb0, 0x0a, 0xc5, 0x3d, 0x5f,
+	0xbc, 0x3f, 0x3f, 0xe0, 0xb4, 0xc7, 0x50, 0xd4, 0x35, 0x7d, 0xe1, 0x09, 0x6d, 0x28, 0xef, 0xf9,
-	0x7a, 0xed, 0x80, 0x77, 0x91, 0x5a, 0x64, 0x13, 0x19, 0x1b, 0x0a, 0x9e, 0xde, 0x44, 0xcf, 0x08,
+	0xc2, 0xeb, 0x04, 0xac, 0x87, 0xd4, 0xb2, 0x9b, 0xc8, 0xd8, 0x50, 0xf0, 0xf4, 0x3a, 0x7a, 0x5a,
-	0xae, 0xb9, 0xbc, 0x64, 0x0d, 0x32, 0x93, 0x59, 0x23, 0x73, 0xb8, 0xa7, 0xc1, 0xba, 0x51, 0x1a,
+	0x70, 0xf4, 0xe5, 0x25, 0x6b, 0x90, 0x4b, 0x66, 0x8d, 0xdc, 0xe1, 0x9e, 0x02, 0xab, 0x46, 0xa9,
-	0x57, 0x4b, 0xcc, 0x08, 0x6e, 0x13, 0xf2, 0xa6, 0x1c, 0xcc, 0xe1, 0xab, 0x50, 0xd4, 0x37, 0x07,
+	0x5d, 0xad, 0xb8, 0x5a, 0x70, 0x5a, 0x50, 0xd4, 0xe5, 0x60, 0x0e, 0x6f, 0x43, 0x59, 0xdd, 0x1c,
-	0xfb, 0xad, 0x39, 0xf3, 0x44, 0xd6, 0xee, 0xed, 0x87, 0x97, 0x76, 0x5b, 0xbd, 0x74, 0xff, 0xea,
+	0xec, 0xb7, 0xfa, 0xcc, 0x89, 0xac, 0xdc, 0xdb, 0x0f, 0x2f, 0xcd, 0xb6, 0x6a, 0xe9, 0x38, 0xb0,
-	0x40, 0x69, 0x72, 0x69, 0x49, 0x03, 0xf2, 0xe8, 0x5f, 0x3c, 0x37, 0xbd, 0xbc, 0xe5, 0x96, 0xd7,
+	0x76, 0x18, 0x8a, 0x11, 0xeb, 0xca, 0xec, 0x29, 0xeb, 0x04, 0x1e, 0x24, 0x18, 0x33, 0x5f, 0xa5,
-	0x3f, 0x20, 0xda, 0x16, 0x4f, 0x43, 0xad, 0x7e, 0x0f, 0xe5, 0x84, 0x7a, 0x41, 0x48, 0xb7, 0x93,
+	0xc6, 0x04, 0xeb, 0xfe, 0x63, 0xc2, 0xdf, 0x2d, 0xa8, 0x24, 0x95, 0x82, 0x34, 0xa1, 0x88, 0x41,
-	0x21, 0x4d, 0xad, 0x7a, 0x66, 0x93, 0x64, 0xc0, 0xf7, 0x20, 0x6f, 0x94, 0x3a, 0xe0, 0x38, 0x2a,
+	0x8d, 0x87, 0xb5, 0x57, 0xb7, 0x94, 0x96, 0xc6, 0x07, 0x44, 0x9b, 0x8a, 0xad, 0xa9, 0xf6, 0x77,
-	0xd8, 0x80, 0xe3, 0x80, 0x40, 0x20, 0x77, 0xe0, 0x45, 0x26, 0xd8, 0x59, 0x86, 0x6b, 0xad, 0x6b,
+	0x50, 0x4d, 0xa9, 0x17, 0xbc, 0xc7, 0xed, 0xf4, 0x7b, 0xcc, 0x2c, 0xb5, 0x7a, 0x93, 0xf4, 0x5b,
-	0x89, 0x73, 0x85, 0x0e, 0x67, 0x19, 0xae, 0xdd, 0x7f, 0x38, 0x50, 0xb1, 0x43, 0x90, 0x1d, 0x16,
+	0xde, 0x83, 0xa2, 0x56, 0xaa, 0xb7, 0x8c, 0xf3, 0x89, 0x79, 0xcb, 0x38, 0x95, 0x10, 0x28, 0x1c,
-	0x39, 0xac, 0x9b, 0x9c, 0xe7, 0x51, 0xac, 0xb3, 0xfe, 0xbf, 0x5e, 0xd2, 0x3f, 0x62, 0x68, 0xfd,
+	0x78, 0x91, 0x7e, 0xc3, 0x79, 0x17, 0xd7, 0x4a, 0xd7, 0xe6, 0xe7, 0x12, 0xa3, 0x9c, 0x77, 0x71,
-	0x26, 0xd7, 0x44, 0x63, 0xce, 0x64, 0xb5, 0x01, 0x0f, 0x17, 0x42, 0xef, 0x95, 0x74, 0x3f, 0x81,
+	0xed, 0xfc, 0xd3, 0x82, 0x9a, 0x99, 0xbc, 0x4c, 0x04, 0x19, 0xac, 0xeb, 0x8b, 0xc6, 0xa2, 0x58,
-	0x07, 0xd3, 0xf1, 0x2e, 0x7d, 0x30, 0xde, 0x00, 0x92, 0x84, 0xd9, 0xf1, 0xef, 0x29, 0x94, 0xf5,
+	0x67, 0xfc, 0x7f, 0xb3, 0x24, 0x94, 0x31, 0xb4, 0x71, 0x93, 0xab, 0xa3, 0x31, 0x67, 0xd2, 0x6e,
-	0xb8, 0x9c, 0x4e, 0x73, 0x61, 0xd5, 0x00, 0x6c, 0x64, 0x08, 0xe4, 0xfa, 0x7c, 0x6c, 0xb2, 0xa1,
+	0xc2, 0xa3, 0x85, 0xd0, 0x7b, 0x65, 0xfa, 0x27, 0xf0, 0x70, 0x3a, 0x53, 0x66, 0xe7, 0xc9, 0x06,
-	0xc4, 0x70, 0xed, 0xfe, 0xc5, 0xd1, 0x53, 0xef, 0x70, 0xa4, 0x8e, 0xb8, 0x94, 0x5e, 0x8f, 0x93,
+	0x90, 0x34, 0xcc, 0xcc, 0x9c, 0xcf, 0xa0, 0xaa, 0x66, 0xf4, 0x6c, 0x9a, 0x03, 0xab, 0x1a, 0x60,
-	0xb7, 0x90, 0x3b, 0x0c, 0x7d, 0x85, 0x76, 0xca, 0xdb, 0x9f, 0xa7, 0x4d, 0xbf, 0xc3, 0x91, 0xd2,
+	0x22, 0x43, 0xa0, 0x30, 0x60, 0x13, 0x9d, 0x0d, 0x15, 0x17, 0xd7, 0xce, 0xdf, 0x2c, 0x35, 0x6a,
-	0x30, 0xcb, 0x3a, 0xf8, 0x01, 0x43, 0x16, 0x79, 0x05, 0xb9, 0x3d, 0x4f, 0x79, 0x36, 0x17, 0x52,
+	0x8f, 0xc6, 0xf2, 0x88, 0x09, 0xe1, 0xf5, 0x55, 0x02, 0x16, 0x0e, 0x43, 0x5f, 0x9a, 0xec, 0xfb,
-	0x86, 0x01, 0x8d, 0x48, 0x10, 0xb5, 0xb8, 0x5b, 0xd0, 0x23, 0xfe, 0x70, 0xa4, 0xdc, 0x17, 0xb0,
+	0x34, 0x6b, 0xe4, 0x1e, 0x8d, 0xa5, 0x82, 0x19, 0xd6, 0xc1, 0x8f, 0x5c, 0x64, 0x91, 0xd7, 0x50,
-	0x7e, 0xd3, 0xfa, 0x02, 0xd7, 0xbe, 0x82, 0x72, 0xc2, 0x0a, 0xde, 0x84, 0x93, 0x26, 0x02, 0x8a,
+	0xd8, 0xf3, 0xa4, 0x67, 0x72, 0x21, 0x63, 0x02, 0x51, 0x88, 0x14, 0x51, 0x89, 0xbb, 0x25, 0xf5,
-	0x4c, 0x2f, 0xb5, 0xaf, 0x93, 0x83, 0xac, 0x9a, 0x3d, 0xdc, 0x4f, 0xa0, 0x82, 0xa6, 0x27, 0x11,
+	0xbf, 0x62, 0x34, 0x96, 0xce, 0x4b, 0x58, 0xbf, 0x69, 0x7d, 0x81, 0x6b, 0x5f, 0x40, 0x35, 0x65,
-	0xfc, 0x53, 0x06, 0x0a, 0xb1, 0x89, 0x57, 0x33, 0x7e, 0x3f, 0x4b, 0xf3, 0x7b, 0xde, 0xe5, 0xaf,
+	0x05, 0xaf, 0xdf, 0x49, 0x0b, 0x01, 0x65, 0x57, 0x2d, 0x95, 0xaf, 0xc9, 0x41, 0x56, 0xf5, 0x1e,
-	0x21, 0x87, 0xfd, 0x2e, 0xb3, 0xac, 0x93, 0x36, 0xbb, 0x09, 0x1a, 0xb6, 0xc2, 0x5f, 0x41, 0x9e,
+	0xce, 0x03, 0xa8, 0xa1, 0xe9, 0x24, 0x82, 0x7f, 0xce, 0x41, 0x29, 0x36, 0xf1, 0x7a, 0xc6, 0xef,
-	0x71, 0xa9, 0xbb, 0x7e, 0x16, 0x89, 0xcf, 0x17, 0x13, 0x0d, 0x66, 0x4a, 0xb6, 0x24, 0x4d, 0x6f,
+	0xe7, 0x59, 0x7e, 0xcf, 0xbb, 0xfc, 0x25, 0x14, 0xb0, 0xc9, 0xe6, 0x96, 0xb5, 0xef, 0x56, 0x2f,
-	0xf9, 0xbd, 0xd0, 0x0b, 0x68, 0x6e, 0x19, 0xdd, 0x60, 0x12, 0x74, 0xa3, 0x98, 0x86, 0xfb, 0xcf,
+	0x45, 0xc3, 0xfe, 0xfb, 0x6b, 0x28, 0xba, 0x4c, 0xa8, 0x51, 0x23, 0x8f, 0xc4, 0x17, 0x8b, 0x89,
-	0x0e, 0x94, 0x97, 0x86, 0x7a, 0xf9, 0x07, 0xca, 0xdc, 0x47, 0x53, 0xf6, 0x7f, 0xfc, 0x68, 0xfa,
+	0x1a, 0x33, 0x25, 0x1b, 0x92, 0xa2, 0xb7, 0xfd, 0x7e, 0xe8, 0x05, 0xb4, 0xb0, 0x8c, 0xae, 0x31,
-	0x97, 0x33, 0x6b, 0x08, 0x9b, 0xbb, 0xbe, 0x4f, 0x43, 0xe1, 0x87, 0xca, 0xa6, 0x6c, 0x42, 0xa3,
+	0x29, 0xba, 0x56, 0x4c, 0xc3, 0xfd, 0x17, 0x0b, 0xaa, 0x4b, 0x43, 0xbd, 0xfc, 0x5f, 0xd1, 0xdc,
-	0x0f, 0xda, 0x18, 0x74, 0x6d, 0x19, 0xd5, 0xcb, 0x69, 0x39, 0xcc, 0xda, 0x72, 0xa8, 0x93, 0xe0,
+	0x3f, 0xb5, 0xfc, 0xff, 0xf9, 0x4f, 0xed, 0xdf, 0xd6, 0xac, 0x21, 0x9c, 0x28, 0xd4, 0x7d, 0x1a,
-	0xbd, 0xe4, 0x11, 0x86, 0xa8, 0xc4, 0x70, 0xad, 0x67, 0xa2, 0x63, 0x81, 0xda, 0x15, 0xcc, 0x16,
+	0x71, 0x3f, 0x94, 0x26, 0x65, 0x53, 0x1a, 0x75, 0xd0, 0xe6, 0xb0, 0x67, 0x6a, 0xb7, 0x5a, 0x4e,
-	0x2b, 0xa1, 0xbd, 0xab, 0x2e, 0xcd, 0x1b, 0xc7, 0x1b, 0x57, 0x58, 0xd7, 0x8f, 0x85, 0xd6, 0x15,
+	0x6b, 0x70, 0xde, 0xd4, 0x60, 0x95, 0x04, 0xef, 0x05, 0x8b, 0x30, 0x44, 0x15, 0x17, 0xd7, 0x6a,
-	0x10, 0x68, 0x04, 0x8d, 0x3b, 0x53, 0x63, 0x5a, 0x34, 0xa9, 0x76, 0xa6, 0xc6, 0xba, 0x44, 0x33,
+	0x10, 0x3b, 0xe6, 0xa8, 0x5d, 0xc1, 0x6c, 0x31, 0x12, 0xda, 0xbb, 0xea, 0xd1, 0xa2, 0x76, 0xbc,
-	0x11, 0x04, 0x6d, 0xaf, 0xd3, 0xa7, 0x25, 0xd3, 0x1b, 0x62, 0xd9, 0xdd, 0x81, 0xd2, 0xe4, 0xd5,
+	0x79, 0x85, 0xcd, 0xe4, 0x98, 0x2b, 0x5d, 0x09, 0x81, 0x5a, 0x50, 0xb8, 0x33, 0x39, 0xa1, 0x65,
-	0xeb, 0xda, 0xde, 0xec, 0x62, 0x68, 0x2b, 0x2c, 0xd3, 0xec, 0xc6, 0x59, 0x9b, 0x99, 0xcf, 0xda,
+	0x9d, 0x6a, 0x67, 0x72, 0xa2, 0xfa, 0x82, 0xcb, 0x83, 0xa0, 0xe3, 0x75, 0x07, 0xb4, 0xa2, 0x1b,
-	0x6c, 0x22, 0x6b, 0x5f, 0x41, 0x65, 0x26, 0x09, 0x34, 0x88, 0x89, 0x2b, 0x69, 0x0d, 0xe1, 0x5a,
+	0x52, 0x2c, 0xab, 0x29, 0x4b, 0x45, 0xd7, 0xf7, 0x02, 0x9c, 0xd9, 0xcb, 0x6e, 0x2c, 0x3a, 0x3b,
-	0xeb, 0x1a, 0x22, 0x30, 0x5f, 0x79, 0x15, 0x86, 0x6b, 0xf7, 0x39, 0x54, 0x66, 0x5e, 0xff, 0xa2,
+	0x50, 0x49, 0x92, 0x42, 0xb5, 0x9a, 0x56, 0x0f, 0x83, 0x5e, 0x73, 0x73, 0xad, 0x5e, 0x9c, 0xcf,
-	0x3a, 0xeb, 0x3e, 0x83, 0x4a, 0x4b, 0x79, 0x6a, 0xb4, 0xe4, 0xb3, 0xfc, 0xdf, 0x0e, 0xac, 0xc5,
+	0xb9, 0xf9, 0x7c, 0xce, 0xa7, 0xf2, 0xf9, 0x35, 0xd4, 0x66, 0xd2, 0x43, 0x81, 0x5c, 0x7e, 0x25,
-	0x18, 0x5b, 0x49, 0x7e, 0x01, 0xc5, 0x4b, 0x1e, 0x29, 0x7e, 0x3d, 0xe9, 0x2d, 0xb4, 0x3e, 0x10,
+	0x8c, 0x21, 0x5c, 0x2b, 0x5d, 0x93, 0x07, 0xfa, 0x4f, 0x67, 0xcd, 0xc5, 0xb5, 0xf3, 0x02, 0x6a,
-	0xed, 0x71, 0x3d, 0xfe, 0x63, 0x40, 0xbf, 0xed, 0x0f, 0x88, 0x60, 0x13, 0x24, 0xf9, 0x16, 0x8a,
+	0x33, 0x89, 0xb1, 0xa8, 0x02, 0x3b, 0xcf, 0xa1, 0xd6, 0x96, 0x9e, 0x1c, 0x2f, 0xf9, 0x4a, 0xf0,
-	0x12, 0xed, 0xf0, 0xb8, 0xd3, 0x7f, 0x96, 0xc6, 0xb2, 0xfb, 0x4d, 0xf0, 0x64, 0x0b, 0x72, 0x81,
+	0x1f, 0x0b, 0xd6, 0x62, 0x8c, 0xa9, 0x31, 0xbf, 0x84, 0xf2, 0x25, 0x8b, 0x24, 0xbb, 0x4e, 0xba,
-	0xe8, 0x49, 0x7c, 0xbb, 0xe5, 0xed, 0xc7, 0x69, 0xbc, 0x77, 0xa2, 0xc7, 0x10, 0x48, 0xde, 0x40,
+	0x0e, 0x6d, 0x0c, 0x79, 0x67, 0xd2, 0x88, 0xbf, 0x53, 0xa8, 0x3c, 0xf8, 0x80, 0x08, 0x37, 0x41,
-	0xf1, 0xca, 0x8b, 0x42, 0x3f, 0xec, 0xc5, 0x9f, 0x8f, 0x4f, 0xd3, 0x48, 0xdf, 0x1b, 0x1c, 0x9b,
+	0x92, 0xaf, 0xa1, 0x2c, 0xd0, 0x0e, 0x8b, 0x07, 0x8f, 0x8f, 0xb3, 0x58, 0x66, 0xbf, 0x04, 0x4f,
-	0x10, 0xdc, 0x8a, 0xbe, 0x14, 0xe7, 0xc2, 0xc6, 0xc4, 0xfd, 0x8d, 0xce, 0x4d, 0x2d, 0x5a, 0xf7,
+	0xb6, 0xa0, 0x10, 0xf0, 0xbe, 0xc0, 0xf7, 0x5e, 0xdd, 0x7e, 0x92, 0xc5, 0x7b, 0xc7, 0xfb, 0x2e,
-	0x0f, 0xa1, 0x62, 0xf2, 0xfb, 0x03, 0x8f, 0xa4, 0x9e, 0x9b, 0x9c, 0x65, 0x77, 0x70, 0x37, 0x09,
+	0x02, 0xc9, 0x5b, 0x28, 0x5f, 0x79, 0x51, 0xe8, 0x87, 0xfd, 0xf8, 0xdf, 0xec, 0xb3, 0x2c, 0xd2,
-	0x65, 0xb3, 0x4c, 0xf7, 0xa3, 0x6d, 0x5f, 0xb1, 0x42, 0x8f, 0xc8, 0x43, 0xaf, 0xd3, 0xf7, 0x7a,
+	0x77, 0x1a, 0xe7, 0x26, 0x04, 0xa7, 0xa6, 0xae, 0xcb, 0x39, 0x37, 0x31, 0x71, 0x7e, 0xab, 0xb2,
-	0xf1, 0x7b, 0x8a, 0x45, 0xfd, 0xe4, 0xd2, 0xee, 0x67, 0xae, 0x61, 0x2c, 0xea, 0x0c, 0x8c, 0xf8,
+	0x56, 0x89, 0xc6, 0xfd, 0x43, 0xa8, 0xe9, 0xcc, 0xff, 0xc0, 0x22, 0xa1, 0xc6, 0x38, 0x6b, 0xd9,
-	0xa5, 0x2f, 0xa7, 0x23, 0xdc, 0x44, 0xde, 0xfe, 0x7b, 0x1e, 0xa0, 0x31, 0x39, 0x0f, 0x39, 0x85,
+	0xed, 0xdc, 0x4d, 0x43, 0xdd, 0x59, 0xa6, 0xf3, 0xbd, 0x69, 0x6c, 0xb1, 0x42, 0xe5, 0xd2, 0xc8,
-	0x15, 0xdc, 0x8f, 0xb8, 0x4b, 0x9b, 0x21, 0xfa, 0x5d, 0x7d, 0x7e, 0x87, 0x86, 0x49, 0xde, 0x43,
+	0xeb, 0x0e, 0xbc, 0x7e, 0xfc, 0x9e, 0x62, 0x51, 0x3d, 0xb9, 0x34, 0xfb, 0xe9, 0x0b, 0x1a, 0x8b,
-	0xde, 0xbc, 0x2d, 0x92, 0x56, 0x83, 0x92, 0xf9, 0x55, 0x7d, 0xb1, 0x1c, 0x64, 0x8c, 0x7e, 0xe1,
+	0x2a, 0x37, 0x23, 0x76, 0xe9, 0x8b, 0xe9, 0x44, 0x99, 0xc8, 0xdb, 0x7f, 0x2d, 0x01, 0x34, 0x93,
-	0x10, 0x66, 0x2b, 0x14, 0x71, 0x97, 0xb4, 0x20, 0x9b, 0xd9, 0x69, 0x07, 0x9d, 0xa9, 0xf6, 0x35,
+	0xf3, 0x90, 0x53, 0x58, 0xc1, 0xfd, 0x88, 0xb3, 0xb4, 0x4d, 0xa2, 0xdf, 0xf6, 0x8b, 0x3b, 0xb4,
-	0x87, 0x7c, 0x07, 0x79, 0x53, 0x63, 0xc8, 0x8f, 0x17, 0x13, 0x62, 0x7b, 0xcb, 0x1f, 0xd7, 0x9c,
+	0x52, 0xf2, 0x41, 0x25, 0x3f, 0x8e, 0x37, 0xe4, 0x65, 0x56, 0x41, 0x48, 0x4f, 0x48, 0xf6, 0x27,
-	0x2f, 0x1c, 0x72, 0x04, 0x39, 0xdd, 0x5c, 0x49, 0x4a, 0xa7, 0x48, 0x74, 0xe6, 0xaa, 0xbb, 0x0c,
+	0xb7, 0xa0, 0x8c, 0xdd, 0xf7, 0x50, 0xd4, 0x59, 0x40, 0xb2, 0xaa, 0x5e, 0x3a, 0x6f, 0xed, 0x97,
-	0x62, 0xa3, 0xf8, 0x11, 0x60, 0xda, 0xe2, 0x49, 0xca, 0xc7, 0xfa, 0xdc, 0xac, 0x50, 0xad, 0xdd,
+	0xcb, 0x41, 0xda, 0xe8, 0x67, 0x16, 0x71, 0x4d, 0x4d, 0x24, 0xce, 0x92, 0xa6, 0x67, 0x6e, 0x4c,
-	0x0e, 0xb4, 0x1b, 0x1c, 0xe9, 0xfe, 0x76, 0x2e, 0x48, 0x6a, 0x67, 0x9b, 0xa4, 0x7b, 0xd5, 0x5d,
+	0x56, 0x00, 0x66, 0xfa, 0x4b, 0xdd, 0x22, 0xdf, 0x42, 0x51, 0x57, 0x35, 0xf2, 0xd3, 0xc5, 0x84,
-	0x06, 0xb1, 0xe6, 0x2e, 0xa0, 0x32, 0xf3, 0x5f, 0x1d, 0xf9, 0x59, 0xba, 0x93, 0x37, 0xff, 0xfa,
+	0xd8, 0xde, 0xf2, 0xc7, 0x75, 0xeb, 0x33, 0x8b, 0x1c, 0x41, 0x41, 0xb5, 0x73, 0x92, 0xd1, 0x9b,
-	0xab, 0xbe, 0xbc, 0x13, 0xd6, 0xee, 0xa4, 0x92, 0x33, 0x92, 0x7d, 0x4c, 0xea, 0xb7, 0xf9, 0x3d,
+	0x52, 0xb3, 0x80, 0xed, 0x2c, 0x83, 0x98, 0x28, 0x7e, 0x0f, 0x30, 0x1d, 0x2a, 0x48, 0xc6, 0x37,
-	0xfb, 0xbf, 0x5b, 0x75, 0xeb, 0xce, 0x78, 0xb3, 0xeb, 0x6e, 0xee, 0xb7, 0x99, 0x61, 0xbb, 0x9d,
+	0x89, 0xb9, 0xe9, 0xc4, 0xae, 0xdf, 0x0e, 0x34, 0x1b, 0x1c, 0xa9, 0x8e, 0x7a, 0xce, 0x49, 0x66,
-	0xc7, 0xbf, 0x30, 0xbf, 0xfa, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x90, 0xec, 0x83, 0x29,
+	0x2f, 0x4d, 0xae, 0x91, 0xed, 0x2c, 0x83, 0x18, 0x73, 0x17, 0x50, 0x9b, 0xf9, 0x24, 0x49, 0x7e,
-	0x15, 0x00, 0x00,
+	0x9e, 0xed, 0xe4, 0xcd, 0x2f, 0x9c, 0xf6, 0xab, 0x3b, 0x61, 0xcd, 0x4e, 0x32, 0x3d, 0x95, 0x99,
+	0xc7, 0xa4, 0x71, 0x9b, 0xdf, 0xb3, 0x9f, 0x17, 0xed, 0xad, 0x3b, 0xe3, 0xf5, 0xae, 0xbb, 0x85,
+	0xdf, 0xe5, 0x46, 0x9d, 0x4e, 0x11, 0xbf, 0xd4, 0x7e, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0xc2, 0xd5, 0x2b, 0x23, 0x10, 0x16, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2040,6 +2129,7 @@ const _ = grpc.SupportPackageIsVersion4
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type ControllerClient interface {
 	Build(ctx context.Context, in *BuildRequest, opts ...grpc.CallOption) (*BuildResponse, error)
+	Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (*InspectResponse, error)
 	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (Controller_StatusClient, error)
 	Input(ctx context.Context, opts ...grpc.CallOption) (Controller_InputClient, error)
 	Invoke(ctx context.Context, opts ...grpc.CallOption) (Controller_InvokeClient, error)
@@ -2067,6 +2157,15 @@ func (c *controllerClient) Build(ctx context.Context, in *BuildRequest, opts ...
 	return out, nil
 }
 
+func (c *controllerClient) Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (*InspectResponse, error) {
+	out := new(InspectResponse)
+	err := c.cc.Invoke(ctx, "/buildx.controller.v1.Controller/Inspect", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *controllerClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (Controller_StatusClient, error) {
 	stream, err := c.cc.NewStream(ctx, &_Controller_serviceDesc.Streams[0], "/buildx.controller.v1.Controller/Status", opts...)
 	if err != nil {
@@ -2212,6 +2311,7 @@ func (c *controllerClient) DisconnectProcess(ctx context.Context, in *Disconnect
 // ControllerServer is the server API for Controller service.
 type ControllerServer interface {
 	Build(context.Context, *BuildRequest) (*BuildResponse, error)
+	Inspect(context.Context, *InspectRequest) (*InspectResponse, error)
 	Status(*StatusRequest, Controller_StatusServer) error
 	Input(Controller_InputServer) error
 	Invoke(Controller_InvokeServer) error
@@ -2229,6 +2329,9 @@ type UnimplementedControllerServer struct {
 func (*UnimplementedControllerServer) Build(ctx context.Context, req *BuildRequest) (*BuildResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Build not implemented")
 }
+func (*UnimplementedControllerServer) Inspect(ctx context.Context, req *InspectRequest) (*InspectResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Inspect not implemented")
+}
 func (*UnimplementedControllerServer) Status(req *StatusRequest, srv Controller_StatusServer) error {
 	return status.Errorf(codes.Unimplemented, "method Status not implemented")
 }
@@ -2276,6 +2379,24 @@ func _Controller_Build_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Controller_Inspect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(InspectRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ControllerServer).Inspect(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/buildx.controller.v1.Controller/Inspect",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ControllerServer).Inspect(ctx, req.(*InspectRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Controller_Status_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(StatusRequest)
 	if err := stream.RecvMsg(m); err != nil {
@@ -2447,6 +2568,10 @@ var _Controller_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Build",
 			Handler:    _Controller_Build_Handler,
 		},
+		{
+			MethodName: "Inspect",
+			Handler:    _Controller_Inspect_Handler,
+		},
 		{
 			MethodName: "List",
 			Handler:    _Controller_List_Handler,

controller/pb/controller.proto

@@ -8,6 +8,7 @@ option go_package = "pb";
 
 service Controller {
   rpc Build(BuildRequest) returns (BuildResponse);
+  rpc Inspect(InspectRequest) returns (InspectResponse);
   rpc Status(StatusRequest) returns (stream StatusResponse);
   rpc Input(stream InputMessage) returns (InputResponse);
   rpc Invoke(stream Message) returns (stream Message);
@@ -105,6 +106,14 @@ message Secret {
   string Env = 3;
 }
 
+message InspectRequest {
+  string Ref = 1;
+}
+
+message InspectResponse {
+  BuildOptions Options = 1;
+}
+
 message UlimitOpt {
   map<string, Ulimit> values = 1;
 }
@@ -184,6 +193,7 @@ message InvokeConfig {
   bool NoCwd = 7; // Do not set cwd but use the image's default
   bool Tty = 8;
   bool Rollback = 9; // Kill all process in the container and recreate it.
+  bool Initial = 10; // Run container from the initial state of that stage (supported only on the failed step)
 }
 
 message FdMessage {

controller/processes/processes.go

@@ -111,7 +111,7 @@ func (m *Manager) StartProcess(pid string, resultCtx *build.ResultContext, cfg *
 			go ctr.Cancel() // Finish the existing container
 		}
 		var err error
-		ctr, err = build.NewContainer(context.TODO(), resultCtx)
+		ctr, err = build.NewContainer(context.TODO(), resultCtx, cfg)
 		if err != nil {
 			return nil, errors.Errorf("failed to create container %v", err)
 		}

controller/remote/client.go

@@ -13,6 +13,7 @@ import (
 	"github.com/docker/buildx/util/progress"
 	"github.com/moby/buildkit/client"
 	"github.com/moby/buildkit/identity"
+	"github.com/moby/buildkit/util/grpcerrors"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
@@ -33,6 +34,8 @@ func NewClient(ctx context.Context, addr string) (*Client, error) {
 		grpc.WithContextDialer(dialer.ContextDialer),
 		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(defaults.DefaultMaxRecvMsgSize)),
 		grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(defaults.DefaultMaxSendMsgSize)),
+		grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor),
+		grpc.WithStreamInterceptor(grpcerrors.StreamClientInterceptor),
 	}
 	conn, err := grpc.DialContext(ctx, dialer.DialAddress(addr), gopts...)
 	if err != nil {
@@ -71,6 +74,9 @@ func (c *Client) List(ctx context.Context) (keys []string, retErr error) {
 }
 
 func (c *Client) Disconnect(ctx context.Context, key string) error {
+	if key == "" {
+		return nil
+	}
 	_, err := c.client().Disconnect(ctx, &pb.DisconnectRequest{Ref: key})
 	return err
 }
@@ -104,6 +110,10 @@ func (c *Client) Invoke(ctx context.Context, ref string, pid string, invokeConfi
 	})
 }
 
+func (c *Client) Inspect(ctx context.Context, ref string) (*pb.InspectResponse, error) {
+	return c.client().Inspect(ctx, &pb.InspectRequest{Ref: ref})
+}
+
 func (c *Client) Build(ctx context.Context, options pb.BuildOptions, in io.ReadCloser, w io.Writer, out console.File, progressMode string) (string, *client.SolveResponse, error) {
 	ref := identity.NewID()
 	pw, err := progress.NewPrinter(context.TODO(), w, out, progressMode)

controller/remote/controller.go

@@ -24,6 +24,7 @@ import (
 	"github.com/docker/buildx/version"
 	"github.com/docker/cli/cli/command"
 	"github.com/moby/buildkit/client"
+	"github.com/moby/buildkit/util/grpcerrors"
 	"github.com/pelletier/go-toml"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -161,7 +162,10 @@ func serveCmd(dockerCli command.Cli) *cobra.Command {
 			if err != nil {
 				return err
 			}
-			rpc := grpc.NewServer()
+			rpc := grpc.NewServer(
+				grpc.UnaryInterceptor(grpcerrors.UnaryServerInterceptor),
+				grpc.StreamInterceptor(grpcerrors.StreamServerInterceptor),
+			)
 			controllerapi.RegisterControllerServer(rpc, b)
 			doneCh := make(chan struct{})
 			errCh := make(chan error, 1)

controller/remote/server.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/docker/buildx/build"
+	controllererrors "github.com/docker/buildx/controller/errdefs"
 	"github.com/docker/buildx/controller/pb"
 	"github.com/docker/buildx/controller/processes"
 	"github.com/docker/buildx/util/ioset"
@@ -36,6 +37,7 @@ type session struct {
 	buildOnGoing atomic.Bool
 	statusChan   chan *client.SolveStatus
 	cancelBuild  func()
+	buildOptions *pb.BuildOptions
 	inputPipe    *io.PipeWriter
 
 	result *build.ResultContext
@@ -111,6 +113,9 @@ func (m *Server) Disconnect(ctx context.Context, req *pb.DisconnectRequest) (res
 			s.cancelBuild()
 		}
 		s.cancelRunningProcesses()
+		if s.result != nil {
+			s.result.Done()
+		}
 	}
 	delete(m.session, key)
 	m.sessionMu.Unlock()
@@ -132,6 +137,23 @@ func (m *Server) Close() error {
 	return nil
 }
 
+func (m *Server) Inspect(ctx context.Context, req *pb.InspectRequest) (*pb.InspectResponse, error) {
+	ref := req.Ref
+	if ref == "" {
+		return nil, errors.New("inspect: empty key")
+	}
+	var bo *pb.BuildOptions
+	m.sessionMu.Lock()
+	if s, ok := m.session[ref]; ok {
+		bo = s.buildOptions
+	} else {
+		m.sessionMu.Unlock()
+		return nil, errors.Errorf("inspect: unknown key %v", ref)
+	}
+	m.sessionMu.Unlock()
+	return &pb.InspectResponse{Options: bo}, nil
+}
+
 func (m *Server) Build(ctx context.Context, req *pb.BuildRequest) (*pb.BuildResponse, error) {
 	ref := req.Ref
 	if ref == "" {
@@ -177,24 +199,35 @@ func (m *Server) Build(ctx context.Context, req *pb.BuildRequest) (*pb.BuildResp
 	// Build the specified request
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	resp, res, err := m.buildFunc(ctx, req.Options, inR, statusChan)
+	resp, res, buildErr := m.buildFunc(ctx, req.Options, inR, statusChan)
 	m.sessionMu.Lock()
 	if s, ok := m.session[ref]; ok {
+		// NOTE: buildFunc can return *build.ResultContext even on error (e.g. when it's implemented using (github.com/docker/buildx/controller/build).RunBuild).
+		if res != nil {
 			s.result = res
 			s.cancelBuild = cancel
+			s.buildOptions = req.Options
 			m.session[ref] = s
+			if buildErr != nil {
+				buildErr = controllererrors.WrapBuild(buildErr, ref)
+			}
+		}
 	} else {
 		m.sessionMu.Unlock()
 		return nil, errors.Errorf("build: unknown key %v", ref)
 	}
 	m.sessionMu.Unlock()
 
+	if buildErr != nil {
+		return nil, buildErr
+	}
+
 	if resp == nil {
 		resp = &client.SolveResponse{}
 	}
 	return &pb.BuildResponse{
 		ExporterResponse: resp.ExporterResponse,
-	}, err
+	}, nil
 }
 
 func (m *Server) Status(req *pb.StatusRequest, stream pb.Controller_StatusServer) error {

docs/reference/buildx.md

@@ -15,6 +15,7 @@ Extended build capabilities with BuildKit
 | [`bake`](buildx_bake.md)                       | Build from a file                          |
 | [`build`](buildx_build.md)                     | Start a build                              |
 | [`create`](buildx_create.md)                   | Create a new builder instance              |
+| [`debug-shell`](buildx_debug-shell.md)         | Start a monitor                            |
 | [`du`](buildx_du.md)                           | Disk usage                                 |
 | [`imagetools`](buildx_imagetools.md)           | Commands to work on images in registry     |
 | [`inspect`](buildx_inspect.md)                 | Inspect current builder instance           |

docs/reference/buildx_debug-shell.md

@@ -0,0 +1,18 @@
+# docker buildx debug-shell
+
+<!---MARKER_GEN_START-->
+Start a monitor
+
+### Options
+
+| Name              | Type     | Default | Description                                                                              |
+|:------------------|:---------|:--------|:-----------------------------------------------------------------------------------------|
+| `--builder`       | `string` |         | Override the configured builder instance                                                 |
+| `--detach`        |          |         | Detach buildx server (supported only on linux) [experimental]                            |
+| `--progress`      | `string` | `auto`  | Set type of progress output (`auto`, `plain`, `tty`). Use plain to show container output |
+| `--root`          | `string` |         | Specify root directory of server to connect [experimental]                               |
+| `--server-config` | `string` |         | Specify buildx server config file (used only when launching new server) [experimental]   |
+
+
+<!---MARKER_GEN_END-->
+

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/compose-spec/compose-go v1.9.0
 	github.com/containerd/console v1.0.3
 	github.com/containerd/containerd v1.7.0
+	github.com/containerd/typeurl/v2 v2.1.0
 	github.com/docker/cli v23.0.1+incompatible
 	github.com/docker/cli-docs-tool v0.5.1
 	github.com/docker/distribution v2.8.1+incompatible
@@ -82,7 +83,6 @@ require (
 	github.com/cloudflare/cfssl v0.0.0-20181213083726-b94e044bb51e // indirect
 	github.com/containerd/continuity v0.3.0 // indirect
 	github.com/containerd/ttrpc v1.2.1 // indirect
-	github.com/containerd/typeurl/v2 v2.1.0 // indirect
 	github.com/cyphar/filepath-securejoin v0.2.3 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/distribution/distribution/v3 v3.0.0-20221103125252-ebfa2a0ac0a9 // indirect

monitor/monitor.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/containerd/console"
 	"github.com/docker/buildx/controller/control"
+	controllererrors "github.com/docker/buildx/controller/errdefs"
 	controllerapi "github.com/docker/buildx/controller/pb"
 	"github.com/docker/buildx/util/ioset"
 	"github.com/moby/buildkit/identity"
@@ -35,7 +36,7 @@ Available commands are:
 `
 
 // RunMonitor provides an interactive session for running and managing containers via specified IO.
-func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildOptions, invokeConfig controllerapi.InvokeConfig, c control.BuildxController, progressMode string, stdin io.ReadCloser, stdout io.WriteCloser, stderr console.File) error {
+func RunMonitor(ctx context.Context, curRef string, options *controllerapi.BuildOptions, invokeConfig controllerapi.InvokeConfig, c control.BuildxController, progressMode string, stdin io.ReadCloser, stdout io.WriteCloser, stderr console.File) error {
 	defer func() {
 		if err := c.Disconnect(ctx, curRef); err != nil {
 			logrus.Warnf("disconnect error: %v", err)
@@ -84,6 +85,8 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
 
 	// Start container automatically
 	fmt.Fprintf(stdout, "Launching interactive container. Press Ctrl-a-c to switch to monitor console\n")
+	invokeConfig.Rollback = false
+	invokeConfig.Initial = false
 	id := m.rollback(ctx, curRef, invokeConfig)
 	fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
 
@@ -120,16 +123,42 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
 				case "":
 					// nop
 				case "reload":
+					var bo *controllerapi.BuildOptions
+					if curRef != "" {
+						// Rebuilding an existing session; Restore the build option used for building this session.
+						res, err := c.Inspect(ctx, curRef)
+						if err != nil {
+							fmt.Printf("failed to inspect the current build session: %v\n", err)
+						} else {
+							bo = res.Options
+						}
+					} else {
+						bo = options
+					}
+					if bo == nil {
+						fmt.Println("reload: no build option is provided")
+						continue
+					}
 					if curRef != "" {
 						if err := c.Disconnect(ctx, curRef); err != nil {
 							fmt.Println("disconnect error", err)
 						}
 					}
-					ref, _, err := c.Build(ctx, options, nil, stdout, stderr, progressMode) // TODO: support stdin, hold build ref
+					var resultUpdated bool
+					ref, _, err := c.Build(ctx, *bo, nil, stdout, stderr, progressMode) // TODO: support stdin, hold build ref
 					if err != nil {
+						var be *controllererrors.BuildError
+						if errors.As(err, &be) {
+							curRef = be.Ref
+							resultUpdated = true
+						} else {
 							fmt.Printf("failed to reload: %v\n", err)
+						}
 					} else {
 						curRef = ref
+						resultUpdated = true
+					}
+					if resultUpdated {
 						// rollback the running container with the new result
 						id := m.rollback(ctx, curRef, invokeConfig)
 						fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
@@ -137,8 +166,15 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
 				case "rollback":
 					cfg := invokeConfig
 					if len(args) >= 2 {
-						cfg.Entrypoint = []string{args[1]}
+						cmds := args[1:]
-						cfg.Cmd = args[2:]
+						if cmds[0] == "--init" {
+							cfg.Initial = true
+							cmds = cmds[1:]
+						}
+						if len(cmds) > 0 {
+							cfg.Entrypoint = []string{cmds[0]}
+							cfg.Cmd = cmds[1:]
+						}
 					}
 					id := m.rollback(ctx, curRef, cfg)
 					fmt.Fprintf(stdout, "Interactive container was restarted with process %q. Press Ctrl-a-c to switch to the new container\n", id)
@@ -254,10 +290,10 @@ func RunMonitor(ctx context.Context, curRef string, options controllerapi.BuildO
 		}()
 		select {
 		case <-doneCh:
-			m.invokeCancel()
+			m.close()
 			return nil
 		case err := <-errCh:
-			m.invokeCancel()
+			m.close()
 			return err
 		case <-monitorDisableCh:
 		}
@@ -293,10 +329,19 @@ func (m *monitor) attach(ctx context.Context, ref, pid string) {
 	m.startInvoke(ctx, ref, pid, controllerapi.InvokeConfig{})
 }
 
+func (m *monitor) close() {
+	if m.invokeCancel != nil {
+		m.invokeCancel()
+	}
+}
+
 func (m *monitor) startInvoke(ctx context.Context, ref, pid string, cfg controllerapi.InvokeConfig) string {
 	if m.invokeCancel != nil {
 		m.invokeCancel() // Finish existing attach
 	}
+	if len(cfg.Entrypoint) == 0 && len(cfg.Cmd) == 0 {
+		cfg.Entrypoint = []string{"sh"} // launch shell by default
+	}
 	go func() {
 		// Start a new invoke
 		if err := m.invoke(ctx, ref, pid, cfg); err != nil {
@@ -316,6 +361,9 @@ func (m *monitor) invoke(ctx context.Context, ref, pid string, cfg controllerapi
 	if err := m.muxIO.SwitchTo(1); err != nil {
 		return errors.Errorf("failed to switch to process IO: %v", err)
 	}
+	if ref == "" {
+		return nil
+	}
 	invokeCtx, invokeCancel := context.WithCancel(ctx)
 
 	containerIn, containerOut := ioset.Pipe()