Persist offline terms agreement (#620)

* Persist offline terms agreement

* address PR comments

Author: lionello

src/cmd/cli/command/commands.go

@@ -357,7 +357,7 @@ var RootCmd = &cobra.Command{
 				term.Debug("Server error:", err)
 				term.Warn("Please log in to continue.")
 
-				defer trackCmd(nil, "Login", P{"reason", err})
+				defer func() { trackCmd(nil, "Login", P{"reason", err}) }()
 				if err = cli.InteractiveLogin(cmd.Context(), client, gitHubClientId, cluster); err != nil {
 					return err
 				}
@@ -373,9 +373,9 @@ var RootCmd = &cobra.Command{
 			if connect.CodeOf(err) == connect.CodeFailedPrecondition {
 				term.Warn(prettyError(err))
 
-				defer trackCmd(nil, "Terms", P{"reason", err})
+				defer func() { trackCmd(nil, "Terms", P{"reason", err}) }()
 				if err = cli.InteractiveAgreeToS(cmd.Context(), client); err != nil {
-					return err
+					return err // fatal
 				}
 			}
 		}
@@ -548,11 +548,10 @@ var generateCmd = &cobra.Command{
 		if client.CheckLoginAndToS(cmd.Context()) != nil {
 			// The user is either not logged in or has not agreed to the terms of service; ask for agreement to the terms now
 			if err := cli.InteractiveAgreeToS(cmd.Context(), client); err != nil {
-				// This might fail because the user did not log in. This is fine: we won't persist the terms agreement, but can proceed with the generation
+				// This might fail because the user did not log in. This is fine: server won't save the terms agreement, but can proceed with the generation
 				if connect.CodeOf(err) != connect.CodeUnauthenticated {
 					return err
 				}
-				// TODO: persist the terms agreement in the state file
 			}
 		}
 

src/pkg/cli/agree_tos.go

@@ -12,7 +12,15 @@ import (
 
 var ErrTermsNotAgreed = errors.New("You must agree to the Defang terms of service to use this tool")
 
-func InteractiveAgreeToS(ctx context.Context, client client.Client) error {
+func InteractiveAgreeToS(ctx context.Context, c client.Client) error {
+	if client.TermsAccepted() {
+		// The user has already agreed to the terms of service recently
+		if err := nonInteractiveAgreeToS(ctx, c); err != nil {
+			term.Debug("unable to agree to terms:", err) // not fatal
+		}
+		return nil
+	}
+
 	fmt.Println("Our latest terms of service can be found at https://defang.io/terms-service.html")
 
 	var agreeToS bool
@@ -28,15 +36,24 @@ func InteractiveAgreeToS(ctx context.Context, client client.Client) error {
 		return ErrTermsNotAgreed
 	}
 
-	return NonInteractiveAgreeToS(ctx, client)
+	return NonInteractiveAgreeToS(ctx, c)
 }
 
-func NonInteractiveAgreeToS(ctx context.Context, client client.Client) error {
+func NonInteractiveAgreeToS(ctx context.Context, c client.Client) error {
 	if DoDryRun {
 		return ErrDryRun
 	}
 
-	if err := client.AgreeToS(ctx); err != nil {
+	// Persist the terms agreement in the state file so that we don't ask again
+	if err := client.AcceptTerms(); err != nil {
+		term.Debug("unable to persist terms agreement:", err) // not fatal
+	}
+
+	return nonInteractiveAgreeToS(ctx, c)
+}
+
+func nonInteractiveAgreeToS(ctx context.Context, c client.Client) error {
+	if err := c.AgreeToS(ctx); err != nil {
 		return err
 	}
 	term.Info("You have agreed to the Defang terms of service")

src/pkg/cli/client/state.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"time"
 
 	"github.com/DefangLabs/defang/src/pkg"
 	"github.com/google/uuid"
@@ -22,25 +23,54 @@ func userStateDir() (string, error) {
 var (
 	stateDir, _ = userStateDir()
 	// StateDir is the directory where the state file is stored
-	StateDir = filepath.Join(stateDir, "defang")
-
-	GetAnonID = func() string {
-		state := State{AnonID: uuid.NewString()}
-
-		// Restore anonID from config file
-		statePath := filepath.Join(StateDir, "state.json")
-		if bytes, err := os.ReadFile(statePath); err == nil {
-			json.Unmarshal(bytes, &state)
-		} else { // could be not found or path error
-			if bytes, err := json.MarshalIndent(state, "", "  "); err == nil {
-				os.MkdirAll(StateDir, 0700)
-				os.WriteFile(statePath, bytes, 0644)
-			}
-		}
-		return state.AnonID
-	}
+	StateDir  = filepath.Join(stateDir, "defang")
+	statePath = filepath.Join(StateDir, "state.json")
+	state     State
 )
 
 type State struct {
-	AnonID string
+	AnonID          string
+	TermsAcceptedAt time.Time
+}
+
+func initState(path string) State {
+	state := State{AnonID: uuid.NewString()}
+	if bytes, err := os.ReadFile(path); err == nil {
+		json.Unmarshal(bytes, &state)
+	} else { // could be not found or path error
+		state.write(path)
+	}
+	return state
+}
+
+func (state State) write(path string) error {
+	if bytes, err := json.MarshalIndent(state, "", "  "); err != nil {
+		return err
+	} else {
+		os.MkdirAll(StateDir, 0700)
+		return os.WriteFile(path, bytes, 0644)
+	}
+}
+
+func (state *State) acceptTerms() error {
+	state.TermsAcceptedAt = time.Now()
+	return state.write(statePath)
+}
+
+func (state State) termsAccepted() bool {
+	// Consider the terms accepted if the timestamp is within the last 24 hours
+	return time.Since(state.TermsAcceptedAt) < 24*time.Hour
+}
+
+func GetAnonID() string {
+	state = initState(statePath)
+	return state.AnonID
+}
+
+func AcceptTerms() error {
+	return state.acceptTerms()
+}
+
+func TermsAccepted() bool {
+	return state.termsAccepted()
 }

src/pkg/cli/client/state_test.go

@@ -2,8 +2,10 @@ package client
 
 import (
 	"os"
+	"path/filepath"
 	"runtime"
 	"testing"
+	"time"
 )
 
 func TestStateDir(t *testing.T) {
@@ -19,3 +21,38 @@ func TestStateDir(t *testing.T) {
 		t.Errorf("userStateDir() returned unexpected directory: %v", stateDir)
 	}
 }
+
+func TestInitState(t *testing.T) {
+	tmp := filepath.Join(t.TempDir(), "state.json")
+	state := initState(tmp)
+	if state.AnonID == "" {
+		t.Errorf("initState() returned empty AnonID")
+	}
+	// 2nd call should read from same file
+	state2 := initState(tmp)
+	if state2.AnonID != state.AnonID {
+		t.Errorf("initState() returned different AnonID on 2nd call")
+	}
+}
+
+func TestTerms(t *testing.T) {
+	tmp := filepath.Join(t.TempDir(), "state.json")
+	state := initState(tmp)
+	if !state.TermsAcceptedAt.IsZero() {
+		t.Errorf("initState() returned non-zero TermsAccepted")
+	}
+	if state.termsAccepted() {
+		t.Errorf("TermsAccepted() returned true, expected false")
+	}
+	if err := state.acceptTerms(); err != nil {
+		t.Errorf("AcceptTerms() returned error: %v", err)
+	}
+	if !state.termsAccepted() {
+		t.Errorf("TermsAccepted() returned false, expected true")
+	}
+	// Old acceptance should not count
+	state.TermsAcceptedAt = state.TermsAcceptedAt.Add(-25 * time.Hour)
+	if state.termsAccepted() {
+		t.Errorf("TermsAccepted() returned true, expected false")
+	}
+}