feat: update InstanceProfile to include initialization status

- Removed the owner field from InstanceProfile as it is no longer needed.
- Added an initialized field to InstanceProfile to indicate if the instance has completed first-time setup.
- Updated GetInstanceProfile method to set initialized based on the existence of an admin user.
- Modified tests to reflect changes in InstanceProfile and ensure correct behavior regarding instance initialization.
- Adjusted frontend logic to redirect users based on the initialized status instead of the owner field.

Author: boojack

proto/api/v1/instance_service.proto

@@ -34,10 +34,6 @@ service InstanceService {
 
 // Instance profile message containing basic instance information.
 message InstanceProfile {
-  // The name of instance owner.
-  // Format: users/{user}
-  string owner = 1;
-
   // Version is the current version of instance.
   string version = 2;
 
@@ -46,6 +42,11 @@ message InstanceProfile {
 
   // Instance URL is the URL of the instance.
   string instance_url = 6;
+
+  // Indicates if the instance has completed first-time setup.
+  // When false, the instance requires initialization (creating the first admin account).
+  // This follows the pattern used by other self-hosted platforms for setup workflows.
+  bool initialized = 7;
 }
 
 // Request for instance profile.

proto/gen/api/v1/instance_service.pb.go

@@ -2132,11 +2132,6 @@ components:
         InstanceProfile:
             type: object
             properties:
-                owner:
-                    type: string
-                    description: |-
-                        The name of instance owner.
-                         Format: users/{user}
                 version:
                     type: string
                     description: Version is the current version of instance.
@@ -2146,6 +2141,12 @@ components:
                 instanceUrl:
                     type: string
                     description: Instance URL is the URL of the instance.
+                initialized:
+                    type: boolean
+                    description: |-
+                        Indicates if the instance has completed first-time setup.
+                         When false, the instance requires initialization (creating the first admin account).
+                         This follows the pattern used by other self-hosted platforms for setup workflows.
             description: Instance profile message containing basic instance information.
         InstanceSetting:
             type: object

proto/gen/openapi.yaml

@@ -15,17 +15,16 @@ import (
 
 // GetInstanceProfile returns the instance profile.
 func (s *APIV1Service) GetInstanceProfile(ctx context.Context, _ *v1pb.GetInstanceProfileRequest) (*v1pb.InstanceProfile, error) {
-	instanceProfile := &v1pb.InstanceProfile{
-		Version:     s.Profile.Version,
-		Demo:        s.Profile.Demo,
-		InstanceUrl: s.Profile.InstanceURL,
-	}
 	owner, err := s.GetInstanceOwner(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to get instance owner: %v", err)
 	}
-	if owner != nil {
-		instanceProfile.Owner = owner.Name
+
+	instanceProfile := &v1pb.InstanceProfile{
+		Version:     s.Profile.Version,
+		Demo:        s.Profile.Demo,
+		InstanceUrl: s.Profile.InstanceURL,
+		Initialized: owner != nil,
 	}
 	return instanceProfile, nil
 }
@@ -291,3 +290,9 @@ func (s *APIV1Service) GetInstanceOwner(ctx context.Context) (*v1pb.User, error)
 	ownerCache = convertUserFromStore(user)
 	return ownerCache, nil
 }
+
+// ClearInstanceOwnerCache clears the cached instance owner.
+// This should be called when an admin user is created or when the owner changes.
+func (s *APIV1Service) ClearInstanceOwnerCache() {
+	ownerCache = nil
+}

server/router/api/v1/instance_service.go

@@ -0,0 +1,58 @@
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	v1pb "github.com/usememos/memos/proto/gen/api/v1"
+)
+
+func TestInstanceOwnerCache(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("Instance becomes initialized after first admin user is created", func(t *testing.T) {
+		// Create test service
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		// Verify instance is not initialized initially
+		profile1, err := ts.Service.GetInstanceProfile(ctx, &v1pb.GetInstanceProfileRequest{})
+		require.NoError(t, err)
+		require.False(t, profile1.Initialized, "Instance should not be initialized before first admin user")
+
+		// Create the first admin user
+		user, err := ts.CreateHostUser(ctx, "admin")
+		require.NoError(t, err)
+		require.NotNil(t, user)
+
+		// Verify instance is now initialized
+		profile2, err := ts.Service.GetInstanceProfile(ctx, &v1pb.GetInstanceProfileRequest{})
+		require.NoError(t, err)
+		require.True(t, profile2.Initialized, "Instance should be initialized after first admin user is created")
+	})
+
+	t.Run("ClearInstanceOwnerCache works correctly", func(t *testing.T) {
+		// Create test service
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		// Create admin user
+		_, err := ts.CreateHostUser(ctx, "admin")
+		require.NoError(t, err)
+
+		// Verify initialized
+		profile1, err := ts.Service.GetInstanceProfile(ctx, &v1pb.GetInstanceProfileRequest{})
+		require.NoError(t, err)
+		require.True(t, profile1.Initialized)
+
+		// Clear cache
+		ts.Service.ClearInstanceOwnerCache()
+
+		// Should still be initialized (cache is refilled from DB)
+		profile2, err := ts.Service.GetInstanceProfile(ctx, &v1pb.GetInstanceProfileRequest{})
+		require.NoError(t, err)
+		require.True(t, profile2.Initialized)
+	})
+}

server/router/api/v1/test/instance_owner_cache_test.go

@@ -2,7 +2,6 @@ package test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -31,11 +30,11 @@ func TestGetInstanceProfile(t *testing.T) {
 		require.True(t, resp.Demo)
 		require.Equal(t, "http://localhost:8080", resp.InstanceUrl)
 
-		// Owner should be empty since no users are created
-		require.Empty(t, resp.Owner)
+		// Instance should not be initialized since no admin users are created
+		require.False(t, resp.Initialized)
 	})
 
-	t.Run("GetInstanceProfile with owner", func(t *testing.T) {
+	t.Run("GetInstanceProfile with initialized instance", func(t *testing.T) {
 		// Create test service for this specific test
 		ts := NewTestService(t)
 		defer ts.Cleanup()
@@ -53,14 +52,13 @@ func TestGetInstanceProfile(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, resp)
 
-		// Verify the response contains expected data including owner
+		// Verify the response contains expected data with initialized flag
 		require.Equal(t, "test-1.0.0", resp.Version)
 		require.True(t, resp.Demo)
 		require.Equal(t, "http://localhost:8080", resp.InstanceUrl)
 
-		// User name should be "users/{id}" format where id is the user's ID
-		expectedOwnerName := fmt.Sprintf("users/%d", hostUser.ID)
-		require.Equal(t, expectedOwnerName, resp.Owner)
+		// Instance should be initialized since an admin user exists
+		require.True(t, resp.Initialized)
 	})
 }
 
@@ -73,9 +71,8 @@ func TestGetInstanceProfile_Concurrency(t *testing.T) {
 		defer ts.Cleanup()
 
 		// Create a host user
-		hostUser, err := ts.CreateHostUser(ctx, "admin")
+		_, err := ts.CreateHostUser(ctx, "admin")
 		require.NoError(t, err)
-		expectedOwnerName := fmt.Sprintf("users/%d", hostUser.ID)
 
 		// Make concurrent requests
 		numGoroutines := 10
@@ -104,7 +101,7 @@ func TestGetInstanceProfile_Concurrency(t *testing.T) {
 				require.Equal(t, "test-1.0.0", resp.Version)
 				require.True(t, resp.Demo)
 				require.Equal(t, "http://localhost:8080", resp.InstanceUrl)
-				require.Equal(t, expectedOwnerName, resp.Owner)
+				require.True(t, resp.Initialized)
 			}
 		}
 	})

