dap: add debug adapter implementation

Adds a simple implementation of the debug adapter that supports the very
basics of a debug adapter.

It supports the launch request, the configuration done request, the
creation of threads, stopping, resuming, and disconnecting from server.

It does not support custom breakpoints, stack traces, or variable
inspection yet. These are planned to be added in the future.

Signed-off-by: Jonathan A. Sternberg <jonathan.sternberg@docker.com>

build/build.go

@@ -313,9 +313,12 @@ func toRepoOnly(in string) (string, error) {
 	return strings.Join(out, ","), nil
 }
 
-type Handler struct {
-	Evaluate func(ctx context.Context, c gateway.Client, res *gateway.Result) error
+type (
+	EvaluateFunc func(ctx context.Context, name string, c gateway.Client, res *gateway.Result) error
+	Handler      struct {
+		Evaluate EvaluateFunc
 	}
+)
 
 func Build(ctx context.Context, nodes []builder.Node, opts map[string]Options, docker *dockerutil.Client, cfg *confutil.Config, w progress.Writer) (resp map[string]*client.SolveResponse, err error) {
 	return BuildWithResultHandler(ctx, nodes, opts, docker, cfg, w, nil)
@@ -510,12 +513,25 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opts map[
 						rKey := resultKey(dp.driverIndex, k)
 						results.Set(rKey, res)
 
+						forceEval := false
 						if children := childTargets[rKey]; len(children) > 0 {
-							if err := waitForChildren(ctx, bh, c, res, results, children); err != nil {
+							// wait for the child targets to register their LLB before evaluating
+							_, err := results.Get(ctx, children...)
+							if err != nil {
 								return nil, err
 							}
-						} else if bh != nil && bh.Evaluate != nil {
-							if err := bh.Evaluate(ctx, c, res); err != nil {
+							forceEval = true
+						}
+
+						// invoke custom evaluate handler if it is present
+						if bh != nil && bh.Evaluate != nil {
+							if err := bh.Evaluate(ctx, k, c, res); err != nil {
+								return nil, err
+							}
+						} else if forceEval {
+							if err := res.EachRef(func(ref gateway.Reference) error {
+								return ref.Evaluate(ctx)
+							}); err != nil {
 								return nil, err
 							}
 						}
@@ -1199,29 +1215,6 @@ func solve(ctx context.Context, c gateway.Client, req gateway.SolveRequest) (*ga
 	return res, nil
 }
 
-func waitForChildren(ctx context.Context, bh *Handler, c gateway.Client, res *gateway.Result, results *waitmap.Map, children []string) error {
-	// wait for the child targets to register their LLB before evaluating
-	_, err := results.Get(ctx, children...)
-	if err != nil {
-		return err
-	}
-	// we need to wait until the child targets have completed before we can release
-	eg, ctx := errgroup.WithContext(ctx)
-	eg.Go(func() error {
-		if bh != nil && bh.Evaluate != nil {
-			return bh.Evaluate(ctx, c, res)
-		}
-		return res.EachRef(func(ref gateway.Reference) error {
-			return ref.Evaluate(ctx)
-		})
-	})
-	eg.Go(func() error {
-		_, err := results.Get(ctx, children...)
-		return err
-	})
-	return eg.Wait()
-}
-
 func catchFrontendError(retErr, frontendErr *error) {
 	*frontendErr = *retErr
 	if errors.Is(*retErr, ErrRestart) {

build/invoke.go

@@ -14,18 +14,18 @@ import (
 )
 
 type InvokeConfig struct {
-	Entrypoint []string
-	Cmd        []string
-	NoCmd      bool
-	Env        []string
-	User       string
-	NoUser     bool
-	Cwd        string
-	NoCwd      bool
-	Tty        bool
-	Rollback   bool
-	Initial    bool
-	SuspendOn  SuspendOn
+	Entrypoint []string  `json:"entrypoint,omitempty"`
+	Cmd        []string  `json:"cmd,omitempty"`
+	NoCmd      bool      `json:"noCmd,omitempty"`
+	Env        []string  `json:"env,omitempty"`
+	User       string    `json:"user,omitempty"`
+	NoUser     bool      `json:"noUser,omitempty"`
+	Cwd        string    `json:"cwd,omitempty"`
+	NoCwd      bool      `json:"noCwd,omitempty"`
+	Tty        bool      `json:"tty,omitempty"`
+	Rollback   bool      `json:"rollback,omitempty"`
+	Initial    bool      `json:"initial,omitempty"`
+	SuspendOn  SuspendOn `json:"suspendOn,omitempty"`
 }
 
 func (cfg *InvokeConfig) NeedsDebug(err error) bool {
@@ -43,6 +43,18 @@ func (s SuspendOn) DebugEnabled(err error) bool {
 	return err != nil || s == SuspendAlways
 }
 
+func (s *SuspendOn) UnmarshalText(text []byte) error {
+	switch string(text) {
+	case "error":
+		*s = SuspendError
+	case "always":
+		*s = SuspendAlways
+	default:
+		return errors.Errorf("unknown suspend name: %s", string(text))
+	}
+	return nil
+}
+
 type Container struct {
 	cancelOnce      sync.Once
 	containerCancel func(error)

build/result.go

@@ -16,7 +16,7 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// NewResultHandle stores a gateway client, gateway result, and the error from
+// NewResultHandle stores a gateway client, gateway reference, and the error from
 // an evaluate call if it is present.
 //
 // This ResultHandle can be used to execute additional build steps in the same
@@ -24,9 +24,10 @@ import (
 // failures and successes.
 //
 // If the returned ResultHandle is not nil, the caller must call Done() on it.
-func NewResultHandle(ctx context.Context, c gateway.Client, res *gateway.Result, err error) *ResultHandle {
+func NewResultHandle(ctx context.Context, c gateway.Client, ref gateway.Reference, meta map[string][]byte, err error) *ResultHandle {
 	rCtx := &ResultHandle{
-		res:      res,
+		ref:      ref,
+		meta:     meta,
 		gwClient: c,
 	}
 	if err != nil && !errors.As(err, &rCtx.solveErr) {
@@ -37,8 +38,9 @@ func NewResultHandle(ctx context.Context, c gateway.Client, res *gateway.Result,
 
 // ResultHandle is a build result with the client that built it.
 type ResultHandle struct {
-	res      *gateway.Result
+	ref      gateway.Reference
 	solveErr *errdefs.SolveError
+	meta     map[string][]byte
 	gwClient gateway.Client
 
 	doneOnce sync.Once
@@ -74,9 +76,9 @@ func (r *ResultHandle) NewContainer(ctx context.Context, cfg *InvokeConfig) (gat
 }
 
 func (r *ResultHandle) getContainerConfig(cfg *InvokeConfig) (containerCfg gateway.NewContainerRequest, _ error) {
-	if r.res != nil && r.solveErr == nil {
+	if r.ref != nil && r.solveErr == nil {
 		logrus.Debugf("creating container from successful build")
-		ccfg, err := containerConfigFromResult(r.res, cfg)
+		ccfg, err := containerConfigFromResult(r.ref, cfg)
 		if err != nil {
 			return containerCfg, err
 		}
@@ -94,9 +96,9 @@ func (r *ResultHandle) getContainerConfig(cfg *InvokeConfig) (containerCfg gatew
 
 func (r *ResultHandle) getProcessConfig(cfg *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 {
+	if r.ref != nil && r.solveErr == nil {
 		logrus.Debugf("creating container from successful build")
-		if err := populateProcessConfigFromResult(&processCfg, r.res, cfg); err != nil {
+		if err := populateProcessConfigFromResult(&processCfg, r.meta, cfg); err != nil {
 			return processCfg, err
 		}
 	} else {
@@ -108,20 +110,11 @@ func (r *ResultHandle) getProcessConfig(cfg *InvokeConfig, stdin io.ReadCloser,
 	return processCfg, nil
 }
 
-func containerConfigFromResult(res *gateway.Result, cfg *InvokeConfig) (*gateway.NewContainerRequest, error) {
+func containerConfigFromResult(ref gateway.Reference, cfg *InvokeConfig) (*gateway.NewContainerRequest, error) {
 	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")
 	}
 
-	ps, err := exptypes.ParsePlatforms(res.Metadata)
-	if err != nil {
-		return nil, err
-	}
-	ref, ok := res.FindRef(ps.Platforms[0].ID)
-	if !ok {
-		return nil, errors.Errorf("no reference found")
-	}
-
 	return &gateway.NewContainerRequest{
 		Mounts: []gateway.Mount{
 			{
@@ -133,8 +126,8 @@ func containerConfigFromResult(res *gateway.Result, cfg *InvokeConfig) (*gateway
 	}, nil
 }
 
-func populateProcessConfigFromResult(req *gateway.StartRequest, res *gateway.Result, cfg *InvokeConfig) error {
-	imgData := res.Metadata[exptypes.ExporterImageConfigKey]
+func populateProcessConfigFromResult(req *gateway.StartRequest, meta map[string][]byte, cfg *InvokeConfig) error {
+	imgData := meta[exptypes.ExporterImageConfigKey]
 	var img *ocispecs.Image
 	if len(imgData) > 0 {
 		img = &ocispecs.Image{}

commands/build.go

@@ -20,7 +20,6 @@ import (
 	"github.com/containerd/console"
 	"github.com/docker/buildx/build"
 	"github.com/docker/buildx/builder"
-	"github.com/docker/buildx/monitor"
 	"github.com/docker/buildx/store"
 	"github.com/docker/buildx/store/storeutil"
 	"github.com/docker/buildx/util/buildflags"
@@ -28,6 +27,7 @@ import (
 	"github.com/docker/buildx/util/confutil"
 	"github.com/docker/buildx/util/desktop"
 	"github.com/docker/buildx/util/dockerutil"
+	"github.com/docker/buildx/util/ioset"
 	"github.com/docker/buildx/util/metricutil"
 	"github.com/docker/buildx/util/osutil"
 	"github.com/docker/buildx/util/platformutil"
@@ -55,7 +55,6 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-	"github.com/tonistiigi/go-csvvalue"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/metric"
 	"google.golang.org/grpc/codes"
@@ -100,8 +99,6 @@ type buildOptions struct {
 	pull         bool
 	exportPush   bool
 	exportLoad   bool
-
-	invokeConfig *invokeConfig
 }
 
 func (o *buildOptions) toOptions() (*BuildOptions, error) {
@@ -276,7 +273,7 @@ func (o *buildOptionsHash) String() string {
 	return o.result
 }
 
-func runBuild(ctx context.Context, dockerCli command.Cli, options buildOptions) (err error) {
+func runBuild(ctx context.Context, dockerCli command.Cli, debugOpts debuggerOptions, options buildOptions) (err error) {
 	mp := dockerCli.MeterProvider()
 
 	ctx, end, err := tracing.TraceCurrentCommand(ctx, []string{"build", options.contextPath},
@@ -320,10 +317,6 @@ func runBuild(ctx context.Context, dockerCli command.Cli, options buildOptions)
 	}
 	driverType := b.Driver
 
-	var term bool
-	if _, err := console.ConsoleFromFile(os.Stderr); err == nil {
-		term = true
-	}
 	attributes := buildMetricAttributes(dockerCli, driverType, &options)
 
 	ctx2, cancel := context.WithCancelCause(context.TODO())
@@ -332,8 +325,38 @@ func runBuild(ctx context.Context, dockerCli command.Cli, options buildOptions)
 	if err != nil {
 		return err
 	}
+
+	var (
+		out io.Writer = os.Stderr
+		dbg debuggerInstance
+	)
+
+	if debugOpts != nil {
+		if options.dockerfileName == "-" || options.contextPath == "-" {
+			// stdin must be usable for debugger
+			return errors.Errorf("Dockerfile or context from stdin is not supported with debugger")
+		}
+
+		dbg, err = debugOpts.New(ioset.In{
+			Stdin:  io.NopCloser(dockerCli.In()),
+			Stdout: nopCloser{dockerCli.Out()},
+			Stderr: nopCloser{dockerCli.Err()},
+		})
+		if err != nil {
+			return err
+		}
+		out = dbg.Out()
+	}
+
+	var term bool
+	if c, ok := out.(console.File); ok {
+		if _, err := console.ConsoleFromFile(c); err == nil {
+			term = true
+		}
+	}
+
 	var printer *progress.Printer
-	printer, err = progress.NewPrinter(ctx2, os.Stderr, progressMode,
+	printer, err = progress.NewPrinter(ctx2, out, progressMode,
 		progress.WithDesc(
 			fmt.Sprintf("building with %q instance using %s driver", b.Name, b.Driver),
 			fmt.Sprintf("%s:%s", b.Driver, b.Name),
@@ -348,7 +371,7 @@ func runBuild(ctx context.Context, dockerCli command.Cli, options buildOptions)
 	}
 
 	done := timeBuildCommand(mp, attributes)
-	resp, inputs, retErr := runBuildWithOptions(ctx, dockerCli, opts, options, printer)
+	resp, inputs, retErr := runBuildWithOptions(ctx, dockerCli, opts, dbg, printer)
 
 	if err := printer.Wait(); retErr == nil {
 		retErr = err
@@ -406,26 +429,19 @@ func getImageID(resp map[string]string) string {
 	return dgst
 }
 
-func runBuildWithOptions(ctx context.Context, dockerCli command.Cli, opts *BuildOptions, options buildOptions, printer *progress.Printer) (_ *client.SolveResponse, _ *build.Inputs, retErr error) {
-	if options.invokeConfig != nil && (options.dockerfileName == "-" || options.contextPath == "-") {
-		// stdin must be usable for monitor
-		return nil, nil, errors.Errorf("Dockerfile or context from stdin is not supported with invoke")
+func runBuildWithOptions(ctx context.Context, dockerCli command.Cli, opts *BuildOptions, dbg debuggerInstance, printer *progress.Printer) (_ *client.SolveResponse, _ *build.Inputs, retErr error) {
+	var bh build.Handler
+	if dbg != nil {
+		if err := dbg.Start(printer, opts); err != nil {
+			return nil, nil, err
 		}
+		defer dbg.Stop()
 
-	var (
-		in io.ReadCloser
-		m  *monitor.Monitor
-		bh build.Handler
-	)
-	if options.invokeConfig == nil {
-		in = dockerCli.In()
-	} else {
-		m = monitor.New(&options.invokeConfig.InvokeConfig, dockerCli.In(), os.Stdout, os.Stderr, printer)
-		defer m.Close()
-
-		bh = m.Handler()
+		bh = dbg.Handler()
+		dockerCli.SetIn(nil)
 	}
 
+	in := dockerCli.In()
 	for {
 		resp, inputs, err := RunBuild(ctx, dockerCli, opts, in, printer, &bh)
 		if err != nil {
@@ -440,7 +456,7 @@ func runBuildWithOptions(ctx context.Context, dockerCli command.Cli, opts *Build
 	}
 }
 
-func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugConfig *debugOptions) *cobra.Command {
+func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugger debuggerOptions) *cobra.Command {
 	cFlags := &commonFlags{}
 	options := &buildOptions{}
 
@@ -453,7 +469,9 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugConfig *debugOp
 			"aliases": "docker build, docker builder build, docker image build, docker buildx b",
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) > 0 {
 				options.contextPath = args[0]
+			}
 			options.builder = rootOpts.builder
 			options.metadataFile = cFlags.metadataFile
 			options.noCache = false
@@ -467,15 +485,7 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions, debugConfig *debugOp
 			options.progress = cFlags.progress
 			cmd.Flags().VisitAll(checkWarnedFlags)
 
-			if debugConfig != nil && (debugConfig.InvokeFlag != "" || debugConfig.OnFlag != "") {
-				iConfig := new(invokeConfig)
-				if err := iConfig.parseInvokeConfig(debugConfig.InvokeFlag, debugConfig.OnFlag); err != nil {
-					return err
-				}
-				options.invokeConfig = iConfig
-			}
-
-			return runBuild(cmd.Context(), dockerCli, *options)
+			return runBuild(cmd.Context(), dockerCli, debugger, *options)
 		},
 		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 			return nil, cobra.ShellCompDirectiveFilterDirs
@@ -866,96 +876,6 @@ func printValue(w io.Writer, printer callFunc, version string, format string, re
 	return printer([]byte(res["result.json"]), w)
 }
 
-type invokeConfig struct {
-	build.InvokeConfig
-	invokeFlag string
-}
-
-func (cfg *invokeConfig) parseInvokeConfig(invoke, on string) error {
-	switch on {
-	case "always":
-		cfg.SuspendOn = build.SuspendAlways
-	case "error":
-		cfg.SuspendOn = build.SuspendError
-	default:
-		if invoke != "" {
-			cfg.SuspendOn = build.SuspendAlways
-		}
-	}
-
-	cfg.invokeFlag = invoke
-	cfg.Tty = true
-	cfg.NoCmd = true
-	switch invoke {
-	case "default", "":
-		return 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"}
-		cfg.NoCmd = false
-		return nil
-	}
-
-	csvParser := csvvalue.NewParser()
-	csvParser.LazyQuotes = true
-	fields, err := csvParser.Fields(invoke, nil)
-	if err != nil {
-		return err
-	}
-	if len(fields) == 1 && !strings.Contains(fields[0], "=") {
-		cfg.Cmd = []string{fields[0]}
-		cfg.NoCmd = false
-		return nil
-	}
-	cfg.NoUser = true
-	cfg.NoCwd = true
-	for _, field := range fields {
-		parts := strings.SplitN(field, "=", 2)
-		if len(parts) != 2 {
-			return errors.Errorf("invalid value %s", field)
-		}
-		key := strings.ToLower(parts[0])
-		value := parts[1]
-		switch key {
-		case "args":
-			cfg.Cmd = append(cfg.Cmd, maybeJSONArray(value)...)
-			cfg.NoCmd = false
-		case "entrypoint":
-			cfg.Entrypoint = append(cfg.Entrypoint, maybeJSONArray(value)...)
-			if cfg.Cmd == nil {
-				cfg.Cmd = []string{}
-				cfg.NoCmd = false
-			}
-		case "env":
-			cfg.Env = append(cfg.Env, maybeJSONArray(value)...)
-		case "user":
-			cfg.User = value
-			cfg.NoUser = false
-		case "cwd":
-			cfg.Cwd = value
-			cfg.NoCwd = false
-		case "tty":
-			cfg.Tty, err = strconv.ParseBool(value)
-			if err != nil {
-				return errors.Errorf("failed to parse tty: %v", err)
-			}
-		default:
-			return errors.Errorf("unknown key %q", key)
-		}
-	}
-	return nil
-}
-
-func maybeJSONArray(v string) []string {
-	var list []string
-	if err := json.Unmarshal([]byte(v), &list); err == nil {
-		return list
-	}
-	return []string{v}
-}
-
 func callAlias(target *string, value string) cobrautil.BoolFuncValue {
 	return func(s string) error {
 		v, err := strconv.ParseBool(s)
@@ -1210,3 +1130,11 @@ func RunBuild(ctx context.Context, dockerCli command.Cli, in *BuildOptions, inSt
 	}
 	return resp[defaultTargetName], inputs, nil
 }
+
+type nopCloser struct {
+	io.Writer
+}
+
+func (nopCloser) Close() error {
+	return nil
+}

commands/dap.go

@@ -0,0 +1,81 @@
+package commands
+
+import (
+	"context"
+
+	"github.com/docker/buildx/dap"
+	"github.com/docker/buildx/util/cobrautil"
+	"github.com/docker/buildx/util/ioset"
+	"github.com/docker/buildx/util/progress"
+	"github.com/docker/cli/cli/command"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+func dapCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
+	var options dapOptions
+	cmd := &cobra.Command{
+		Use:   "dap",
+		Short: "Start debug adapter protocol compatible debugger",
+	}
+	cobrautil.MarkCommandExperimental(cmd)
+
+	flags := cmd.Flags()
+	flags.StringVar(&options.OnFlag, "on", "error", "When to pause the adapter ([always, error])")
+
+	cobrautil.MarkFlagsExperimental(flags, "on")
+
+	dapBuildCmd := buildCmd(dockerCli, rootOpts, &options)
+	dapBuildCmd.Args = cobra.RangeArgs(0, 1)
+	cmd.AddCommand(dapBuildCmd)
+	return cmd
+}
+
+type dapOptions struct {
+	// OnFlag is a flag to configure the timing of launching the debugger.
+	OnFlag string
+}
+
+func (d *dapOptions) New(in ioset.In) (debuggerInstance, error) {
+	invokeConfig, err := parseInvokeConfig("", d.OnFlag)
+	if err != nil {
+		return nil, err
+	}
+
+	conn := dap.NewConn(in.Stdin, in.Stdout)
+	return &adapterProtocolDebugger{
+		Adapter: dap.New[LaunchConfig](invokeConfig),
+		conn:    conn,
+	}, nil
+}
+
+type LaunchConfig struct {
+	Dockerfile  string `json:"dockerfile,omitempty"`
+	ContextPath string `json:"contextPath,omitempty"`
+	Target      string `json:"target,omitempty"`
+}
+
+type adapterProtocolDebugger struct {
+	*dap.Adapter[LaunchConfig]
+	conn dap.Conn
+}
+
+func (d *adapterProtocolDebugger) Start(printer *progress.Printer, opts *BuildOptions) error {
+	cfg, err := d.Adapter.Start(context.Background(), d.conn)
+	if err != nil {
+		return errors.Wrap(err, "debug adapter did not start")
+	}
+
+	if cfg.Dockerfile != "" {
+		opts.DockerfileName = cfg.Dockerfile
+	}
+	if cfg.ContextPath != "" {
+		opts.ContextPath = cfg.ContextPath
+	}
+	return nil
+}
+
+func (d *adapterProtocolDebugger) Stop() error {
+	defer d.conn.Close()
+	return d.Adapter.Stop()
+}

commands/debug.go

@@ -1,9 +1,21 @@
 package commands
 
 import (
+	"encoding/json"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/docker/buildx/build"
+	"github.com/docker/buildx/monitor"
 	"github.com/docker/buildx/util/cobrautil"
+	"github.com/docker/buildx/util/ioset"
+	"github.com/docker/buildx/util/progress"
 	"github.com/docker/cli/cli/command"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/tonistiigi/go-csvvalue"
 )
 
 type debugOptions struct {
@@ -14,9 +26,21 @@ type debugOptions struct {
 	OnFlag string
 }
 
+// debuggerOptions will start a debuggerOptions instance.
+type debuggerOptions interface {
+	New(in ioset.In) (debuggerInstance, error)
+}
+
+// debuggerInstance is an instance of a Debugger that has been started.
+type debuggerInstance interface {
+	Start(printer *progress.Printer, opts *BuildOptions) error
+	Handler() build.Handler
+	Stop() error
+	Out() io.Writer
+}
+
 func debugCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	var options debugOptions
-
 	cmd := &cobra.Command{
 		Use:   "debug",
 		Short: "Start debugger",
@@ -32,3 +56,123 @@ func debugCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	cmd.AddCommand(buildCmd(dockerCli, rootOpts, &options))
 	return cmd
 }
+
+func (d *debugOptions) New(in ioset.In) (debuggerInstance, error) {
+	cfg, err := parseInvokeConfig(d.InvokeFlag, d.OnFlag)
+	if err != nil {
+		return nil, err
+	}
+
+	return &monitorDebuggerInstance{
+		cfg: cfg,
+		in:  in.Stdin,
+	}, nil
+}
+
+type monitorDebuggerInstance struct {
+	cfg *build.InvokeConfig
+	in  io.ReadCloser
+	m   *monitor.Monitor
+}
+
+func (d *monitorDebuggerInstance) Start(printer *progress.Printer, opts *BuildOptions) error {
+	d.m = monitor.New(d.cfg, d.in, os.Stdout, os.Stderr, printer)
+	return nil
+}
+
+func (d *monitorDebuggerInstance) Handler() build.Handler {
+	return d.m.Handler()
+}
+
+func (d *monitorDebuggerInstance) Stop() error {
+	return d.m.Close()
+}
+
+func (d *monitorDebuggerInstance) Out() io.Writer {
+	return os.Stderr
+}
+
+func parseInvokeConfig(invoke, on string) (*build.InvokeConfig, error) {
+	cfg := &build.InvokeConfig{}
+	switch on {
+	case "always":
+		cfg.SuspendOn = build.SuspendAlways
+	case "error":
+		cfg.SuspendOn = build.SuspendError
+	default:
+		if invoke != "" {
+			cfg.SuspendOn = build.SuspendAlways
+		}
+	}
+
+	cfg.Tty = true
+	cfg.NoCmd = true
+	switch invoke {
+	case "default", "":
+		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"}
+		cfg.NoCmd = false
+		return cfg, nil
+	}
+
+	csvParser := csvvalue.NewParser()
+	csvParser.LazyQuotes = true
+	fields, err := csvParser.Fields(invoke, nil)
+	if err != nil {
+		return nil, err
+	}
+	if len(fields) == 1 && !strings.Contains(fields[0], "=") {
+		cfg.Cmd = []string{fields[0]}
+		cfg.NoCmd = false
+		return cfg, nil
+	}
+	cfg.NoUser = true
+	cfg.NoCwd = true
+	for _, field := range fields {
+		parts := strings.SplitN(field, "=", 2)
+		if len(parts) != 2 {
+			return nil, errors.Errorf("invalid value %s", field)
+		}
+		key := strings.ToLower(parts[0])
+		value := parts[1]
+		switch key {
+		case "args":
+			cfg.Cmd = append(cfg.Cmd, maybeJSONArray(value)...)
+			cfg.NoCmd = false
+		case "entrypoint":
+			cfg.Entrypoint = append(cfg.Entrypoint, maybeJSONArray(value)...)
+			if cfg.Cmd == nil {
+				cfg.Cmd = []string{}
+				cfg.NoCmd = false
+			}
+		case "env":
+			cfg.Env = append(cfg.Env, maybeJSONArray(value)...)
+		case "user":
+			cfg.User = value
+			cfg.NoUser = false
+		case "cwd":
+			cfg.Cwd = value
+			cfg.NoCwd = false
+		case "tty":
+			cfg.Tty, err = strconv.ParseBool(value)
+			if err != nil {
+				return nil, errors.Errorf("failed to parse tty: %v", err)
+			}
+		default:
+			return nil, errors.Errorf("unknown key %q", key)
+		}
+	}
+	return cfg, nil
+}
+
+func maybeJSONArray(v string) []string {
+	var list []string
+	if err := json.Unmarshal([]byte(v), &list); err == nil {
+		return list
+	}
+	return []string{v}
+}

commands/root.go

@@ -120,6 +120,7 @@ func addCommands(cmd *cobra.Command, opts *rootOptions, dockerCli command.Cli) {
 	)
 	if confutil.IsExperimental() {
 		cmd.AddCommand(debugCmd(dockerCli, opts))
+		cmd.AddCommand(dapCmd(dockerCli, opts))
 	}
 
 	cmd.RegisterFlagCompletionFunc( //nolint:errcheck

dap/adapter.go

@@ -0,0 +1,456 @@
+package dap
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"sync"
+
+	"github.com/docker/buildx/build"
+	"github.com/google/go-dap"
+	gateway "github.com/moby/buildkit/frontend/gateway/client"
+	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
+)
+
+type Adapter[T any] struct {
+	srv *Server
+	eg  *errgroup.Group
+	cfg build.InvokeConfig
+
+	initialized   chan struct{}
+	started       chan launchResponse[T]
+	configuration chan struct{}
+
+	evaluateReqCh chan *evaluateRequest
+
+	threads      map[int]*thread
+	threadsMu    sync.RWMutex
+	nextThreadID int
+}
+
+func New[T any](cfg *build.InvokeConfig) *Adapter[T] {
+	d := &Adapter[T]{
+		initialized:   make(chan struct{}),
+		started:       make(chan launchResponse[T], 1),
+		configuration: make(chan struct{}),
+		evaluateReqCh: make(chan *evaluateRequest),
+		threads:       make(map[int]*thread),
+		nextThreadID:  1,
+	}
+	if cfg != nil {
+		d.cfg = *cfg
+	}
+	d.srv = NewServer(d.dapHandler())
+	return d
+}
+
+func (d *Adapter[T]) Start(ctx context.Context, conn Conn) (T, error) {
+	d.eg, _ = errgroup.WithContext(ctx)
+	d.eg.Go(func() error {
+		return d.srv.Serve(ctx, conn)
+	})
+
+	<-d.initialized
+
+	resp, ok := <-d.started
+	if !ok {
+		resp.Error = context.Canceled
+	}
+	return resp.Config, resp.Error
+}
+
+func (d *Adapter[T]) Stop() error {
+	if d.eg == nil {
+		return nil
+	}
+
+	d.srv.Go(func(c Context) {
+		c.C() <- &dap.TerminatedEvent{
+			Event: dap.Event{
+				Event: "terminated",
+			},
+		}
+		// TODO: detect exit code from threads
+		// c.C() <- &dap.ExitedEvent{
+		// 	Event: dap.Event{
+		// 		Event: "exited",
+		// 	},
+		// 	Body: dap.ExitedEventBody{
+		// 		ExitCode: exitCode,
+		// 	},
+		// }
+	})
+	d.srv.Stop()
+
+	err := d.eg.Wait()
+	d.eg = nil
+	return err
+}
+
+func (d *Adapter[T]) Initialize(c Context, req *dap.InitializeRequest, resp *dap.InitializeResponse) error {
+	close(d.initialized)
+
+	// Set capabilities.
+	resp.Body.SupportsConfigurationDoneRequest = true
+	return nil
+}
+
+type launchResponse[T any] struct {
+	Config T
+	Error  error
+}
+
+func (d *Adapter[T]) Launch(c Context, req *dap.LaunchRequest, resp *dap.LaunchResponse) error {
+	defer close(d.started)
+
+	var cfg T
+	if err := json.Unmarshal(req.Arguments, &cfg); err != nil {
+		d.started <- launchResponse[T]{Error: err}
+		return err
+	}
+
+	d.start(c)
+
+	d.started <- launchResponse[T]{Config: cfg}
+	return nil
+}
+
+func (d *Adapter[T]) Disconnect(c Context, req *dap.DisconnectRequest, resp *dap.DisconnectResponse) error {
+	close(d.evaluateReqCh)
+	return nil
+}
+
+func (d *Adapter[T]) start(c Context) {
+	c.Go(d.launch)
+}
+
+func (d *Adapter[T]) Continue(c Context, req *dap.ContinueRequest, resp *dap.ContinueResponse) error {
+	d.threadsMu.RLock()
+	t := d.threads[req.Arguments.ThreadId]
+	d.threadsMu.RUnlock()
+
+	t.Resume(c)
+	return nil
+}
+
+func (d *Adapter[T]) SetBreakpoints(c Context, req *dap.SetBreakpointsRequest, resp *dap.SetBreakpointsResponse) error {
+	// TODO: implement breakpoints
+	for range req.Arguments.Breakpoints {
+		// Fail to create all breakpoints that were requested.
+		resp.Body.Breakpoints = append(resp.Body.Breakpoints, dap.Breakpoint{
+			Verified: false,
+			Message:  "breakpoints unsupported",
+		})
+	}
+	return nil
+}
+
+func (d *Adapter[T]) ConfigurationDone(c Context, req *dap.ConfigurationDoneRequest, resp *dap.ConfigurationDoneResponse) error {
+	d.configuration <- struct{}{}
+	close(d.configuration)
+	return nil
+}
+
+func (d *Adapter[T]) launch(c Context) {
+	// Send initialized event.
+	c.C() <- &dap.InitializedEvent{
+		Event: dap.Event{
+			Event: "initialized",
+		},
+	}
+
+	// Wait for configuration.
+	select {
+	case <-c.Done():
+		return
+	case <-d.configuration:
+		// TODO: actual configuration
+	}
+
+	for {
+		select {
+		case <-c.Done():
+			return
+		case req, ok := <-d.evaluateReqCh:
+			if !ok {
+				return
+			}
+
+			t := d.newThread(c, req.name)
+			started := c.Go(func(c Context) {
+				defer d.deleteThread(c, t)
+				defer close(req.errCh)
+				req.errCh <- t.Evaluate(c, req.c, req.ref, req.meta, d.cfg)
+			})
+
+			if !started {
+				req.errCh <- context.Canceled
+				close(req.errCh)
+			}
+		}
+	}
+}
+
+func (d *Adapter[T]) newThread(ctx Context, name string) (t *thread) {
+	d.threadsMu.Lock()
+	id := d.nextThreadID
+	t = &thread{
+		id:   id,
+		name: name,
+	}
+	d.threads[t.id] = t
+	d.nextThreadID++
+	d.threadsMu.Unlock()
+
+	ctx.C() <- &dap.ThreadEvent{
+		Event: dap.Event{Event: "thread"},
+		Body: dap.ThreadEventBody{
+			Reason:   "started",
+			ThreadId: t.id,
+		},
+	}
+	return t
+}
+
+func (d *Adapter[T]) getThread(id int) (t *thread) {
+	d.threadsMu.Lock()
+	t = d.threads[id]
+	d.threadsMu.Unlock()
+	return t
+}
+
+func (d *Adapter[T]) deleteThread(ctx Context, t *thread) {
+	d.threadsMu.Lock()
+	delete(d.threads, t.id)
+	d.threadsMu.Unlock()
+
+	ctx.C() <- &dap.ThreadEvent{
+		Event: dap.Event{Event: "thread"},
+		Body: dap.ThreadEventBody{
+			Reason:   "exited",
+			ThreadId: t.id,
+		},
+	}
+}
+
+type evaluateRequest struct {
+	name  string
+	c     gateway.Client
+	ref   gateway.Reference
+	meta  map[string][]byte
+	errCh chan<- error
+}
+
+func (d *Adapter[T]) EvaluateResult(ctx context.Context, name string, c gateway.Client, res *gateway.Result) error {
+	eg, _ := errgroup.WithContext(ctx)
+	if res.Ref != nil {
+		eg.Go(func() error {
+			return d.evaluateRef(ctx, name, c, res.Ref, res.Metadata)
+		})
+	}
+
+	for k, ref := range res.Refs {
+		refName := fmt.Sprintf("%s (%s)", name, k)
+		eg.Go(func() error {
+			return d.evaluateRef(ctx, refName, c, ref, res.Metadata)
+		})
+	}
+	return eg.Wait()
+}
+
+func (d *Adapter[T]) evaluateRef(ctx context.Context, name string, c gateway.Client, ref gateway.Reference, meta map[string][]byte) error {
+	errCh := make(chan error, 1)
+
+	// Send a solve request to the launch routine
+	// which will perform the solve in the context of the server.
+	ereq := &evaluateRequest{
+		name:  name,
+		c:     c,
+		ref:   ref,
+		meta:  meta,
+		errCh: errCh,
+	}
+	select {
+	case d.evaluateReqCh <- ereq:
+	case <-ctx.Done():
+		return context.Cause(ctx)
+	}
+
+	// Wait for the response.
+	select {
+	case err := <-errCh:
+		return err
+	case <-ctx.Done():
+		return context.Cause(ctx)
+	}
+}
+
+func (d *Adapter[T]) Threads(c Context, req *dap.ThreadsRequest, resp *dap.ThreadsResponse) error {
+	d.threadsMu.RLock()
+	defer d.threadsMu.RUnlock()
+
+	resp.Body.Threads = []dap.Thread{}
+	for _, t := range d.threads {
+		resp.Body.Threads = append(resp.Body.Threads, dap.Thread{
+			Id:   t.id,
+			Name: t.name,
+		})
+	}
+	return nil
+}
+
+func (d *Adapter[T]) StackTrace(c Context, req *dap.StackTraceRequest, resp *dap.StackTraceResponse) error {
+	t := d.getThread(req.Arguments.ThreadId)
+	if t == nil {
+		return errors.Errorf("no such thread: %d", req.Arguments.ThreadId)
+	}
+
+	resp.Body.StackFrames = t.StackFrames()
+	return nil
+}
+
+func (d *Adapter[T]) evaluate(ctx context.Context, name string, c gateway.Client, res *gateway.Result) error {
+	errCh := make(chan error, 1)
+
+	started := d.srv.Go(func(ctx Context) {
+		defer close(errCh)
+		errCh <- d.EvaluateResult(ctx, name, c, res)
+	})
+	if !started {
+		return context.Canceled
+	}
+
+	select {
+	case err := <-errCh:
+		return err
+	case <-ctx.Done():
+		return context.Cause(ctx)
+	}
+}
+
+func (d *Adapter[T]) Handler() build.Handler {
+	return build.Handler{
+		Evaluate: d.evaluate,
+	}
+}
+
+func (d *Adapter[T]) dapHandler() Handler {
+	return Handler{
+		Initialize:        d.Initialize,
+		Launch:            d.Launch,
+		Continue:          d.Continue,
+		SetBreakpoints:    d.SetBreakpoints,
+		ConfigurationDone: d.ConfigurationDone,
+		Disconnect:        d.Disconnect,
+		Threads:           d.Threads,
+		StackTrace:        d.StackTrace,
+	}
+}
+
+type thread struct {
+	id   int
+	name string
+
+	paused chan struct{}
+	rCtx   *build.ResultHandle
+	mu     sync.Mutex
+}
+
+func (t *thread) Evaluate(ctx Context, c gateway.Client, ref gateway.Reference, meta map[string][]byte, cfg build.InvokeConfig) error {
+	err := ref.Evaluate(ctx)
+	if reason, desc := t.needsDebug(cfg, err); reason != "" {
+		rCtx := build.NewResultHandle(ctx, c, ref, meta, err)
+
+		select {
+		case <-t.pause(ctx, rCtx, reason, desc):
+		case <-ctx.Done():
+			t.Resume(ctx)
+			return context.Cause(ctx)
+		}
+	}
+	return err
+}
+
+func (t *thread) needsDebug(cfg build.InvokeConfig, err error) (reason, desc string) {
+	if !cfg.NeedsDebug(err) {
+		return
+	}
+
+	if err != nil {
+		reason = "exception"
+		desc = "Encountered an error during result evaluation"
+	} else {
+		reason = "pause"
+		desc = "Result evaluation completed"
+	}
+	return
+}
+
+func (t *thread) pause(c Context, rCtx *build.ResultHandle, reason, desc string) <-chan struct{} {
+	if t.paused == nil {
+		t.paused = make(chan struct{})
+	}
+	t.rCtx = rCtx
+
+	c.C() <- &dap.StoppedEvent{
+		Event: dap.Event{Event: "stopped"},
+		Body: dap.StoppedEventBody{
+			Reason:      reason,
+			Description: desc,
+			ThreadId:    t.id,
+		},
+	}
+	return t.paused
+}
+
+func (t *thread) Resume(c Context) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	if t.paused == nil {
+		return
+	}
+
+	if t.rCtx != nil {
+		t.rCtx.Done()
+		t.rCtx = nil
+	}
+
+	close(t.paused)
+	t.paused = nil
+}
+
+// TODO: return a suitable stack frame for the thread.
+// For now, just returns nothing.
+func (t *thread) StackFrames() []dap.StackFrame {
+	return []dap.StackFrame{}
+}
+
+func (d *Adapter[T]) Out() io.Writer {
+	return &adapterWriter[T]{d}
+}
+
+type adapterWriter[T any] struct {
+	*Adapter[T]
+}
+
+func (d *adapterWriter[T]) Write(p []byte) (n int, err error) {
+	started := d.srv.Go(func(c Context) {
+		<-d.initialized
+
+		c.C() <- &dap.OutputEvent{
+			Event: dap.Event{Event: "output"},
+			Body: dap.OutputEventBody{
+				Category: "stdout",
+				Output:   string(p),
+			},
+		}
+	})
+
+	if !started {
+		return 0, io.ErrClosedPipe
+	}
+	return n, nil
+}

dap/adapter_test.go

@@ -0,0 +1,129 @@
+package dap
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"testing"
+	"time"
+
+	"github.com/google/go-dap"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/sync/errgroup"
+)
+
+func TestLaunch(t *testing.T) {
+	adapter, conn, client := NewTestAdapter[any](t)
+
+	ctx, cancel := context.WithTimeoutCause(context.Background(), 10*time.Second, context.DeadlineExceeded)
+	defer cancel()
+
+	eg, _ := errgroup.WithContext(ctx)
+	eg.Go(func() error {
+		_, err := adapter.Start(ctx, conn)
+		assert.NoError(t, err)
+		return nil
+	})
+
+	var (
+		initialized       = make(chan struct{})
+		configurationDone <-chan *dap.ConfigurationDoneResponse
+	)
+
+	client.RegisterEvent("initialized", func(em dap.EventMessage) {
+		// Send configuration done since we don't do any configuration.
+		configurationDone = DoRequest[*dap.ConfigurationDoneResponse](t, client, &dap.ConfigurationDoneRequest{
+			Request: dap.Request{Command: "configurationDone"},
+		})
+		close(initialized)
+	})
+
+	eg.Go(func() error {
+		initializeResp := <-DoRequest[*dap.InitializeResponse](t, client, &dap.InitializeRequest{
+			Request: dap.Request{Command: "initialize"},
+		})
+		assert.True(t, initializeResp.Success)
+		assert.True(t, initializeResp.Body.SupportsConfigurationDoneRequest)
+
+		launchResp := <-DoRequest[*dap.LaunchResponse](t, client, &dap.LaunchRequest{
+			Request: dap.Request{Command: "launch"},
+		})
+		assert.True(t, launchResp.Success)
+
+		// We should have received the initialized event.
+		select {
+		case <-initialized:
+		default:
+			assert.Fail(t, "did not receive initialized event")
+		}
+
+		select {
+		case <-configurationDone:
+		case <-time.After(time.Second):
+			assert.Fail(t, "did not receive configurationDone response")
+		}
+		return nil
+	})
+
+	eg.Wait()
+}
+
+func NewTestAdapter[T any](t *testing.T) (*Adapter[T], Conn, *Client) {
+	t.Helper()
+
+	rd1, wr1 := io.Pipe()
+	rd2, wr2 := io.Pipe()
+
+	srvConn := logConn(t, "server", NewConn(rd1, wr2))
+	t.Cleanup(func() {
+		srvConn.Close()
+	})
+
+	clientConn := logConn(t, "client", NewConn(rd2, wr1))
+	t.Cleanup(func() {
+		clientConn.Close()
+	})
+
+	adapter := New[T](nil)
+	t.Cleanup(func() { adapter.Stop() })
+
+	client := NewClient(clientConn)
+	return adapter, srvConn, client
+}
+
+func logConn(t *testing.T, prefix string, conn Conn) Conn {
+	return &loggingConn{
+		Conn:   conn,
+		t:      t,
+		prefix: prefix,
+	}
+}
+
+type loggingConn struct {
+	Conn
+	t      *testing.T
+	prefix string
+}
+
+func (c *loggingConn) SendMsg(m dap.Message) error {
+	b, _ := json.Marshal(m)
+	c.t.Logf("[%s] send: %v", c.prefix, string(b))
+
+	err := c.Conn.SendMsg(m)
+	if err != nil {
+		c.t.Logf("[%s] send error: %v", c.prefix, err)
+	}
+	return err
+}
+
+func (c *loggingConn) RecvMsg(ctx context.Context) (dap.Message, error) {
+	m, err := c.Conn.RecvMsg(ctx)
+	if err != nil {
+		c.t.Logf("[%s] recv error: %v", c.prefix, err)
+		return nil, err
+	}
+
+	b, _ := json.Marshal(m)
+	c.t.Logf("[%s] recv: %v", c.prefix, string(b))
+	return m, nil
+}

dap/client_test.go

@@ -0,0 +1,135 @@
+package dap
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/google/go-dap"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/sync/errgroup"
+)
+
+type Client struct {
+	conn Conn
+
+	requests   map[int]chan<- dap.ResponseMessage
+	requestsMu sync.Mutex
+
+	events   map[string]func(dap.EventMessage)
+	eventsMu sync.RWMutex
+
+	seq    atomic.Int64
+	eg     *errgroup.Group
+	cancel context.CancelCauseFunc
+}
+
+func NewClient(conn Conn) *Client {
+	c := &Client{
+		conn:     conn,
+		requests: make(map[int]chan<- dap.ResponseMessage),
+		events:   make(map[string]func(dap.EventMessage)),
+	}
+
+	var ctx context.Context
+	ctx, c.cancel = context.WithCancelCause(context.Background())
+
+	c.eg, _ = errgroup.WithContext(context.Background())
+	c.eg.Go(func() error {
+		for {
+			m, err := conn.RecvMsg(ctx)
+			if err != nil {
+				if errors.Is(err, context.Canceled) {
+					return nil
+				}
+				return err
+			}
+
+			switch m := m.(type) {
+			case dap.RequestMessage:
+				// TODO: no reverse requests are currently supported
+				conn.SendMsg(&dap.Response{
+					ProtocolMessage: dap.ProtocolMessage{
+						Seq:  c.nextSeq(),
+						Type: "response",
+					},
+					RequestSeq: m.GetRequest().GetSeq(),
+					Success:    false,
+					Command:    m.GetRequest().Command,
+					Message:    "not implemented",
+				})
+			case dap.ResponseMessage:
+				c.requestsMu.Lock()
+				req := m.GetResponse().GetResponse().RequestSeq
+				ch := c.requests[req]
+				delete(c.requests, req)
+				c.requestsMu.Unlock()
+
+				if ch != nil {
+					ch <- m
+				}
+			case dap.EventMessage:
+				c.invokeEventCallback(m)
+			}
+		}
+	})
+	return c
+}
+
+func (c *Client) Do(t *testing.T, req dap.RequestMessage) <-chan dap.ResponseMessage {
+	req.GetRequest().Type = "request"
+	req.GetRequest().Seq = c.nextSeq()
+
+	ch := make(chan dap.ResponseMessage, 1)
+	if err := c.conn.SendMsg(req); err != nil {
+		assert.NoError(t, err)
+		close(ch)
+		return ch
+	}
+
+	c.requestsMu.Lock()
+	c.requests[req.GetSeq()] = ch
+	c.requestsMu.Unlock()
+	return ch
+}
+
+func DoRequest[ResponseMessage dap.ResponseMessage, RequestMessage dap.RequestMessage](t *testing.T, c *Client, req RequestMessage) <-chan ResponseMessage {
+	ch := make(chan ResponseMessage, 1)
+	go func() {
+		defer close(ch)
+
+		if m := <-c.Do(t, req); m != nil {
+			ch <- m.(ResponseMessage)
+		}
+	}()
+	return ch
+}
+
+func (c *Client) RegisterEvent(event string, fn func(dap.EventMessage)) {
+	c.eventsMu.Lock()
+	defer c.eventsMu.Unlock()
+
+	c.events[event] = fn
+}
+
+func (c *Client) invokeEventCallback(event dap.EventMessage) {
+	c.eventsMu.RLock()
+	fn := c.events[event.GetEvent().Event]
+	c.eventsMu.RUnlock()
+
+	if fn != nil {
+		fn(event)
+	}
+}
+
+func (c *Client) Close() error {
+	c.cancel(context.Canceled)
+	return c.eg.Wait()
+}
+
+func (c *Client) nextSeq() int {
+	seq := c.seq.Add(1)
+	return int(seq)
+}

dap/conn.go

@@ -0,0 +1,109 @@
+package dap
+
+import (
+	"bufio"
+	"context"
+	"io"
+	"sync"
+
+	"github.com/google/go-dap"
+	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
+)
+
+type Conn interface {
+	SendMsg(m dap.Message) error
+	RecvMsg(ctx context.Context) (dap.Message, error)
+	io.Closer
+}
+
+type conn struct {
+	recvCh <-chan dap.Message
+	sendCh chan<- dap.Message
+
+	ctx    context.Context
+	cancel context.CancelCauseFunc
+
+	eg   *errgroup.Group
+	once sync.Once
+}
+
+func NewConn(rd io.Reader, wr io.Writer) Conn {
+	recvCh := make(chan dap.Message, 100)
+	sendCh := make(chan dap.Message, 100)
+	errCh := make(chan error, 1)
+
+	// Reader input may never close so this is an orphaned goroutine.
+	// It's ok if it does actually close but not necessary for the
+	// proper functioning of this connection.
+	//
+	// The reason this might not close is because stdin close is controlled
+	// by the OS and can't be closed from within the program.
+	go func() {
+		defer close(errCh)
+		defer close(recvCh)
+
+		rd := bufio.NewReader(rd)
+		for {
+			m, err := dap.ReadProtocolMessage(rd)
+			if err != nil {
+				if !errors.Is(err, io.EOF) {
+					// TODO: not actually using this yet
+					errCh <- err
+				}
+				return
+			}
+			recvCh <- m
+		}
+	}()
+
+	eg, _ := errgroup.WithContext(context.Background())
+	eg.Go(func() error {
+		for m := range sendCh {
+			if err := dap.WriteProtocolMessage(wr, m); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+
+	ctx, cancel := context.WithCancelCause(context.Background())
+	return &conn{
+		recvCh: recvCh,
+		sendCh: sendCh,
+		ctx:    ctx,
+		cancel: cancel,
+		eg:     eg,
+	}
+}
+
+func (c *conn) SendMsg(m dap.Message) error {
+	select {
+	case c.sendCh <- m:
+		return nil
+	default:
+		return errors.New("send channel full")
+	}
+}
+
+func (c *conn) RecvMsg(ctx context.Context) (dap.Message, error) {
+	select {
+	case m, ok := <-c.recvCh:
+		if !ok {
+			return nil, io.EOF
+		}
+		return m, nil
+	case <-ctx.Done():
+		return nil, context.Cause(ctx)
+	case <-c.ctx.Done():
+		return nil, c.ctx.Err()
+	}
+}
+
+func (c *conn) Close() error {
+	c.cancel(context.Canceled)
+	c.once.Do(func() {
+		close(c.sendCh)
+	})
+	return c.eg.Wait()
+}

dap/handler.go

@@ -0,0 +1,58 @@
+package dap
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/google/go-dap"
+	"github.com/pkg/errors"
+)
+
+type Context interface {
+	context.Context
+	C() chan<- dap.Message
+	Go(f func(c Context)) bool
+}
+
+type dispatchContext struct {
+	context.Context
+	srv *Server
+	ch  chan<- dap.Message
+}
+
+func (c *dispatchContext) C() chan<- dap.Message {
+	return c.ch
+}
+
+func (c *dispatchContext) Go(f func(c Context)) bool {
+	return c.srv.Go(f)
+}
+
+type HandlerFunc[Req dap.RequestMessage, Resp dap.ResponseMessage] func(c Context, req Req, resp Resp) error
+
+func (h HandlerFunc[Req, Resp]) Do(c Context, req Req) (resp Resp, err error) {
+	if h == nil {
+		return resp, errors.New("not implemented")
+	}
+
+	respT := reflect.TypeFor[Resp]()
+	rv := reflect.New(respT.Elem())
+	resp = rv.Interface().(Resp)
+	err = h(c, req, resp)
+	return resp, err
+}
+
+type Handler struct {
+	Initialize        HandlerFunc[*dap.InitializeRequest, *dap.InitializeResponse]
+	Launch            HandlerFunc[*dap.LaunchRequest, *dap.LaunchResponse]
+	Attach            HandlerFunc[*dap.AttachRequest, *dap.AttachResponse]
+	SetBreakpoints    HandlerFunc[*dap.SetBreakpointsRequest, *dap.SetBreakpointsResponse]
+	ConfigurationDone HandlerFunc[*dap.ConfigurationDoneRequest, *dap.ConfigurationDoneResponse]
+	Disconnect        HandlerFunc[*dap.DisconnectRequest, *dap.DisconnectResponse]
+	Terminate         HandlerFunc[*dap.TerminateRequest, *dap.TerminateResponse]
+	Continue          HandlerFunc[*dap.ContinueRequest, *dap.ContinueResponse]
+	Restart           HandlerFunc[*dap.RestartRequest, *dap.RestartResponse]
+	Threads           HandlerFunc[*dap.ThreadsRequest, *dap.ThreadsResponse]
+	StackTrace        HandlerFunc[*dap.StackTraceRequest, *dap.StackTraceResponse]
+	Evaluate          HandlerFunc[*dap.EvaluateRequest, *dap.EvaluateResponse]
+}

dap/server.go

@@ -0,0 +1,205 @@
+package dap
+
+import (
+	"context"
+	"sync"
+
+	"github.com/google/go-dap"
+	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
+)
+
+var ErrServerStopped = errors.New("dap: server stopped")
+
+type Server struct {
+	h Handler
+
+	mu sync.RWMutex
+	ch chan dap.Message
+
+	eg     *errgroup.Group
+	ctx    context.Context
+	cancel context.CancelCauseFunc
+
+	initialized bool
+}
+
+func NewServer(h Handler) *Server {
+	return &Server{h: h}
+}
+
+func (s *Server) Serve(ctx context.Context, conn Conn) error {
+	writeCh := make(chan dap.Message)
+	s.ch = writeCh
+
+	s.ctx, s.cancel = context.WithCancelCause(ctx)
+
+	// Start an error group to handle server-initiated tasks.
+	s.eg, _ = errgroup.WithContext(s.ctx)
+	s.eg.Go(func() error {
+		<-s.ctx.Done()
+		return s.ctx.Err()
+	})
+
+	eg, _ := errgroup.WithContext(s.ctx)
+	eg.Go(func() error {
+		return s.readLoop(conn)
+	})
+
+	eg.Go(func() error {
+		return s.writeLoop(conn, writeCh)
+	})
+
+	eg.Go(func() error {
+		// TODO: reevaluate this logic for shutting down
+		defer close(writeCh)
+		err := s.eg.Wait()
+
+		s.mu.Lock()
+		s.ch = nil
+		s.mu.Unlock()
+		return err
+	})
+
+	return eg.Wait()
+}
+
+func (s *Server) readLoop(conn Conn) error {
+	for {
+		m, err := conn.RecvMsg(s.ctx)
+		if err != nil {
+			return nil
+		}
+
+		switch m := m.(type) {
+		case dap.RequestMessage:
+			if ok := s.dispatch(m); !ok {
+				return nil
+			}
+		}
+	}
+}
+
+func (s *Server) dispatch(m dap.RequestMessage) bool {
+	fn := func(c Context) {
+		rmsg, err := s.handleMessage(c, m)
+		if err != nil {
+			rmsg = &dap.Response{}
+			rmsg.GetResponse().Message = err.Error()
+		}
+		rmsg.GetResponse().RequestSeq = m.GetSeq()
+		rmsg.GetResponse().Command = m.GetRequest().Command
+		rmsg.GetResponse().Success = err == nil
+		c.C() <- rmsg
+	}
+	return s.Go(fn)
+}
+
+func (s *Server) handleMessage(c Context, m dap.Message) (dap.ResponseMessage, error) {
+	switch req := m.(type) {
+	case *dap.InitializeRequest:
+		resp, err := s.handleInitialize(c, req)
+		if err != nil {
+			return nil, err
+		}
+		return resp, nil
+	case *dap.LaunchRequest:
+		return s.h.Launch.Do(c, req)
+	case *dap.AttachRequest:
+		return s.h.Attach.Do(c, req)
+	case *dap.SetBreakpointsRequest:
+		return s.h.SetBreakpoints.Do(c, req)
+	case *dap.ConfigurationDoneRequest:
+		return s.h.ConfigurationDone.Do(c, req)
+	case *dap.DisconnectRequest:
+		return s.h.Disconnect.Do(c, req)
+	case *dap.TerminateRequest:
+		return s.h.Terminate.Do(c, req)
+	case *dap.ContinueRequest:
+		return s.h.Continue.Do(c, req)
+	case *dap.RestartRequest:
+		return s.h.Restart.Do(c, req)
+	case *dap.ThreadsRequest:
+		return s.h.Threads.Do(c, req)
+	case *dap.StackTraceRequest:
+		return s.h.StackTrace.Do(c, req)
+	case *dap.EvaluateRequest:
+		return s.h.Evaluate.Do(c, req)
+	default:
+		return nil, errors.New("not implemented")
+	}
+}
+
+func (s *Server) handleInitialize(c Context, req *dap.InitializeRequest) (*dap.InitializeResponse, error) {
+	if s.initialized {
+		return nil, errors.New("already initialized")
+	}
+
+	resp, err := s.h.Initialize.Do(c, req)
+	if err != nil {
+		return nil, err
+	}
+	s.initialized = true
+	return resp, nil
+}
+
+func (s *Server) writeLoop(conn Conn, respCh <-chan dap.Message) error {
+	var seq int
+	for m := range respCh {
+		switch m := m.(type) {
+		case dap.RequestMessage:
+			m.GetRequest().Seq = seq
+			m.GetRequest().Type = "request"
+		case dap.EventMessage:
+			m.GetEvent().Seq = seq
+			m.GetEvent().Type = "event"
+		case dap.ResponseMessage:
+			m.GetResponse().Seq = seq
+			m.GetResponse().Type = "response"
+		}
+		seq++
+
+		if err := conn.SendMsg(m); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *Server) Go(fn func(c Context)) bool {
+	acquireChannel := func() (chan<- dap.Message, bool) {
+		s.mu.RLock()
+		defer s.mu.RUnlock()
+
+		return s.ch, s.ch != nil
+	}
+
+	ctx, cancel := context.WithCancelCause(s.ctx)
+	c := &dispatchContext{
+		Context: ctx,
+		srv:     s,
+	}
+
+	started := make(chan bool, 1)
+	s.eg.Go(func() error {
+		var ok bool
+		c.ch, ok = acquireChannel()
+		started <- ok
+
+		if c.ch == nil {
+			return nil
+		}
+
+		defer cancel(context.Canceled)
+		fn(c)
+		return nil
+	})
+	return <-started
+}
+
+func (s *Server) Stop() {
+	s.mu.Lock()
+	s.ch = nil
+	s.mu.Unlock()
+	s.cancel(ErrServerStopped)
+}

docs/reference/buildx.md

@@ -10,10 +10,11 @@ Extended build capabilities with BuildKit
 ### Subcommands
 
 | Name                                 | Description                                                     |
-|:-------------------------------------|:------------------------------------------------|
+|:-------------------------------------|:----------------------------------------------------------------|
 | [`bake`](buildx_bake.md)             | Build from a file                                               |
 | [`build`](buildx_build.md)           | Start a build                                                   |
 | [`create`](buildx_create.md)         | Create a new builder instance                                   |
+| [`dap`](buildx_dap.md)               | Start debug adapter protocol compatible debugger (EXPERIMENTAL) |
 | [`debug`](buildx_debug.md)           | Start debugger (EXPERIMENTAL)                                   |
 | [`dial-stdio`](buildx_dial-stdio.md) | Proxy current stdio streams to builder instance                 |
 | [`du`](buildx_du.md)                 | Disk usage                                                      |

docs/reference/buildx_dap.md

@@ -0,0 +1,23 @@
+# docker buildx dap
+
+<!---MARKER_GEN_START-->
+Start debug adapter protocol compatible debugger (EXPERIMENTAL)
+
+### Subcommands
+
+| Name                           | Description   |
+|:-------------------------------|:--------------|
+| [`build`](buildx_dap_build.md) | Start a build |
+
+
+### Options
+
+| Name            | Type     | Default | Description                                                |
+|:----------------|:---------|:--------|:-----------------------------------------------------------|
+| `--builder`     | `string` |         | Override the configured builder instance                   |
+| `-D`, `--debug` | `bool`   |         | Enable debug logging                                       |
+| `--on`          | `string` | `error` | When to pause the adapter ([always, error]) (EXPERIMENTAL) |
+
+
+<!---MARKER_GEN_END-->
+

docs/reference/buildx_dap_build.md

@@ -0,0 +1,52 @@
+# docker buildx dap build
+
+<!---MARKER_GEN_START-->
+Start a build
+
+### Aliases
+
+`docker build`, `docker builder build`, `docker image build`, `docker buildx b`
+
+### Options
+
+| Name                | Type          | Default   | Description                                                                                                  |
+|:--------------------|:--------------|:----------|:-------------------------------------------------------------------------------------------------------------|
+| `--add-host`        | `stringSlice` |           | Add a custom host-to-IP mapping (format: `host:ip`)                                                          |
+| `--allow`           | `stringArray` |           | Allow extra privileged entitlement (e.g., `network.host`, `security.insecure`)                               |
+| `--annotation`      | `stringArray` |           | Add annotation to the image                                                                                  |
+| `--attest`          | `stringArray` |           | Attestation parameters (format: `type=sbom,generator=image`)                                                 |
+| `--build-arg`       | `stringArray` |           | Set build-time variables                                                                                     |
+| `--build-context`   | `stringArray` |           | Additional build contexts (e.g., name=path)                                                                  |
+| `--builder`         | `string`      |           | Override the configured builder instance                                                                     |
+| `--cache-from`      | `stringArray` |           | External cache sources (e.g., `user/app:cache`, `type=local,src=path/to/dir`)                                |
+| `--cache-to`        | `stringArray` |           | Cache export destinations (e.g., `user/app:cache`, `type=local,dest=path/to/dir`)                            |
+| `--call`            | `string`      | `build`   | Set method for evaluating build (`check`, `outline`, `targets`)                                              |
+| `--cgroup-parent`   | `string`      |           | Set the parent cgroup for the `RUN` instructions during build                                                |
+| `--check`           | `bool`        |           | Shorthand for `--call=check`                                                                                 |
+| `-D`, `--debug`     | `bool`        |           | Enable debug logging                                                                                         |
+| `-f`, `--file`      | `string`      |           | Name of the Dockerfile (default: `PATH/Dockerfile`)                                                          |
+| `--iidfile`         | `string`      |           | Write the image ID to a file                                                                                 |
+| `--label`           | `stringArray` |           | Set metadata for an image                                                                                    |
+| `--load`            | `bool`        |           | Shorthand for `--output=type=docker`                                                                         |
+| `--metadata-file`   | `string`      |           | Write build result metadata to a file                                                                        |
+| `--network`         | `string`      | `default` | Set the networking mode for the `RUN` instructions during build                                              |
+| `--no-cache`        | `bool`        |           | Do not use cache when building the image                                                                     |
+| `--no-cache-filter` | `stringArray` |           | Do not cache specified stages                                                                                |
+| `-o`, `--output`    | `stringArray` |           | Output destination (format: `type=local,dest=path`)                                                          |
+| `--platform`        | `stringArray` |           | Set target platform for build                                                                                |
+| `--progress`        | `string`      | `auto`    | Set type of progress output (`auto`, `quiet`, `plain`, `tty`, `rawjson`). Use plain to show container output |
+| `--provenance`      | `string`      |           | Shorthand for `--attest=type=provenance`                                                                     |
+| `--pull`            | `bool`        |           | Always attempt to pull all referenced images                                                                 |
+| `--push`            | `bool`        |           | Shorthand for `--output=type=registry`                                                                       |
+| `-q`, `--quiet`     | `bool`        |           | Suppress the build output and print image ID on success                                                      |
+| `--sbom`            | `string`      |           | Shorthand for `--attest=type=sbom`                                                                           |
+| `--secret`          | `stringArray` |           | Secret to expose to the build (format: `id=mysecret[,src=/local/secret]`)                                    |
+| `--shm-size`        | `bytes`       | `0`       | Shared memory size for build containers                                                                      |
+| `--ssh`             | `stringArray` |           | SSH agent socket or keys to expose to the build (format: `default\|<id>[=<socket>\|<key>[,<key>]]`)          |
+| `-t`, `--tag`       | `stringArray` |           | Name and optionally a tag (format: `name:tag`)                                                               |
+| `--target`          | `string`      |           | Set the target build stage to build                                                                          |
+| `--ulimit`          | `ulimit`      |           | Ulimit options                                                                                               |
+
+
+<!---MARKER_GEN_END-->
+

go.mod

@@ -21,6 +21,7 @@ require (
 	github.com/docker/docker v28.2.2+incompatible
 	github.com/docker/go-units v0.5.0
 	github.com/gofrs/flock v0.12.1
+	github.com/google/go-dap v0.12.0
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/google/uuid v1.6.0
 	github.com/hashicorp/go-cty-funcs v0.0.0-20250210171435-dda779884a9f

go.sum

@@ -177,6 +177,8 @@ github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYu
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/go-dap v0.12.0 h1:rVcjv3SyMIrpaOoTAdFDyHs99CwVOItIJGKLQFQhNeM=
+github.com/google/go-dap v0.12.0/go.mod h1:tNjCASCm5cqePi/RVXXWEVqtnNLV1KTWtYOqu6rZNzc=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
 github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=

monitor/monitor.go

@@ -19,6 +19,7 @@ import (
 	"github.com/docker/buildx/util/ioset"
 	"github.com/docker/buildx/util/progress"
 	"github.com/google/shlex"
+	"github.com/moby/buildkit/exporter/containerimage/exptypes"
 	gateway "github.com/moby/buildkit/frontend/gateway/client"
 	"github.com/moby/buildkit/identity"
 	"github.com/moby/buildkit/solver/errdefs"
@@ -56,7 +57,7 @@ func (m *Monitor) Handler() build.Handler {
 	}
 }
 
-func (m *Monitor) Evaluate(ctx context.Context, c gateway.Client, res *gateway.Result) error {
+func (m *Monitor) Evaluate(ctx context.Context, _ string, c gateway.Client, res *gateway.Result) error {
 	buildErr := res.EachRef(func(ref gateway.Reference) error {
 		return ref.Evaluate(ctx)
 	})
@@ -70,7 +71,17 @@ func (m *Monitor) Evaluate(ctx context.Context, c gateway.Client, res *gateway.R
 			logrus.Warnf("failed to print error information: %v", err)
 		}
 
-		rCtx := build.NewResultHandle(ctx, c, res, buildErr)
+		ps, err := exptypes.ParsePlatforms(res.Metadata)
+		if err != nil {
+			return err
+		}
+
+		ref, ok := res.FindRef(ps.Platforms[0].ID)
+		if !ok {
+			return errors.Errorf("no reference found for %s", ps.Platforms[0].ID)
+		}
+
+		rCtx := build.NewResultHandle(ctx, c, ref, res.Metadata, buildErr)
 		if monitorErr := m.Run(ctx, rCtx); monitorErr != nil {
 			if errors.Is(monitorErr, build.ErrRestart) {
 				return build.ErrRestart

util/progress/printer.go

@@ -2,10 +2,10 @@ package progress
 
 import (
 	"context"
+	"io"
 	"os"
 	"sync"
 
-	"github.com/containerd/console"
 	"github.com/docker/buildx/util/logutil"
 	"github.com/mitchellh/hashstructure/v2"
 	"github.com/moby/buildkit/client"
@@ -25,7 +25,7 @@ const (
 )
 
 type Printer struct {
-	out  console.File
+	out  io.Writer
 	mode progressui.DisplayMode
 	opt  *printerOpts
 
@@ -121,7 +121,7 @@ func (p *Printer) ClearLogSource(v any) {
 	}
 }
 
-func NewPrinter(ctx context.Context, out console.File, mode progressui.DisplayMode, opts ...PrinterOpt) (*Printer, error) {
+func NewPrinter(ctx context.Context, out io.Writer, mode progressui.DisplayMode, opts ...PrinterOpt) (*Printer, error) {
 	opt := &printerOpts{}
 	for _, o := range opts {
 		o(opt)

vendor/github.com/google/go-dap/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/google/go-dap/README.md

@@ -0,0 +1,20 @@
+# go-dap: Go implementation of the Debug Adapter Protocol
+
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/google/go-dap)](https://pkg.go.dev/github.com/google/go-dap)
+[![Build Status](https://github.com/google/go-dap/actions/workflows/go.yml/badge.svg?branch=master)](https://github.com/google/go-dap/actions)
+[![Go Report Card](https://goreportcard.com/badge/github.com/google/go-dap)](https://goreportcard.com/report/github.com/google/go-dap)
+
+For an overview of DAP, see
+https://microsoft.github.io/debug-adapter-protocol/overview
+
+## Contributing
+
+We'd love to accept your patches and contributions to this project. See
+[docs/contributing](https://github.com/google/go-dap/blob/master/docs/contributing.md)
+for more details.
+
+## License
+
+This project is licensed under the Apache License 2.0
+
+This is not an officially supported Google product.

vendor/github.com/google/go-dap/codec.go

@@ -0,0 +1,188 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains utilities for decoding JSON-encoded bytes into DAP message.
+
+package dap
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// DecodeProtocolMessageFieldError describes which JSON attribute
+// has an unsupported value that the decoding cannot handle.
+type DecodeProtocolMessageFieldError struct {
+	Seq        int
+	SubType    string
+	FieldName  string
+	FieldValue string
+	Message    json.RawMessage
+}
+
+func (e *DecodeProtocolMessageFieldError) Error() string {
+	return fmt.Sprintf("%s %s '%s' is not supported (seq: %d)", e.SubType, e.FieldName, e.FieldValue, e.Seq)
+}
+
+// defaultCodec is used to decode vanilla DAP messages.
+var defaultCodec = NewCodec()
+
+// Codec is responsible for turning byte blobs into DAP messages.
+type Codec struct {
+	eventCtor    map[string]messageCtor
+	requestCtor  map[string]messageCtor
+	responseCtor map[string]messageCtor
+}
+
+// NewCodec constructs a new codec that extends the vanilla DAP protocol.
+// Unless you need to register custom DAP messages, use
+// DecodeProtocolMessage instead.
+func NewCodec() *Codec {
+	ret := &Codec{
+		eventCtor:    make(map[string]messageCtor),
+		requestCtor:  make(map[string]messageCtor),
+		responseCtor: make(map[string]messageCtor),
+	}
+	for k, v := range eventCtor {
+		ret.eventCtor[k] = v
+	}
+	for k, v := range requestCtor {
+		ret.requestCtor[k] = v
+	}
+	for k, v := range responseCtor {
+		ret.responseCtor[k] = v
+	}
+	return ret
+}
+
+// RegisterRequest registers a new custom DAP command, so that it can be
+// unmarshalled by DecodeMessage. Returns an error when the command already
+// exists.
+//
+// The ctor functions need to return a new instance of the underlying DAP
+// message type. A typical usage looks like this:
+//
+//	reqCtor := func() Message { return &LaunchRequest{} }
+//	respCtor := func() Message { return &LaunchResponse{} }
+//      codec.RegisterRequest("launch", reqCtor, respCtor)
+func (c *Codec) RegisterRequest(command string, requestCtor, responseCtor func() Message) error {
+	_, hasReqCtor := c.requestCtor[command]
+	_, hasRespCtor := c.responseCtor[command]
+	if hasReqCtor || hasRespCtor {
+		return fmt.Errorf("command %q is already registered", command)
+	}
+	c.requestCtor[command] = requestCtor
+	c.responseCtor[command] = responseCtor
+	return nil
+}
+
+// RegisterEvent registers a new custom DAP event, so that it can be
+// unmarshalled by DecodeMessage. Returns an error when the event already
+// exists.
+//
+// The ctor function needs to return a new instance of the underlying DAP
+// message type. A typical usage looks like this:
+//
+//	ctor := func() Message { return &StoppedEvent{} }
+//      codec.RegisterEvent("stopped", ctor)
+func (c *Codec) RegisterEvent(event string, ctor func() Message) error {
+	if _, hasEventCtor := c.eventCtor[event]; hasEventCtor {
+		return fmt.Errorf("event %q is already registered", event)
+	}
+	c.eventCtor[event] = ctor
+	return nil
+}
+
+// DecodeMessage parses the JSON-encoded data and returns the result of
+// the appropriate type within the ProtocolMessage hierarchy. If message type,
+// command, etc cannot be cast, returns DecodeProtocolMessageFieldError.
+// See also godoc for json.Unmarshal, which is used for underlying decoding.
+func (c *Codec) DecodeMessage(data []byte) (Message, error) {
+	// This struct is the union of the ResponseMessage, RequestMessage, and
+	// EventMessage types. It is an optimization that saves an additional
+	// json.Unmarshal call.
+	var m struct {
+		ProtocolMessage
+		Command string `json:"command"`
+		Event   string `json:"event"`
+		Success bool   `json:"success"`
+	}
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil, err
+	}
+	switch m.Type {
+	case "request":
+		return c.decodeRequest(m.Command, m.Seq, data)
+	case "response":
+		return c.decodeResponse(m.Command, m.Seq, m.Success, data)
+	case "event":
+		return c.decodeEvent(m.Event, m.Seq, data)
+	default:
+		return nil, &DecodeProtocolMessageFieldError{m.Seq, "ProtocolMessage", "type", m.Type, json.RawMessage(data)}
+	}
+}
+
+// decodeRequest determines what request type in the ProtocolMessage hierarchy
+// data corresponds to and uses json.Unmarshal to populate the corresponding
+// struct to be returned.
+func (c *Codec) decodeRequest(command string, seq int, data []byte) (Message, error) {
+	ctor, ok := c.requestCtor[command]
+	if !ok {
+		return nil, &DecodeProtocolMessageFieldError{seq, "Request", "command", command, json.RawMessage(data)}
+	}
+	requestPtr := ctor()
+	err := json.Unmarshal(data, requestPtr)
+	return requestPtr, err
+}
+
+// decodeResponse determines what response type in the ProtocolMessage hierarchy
+// data corresponds to and uses json.Unmarshal to populate the corresponding
+// struct to be returned.
+func (c *Codec) decodeResponse(command string, seq int, success bool, data []byte) (Message, error) {
+	if !success {
+		var er ErrorResponse
+		err := json.Unmarshal(data, &er)
+		return &er, err
+	}
+	ctor, ok := c.responseCtor[command]
+	if !ok {
+		return nil, &DecodeProtocolMessageFieldError{seq, "Response", "command", command, json.RawMessage(data)}
+	}
+	responsePtr := ctor()
+	err := json.Unmarshal(data, responsePtr)
+	return responsePtr, err
+}
+
+// decodeEvent determines what event type in the ProtocolMessage hierarchy
+// data corresponds to and uses json.Unmarshal to populate the corresponding
+// struct to be returned.
+func (c *Codec) decodeEvent(event string, seq int, data []byte) (Message, error) {
+	ctor, ok := c.eventCtor[event]
+	if !ok {
+		return nil, &DecodeProtocolMessageFieldError{seq, "Event", "event", event, json.RawMessage(data)}
+	}
+	eventPtr := ctor()
+	err := json.Unmarshal(data, eventPtr)
+	return eventPtr, err
+}
+
+// DecodeProtocolMessage parses the JSON-encoded ProtocolMessage and returns
+// the message embedded in it. If message type, command, etc cannot be cast,
+// returns DecodeProtocolMessageFieldError. See also godoc for json.Unmarshal,
+// which is used for underlying decoding.
+func DecodeProtocolMessage(data []byte) (Message, error) {
+	return defaultCodec.DecodeMessage(data)
+}
+
+type messageCtor func() Message

vendor/github.com/google/go-dap/doc.go

@@ -0,0 +1,20 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package dap contains data types and code for Debug Adapter Protocol (DAP) specification.
+// https://github.com/microsoft/vscode-debugadapter-node/blob/main/debugProtocol.json
+package dap
+
+//go:generate go run ./cmd/gentypes/gentypes.go -o schematypes.go -u cmd/gentypes/debugProtocol.json
+

vendor/github.com/google/go-dap/io.go

@@ -0,0 +1,137 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains utilities for DAP Base protocol I/O.
+// For additional information, see "Base protocol" section in
+// https://microsoft.github.io/debug-adapter-protocol/overview.
+
+package dap
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// BaseProtocolError represents base protocol error, which occurs when the raw
+// message does not conform to the header+content format of the base protocol.
+type BaseProtocolError struct {
+	Err string
+}
+
+func (bpe *BaseProtocolError) Error() string { return bpe.Err }
+
+var (
+	// ErrHeaderDelimiterNotCrLfCrLf is returned when only partial header
+	// delimiter \r\n\r\n is encountered.
+	ErrHeaderDelimiterNotCrLfCrLf = &BaseProtocolError{fmt.Sprintf("header delimiter is not %q", crLfcrLf)}
+
+	// ErrHeaderNotContentLength is returned when the parsed header is
+	// not of valid Content-Length format.
+	ErrHeaderNotContentLength = &BaseProtocolError{fmt.Sprintf("header format is not %q", contentLengthHeaderRegex)}
+
+	// ErrHeaderContentTooLong is returned when the content length specified in
+	// the header is above contentMaxLength.
+	ErrHeaderContentTooLong = &BaseProtocolError{fmt.Sprintf("content length over %v bytes", contentMaxLength)}
+)
+
+const (
+	crLfcrLf               = "\r\n\r\n"
+	contentLengthHeaderFmt = "Content-Length: %d\r\n\r\n"
+	contentMaxLength       = 4 * 1024 * 1024
+)
+
+var (
+	contentLengthHeaderRegex = regexp.MustCompile("^Content-Length: ([0-9]+)$")
+)
+
+// WriteBaseMessage formats content with Content-Length header and delimiters
+// as per the base protocol and writes the resulting message to w.
+func WriteBaseMessage(w io.Writer, content []byte) error {
+	header := fmt.Sprintf(contentLengthHeaderFmt, len(content))
+	if _, err := w.Write([]byte(header)); err != nil {
+		return err
+	}
+	_, err := w.Write(content)
+	return err
+}
+
+// ReadBaseMessage reads one message from r consisting of a Content-Length
+// header and a content part. It parses the header to determine the size of
+// the content part and extracts and returns the actual content of the message.
+// Returns nil bytes on error, which can be one of the standard IO errors or
+// a BaseProtocolError defined in this package.
+func ReadBaseMessage(r *bufio.Reader) ([]byte, error) {
+	contentLength, err := readContentLengthHeader(r)
+	if err != nil {
+		return nil, err
+	}
+	if contentLength > contentMaxLength {
+		return nil, ErrHeaderContentTooLong
+	}
+	content := make([]byte, contentLength)
+	if _, err = io.ReadFull(r, content); err != nil {
+		return nil, err
+	}
+	return content, nil
+}
+
+// readContentLengthHeader looks for the only header field that is supported
+// and required:
+// 		Content-Length: [0-9]+\r\n\r\n
+// Extracts and returns the content length.
+func readContentLengthHeader(r *bufio.Reader) (contentLength int64, err error) {
+	// Look for <some header>\r\n\r\n
+	headerWithCr, err := r.ReadString('\r')
+	if err != nil {
+		return 0, err
+	}
+	nextThree := make([]byte, 3)
+	if _, err = io.ReadFull(r, nextThree); err != nil {
+		return 0, err
+	}
+	if string(nextThree) != "\n\r\n" {
+		return 0, ErrHeaderDelimiterNotCrLfCrLf
+	}
+
+	// If header is in the right format, get the length
+	header := strings.TrimSuffix(headerWithCr, "\r")
+	headerAndLength := contentLengthHeaderRegex.FindStringSubmatch(header)
+	if len(headerAndLength) < 2 {
+		return 0, ErrHeaderNotContentLength
+	}
+	return strconv.ParseInt(headerAndLength[1], 10, 64)
+}
+
+// WriteProtocolMessage encodes message and writes it to w.
+func WriteProtocolMessage(w io.Writer, message Message) error {
+	b, err := json.Marshal(message)
+	if err != nil {
+		return err
+	}
+	return WriteBaseMessage(w, b)
+}
+
+// ReadProtocolMessage reads a message from r, decodes and returns it.
+func ReadProtocolMessage(r *bufio.Reader) (Message, error) {
+	content, err := ReadBaseMessage(r)
+	if err != nil {
+		return nil, err
+	}
+	return DecodeProtocolMessage(content)
+}

vendor/modules.txt

@@ -360,6 +360,9 @@ github.com/google/go-cmp/cmp/internal/diff
 github.com/google/go-cmp/cmp/internal/flags
 github.com/google/go-cmp/cmp/internal/function
 github.com/google/go-cmp/cmp/internal/value
+# github.com/google/go-dap v0.12.0
+## explicit; go 1.18
+github.com/google/go-dap
 # github.com/google/gofuzz v1.2.0
 ## explicit; go 1.12
 github.com/google/gofuzz