From e42f37cb0b1410774e551d25c04f11e756414fa3 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Fri, 30 Oct 2026 15:44:05 -0600 Subject: [PATCH 1/2] feat(cli): add progress visibility control --- cmd/ci/ci.go | 2 +- cmd/ci/status.go | 3 +- cmd/ci/status_test.go | 16 +- cmd/config/apply.go | 15 +- cmd/config/apply_test.go | 14 +- cmd/flag_aliases_test.go | 36 ++- cmd/flags/flags.go | 5 + cmd/internal/runusercommands.go | 19 +- cmd/internal/status_no_status_test.go | 25 ++ cmd/provider/add.go | 7 +- cmd/provider/init.go | 1 + cmd/provider/set_source.go | 7 +- cmd/provider/status.go | 7 +- cmd/provider/status_no_status_test.go | 21 ++ cmd/workspace/build.go | 1 + cmd/workspace/delete.go | 1 + cmd/workspace/delete_test.go | 4 +- cmd/workspace/exec.go | 1 + cmd/workspace/import.go | 1 + cmd/workspace/status_no_status_test.go | 21 ++ cmd/workspace/status_reporter.go | 18 +- cmd/workspace/stop.go | 2 +- cmd/workspace/task_tail_test.go | 14 +- cmd/workspace/up/detach_test.go | 7 + cmd/workspace/up/early_task_test.go | 4 +- cmd/workspace/up/status.go | 7 +- cmd/workspace/up/status_no_status_test.go | 68 +++++ cmd/workspace/up/up.go | 1 + desktop/e2e/no-status-protocol.e2e.ts | 78 +++++ e2e/tests/ci/ci.go | 271 +++++++++++++++++- e2e/tests/ssh/task_cancel.go | 50 ++++ e2e/tests/up/up.go | 49 +++- pkg/flags/names/names.go | 1 + pkg/flags/names/names_test.go | 1 + pkg/status/render.go | 12 +- pkg/status/reporter_test.go | 81 +++++- .../continuous-integration.mdx | 30 ++ .../docs/troubleshooting/troubleshooting.mdx | 10 + 38 files changed, 862 insertions(+), 49 deletions(-) create mode 100644 cmd/internal/status_no_status_test.go create mode 100644 cmd/provider/status_no_status_test.go create mode 100644 cmd/workspace/status_no_status_test.go create mode 100644 cmd/workspace/up/status_no_status_test.go create mode 100644 desktop/e2e/no-status-protocol.e2e.ts diff --git a/cmd/ci/ci.go b/cmd/ci/ci.go index 975ffc8418..0cc61f6e10 100644 --- a/cmd/ci/ci.go +++ b/cmd/ci/ci.go @@ -209,7 +209,7 @@ func (cmd *CICmd) execute(ctx context.Context, source string) (err error) { // workspace. ctx, cancel := up.WithSignals(ctx) defer cancel() - reporter, err := newStatusReporter(os.Stderr, cmd.Verbosity > 0 || cmd.Debug) + reporter, err := newStatusReporter(os.Stderr, cmd.Verbosity > 0 || cmd.Debug, cmd.NoStatus) if err != nil { return err } diff --git a/cmd/ci/status.go b/cmd/ci/status.go index 269885d5cf..e1773cc2e0 100644 --- a/cmd/ci/status.go +++ b/cmd/ci/status.go @@ -6,12 +6,13 @@ import ( "github.com/devsy-org/devsy/pkg/status" ) -func newStatusReporter(out io.Writer, verbose bool) (status.Reporter, error) { +func newStatusReporter(out io.Writer, verbose bool, noStatus bool) (status.Reporter, error) { return status.NewCLIReporter(status.CLIOptions{ Format: "plain", Out: out, Prefix: "ci", Verbose: verbose, + NoStatus: noStatus, Pipeline: status.PipelineWorkspaceUp, Labels: map[status.Phase]string{ status.PhaseCloningRepository: "cloning repository", diff --git a/cmd/ci/status_test.go b/cmd/ci/status_test.go index b974c62aec..e6794a2f38 100644 --- a/cmd/ci/status_test.go +++ b/cmd/ci/status_test.go @@ -10,7 +10,7 @@ import ( func TestStatusReporterUsesDeterministicASCIIOutput(t *testing.T) { var out bytes.Buffer - reporter, err := newStatusReporter(&out, false) + reporter, err := newStatusReporter(&out, false, false) if err != nil { t.Fatalf("newStatusReporter: %v", err) } @@ -35,3 +35,17 @@ func TestStatusReporterUsesDeterministicASCIIOutput(t *testing.T) { } } } + +func TestStatusReporterNoStatus(t *testing.T) { + for _, verbose := range []bool{false, true} { + var out bytes.Buffer + reporter, err := newStatusReporter(&out, verbose, true) + if err != nil { + t.Fatal(err) + } + reporter.Report(status.Event{Phase: status.PhaseRunningCommand, State: status.StateStarted}) + if out.Len() != 0 { + t.Fatalf("unexpected status: %q", out.String()) + } + } +} diff --git a/cmd/config/apply.go b/cmd/config/apply.go index 6f1075506b..e9870b34cf 100644 --- a/cmd/config/apply.go +++ b/cmd/config/apply.go @@ -74,7 +74,12 @@ func (cmd *ApplyCmd) Run(ctx context.Context) error { return err } emitJSON := mode == output.ModeJSON - reporter, err := newStatusReporter(cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug) + reporter, err := newStatusReporter( + cmd.ResultFormat, + os.Stdout, + cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, + ) if err != nil { return err } @@ -189,12 +194,18 @@ func (cmd *ApplyCmd) prepareContainer( return containerDetails, result, nil } -func newStatusReporter(resultFormat string, out io.Writer, verbose bool) (status.Reporter, error) { +func newStatusReporter( + resultFormat string, + out io.Writer, + verbose bool, + noStatus bool, +) (status.Reporter, error) { return status.NewCLIReporter(status.CLIOptions{ Format: resultFormat, Out: out, Prefix: "config", Verbose: verbose, + NoStatus: noStatus, Pipeline: status.PipelineWorkspaceUp, Labels: map[status.Phase]string{ status.PhaseResolvingConfig: "resolving devcontainer config", diff --git a/cmd/config/apply_test.go b/cmd/config/apply_test.go index b0e9bfe0f9..7c0c3685ba 100644 --- a/cmd/config/apply_test.go +++ b/cmd/config/apply_test.go @@ -97,7 +97,7 @@ func TestApplyCmd_ResolveDockerPath_Custom(t *testing.T) { func TestApplyStatusReporterEmitsCurrentStatusEnvelope(t *testing.T) { var out bytes.Buffer - reporter, err := newStatusReporter("json", &out, false) + reporter, err := newStatusReporter("json", &out, false, false) require.NoError(t, err) reporter.Report(status.Event{ Phase: status.PhaseReady, @@ -111,3 +111,15 @@ func TestApplyStatusReporterEmitsCurrentStatusEnvelope(t *testing.T) { assert.Equal(t, string(status.PipelineWorkspaceUp), envelope["pipeline"]) assert.Equal(t, string(status.StateSucceeded), envelope["state"]) } + +func TestStatusReporterNoStatus(t *testing.T) { + for _, format := range []string{"plain", "json"} { + t.Run(format, func(t *testing.T) { + var out bytes.Buffer + reporter, err := newStatusReporter(format, &out, false, true) + require.NoError(t, err) + reporter.Report(status.Event{Phase: status.PhaseReady, State: status.StateSucceeded}) + require.Empty(t, out.String()) + }) + } +} diff --git a/cmd/flag_aliases_test.go b/cmd/flag_aliases_test.go index 56399bfd8d..3f4f33cc7c 100644 --- a/cmd/flag_aliases_test.go +++ b/cmd/flag_aliases_test.go @@ -1,6 +1,8 @@ package cmd import ( + "bytes" + "strings" "testing" "github.com/devsy-org/devsy/pkg/flags/names" @@ -8,7 +10,10 @@ import ( "github.com/stretchr/testify/require" ) -const formatJSON = "json" +const ( + formatJSON = "json" + flagHelp = "--help" +) func TestGlobalFlags_LogFormatAlias(t *testing.T) { rootCmd, globalFlags := BuildRoot() @@ -18,6 +23,35 @@ func TestGlobalFlags_LogFormatAlias(t *testing.T) { assert.Equal(t, formatJSON, globalFlags.LogOutput) } +func TestGlobalFlags_NoStatus(t *testing.T) { + for _, tc := range []struct { + name string + args []string + want bool + }{ + {name: "default", args: []string{"ci", flagHelp}}, + {name: "before command", args: []string{"--no-status", "ci", flagHelp}, want: true}, + {name: "after command", args: []string{"ci", "--no-status", flagHelp}, want: true}, + {name: "explicit false", args: []string{"ci", "--no-status=false", flagHelp}}, + } { + t.Run(tc.name, func(t *testing.T) { + rootCmd, globalFlags := BuildRoot() + var out bytes.Buffer + rootCmd.SetOut(&out) + rootCmd.SetErr(&out) + rootCmd.SetArgs(tc.args) + require.NoError(t, rootCmd.Execute()) + assert.Equal(t, tc.want, globalFlags.NoStatus) + assert.Contains(t, out.String(), "--no-status") + assert.Contains( + t, + strings.Join(strings.Fields(out.String()), " "), + "Suppress live CLI progress messages; preserve results, errors, and recorded events", + ) + }) + } +} + func TestLogFormatAlias_IsHidden(t *testing.T) { rootCmd, _ := BuildRoot() f := rootCmd.PersistentFlags().Lookup(names.LogFormat) diff --git a/cmd/flags/flags.go b/cmd/flags/flags.go index 15cba104c9..4048ae5882 100644 --- a/cmd/flags/flags.go +++ b/cmd/flags/flags.go @@ -21,6 +21,7 @@ type GlobalFlags struct { Verbosity int Quiet bool Debug bool + NoStatus bool } // SetGlobalFlags applies the global flags. @@ -59,6 +60,10 @@ func registerCoreFlags(flags *flag.FlagSet, globalFlags *GlobalFlags) { } func registerOutputFlags(flags *flag.FlagSet, globalFlags *GlobalFlags) { + flags.BoolVar( + &globalFlags.NoStatus, names.NoStatus, false, + "Suppress live CLI progress messages; preserve results, errors, and recorded events", + ) flags.StringVar( &globalFlags.ResultFormat, names.ResultFormat, diff --git a/cmd/internal/runusercommands.go b/cmd/internal/runusercommands.go index 638cefa660..2d137b4315 100644 --- a/cmd/internal/runusercommands.go +++ b/cmd/internal/runusercommands.go @@ -77,13 +77,15 @@ func newLifecycleStatusReporter( resultFormat string, out *os.File, verbose bool, + noStatus bool, ) (status.Reporter, error) { - reporter, err := status.NewReporter(status.ReporterOptions{ - Format: resultFormat, - Out: out, - Prefix: "lifecycle", - Verbose: verbose, - SuppressFailureDetails: true, + return status.NewCLIReporter(status.CLIOptions{ + Format: resultFormat, + Out: out, + Prefix: "lifecycle", + Verbose: verbose, + NoStatus: noStatus, + Pipeline: status.PipelineWorkspaceUp, Labels: map[status.Phase]string{ status.PhaseRunningLifecycleHook: "running lifecycle hooks", status.PhaseReady: "ready", @@ -92,10 +94,6 @@ func newLifecycleStatusReporter( return devcconfig.WriteStatusJSON(out, e) }, }) - if err != nil { - return nil, err - } - return status.ForPipeline(reporter, status.PipelineWorkspaceUp), nil } // Run executes the run-user-commands logic. @@ -107,6 +105,7 @@ func (cmd *RunUserCommandsCmd) Run(ctx context.Context) error { cmd.ResultFormat, os.Stderr, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/internal/status_no_status_test.go b/cmd/internal/status_no_status_test.go new file mode 100644 index 0000000000..6f29a53780 --- /dev/null +++ b/cmd/internal/status_no_status_test.go @@ -0,0 +1,25 @@ +package cmdinternal + +import ( + "os" + "testing" + + "github.com/devsy-org/devsy/pkg/status" + "github.com/stretchr/testify/require" +) + +func TestLifecycleStatusReporterNoStatus(t *testing.T) { + for _, format := range []string{"plain", "json"} { + t.Run(format, func(t *testing.T) { + out, err := os.CreateTemp(t.TempDir(), "status") + require.NoError(t, err) + t.Cleanup(func() { _ = out.Close() }) + reporter, err := newLifecycleStatusReporter(format, out, false, true) + require.NoError(t, err) + reporter.Report(status.Event{Phase: status.PhaseReady, State: status.StateSucceeded}) + info, err := out.Stat() + require.NoError(t, err) + require.Zero(t, info.Size()) + }) + } +} diff --git a/cmd/provider/add.go b/cmd/provider/add.go index d7cb7e739e..b9693e4fa7 100644 --- a/cmd/provider/add.go +++ b/cmd/provider/add.go @@ -92,7 +92,12 @@ func (cmd *AddCmd) Run(ctx context.Context, devsyConfig *config.Config, args []s return err } - reporter, err := newStatusReporter(cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug) + reporter, err := newStatusReporter( + cmd.ResultFormat, + os.Stdout, + cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, + ) if err != nil { return err } diff --git a/cmd/provider/init.go b/cmd/provider/init.go index 4c28c8db5a..3ab5c79358 100644 --- a/cmd/provider/init.go +++ b/cmd/provider/init.go @@ -58,6 +58,7 @@ func NewInitCmd(f *flags.GlobalFlags) *cobra.Command { cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/provider/set_source.go b/cmd/provider/set_source.go index e974340067..542c23999b 100644 --- a/cmd/provider/set_source.go +++ b/cmd/provider/set_source.go @@ -87,7 +87,12 @@ func (cmd *SetSourceCmd) Run(ctx context.Context, devsyConfig *config.Config, ar providerSource = args[1] } - reporter, err := newStatusReporter(cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug) + reporter, err := newStatusReporter( + cmd.ResultFormat, + os.Stdout, + cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, + ) if err != nil { return err } diff --git a/cmd/provider/status.go b/cmd/provider/status.go index 25f699e9a1..a9c6ad6b6e 100644 --- a/cmd/provider/status.go +++ b/cmd/provider/status.go @@ -13,14 +13,15 @@ import ( func newStatusReporter( resultFormat string, out io.Writer, - verbose ...bool, + verbose bool, + noStatus bool, ) (status.Reporter, error) { - showDurations := len(verbose) > 0 && verbose[0] return status.NewCLIReporter(status.CLIOptions{ Format: resultFormat, Out: out, Prefix: "provider", - Verbose: showDurations, + Verbose: verbose, + NoStatus: noStatus, Pipeline: status.PipelineProvider, Labels: phaseLabels, Envelope: func(e status.Event) error { diff --git a/cmd/provider/status_no_status_test.go b/cmd/provider/status_no_status_test.go new file mode 100644 index 0000000000..f0946442ac --- /dev/null +++ b/cmd/provider/status_no_status_test.go @@ -0,0 +1,21 @@ +package provider + +import ( + "bytes" + "testing" + + "github.com/devsy-org/devsy/pkg/status" + "github.com/stretchr/testify/require" +) + +func TestStatusReporterNoStatus(t *testing.T) { + for _, format := range []string{"plain", "json"} { + t.Run(format, func(t *testing.T) { + var out bytes.Buffer + reporter, err := newStatusReporter(format, &out, false, true) + require.NoError(t, err) + reporter.Report(status.Event{Phase: status.PhaseReady, State: status.StateSucceeded}) + require.Empty(t, out.String()) + }) + } +} diff --git a/cmd/workspace/build.go b/cmd/workspace/build.go index b222148826..1989ef43c6 100644 --- a/cmd/workspace/build.go +++ b/cmd/workspace/build.go @@ -257,6 +257,7 @@ func (cmd *BuildCmd) build( cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/workspace/delete.go b/cmd/workspace/delete.go index 54a9e4ce1f..204380583e 100644 --- a/cmd/workspace/delete.go +++ b/cmd/workspace/delete.go @@ -83,6 +83,7 @@ func (cmd *DeleteCmd) Run(cobraCmd *cobra.Command, args []string) error { cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/workspace/delete_test.go b/cmd/workspace/delete_test.go index 282ebb2315..7e15cc27a8 100644 --- a/cmd/workspace/delete_test.go +++ b/cmd/workspace/delete_test.go @@ -114,7 +114,7 @@ func TestDeleteCmd_DeleteResolvedJournalsUnderSelectedWorkspace(t *testing.T) { DefaultContext: testContext, Contexts: map[string]*config.ContextConfig{testContext: {}}, } - reporter, err := newWorkspaceStatusReporter(formatPlain, os.Stdout, false) + reporter, err := newWorkspaceStatusReporter(formatPlain, os.Stdout, false, false) require.NoError(t, err) captureStdout(t, func() { @@ -166,7 +166,7 @@ func TestDeleteCmd_DeleteMultipleReusesResolvedClients(t *testing.T) { DefaultContext: testContext, Contexts: map[string]*config.ContextConfig{testContext: {}}, } - reporter, err := newWorkspaceStatusReporter(formatPlain, os.Stdout, false) + reporter, err := newWorkspaceStatusReporter(formatPlain, os.Stdout, false, false) require.NoError(t, err) targets := map[string]resolvedDeleteTarget{ diff --git a/cmd/workspace/exec.go b/cmd/workspace/exec.go index 6c75f111ae..846e514766 100644 --- a/cmd/workspace/exec.go +++ b/cmd/workspace/exec.go @@ -107,6 +107,7 @@ func (cmd *ExecCmd) Run(ctx context.Context, args []string) error { cmd.ResultFormat, os.Stderr, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/workspace/import.go b/cmd/workspace/import.go index 86eec98fbf..9988140cb5 100644 --- a/cmd/workspace/import.go +++ b/cmd/workspace/import.go @@ -92,6 +92,7 @@ func (cmd *ImportCmd) execute(ctx context.Context) error { cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus, ) if err != nil { return err diff --git a/cmd/workspace/status_no_status_test.go b/cmd/workspace/status_no_status_test.go new file mode 100644 index 0000000000..01d6bd327a --- /dev/null +++ b/cmd/workspace/status_no_status_test.go @@ -0,0 +1,21 @@ +package workspace + +import ( + "bytes" + "testing" + + "github.com/devsy-org/devsy/pkg/status" + "github.com/stretchr/testify/require" +) + +func TestStatusReporterNoStatus(t *testing.T) { + for _, format := range []string{"plain", formatJSON} { + t.Run(format, func(t *testing.T) { + var out bytes.Buffer + reporter, err := newWorkspaceStatusReporter(format, &out, false, true) + require.NoError(t, err) + reporter.Report(status.Event{Phase: status.PhaseReady, State: status.StateSucceeded}) + require.Empty(t, out.String()) + }) + } +} diff --git a/cmd/workspace/status_reporter.go b/cmd/workspace/status_reporter.go index 50a3223847..773ab2e748 100644 --- a/cmd/workspace/status_reporter.go +++ b/cmd/workspace/status_reporter.go @@ -15,13 +15,15 @@ func newWorkspaceStatusReporter( resultFormat string, out io.Writer, verbose bool, + noStatus bool, ) (status.Reporter, error) { - reporter, err := status.NewReporter(status.ReporterOptions{ - Format: resultFormat, - Out: out, - Prefix: workspaceStatusPrefix, - Verbose: verbose, - SuppressFailureDetails: true, + return status.NewCLIReporter(status.CLIOptions{ + Format: resultFormat, + Out: out, + Prefix: workspaceStatusPrefix, + Verbose: verbose, + NoStatus: noStatus, + Pipeline: status.PipelineWorkspaceUp, Labels: map[status.Phase]string{ status.PhaseRunningCommand: "running command", status.PhaseBuildingImage: "building devcontainer", @@ -36,8 +38,4 @@ func newWorkspaceStatusReporter( return config2.WriteStatusJSON(out, e) }, }) - if err != nil { - return nil, err - } - return status.ForPipeline(reporter, status.PipelineWorkspaceUp), nil } diff --git a/cmd/workspace/stop.go b/cmd/workspace/stop.go index ecf2eb91c3..fe8f01a89d 100644 --- a/cmd/workspace/stop.go +++ b/cmd/workspace/stop.go @@ -99,7 +99,7 @@ func (cmd *StopCmd) runArgs(ctx context.Context, args []string) error { func (cmd *StopCmd) newStatusReporter() (status.Reporter, error) { return newWorkspaceStatusReporter( - cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, + cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, cmd.NoStatus, ) } diff --git a/cmd/workspace/task_tail_test.go b/cmd/workspace/task_tail_test.go index f87c355652..bbdf2eb44e 100644 --- a/cmd/workspace/task_tail_test.go +++ b/cmd/workspace/task_tail_test.go @@ -237,8 +237,16 @@ func TestLogTailerStreamsStatusLifecyclesSeparatelyFromLogs(t *testing.T) { State: status.StateSucceeded, Duration: 3 * time.Second, }, } - for _, event := range events { - require.NoError(t, devcconfig.WriteStatusJSON(&worker, event)) + reporter, err := status.NewCLIReporter(status.CLIOptions{ + Format: formatJSON, + Out: &worker, + Pipeline: status.PipelineWorkspaceUp, + Envelope: func(event status.Event) error { return devcconfig.WriteStatusJSON(&worker, event) }, + }) + require.NoError(t, err) + for i := range events { + events[i].Pipeline = status.PipelineWorkspaceUp + reporter.Report(events[i]) } worker.WriteString("worker log\n{\"kind\":\"result\",\"outcome\":\"success\"}\n") require.NoError(t, os.WriteFile(path, worker.Bytes(), 0o600)) @@ -445,7 +453,7 @@ func TestFollowTaskReconciliationDiagnostics(t *testing.T) { log.Init( log.Config{ Level: level, - Format: "json", + Format: formatJSON, Redactor: secrets.NewRedactor([]string{"TOKEN=" + secret}), }, ) diff --git a/cmd/workspace/up/detach_test.go b/cmd/workspace/up/detach_test.go index 4635e1faef..b349f525b2 100644 --- a/cmd/workspace/up/detach_test.go +++ b/cmd/workspace/up/detach_test.go @@ -141,3 +141,10 @@ func assertWorkerLockReleased(t *testing.T, store *task.Store, id string) { t.Fatalf("release worker lock: %v", err) } } + +func TestDetachedArgsRetainsNoStatus(t *testing.T) { + got := detachedArgs([]string{"--detach", "--no-status", "."}) + if len(got) != 2 || got[0] != "--no-status" || got[1] != "." { + t.Fatalf("detachedArgs() = %v", got) + } +} diff --git a/cmd/workspace/up/early_task_test.go b/cmd/workspace/up/early_task_test.go index bc4b8accf7..4bedfdb6ff 100644 --- a/cmd/workspace/up/early_task_test.go +++ b/cmd/workspace/up/early_task_test.go @@ -33,7 +33,7 @@ func TestDetachedRejectsInvalidIDBeforeCreatingTask(t *testing.T) { store := isolatedTaskStore(t) cmd := &UpCmd{GlobalFlags: &flags.GlobalFlags{}} cmd.ID = id - cmd.ResultFormat = "json" + cmd.ResultFormat = formatJSON err := cmd.runDetached(nil, &config.Config{}) assert.ErrorContains(t, err, "workspace name") tasks, err := store.List() @@ -93,7 +93,7 @@ func TestWorkerRecordsConfigAndClientErrors(t *testing.T) { require.NoError(t, err) require.NoError(t, tk.SetPID(os.Getpid())) cmd := &UpCmd{GlobalFlags: &flags.GlobalFlags{}, taskID: tk.ID()} - cmd.ResultFormat = "json" + cmd.ResultFormat = formatJSON expected := "prepare workspace client" switch stage { case "config": diff --git a/cmd/workspace/up/status.go b/cmd/workspace/up/status.go index b19b1f593c..8d17c43993 100644 --- a/cmd/workspace/up/status.go +++ b/cmd/workspace/up/status.go @@ -11,14 +11,15 @@ import ( func newStatusReporter( resultFormat string, out io.Writer, - verbose ...bool, + verbose bool, + noStatus bool, ) (status.Reporter, error) { - showDurations := len(verbose) > 0 && verbose[0] return status.NewCLIReporter(status.CLIOptions{ Format: resultFormat, Out: out, Prefix: "up", - Verbose: showDurations, + Verbose: verbose, + NoStatus: noStatus, Pipeline: status.PipelineWorkspaceUp, Labels: phaseLabels, Envelope: func(e status.Event) error { diff --git a/cmd/workspace/up/status_no_status_test.go b/cmd/workspace/up/status_no_status_test.go new file mode 100644 index 0000000000..94fff7830a --- /dev/null +++ b/cmd/workspace/up/status_no_status_test.go @@ -0,0 +1,68 @@ +package up + +import ( + "bytes" + "os" + "strings" + "testing" + + "github.com/devsy-org/devsy/cmd/flags" + devcconfig "github.com/devsy-org/devsy/pkg/devcontainer/config" + "github.com/devsy-org/devsy/pkg/status" + "github.com/devsy-org/devsy/pkg/task" + "github.com/devsy-org/devsy/pkg/workspacejournal" + "github.com/stretchr/testify/require" +) + +const formatJSON = "json" + +func TestConfigureRunNoStatusPreservesJournalAndWorkerRecording(t *testing.T) { + for _, worker := range []bool{false, true} { + t.Run(map[bool]string{false: "foreground", true: "worker"}[worker], func(t *testing.T) { + store := isolatedTaskStore(t) + var out bytes.Buffer + cmd := &UpCmd{ + GlobalFlags: &flags.GlobalFlags{NoStatus: true, ResultFormat: formatJSON}, + Out: &out, + } + if worker { + tk, err := store.Create(task.CreateOptions{Command: "up"}) + require.NoError(t, err) + require.NoError(t, tk.SetPID(os.Getpid())) + cmd.taskID = tk.ID() + cmd.workerTask, err = cmd.openTask() + require.NoError(t, err) + require.NotNil(t, cmd.workerTask) + t.Cleanup(func() { require.NoError(t, cmd.workerTask.ReleaseWorkerLock()) }) + } + _, _, err := cmd.configureRun("test-workspace") + require.NoError(t, err) + for _, event := range []status.Event{ + {Phase: status.PhasePreparingDevContainer, State: status.StateStarted, OperationID: "parent"}, + { + Phase: status.PhaseStartingContainer, State: status.StateSucceeded, + OperationID: "child", ParentOperationID: "parent", + }, + } { + cmd.statusReporter.Report(event) + } + dir, err := workspacejournal.DefaultDir() + require.NoError(t, err) + events, err := workspacejournal.Read(dir, "test-workspace", 10) + require.NoError(t, err) + require.Len(t, events, 2) + if worker { + lines := strings.Split(strings.TrimSpace(out.String()), "\n") + require.Len(t, lines, 2) + completion, ok := devcconfig.ParseStatusLine(lines[1]) + require.True(t, ok) + require.Equal(t, status.PhaseStartingContainer, completion.Phase) + require.Equal(t, status.StateSucceeded, completion.State) + require.Equal(t, "child", completion.OperationID) + require.Equal(t, "parent", completion.ParentOperationID) + } else { + require.Empty(t, out.String()) + } + }) + } +} diff --git a/cmd/workspace/up/up.go b/cmd/workspace/up/up.go index 907d2de5cf..04f617948c 100644 --- a/cmd/workspace/up/up.go +++ b/cmd/workspace/up/up.go @@ -326,6 +326,7 @@ func (cmd *UpCmd) configureRun(workspaceID string) (bool, io.Writer, error) { cmd.ResultFormat, out, cmd.Verbosity > 0 || cmd.Debug, + cmd.NoStatus && cmd.workerTask == nil, ) if err == nil { cmd.statusReporter = withJournal(cmd.statusReporter, workspaceID) diff --git a/desktop/e2e/no-status-protocol.e2e.ts b/desktop/e2e/no-status-protocol.e2e.ts new file mode 100644 index 0000000000..31630c2a02 --- /dev/null +++ b/desktop/e2e/no-status-protocol.e2e.ts @@ -0,0 +1,78 @@ +import { execFileSync } from "node:child_process" +import { existsSync, mkdtempSync, rmSync } from "node:fs" +import { tmpdir } from "node:os" +import { dirname, join, resolve } from "node:path" +import { fileURLToPath } from "node:url" +import { expect, test } from "@playwright/test" +import { ProviderJobs } from "../src/main/provider-jobs.js" +import { + normalizeOperationStatus, + parseCliEnvelope, +} from "../src/shared/cli-error.js" + +const DESKTOP_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..") +const REPO_DIR = resolve(DESKTOP_DIR, "..") + +test("candidate CLI status reaches the Desktop timeline with --no-status", () => { + test.setTimeout(120000) + const binary = resolve( + DESKTOP_DIR, + "resources/bin", + process.platform === "win32" ? "devsy.exe" : "devsy", + ) + expect(existsSync(binary), `candidate CLI missing at ${binary}`).toBe(true) + + const home = mkdtempSync(join(tmpdir(), "devsy-desktop-protocol-")) + const env = { + ...process.env, + DEVSY_HOME: home, + DEVSY_UI: "true", + DEVSY_DISABLE_TELEMETRY: "true", + } + const name = "e2e-no-status-protocol" + const jobs = new ProviderJobs() + jobs.start(name, "installing") + + try { + const statusOutput = execFileSync( + binary, + [ + "--no-status", + "--result-format=json", + "--log-output=json", + "provider", + "add", + resolve(REPO_DIR, "providers/docker/provider.yaml"), + "--name", + name, + "--use=false", + ], + { encoding: "utf8", env }, + ) + const seenPhases: string[] = [] + for (const line of statusOutput.split(/\r?\n/)) { + const envelope = parseCliEnvelope(line) + if (envelope?.kind !== "status") continue + seenPhases.push(`${envelope.phase}:${envelope.state}`) + jobs.reportStatus(name, normalizeOperationStatus(envelope)) + } + + expect(seenPhases).toContain("installing_provider:started") + expect(seenPhases).toContain("installing_provider:succeeded") + expect(jobs.get(name)).toMatchObject({ + activity: "installing", + phase: "installing_provider", + state: "succeeded", + }) + + const listOutput = execFileSync( + binary, + ["--result-format=json", "provider", "list"], + { encoding: "utf8", env }, + ) + const providers = JSON.parse(listOutput) as Record + expect(providers).toHaveProperty(name) + } finally { + rmSync(home, { recursive: true, force: true }) + } +}) diff --git a/e2e/tests/ci/ci.go b/e2e/tests/ci/ci.go index 2bd8d3ae08..0e3af2eaff 100644 --- a/e2e/tests/ci/ci.go +++ b/e2e/tests/ci/ci.go @@ -1,12 +1,15 @@ package ci import ( + "bufio" + "bytes" "context" "errors" "os" "os/exec" "path/filepath" "strings" + "time" "github.com/devsy-org/devsy/e2e/framework" "github.com/devsy-org/devsy/pkg/workspace" @@ -15,9 +18,11 @@ import ( ) const ( - ciCommand = "ci" - secretCmd = "secret" - ciSecretName = "MY_SECRET" + ciCommand = "ci" + secretCmd = "secret" + ciSecretName = "MY_SECRET" + noStatusFlag = "--no-status" + resultFormatPlainFlag = "--result-format=plain" ) func expectWorkspaceGone(ctx context.Context, f *framework.Framework, name string) { @@ -69,6 +74,237 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere expectWorkspaceGone(ctx, f, tempDir) }, ginkgo.SpecTimeout(framework.TimeoutShort())) + ginkgo.DescribeTable( + "should preserve child streams and control progress visibility", + func(ctx context.Context, flags []string, wantStatus, wantDebug bool) { + tempDir, f := setupCI(initialDir) + args := []string{ciCommand} + args = append(args, flags...) + args = append(args, tempDir, "--", "sh", "-c", + "printf 'child-out:[RUN] {\"kind\":\"status\"}'; printf 'child-err' >&2") + stdout, stderr, err := f.ExecCommandCapture(ctx, args) + framework.ExpectNoError(err) + gomega.Expect(stdout).To(gomega.Equal(`child-out:[RUN] {"kind":"status"}`)) + gomega.Expect(stderr).To(gomega.ContainSubstring("child-err")) + if wantStatus { + gomega.Expect(stderr).To(gomega.ContainSubstring("[RUN]")) + } else { + gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[RUN]")) + gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[OK]")) + } + if len(flags) > 0 && flags[0] == noStatusFlag && len(flags) == 2 { + gomega.Expect(stderr).To(gomega.Equal("child-err")) + } + if wantDebug { + gomega.Expect(stderr).To(gomega.ContainSubstring("running command in devcontainer")) + } + expectWorkspaceGone(ctx, f, tempDir) + }, + ginkgo.Entry( + "default", + []string{}, + true, + false, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ), + ginkgo.Entry("disabled", []string{noStatusFlag, resultFormatPlainFlag}, false, false, + ginkgo.SpecTimeout(framework.TimeoutShort())), + ginkgo.Entry( + "quiet", + []string{noStatusFlag, "--quiet", resultFormatPlainFlag}, + false, + false, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ), + ginkgo.Entry( + "warn level", + []string{noStatusFlag, "--log-level=warn", resultFormatPlainFlag}, false, false, + ginkgo.SpecTimeout(framework.TimeoutShort())), + ginkgo.Entry( + "debug", + []string{ + noStatusFlag, + "--debug", + "--log-output=json", + resultFormatPlainFlag, + }, + false, + true, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ), + ginkgo.Entry( + "explicit false", + []string{"--no-status=false", resultFormatPlainFlag}, + true, + false, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ), + ) + + ginkgo.DescribeTable("should preserve a real warning while suppressing progress", + func(ctx context.Context, flags []string, wantWarning bool) { + tempDir, f := setupCI(initialDir) + configPath := filepath.Join(tempDir, ".devcontainer", "devcontainer.json") + framework.ExpectNoError(os.WriteFile(configPath, []byte(`{ + "name": "CI warning test", + "image": "ghcr.io/devsy-org/test-images/base:ubuntu", + "workspaceFolder": "/workspaces/ci" +}`), 0o600)) + args := []string{ciCommand, noStatusFlag} + args = append(args, flags...) + args = append(args, resultFormatPlainFlag, tempDir, + "--", "sh", "-c", "printf 'warning-child-out'; printf 'warning-child-err' >&2") + stdout, stderr, err := f.ExecCommandCapture(ctx, args) + framework.ExpectNoError(err) + gomega.Expect(stdout).To(gomega.Equal("warning-child-out")) + gomega.Expect(stderr).To(gomega.ContainSubstring("warning-child-err")) + if wantWarning { + gomega.Expect(stderr). + To(gomega.ContainSubstring("sets workspaceFolder without workspaceMount")) + } else { + gomega.Expect(stderr).NotTo(gomega.ContainSubstring( + "sets workspaceFolder without workspaceMount", + )) + } + gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[RUN]")) + expectWorkspaceGone(ctx, f, tempDir) + }, + ginkgo.Entry("warning level", []string{"--log-level=warn"}, true, + ginkgo.SpecTimeout(framework.TimeoutShort())), + ginkgo.Entry("quiet", []string{"--quiet"}, false, + ginkgo.SpecTimeout(framework.TimeoutShort())), + ) + + ginkgo.It("should retain public JSON result output without status events", + func(ctx context.Context) { + tempDir, f := setupCI(initialDir) + stdout, stderr, err := f.ExecCommandCapture(ctx, []string{ + ciCommand, noStatusFlag, "--result-format=json", tempDir, + "--", "sh", "-c", "printf 'json-child'", + }) + framework.ExpectNoError(err) + gomega.Expect(stdout).To(gomega.Equal("json-child")) + gomega.Expect(stderr).To(gomega.ContainSubstring(`"kind":"result"`)) + gomega.Expect(stderr).NotTo(gomega.ContainSubstring(`"kind":"status"`)) + expectWorkspaceGone(ctx, f, tempDir) + }, ginkgo.SpecTimeout(framework.TimeoutShort())) + + ginkgo.It( + "should preserve child stderr and cleanup when the child exits non-zero with status disabled", + func(ctx context.Context) { + tempDir, f := setupCI(initialDir) + _, stderr, err := f.ExecCommandCapture(ctx, []string{ + ciCommand, noStatusFlag, resultFormatPlainFlag, tempDir, + "--", "sh", "-c", "printf 'child-failed' >&2; exit 7", + }) + var exitErr *exec.ExitError + gomega.Expect(errors.As(err, &exitErr)).To(gomega.BeTrue(), "got %v", err) + gomega.Expect(exitErr.ExitCode()).To(gomega.Equal(7)) + gomega.Expect(stderr).To(gomega.ContainSubstring("child-failed")) + gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[FAIL]")) + expectWorkspaceGone(ctx, f, tempDir) + }, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ) + + ginkgo.It( + "should emit a machine error envelope and preserve child exit status with status disabled", + func(ctx context.Context) { + tempDir, f := setupCI(initialDir) + _, stderr, err := f.ExecCommandCapture(ctx, []string{ + ciCommand, noStatusFlag, "--log-output=json", resultFormatPlainFlag, tempDir, + "--", "sh", "-c", "printf 'machine-child-error' >&2; exit 7", + }) + var exitErr *exec.ExitError + gomega.Expect(errors.As(err, &exitErr)).To(gomega.BeTrue(), "got %v", err) + gomega.Expect(exitErr.ExitCode()).To(gomega.Equal(7)) + gomega.Expect(stderr).To(gomega.ContainSubstring("machine-child-error")) + gomega.Expect(stderr).To(gomega.ContainSubstring(`"kind":"error"`)) + gomega.Expect(stderr).NotTo(gomega.ContainSubstring(`"kind":"status"`)) + expectWorkspaceGone(ctx, f, tempDir) + }, ginkgo.SpecTimeout(framework.TimeoutShort())) + + ginkgo.It("should retain build failure diagnostics and cleanup with status disabled", + func(ctx context.Context) { + tempDir, f := setupCIFrom(initialDir, "tests/up/testdata/docker-recovery") + _, stderr, err := f.ExecCommandCapture(ctx, []string{ + ciCommand, noStatusFlag, resultFormatPlainFlag, tempDir, + "--", "sh", "-c", "exit 0", + }) + gomega.Expect(err).To(gomega.HaveOccurred()) + gomega.Expect(stderr).To(gomega.ContainSubstring("intentional build failure")) + gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[FAIL]")) + expectWorkspaceGone(ctx, f, tempDir) + }, ginkgo.SpecTimeout(framework.TimeoutLong())) + + ginkgo.It("should cancel the running command and cleanup with status disabled", + func(ctx context.Context) { + tempDir, f := setupCI(initialDir) + binaryPath := filepath.Join(f.DevsyBinDir, f.DevsyBinName) + cmd := &exec.Cmd{ + Path: binaryPath, + Args: []string{ + binaryPath, ciCommand, noStatusFlag, resultFormatPlainFlag, tempDir, + "--", "sh", "-c", "printf 'ci-ready\\n'; sleep 120", + }, + WaitDelay: 5 * time.Second, + } + stdout, err := cmd.StdoutPipe() + framework.ExpectNoError(err) + var stderr bytes.Buffer + cmd.Stderr = &stderr + framework.ExpectNoError(cmd.Start()) + ready := make(chan struct{}, 1) + go func() { + scanner := bufio.NewScanner(stdout) + for scanner.Scan() { + if scanner.Text() == "ci-ready" { + select { + case ready <- struct{}{}: + default: + } + } + } + }() + ginkgo.DeferCleanup(func() { + if cmd.ProcessState == nil { + _ = cmd.Process.Signal(os.Interrupt) + _, _ = waitCommandBounded(cmd) + } + }) + + select { + case <-ready: + case <-ctx.Done(): + ginkgo.Fail("timed out waiting for the CI child readiness marker") + } + + framework.ExpectNoError(cmd.Process.Signal(os.Interrupt)) + var timedOut bool + err, timedOut = waitCommandBounded(cmd) + gomega.Expect(timedOut).To(gomega.BeFalse(), "CI command did not stop after interrupt") + gomega.Expect(err).To(gomega.HaveOccurred()) + gomega.Expect(stderr.String()).NotTo(gomega.ContainSubstring("[RUN]")) + gomega.Expect(stderr.String()).NotTo(gomega.ContainSubstring("[FAIL]")) + expectWorkspaceGone(ctx, f, tempDir) + }, ginkgo.SpecTimeout(framework.TimeoutLong())) + + ginkgo.It("should retain the workspace when --no-status and --keep are passed", + func(ctx context.Context) { + tempDir, f := setupCI(initialDir) + ginkgo.DeferCleanup(f.DevsyWorkspaceDelete, tempDir) + + stdout, _, err := f.ExecCommandCapture(ctx, []string{ + ciCommand, noStatusFlag, resultFormatPlainFlag, tempDir, + "--keep", "--", "sh", "-c", "printf kept", + }) + framework.ExpectNoError(err) + gomega.Expect(stdout).To(gomega.Equal("kept")) + + _, err = f.FindWorkspace(ctx, tempDir) + framework.ExpectNoError(err) + }, ginkgo.SpecTimeout(framework.TimeoutShort())) + ginkgo.It("should retain the workspace when --keep is passed", func(ctx context.Context) { tempDir, f := setupCI(initialDir) @@ -189,3 +425,32 @@ func setupCIFrom(initialDir, testdataPath string) (string, *framework.Framework) return tempDir, f } + +func waitCommandBounded(cmd *exec.Cmd) (error, bool) { + done := make(chan error, 1) + go func() { + done <- cmd.Wait() + }() + + grace := time.NewTimer(15 * time.Second) + defer grace.Stop() + select { + case err := <-done: + return err, false + case <-grace.C: + if cmd.Cancel != nil { + _ = cmd.Cancel() + } else if cmd.Process != nil { + _ = cmd.Process.Kill() + } + } + + forced := time.NewTimer(10 * time.Second) + defer forced.Stop() + select { + case err := <-done: + return err, true + case <-forced.C: + return errors.New("CI command did not exit after forced termination"), true + } +} diff --git a/e2e/tests/ssh/task_cancel.go b/e2e/tests/ssh/task_cancel.go index fb5a296784..8555f8e27a 100644 --- a/e2e/tests/ssh/task_cancel.go +++ b/e2e/tests/ssh/task_cancel.go @@ -2,8 +2,10 @@ package ssh import ( "context" + "encoding/json" "os" "strconv" + "strings" "time" "github.com/devsy-org/devsy/e2e/framework" @@ -68,6 +70,33 @@ var _ = ginkgo.Describe( }, ) + ginkgo.It("should retain nested status history for a detached worker with status disabled", + ginkgo.SpecTimeout(framework.TimeoutLong()), + func(ctx context.Context) { + tempDir := framework.CopyTestdata("tests/ssh/testdata/local-test", initialDir) + f := setupTunnelProvider(ctx, initialDir) + ginkgo.DeferCleanup(func(cleanupCtx context.Context) { + _ = f.DevsyWorkspaceDelete(cleanupCtx, tempDir) + }) + + taskID, err := startDetachedTunnelUp(ctx, f, tempDir, "--no-status") + framework.ExpectNoError(err) + ginkgo.DeferCleanup(func(cleanupCtx context.Context) { + _ = f.DevsyWorkspaceTaskCancel(cleanupCtx, taskID) + }) + waitDetachedTunnelReady(ctx, f, taskID) + framework.ExpectNoError(f.DevsyWorkspaceTaskCancel(ctx, taskID)) + canceled := waitDetachedTaskCanceled(ctx, f, taskID) + gomega.Expect(canceled.Error).To(gomega.Equal("canceled")) + + followOut, _, followErr := f.ExecCommandCapture(ctx, []string{ + "workspace", "task", "logs", taskID, "--follow", "--result-format=json", + }) + gomega.Expect(followErr).To(gomega.HaveOccurred()) + expectNestedWorkerCompletion(followOut) + }, + ) + ginkgo.It("should quiesce a persisted detached task when stop runs without a task ID", ginkgo.SpecTimeout(framework.TimeoutLong()), func(ctx context.Context) { @@ -98,6 +127,27 @@ var _ = ginkgo.Describe( }, ) +func expectNestedWorkerCompletion(output string) { + found := false + for line := range strings.SplitSeq(output, "\n") { + var event struct { + Kind string `json:"kind"` + ParentOperationID string `json:"parentOperationId"` + State string `json:"state"` + } + if json.Unmarshal([]byte(line), &event) != nil || event.Kind != "status" { + continue + } + if event.ParentOperationID != "" && + (event.State == "succeeded" || event.State == "failed") { + found = true + break + } + } + gomega.Expect(found).To(gomega.BeTrue(), + "follow output should contain a nested worker completion with a parent operation ID: %s", output) +} + func expectWorkspaceStaysStopped(ctx context.Context, f *framework.Framework, workspace string) { gomega.Consistently(func() string { status, err := f.DevsyStatus(ctx, workspace) diff --git a/e2e/tests/up/up.go b/e2e/tests/up/up.go index 1632c22232..dbf7d2f504 100644 --- a/e2e/tests/up/up.go +++ b/e2e/tests/up/up.go @@ -12,12 +12,21 @@ import ( pkgconfig "github.com/devsy-org/devsy/pkg/config" docker "github.com/devsy-org/devsy/pkg/docker" "github.com/devsy-org/devsy/pkg/language" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/workspacejournal" "github.com/onsi/ginkgo/v2" "github.com/onsi/gomega" ) +const ( + noStatusFlag = "--no-status" + resultFormatFlag = "--result-format" + debugFlag = "--debug" + eventsCommand = "events" + ideNone = "none" +) + var _ = ginkgo.Describe("testing up command", ginkgo.Label("up-workspaces"), func() { var dockerHelper *docker.DockerHelper var initialDir string @@ -145,6 +154,44 @@ var _ = ginkgo.Describe("testing up command", ginkgo.Label("up-workspaces"), fun framework.ExpectEqual(out, value, "should be set now") }, ginkgo.SpecTimeout(framework.TimeoutShort())) + ginkgo.It("suppresses up progress while retaining workspace events", + func(ctx context.Context) { + f, err := framework.SetupDockerProvider(filepath.Join(initialDir, "bin"), "docker") + framework.ExpectNoError(err) + + tempDir, err := framework.CopyToTempDir("tests/up/testdata/no-devcontainer") + framework.ExpectNoError(err) + ginkgo.DeferCleanup(framework.CleanupTempDir, initialDir, tempDir) + ginkgo.DeferCleanup(f.DevsyWorkspaceDelete, tempDir) + + stdout, stderr, err := f.ExecCommandCapture(ctx, []string{ + cmdWorkspace, "up", noStatusFlag, resultFormatFlag + "=plain", debugFlag, + flagIDEOption, ideNone, tempDir, + }) + framework.ExpectNoError(err) + gomega.Expect(stdout).NotTo(gomega.ContainSubstring("[RUN]")) + gomega.Expect(stdout).NotTo(gomega.ContainSubstring("[OK]")) + gomega.Expect(stderr).To(gomega.ContainSubstring("resolving workspace with ide=")) + + workspace, err := f.FindWorkspace(ctx, tempDir) + framework.ExpectNoError(err) + eventsOutput, err := f.ExecCommandOutput(ctx, []string{ + cmdWorkspace, eventsCommand, resultFormatFlag, output.ModeJSON, workspace.ID, + }) + framework.ExpectNoError(err) + var eventEnvelope struct { + SchemaVersion int `json:"schemaVersion"` + Events []workspacejournal.Event `json:"events"` + } + framework.ExpectNoError(json.Unmarshal([]byte(eventsOutput), &eventEnvelope)) + gomega.Expect(eventEnvelope.Events).NotTo(gomega.BeEmpty()) + gomega.Expect(eventEnvelope.Events[len(eventEnvelope.Events)-1]).To(gomega.SatisfyAll( + gomega.HaveField("WorkspaceID", workspace.ID), + gomega.HaveField("Pipeline", status.PipelineWorkspaceUp), + gomega.HaveField("State", status.StateSucceeded), + )) + }, ginkgo.SpecTimeout(framework.TimeoutShort())) + ginkgo.It("create workspace without devcontainer.json", func(ctx context.Context) { const ( providerName = "test-docker" @@ -191,7 +238,7 @@ var _ = ginkgo.Describe("testing up command", ginkgo.Label("up-workspaces"), fun projectName := workspace.ID eventsOutput, err := f.ExecCommandOutput(ctx, []string{ - cmdWorkspace, "events", "--result-format", "json", projectName, + cmdWorkspace, eventsCommand, resultFormatFlag, output.ModeJSON, projectName, }) framework.ExpectNoError(err) var eventEnvelope struct { diff --git a/pkg/flags/names/names.go b/pkg/flags/names/names.go index e3bade3f63..81280858f2 100644 --- a/pkg/flags/names/names.go +++ b/pkg/flags/names/names.go @@ -207,6 +207,7 @@ const ( LogLevel = "log-level" LogFormat = "log-format" ResultFormat = "result-format" + NoStatus = "no-status" SetupInfo = "setup-info" SecretsEnv = "secrets-env" OwnerTrust = "ownertrust" diff --git a/pkg/flags/names/names_test.go b/pkg/flags/names/names_test.go index d2f4a7756a..a8f6dd3363 100644 --- a/pkg/flags/names/names_test.go +++ b/pkg/flags/names/names_test.go @@ -137,6 +137,7 @@ var wireNames = []struct { {names.LogOutput, "log-output"}, {names.LogFormat, "log-format"}, {names.ResultFormat, "result-format"}, + {names.NoStatus, "no-status"}, {names.SetupInfo, "setup-info"}, {names.SecretsEnv, "secrets-env"}, {names.Value, "value"}, diff --git a/pkg/status/render.go b/pkg/status/render.go index 42ef11ce1e..6ab99f8c16 100644 --- a/pkg/status/render.go +++ b/pkg/status/render.go @@ -22,6 +22,7 @@ type ReporterOptions struct { Envelope func(Event) error Interactive bool Verbose bool + NoStatus bool // SuppressFailureDetails leaves failure details to the command boundary. SuppressFailureDetails bool } @@ -34,7 +35,14 @@ const ( // NewReporter selects a status presentation. func NewReporter(opts ReporterOptions) (Reporter, error) { - return newReporter(resolveFormat(opts), opts) + r, err := newReporter(resolveFormat(opts), opts) + if err != nil { + return nil, err + } + if opts.NoStatus && os.Getenv("DEVSY_UI") != "true" { + return Nop(), nil + } + return r, nil } // CLIOptions configures the progress reporter for a CLI command. @@ -46,6 +54,7 @@ type CLIOptions struct { Labels map[Phase]string Envelope func(Event) error Verbose bool + NoStatus bool } // NewCLIReporter builds the progress reporter for CLI commands: NewReporter @@ -59,6 +68,7 @@ func NewCLIReporter(o CLIOptions) (Reporter, error) { Labels: o.Labels, Envelope: o.Envelope, Verbose: o.Verbose, + NoStatus: o.NoStatus, SuppressFailureDetails: true, }) if err != nil { diff --git a/pkg/status/reporter_test.go b/pkg/status/reporter_test.go index e465c8f746..99d2b24264 100644 --- a/pkg/status/reporter_test.go +++ b/pkg/status/reporter_test.go @@ -2,8 +2,12 @@ package status import ( "bytes" + "context" + "errors" "testing" "time" + + "github.com/stretchr/testify/require" ) func TestNewReporter_SelectsPlainAndEnvelope(t *testing.T) { @@ -103,7 +107,8 @@ func TestNewReporter_DesktopForcesEnvelope(t *testing.T) { t.Setenv("DEVSY_UI", "true") var events []Event reporter, err := NewReporter(ReporterOptions{ - Format: "plain", + Format: "plain", + NoStatus: true, Envelope: func(e Event) error { events = append(events, e) return nil @@ -118,6 +123,80 @@ func TestNewReporter_DesktopForcesEnvelope(t *testing.T) { } } +func TestNewReporter_NoStatus(t *testing.T) { + t.Setenv("DEVSY_UI", "") + var out bytes.Buffer + calls := 0 + for _, format := range []string{formatPlain, formatJSON} { + reporter, err := NewReporter(ReporterOptions{ + Format: format, Out: &out, NoStatus: true, + Envelope: func(Event) error { calls++; return nil }, + }) + if err != nil { + t.Fatalf("%s reporter: %v", format, err) + } + reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) + } + if out.Len() != 0 || calls != 0 { + t.Fatalf("suppressed output = %q, envelope calls = %d", out.String(), calls) + } + for _, opts := range []ReporterOptions{ + {Format: "ansi", NoStatus: true}, + {Format: formatJSON, NoStatus: true}, + } { + if _, err := NewReporter(opts); err == nil { + t.Fatalf("expected validation error for %+v", opts) + } + } +} + +func TestNoStatusTeePreservesRunEvents(t *testing.T) { + t.Setenv("DEVSY_UI", "") + var out bytes.Buffer + presentation, err := NewCLIReporter(CLIOptions{Format: formatPlain, Out: &out, NoStatus: true}) + if err != nil { + t.Fatal(err) + } + memory := NewMemoryReporter() + reporter := Tee(presentation, memory) + wantErr := errors.New("failure") + calls := 0 + err = Run( + context.Background(), + reporter, + Operation{Phase: PhaseBuildingImage}, + func(ctx context.Context) error { + return Run( + ctx, + reporter, + Operation{Phase: PhaseStartingContainer}, + func(context.Context) error { + calls++ + return wantErr + }, + ) + }, + ) + require.ErrorIs(t, err, wantErr) + require.Equal(t, 1, calls) + require.Empty(t, out.String()) + events := memory.Events() + require.Len(t, events, 4) + outer, inner, innerDone, outerDone := events[0], events[1], events[2], events[3] + require.Equal(t, StateStarted, outer.State) + require.Equal(t, StateStarted, inner.State) + require.Equal(t, StateFailed, innerDone.State) + require.Equal(t, StateFailed, outerDone.State) + require.NotEmpty(t, outer.OperationID) + require.NotEmpty(t, inner.OperationID) + require.NotEqual(t, outer.OperationID, inner.OperationID) + require.Equal(t, outer.OperationID, inner.ParentOperationID) + require.Equal(t, outer.OperationID, innerDone.ParentOperationID) + require.Equal(t, inner.OperationID, innerDone.OperationID) + require.Equal(t, outer.OperationID, outerDone.OperationID) + require.Equal(t, outer.ParentOperationID, outerDone.ParentOperationID) +} + func TestNewReporter_RejectsUnknownFormat(t *testing.T) { _, err := NewReporter(ReporterOptions{Format: "ansi", Out: &bytes.Buffer{}}) if err == nil { diff --git a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx index 090f5de340..17c7ce8f8a 100644 --- a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx @@ -56,6 +56,36 @@ Run `devsy ci --help` for the full list. The most used: - `--platform` runs the container under another platform, such as `linux/amd64`. - `--secret`, `--env`, `--build-secret`, and `--git-token` inject stored Devsy secrets and variables. See [Secrets](./secrets.mdx). +### Control progress output + +Use `--no-status` to hide Devsy's live progress messages. It does not filter +diagnostics or the command's own output. + +| Output | Effect of `--no-status` | +| --- | --- | +| Devsy progress | Hidden, including progress from the nested workspace command | +| Devsy diagnostics | Still controlled by `--quiet`, `--log-level`, and diagnostic format | +| Command stdout and stderr | Preserved on their original streams | +| Recorded events | Still recorded where the command already records them | + +For example, keep warnings and errors while hiding progress: + +```sh +devsy ci --no-status --result-format=plain --log-level=warn . -- bash .tools/test.sh +``` + +To show errors while hiding warnings, use `--quiet` instead. Quiet mode takes +precedence over `--log-level=warn` and suppresses warnings too: + +```sh +devsy ci --no-status --result-format=plain --quiet . -- bash .tools/test.sh +``` + +When stdout is redirected, use `--result-format=plain` to keep the nested +workspace command's success result JSON off stderr. Use +`--result-format=json` when the caller needs the structured result; child +stdout and stderr remain separate from Devsy diagnostics. + ## Pre-building and pushing images To pre-build and publish a devcontainer image for reuse as a build cache, use `devsy workspace build`: diff --git a/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx b/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx index d23421c742..37970b1024 100644 --- a/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx +++ b/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx @@ -45,6 +45,16 @@ Pass `--log-output json` to get errors as JSON with a stable `code` and a `messa Run with `--debug` to see the full error chain. +### Hide live progress while keeping diagnostics + +Pass `--no-status` to hide Devsy's live progress messages. Diagnostics still +follow `--quiet`, `--log-level`, and diagnostic format settings, and a command's +stdout and stderr remain on their original streams. Existing event and task +recording also continues when available. Hiding progress does not disable +capture or history. The flag cannot recover lifecycle output that was not +retained when the command ran. See the [lifecycle transcript discussion](https://github.com/devsy-org/devsy/discussions/1724) +for related work on retaining lifecycle output. + ### VS Code-family editor launch diagnostics For VS Code, VSCodium, and related editors, a failed CLI launch records the From 33a2258fa611c125490ce55c568239b5c85c0aea Mon Sep 17 00:00:00 2001 From: Samuel K Date: Fri, 30 Oct 2026 16:51:47 -0600 Subject: [PATCH 2/2] test(ci): distinguish diagnostics from status markers --- e2e/tests/ci/ci.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/e2e/tests/ci/ci.go b/e2e/tests/ci/ci.go index 0e3af2eaff..71a80e328d 100644 --- a/e2e/tests/ci/ci.go +++ b/e2e/tests/ci/ci.go @@ -87,10 +87,10 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere gomega.Expect(stdout).To(gomega.Equal(`child-out:[RUN] {"kind":"status"}`)) gomega.Expect(stderr).To(gomega.ContainSubstring("child-err")) if wantStatus { - gomega.Expect(stderr).To(gomega.ContainSubstring("[RUN]")) + gomega.Expect(stderr).To(gomega.MatchRegexp(`\[RUN\]\s+ci:`)) } else { - gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[RUN]")) - gomega.Expect(stderr).NotTo(gomega.ContainSubstring("[OK]")) + gomega.Expect(stderr). + NotTo(gomega.MatchRegexp(`\[(RUN|OK|FAIL)\]\s+(ci|workspace):`)) } if len(flags) > 0 && flags[0] == noStatusFlag && len(flags) == 2 { gomega.Expect(stderr).To(gomega.Equal("child-err"))