feat: add Docker Desktop Logs view hints and navigation shortcut

Add CLI hooks handler to show "What's next:" hints pointing to the
Docker Desktop Logs view after `docker logs`, `docker compose logs`,
and `docker compose up -d`.

Add `l` keyboard shortcut in the `compose up` navigation menu to
open the Logs view, gated on Docker Desktop feature flag and settings.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Guillaume Lours <glours@users.noreply.github.com>

Author: glours

cmd/compose/compose.go

@@ -409,7 +409,7 @@ const PluginName = "compose"
 
 // RunningAsStandalone detects when running as a standalone program
 func RunningAsStandalone() bool {
-	return len(os.Args) < 2 || os.Args[1] != metadata.MetadataSubcommandName && os.Args[1] != PluginName
+	return len(os.Args) < 2 || os.Args[1] != metadata.MetadataSubcommandName && os.Args[1] != metadata.HookSubcommandName && os.Args[1] != PluginName
 }
 
 type BackendOptions struct {

cmd/compose/hooks.go

@@ -0,0 +1,102 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   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.
+*/
+
+package compose
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/docker/cli/cli-plugins/hooks"
+	"github.com/docker/cli/cli-plugins/metadata"
+	"github.com/spf13/cobra"
+)
+
+const deepLink = "docker-desktop://dashboard/logs"
+
+const composeLogsHint = "Filter, search, and stream logs from all your Compose services\nin one place with Docker Desktop's Logs view. " + deepLink
+
+const dockerLogsHint = "View and search logs for all containers in one place\nwith Docker Desktop's Logs view. " + deepLink
+
+// hookHint defines a hint that can be returned by the hooks handler.
+// When checkFlags is nil, the hint is always returned for the matching command.
+// When checkFlags is set, the hint is only returned if the check passes.
+type hookHint struct {
+	template   string
+	checkFlags func(flags map[string]string) bool
+}
+
+// hooksHints maps hook root commands to their hint definitions.
+var hooksHints = map[string]hookHint{
+	// standalone "docker logs" (not a compose subcommand)
+	"logs":         {template: dockerLogsHint},
+	"compose logs": {template: composeLogsHint},
+	"compose up": {
+		template: composeLogsHint,
+		checkFlags: func(flags map[string]string) bool {
+			// Only show the hint when running in detached mode
+			_, hasDetach := flags["detach"]
+			_, hasD := flags["d"]
+			return hasDetach || hasD
+		},
+	},
+}
+
+// HooksCommand returns the hidden subcommand that the Docker CLI invokes
+// after command execution when the compose plugin has hooks configured.
+// Docker Desktop is responsible for registering which commands trigger hooks
+// and for gating on feature flags/settings — the hook handler simply
+// responds with the appropriate hint message.
+func HooksCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:    metadata.HookSubcommandName,
+		Hidden: true,
+		// Override PersistentPreRunE to prevent the parent's PersistentPreRunE
+		// (plugin initialization) from running for hook invocations.
+		PersistentPreRunE: func(*cobra.Command, []string) error { return nil },
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handleHook(args, os.Stdout)
+		},
+	}
+}
+
+func handleHook(args []string, w io.Writer) error {
+	if len(args) == 0 {
+		return nil
+	}
+
+	var hookData hooks.Request
+	if err := json.Unmarshal([]byte(args[0]), &hookData); err != nil {
+		return nil
+	}
+
+	hint, ok := hooksHints[hookData.RootCmd]
+	if !ok {
+		return nil
+	}
+
+	if hint.checkFlags != nil && !hint.checkFlags(hookData.Flags) {
+		return nil
+	}
+
+	enc := json.NewEncoder(w)
+	enc.SetEscapeHTML(false)
+	return enc.Encode(hooks.Response{
+		Type:     hooks.NextSteps,
+		Template: hint.template,
+	})
+}

cmd/compose/hooks_test.go