server/router/api/v1/test/instance_service_test.go

@@ -177,6 +177,12 @@ func (s *APIV1Service) CreateUser(ctx context.Context, request *v1pb.CreateUserR
 		return nil, status.Errorf(codes.Internal, "failed to create user: %v", err)
 	}
 
+	// If this is the first admin user being created, clear the owner cache
+	// so that GetInstanceProfile will return initialized=true
+	if roleToAssign == store.RoleAdmin {
+		s.ClearInstanceOwnerCache()
+	}
+
 	return convertUserFromStore(user), nil
 }
 

server/router/api/v1/user_service.go

@@ -20,12 +20,12 @@ const App = () => {
     cleanupExpiredOAuthState();
   }, []);
 
-  // Redirect to sign up page if no instance owner
+  // Redirect to sign up page if instance not initialized (no admin account exists yet)
   useEffect(() => {
-    if (!instanceProfile.owner) {
+    if (!instanceProfile.initialized) {
       navigateTo("/auth/signup");
     }
-  }, [instanceProfile.owner, navigateTo]);
+  }, [instanceProfile.initialized, navigateTo]);
 
   useEffect(() => {
     if (instanceGeneralSetting.additionalStyle) {

web/src/App.tsx

@@ -1,9 +1,9 @@
 import { MemoRenderContext } from "@/components/MasonryView";
 import MemoView from "@/components/MemoView";
 import PagedMemoList from "@/components/PagedMemoList";
+import { useInstance } from "@/contexts/InstanceContext";
 import { useMemoFilters, useMemoSorting } from "@/hooks";
 import useCurrentUser from "@/hooks/useCurrentUser";
-import { useInstance } from "@/contexts/InstanceContext";
 import { State } from "@/types/proto/api/v1/common_pb";
 import { Memo } from "@/types/proto/api/v1/memo_service_pb";
 

web/src/pages/Home.tsx

@@ -9,18 +9,22 @@ import AuthFooter from "@/components/AuthFooter";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { authServiceClient, userServiceClient } from "@/connect";
+import { useAuth } from "@/contexts/AuthContext";
 import { useInstance } from "@/contexts/InstanceContext";
 import useLoading from "@/hooks/useLoading";
+import useNavigateTo from "@/hooks/useNavigateTo";
 import { handleError } from "@/lib/error";
 import { User_Role, UserSchema } from "@/types/proto/api/v1/user_service_pb";
 import { useTranslate } from "@/utils/i18n";
 
 const SignUp = () => {
   const t = useTranslate();
+  const navigateTo = useNavigateTo();
   const actionBtnLoadingState = useLoading(false);
   const [username, setUsername] = useState("");
   const [password, setPassword] = useState("");
-  const { generalSetting: instanceGeneralSetting, profile } = useInstance();
+  const { initialize: initAuth } = useAuth();
+  const { generalSetting: instanceGeneralSetting, profile, initialize: initInstance } = useInstance();
 
   const handleUsernameInputChanged = (e: React.ChangeEvent<HTMLInputElement>) => {
     const text = e.target.value as string;
@@ -64,7 +68,11 @@ const SignUp = () => {
       if (response.accessToken) {
         setAccessToken(response.accessToken, response.accessTokenExpiresAt ? timestampDate(response.accessTokenExpiresAt) : undefined);
       }
-      window.location.href = "/";
+      // Refresh auth context to load the current user
+      await initAuth();
+      // Refetch instance profile to update the initialized status
+      await initInstance();
+      navigateTo("/");
     } catch (error: unknown) {
       handleError(error, toast.error, {
         fallbackMessage: "Sign up failed",
@@ -127,7 +135,7 @@ const SignUp = () => {
         ) : (
           <p className="w-full text-2xl mt-2 text-muted-foreground">Sign up is not allowed.</p>
         )}
-        {!profile.owner ? (
+        {!profile.initialized ? (
           <p className="w-full mt-4 text-sm font-medium text-muted-foreground">{t("auth.host-tip")}</p>
         ) : (
           <p className="w-full mt-4 text-sm">