@@ -0,0 +1,136 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   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.
+*/
+
+package compose
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/docker/cli/cli-plugins/hooks"
+	"gotest.tools/v3/assert"
+)
+
+func TestHandleHook_NoArgs(t *testing.T) {
+	var buf bytes.Buffer
+	err := handleHook(nil, &buf)
+	assert.NilError(t, err)
+	assert.Equal(t, buf.String(), "")
+}
+
+func TestHandleHook_InvalidJSON(t *testing.T) {
+	var buf bytes.Buffer
+	err := handleHook([]string{"not json"}, &buf)
+	assert.NilError(t, err)
+	assert.Equal(t, buf.String(), "")
+}
+
+func TestHandleHook_UnknownCommand(t *testing.T) {
+	data := marshalHookData(t, hooks.Request{
+		RootCmd: "compose push",
+	})
+	var buf bytes.Buffer
+	err := handleHook([]string{data}, &buf)
+	assert.NilError(t, err)
+	assert.Equal(t, buf.String(), "")
+}
+
+func TestHandleHook_LogsCommand(t *testing.T) {
+	tests := []struct {
+		rootCmd  string
+		wantHint string
+	}{
+		{rootCmd: "compose logs", wantHint: composeLogsHint},
+		{rootCmd: "logs", wantHint: dockerLogsHint},
+	}
+	for _, tt := range tests {
+		t.Run(tt.rootCmd, func(t *testing.T) {
+			data := marshalHookData(t, hooks.Request{
+				RootCmd: tt.rootCmd,
+			})
+			var buf bytes.Buffer
+			err := handleHook([]string{data}, &buf)
+			assert.NilError(t, err)
+
+			msg := unmarshalResponse(t, buf.Bytes())
+			assert.Equal(t, msg.Type, hooks.NextSteps)
+			assert.Equal(t, msg.Template, tt.wantHint)
+		})
+	}
+}
+
+func TestHandleHook_ComposeUpDetached(t *testing.T) {
+	tests := []struct {
+		name     string
+		flags    map[string]string
+		wantHint bool
+	}{
+		{
+			name:     "with --detach flag",
+			flags:    map[string]string{"detach": ""},
+			wantHint: true,
+		},
+		{
+			name:     "with -d flag",
+			flags:    map[string]string{"d": ""},
+			wantHint: true,
+		},
+		{
+			name:     "without detach flag",
+			flags:    map[string]string{"build": ""},
+			wantHint: false,
+		},
+		{
+			name:     "no flags",
+			flags:    map[string]string{},
+			wantHint: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			data := marshalHookData(t, hooks.Request{
+				RootCmd: "compose up",
+				Flags:   tt.flags,
+			})
+			var buf bytes.Buffer
+			err := handleHook([]string{data}, &buf)
+			assert.NilError(t, err)
+
+			if tt.wantHint {
+				msg := unmarshalResponse(t, buf.Bytes())
+				assert.Equal(t, msg.Template, composeLogsHint)
+			} else {
+				assert.Equal(t, buf.String(), "")
+			}
+		})
+	}
+}
+
+func marshalHookData(t *testing.T, data hooks.Request) string {
+	t.Helper()
+	b, err := json.Marshal(data)
+	assert.NilError(t, err)
+	return string(b)
+}
+
+func unmarshalResponse(t *testing.T, data []byte) hooks.Response {
+	t.Helper()
+	var msg hooks.Response
+	err := json.Unmarshal(data, &msg)
+	assert.NilError(t, err)
+	return msg
+}

cmd/formatter/shortcut.go

@@ -94,13 +94,15 @@ type LogKeyboard struct {
 	Watch                 *KeyboardWatch
 	Detach                func()
 	IsDockerDesktopActive bool
+	IsLogsViewEnabled     bool
 	logLevel              KEYBOARD_LOG_LEVEL
 	signalChannel         chan<- os.Signal
 }
 
-func NewKeyboardManager(isDockerDesktopActive bool, sc chan<- os.Signal) *LogKeyboard {
+func NewKeyboardManager(isDockerDesktopActive, isLogsViewEnabled bool, sc chan<- os.Signal) *LogKeyboard {
 	return &LogKeyboard{
 		IsDockerDesktopActive: isDockerDesktopActive,
+		IsLogsViewEnabled:     isLogsViewEnabled,
 		logLevel:              INFO,
 		signalChannel:         sc,
 	}
@@ -173,6 +175,10 @@ func (lk *LogKeyboard) navigationMenu() string {
 		items = append(items, shortcutKeyColor("o")+navColor(" View Config"))
 	}
 
+	if lk.IsLogsViewEnabled {
+		items = append(items, shortcutKeyColor("l")+navColor(" View Logs"))
+	}
+
 	isEnabled := " Enable"
 	if lk.Watch != nil && lk.Watch.Watching {
 		isEnabled = " Disable"
@@ -232,6 +238,24 @@ func (lk *LogKeyboard) openDDComposeUI(ctx context.Context, project *types.Proje
 	}()
 }
 
+func (lk *LogKeyboard) openDDLogsView(ctx context.Context) {
+	if !lk.IsLogsViewEnabled {
+		return
+	}
+	go func() {
+		_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/logsview", tracing.SpanOptions{},
+			func(ctx context.Context) error {
+				link := "docker-desktop://dashboard/logs"
+				err := open.Run(link)
+				if err != nil {
+					err = fmt.Errorf("could not open Docker Desktop Logs view")
+					lk.keyboardError("View Logs", err)
+				}
+				return err
+			})()
+	}()
+}
+
 func (lk *LogKeyboard) openDDWatchDocs(ctx context.Context, project *types.Project) {
 	go func() {
 		_ = tracing.EventWrapFuncForErrGroup(ctx, "menu/gui/watch", tracing.SpanOptions{},
@@ -311,6 +335,8 @@ func (lk *LogKeyboard) HandleKeyEvents(ctx context.Context, event keyboard.KeyEv
 		lk.ToggleWatch(ctx, options)
 	case 'o':
 		lk.openDDComposeUI(ctx, project)
+	case 'l':
+		lk.openDDLogsView(ctx)
 	}
 	switch key := event.Key; key {
 	case keyboard.KeyCtrlC:

cmd/main.go

@@ -44,6 +44,7 @@ func pluginMain() {
 			}
 
 			cmd := commands.RootCommand(cli, backendOptions)
+			cmd.AddCommand(commands.HooksCommand())
 			originalPreRunE := cmd.PersistentPreRunE
 			cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 				// initialize the cli instance