🎉 Initial Commit

pkg/cmd/main.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"git.solsynth.dev/hydrogen/messaging/pkg/grpc"
+	"git.solsynth.dev/hydrogen/messaging/pkg/server"
+
+	messaging "git.solsynth.dev/hydrogen/messaging/pkg"
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
+)
+
+func init() {
+	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stdout})
+}
+
+func main() {
+	// Configure settings
+	viper.AddConfigPath(".")
+	viper.AddConfigPath("..")
+	viper.SetConfigName("settings")
+	viper.SetConfigType("toml")
+
+	// Load settings
+	if err := viper.ReadInConfig(); err != nil {
+		log.Panic().Err(err).Msg("An error occurred when loading settings.")
+	}
+
+	// Connect to database
+	if err := database.NewSource(); err != nil {
+		log.Fatal().Err(err).Msg("An error occurred when connect to database.")
+	} else if err := database.RunMigration(database.C); err != nil {
+		log.Fatal().Err(err).Msg("An error occurred when running database auto migration.")
+	}
+
+	// Connect other services
+	go func() {
+		if err := grpc.ConnectPassport(); err != nil {
+			log.Fatal().Err(err).Msg("An error occurred when connecting to identity grpc endpoint...")
+		}
+	}()
+
+	// Server
+	server.NewServer()
+	go server.Listen()
+
+	// Messages
+	log.Info().Msgf("Messaging v%s is started...", messaging.AppVersion)
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	log.Info().Msgf("Messaging v%s is quitting...", messaging.AppVersion)
+}

pkg/database/migrator.go

@@ -0,0 +1,19 @@
+package database
+
+import (
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"gorm.io/gorm"
+)
+
+func RunMigration(source *gorm.DB) error {
+	if err := source.AutoMigrate(
+		&models.Account{},
+		&models.Channel{},
+		&models.ChannelMember{},
+		&models.Attachment{},
+	); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/database/source.go

@@ -0,0 +1,28 @@
+package database
+
+import (
+	"github.com/rs/zerolog/log"
+	"github.com/samber/lo"
+	"github.com/spf13/viper"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/schema"
+)
+
+var C *gorm.DB
+
+func NewSource() error {
+	var err error
+
+	dialector := postgres.Open(viper.GetString("database.dsn"))
+	C, err = gorm.Open(dialector, &gorm.Config{NamingStrategy: schema.NamingStrategy{
+		TablePrefix: viper.GetString("database.prefix"),
+	}, Logger: logger.New(&log.Logger, logger.Config{
+		Colorful:                  true,
+		IgnoreRecordNotFoundError: true,
+		LogLevel:                  lo.Ternary(viper.GetBool("debug.database"), logger.Info, logger.Silent),
+	})})
+
+	return err
+}

pkg/grpc/client.go

@@ -0,0 +1,24 @@
+package grpc
+
+import (
+	idpb "git.solsynth.dev/hydrogen/identity/pkg/grpc/proto"
+	"google.golang.org/grpc/credentials/insecure"
+
+	"github.com/spf13/viper"
+	"google.golang.org/grpc"
+)
+
+var Notify idpb.NotifyClient
+var Auth idpb.AuthClient
+
+func ConnectPassport() error {
+	addr := viper.GetString("identity.grpc_endpoint")
+	if conn, err := grpc.Dial(addr, grpc.WithTransportCredentials(insecure.NewCredentials())); err != nil {
+		return err
+	} else {
+		Notify = idpb.NewNotifyClient(conn)
+		Auth = idpb.NewAuthClient(conn)
+	}
+
+	return nil
+}

pkg/meta.go

@@ -0,0 +1,5 @@
+package pkg
+
+const (
+	AppVersion = "1.0.0"
+)

pkg/models/accounts.go

@@ -0,0 +1,19 @@
+package models
+
+// Account profiles basically fetched from Hydrogen.Identity
+// But cache at here for better usage
+// At the same time this model can make relations between local models
+type Account struct {
+	BaseModel
+
+	Name         string       `json:"name"`
+	Nick         string       `json:"nick"`
+	Avatar       string       `json:"avatar"`
+	Banner       string       `json:"banner"`
+	Description  string       `json:"description"`
+	EmailAddress string       `json:"email_address"`
+	PowerLevel   int          `json:"power_level"`
+	Attachments  []Attachment `json:"attachments" gorm:"foreignKey:AuthorID"`
+	Channels     []Channel    `json:"channels"`
+	ExternalID   uint         `json:"external_id"`
+}

pkg/models/attachments.go

@@ -0,0 +1,43 @@
+package models
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/spf13/viper"
+)
+
+type AttachmentType = uint8
+
+const (
+	AttachmentOthers = AttachmentType(iota)
+	AttachmentPhoto
+	AttachmentVideo
+	AttachmentAudio
+)
+
+type Attachment struct {
+	BaseModel
+
+	FileID      string         `json:"file_id"`
+	Filesize    int64          `json:"filesize"`
+	Filename    string         `json:"filename"`
+	Mimetype    string         `json:"mimetype"`
+	Hashcode    string         `json:"hashcode"`
+	Type        AttachmentType `json:"type"`
+	ExternalUrl string         `json:"external_url"`
+	Author      Account        `json:"author"`
+	ArticleID   *uint          `json:"article_id"`
+	MomentID    *uint          `json:"moment_id"`
+	CommentID   *uint          `json:"comment_id"`
+	AuthorID    uint           `json:"author_id"`
+}
+
+func (v Attachment) GetStoragePath() string {
+	basepath := viper.GetString("content")
+	return filepath.Join(basepath, v.FileID)
+}
+
+func (v Attachment) GetAccessPath() string {
+	return fmt.Sprintf("/api/attachments/o/%s", v.FileID)
+}

pkg/models/base.go

@@ -0,0 +1,17 @@
+package models
+
+import (
+	"time"
+
+	"gorm.io/datatypes"
+	"gorm.io/gorm"
+)
+
+type JSONMap = datatypes.JSONType[map[string]any]
+
+type BaseModel struct {
+	ID        uint           `json:"id" gorm:"primaryKey"`
+	CreatedAt time.Time      `json:"created_at"`
+	UpdatedAt time.Time      `json:"updated_at"`
+	DeletedAt gorm.DeletedAt `json:"deleted_at" gorm:"index"`
+}

pkg/models/channels.go

@@ -0,0 +1,19 @@
+package models
+
+type Channel struct {
+	BaseModel
+
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	Members     []ChannelMember `json:"members"`
+	AccountID   uint            `json:"account_id"`
+}
+
+type ChannelMember struct {
+	BaseModel
+
+	ChannelID uint    `json:"channel_id"`
+	AccountID uint    `json:"account_id"`
+	Channel   Channel `json:"channel"`
+	Account   Account `json:"account"`
+}

pkg/security/encryptor.go

@@ -0,0 +1,12 @@
+package security
+
+import "golang.org/x/crypto/bcrypt"
+
+func HashPassword(raw string) string {
+	data, _ := bcrypt.GenerateFromPassword([]byte(raw), 12)
+	return string(data)
+}
+
+func VerifyPassword(text string, password string) bool {
+	return bcrypt.CompareHashAndPassword([]byte(password), []byte(text)) == nil
+}

pkg/security/jwt.go

@@ -0,0 +1,81 @@
+package security
+
+import (
+	"fmt"
+	"github.com/gofiber/fiber/v2"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/spf13/viper"
+)
+
+type PayloadClaims struct {
+	jwt.RegisteredClaims
+
+	Type string `json:"typ"`
+}
+
+const (
+	JwtAccessType  = "access"
+	JwtRefreshType = "refresh"
+)
+
+const (
+	CookieAccessKey  = "identity_auth_key"
+	CookieRefreshKey = "identity_refresh_key"
+)
+
+func EncodeJwt(id string, typ, sub string, aud []string, exp time.Time) (string, error) {
+	tk := jwt.NewWithClaims(jwt.SigningMethodHS512, PayloadClaims{
+		jwt.RegisteredClaims{
+			Subject:   sub,
+			Audience:  aud,
+			Issuer:    fmt.Sprintf("https://%s", viper.GetString("domain")),
+			ExpiresAt: jwt.NewNumericDate(exp),
+			NotBefore: jwt.NewNumericDate(time.Now()),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			ID:        id,
+		},
+		typ,
+	})
+
+	return tk.SignedString([]byte(viper.GetString("secret")))
+}
+
+func DecodeJwt(str string) (PayloadClaims, error) {
+	var claims PayloadClaims
+	tk, err := jwt.ParseWithClaims(str, &claims, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+		}
+		return []byte(viper.GetString("secret")), nil
+	})
+	if err != nil {
+		return claims, err
+	}
+
+	if data, ok := tk.Claims.(*PayloadClaims); ok {
+		return *data, nil
+	} else {
+		return claims, fmt.Errorf("unexpected token payload: not payload claims type")
+	}
+}
+
+func SetJwtCookieSet(c *fiber.Ctx, access, refresh string) {
+	c.Cookie(&fiber.Cookie{
+		Name:     CookieAccessKey,
+		Value:    access,
+		Domain:   viper.GetString("security.cookie_domain"),
+		SameSite: viper.GetString("security.cookie_samesite"),
+		Expires:  time.Now().Add(60 * time.Minute),
+		Path:     "/",
+	})
+	c.Cookie(&fiber.Cookie{
+		Name:     CookieRefreshKey,
+		Value:    refresh,
+		Domain:   viper.GetString("security.cookie_domain"),
+		SameSite: viper.GetString("security.cookie_samesite"),
+		Expires:  time.Now().Add(24 * 30 * time.Hour),
+		Path:     "/",
+	})
+}

pkg/server/attachments_api.go

@@ -0,0 +1,61 @@
+package server
+
+import (
+	"path/filepath"
+
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"git.solsynth.dev/hydrogen/messaging/pkg/services"
+	"github.com/gofiber/fiber/v2"
+	"github.com/spf13/viper"
+)
+
+func readAttachment(c *fiber.Ctx) error {
+	id := c.Params("fileId")
+	basepath := viper.GetString("content")
+
+	return c.SendFile(filepath.Join(basepath, id))
+}
+
+func uploadAttachment(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	hashcode := c.FormValue("hashcode")
+	if len(hashcode) != 64 {
+		return fiber.NewError(fiber.StatusBadRequest, "please provide a SHA256 hashcode, length should be 64 characters")
+	}
+	file, err := c.FormFile("attachment")
+	if err != nil {
+		return err
+	}
+
+	attachment, err := services.NewAttachment(user, file, hashcode)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	if err := c.SaveFile(file, attachment.GetStoragePath()); err != nil {
+		return err
+	}
+
+	return c.JSON(fiber.Map{
+		"info": attachment,
+		"url":  attachment.GetAccessPath(),
+	})
+}
+
+func deleteAttachment(c *fiber.Ctx) error {
+	id, _ := c.ParamsInt("id", 0)
+	user := c.Locals("principal").(models.Account)
+
+	attachment, err := services.GetAttachmentByID(uint(id))
+	if err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	} else if attachment.AuthorID != user.ID {
+		return fiber.NewError(fiber.StatusNotFound, "record not created by you")
+	}
+
+	if err := services.DeleteAttachment(attachment); err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
+	} else {
+		return c.SendStatus(fiber.StatusOK)
+	}
+}

pkg/server/auth.go

@@ -0,0 +1,52 @@
+package server
+
+import (
+	"strings"
+
+	"git.solsynth.dev/hydrogen/messaging/pkg/security"
+	"git.solsynth.dev/hydrogen/messaging/pkg/services"
+	"github.com/gofiber/fiber/v2"
+)
+
+func authMiddleware(c *fiber.Ctx) error {
+	var token string
+	if cookie := c.Cookies(security.CookieAccessKey); len(cookie) > 0 {
+		token = cookie
+	}
+	if header := c.Get(fiber.HeaderAuthorization); len(header) > 0 {
+		tk := strings.Replace(header, "Bearer", "", 1)
+		token = strings.TrimSpace(tk)
+	}
+
+	c.Locals("token", token)
+
+	if err := authFunc(c); err != nil {
+		return err
+	}
+
+	return c.Next()
+}
+
+func authFunc(c *fiber.Ctx, overrides ...string) error {
+	var token string
+	if len(overrides) > 0 {
+		token = overrides[0]
+	} else {
+		if tk, ok := c.Locals("token").(string); !ok {
+			return fiber.NewError(fiber.StatusUnauthorized)
+		} else {
+			token = tk
+		}
+	}
+
+	rtk := c.Cookies(security.CookieRefreshKey)
+	if user, atk, rtk, err := services.Authenticate(token, rtk); err == nil {
+		if atk != token {
+			security.SetJwtCookieSet(c, atk, rtk)
+		}
+		c.Locals("principal", user)
+		return nil
+	} else {
+		return fiber.NewError(fiber.StatusUnauthorized, err.Error())
+	}
+}

pkg/server/channel_members_api.go

@@ -0,0 +1,86 @@
+package server
+
+import (
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"git.solsynth.dev/hydrogen/messaging/pkg/services"
+	"github.com/gofiber/fiber/v2"
+)
+
+func listChannelMembers(c *fiber.Ctx) error {
+	channelId, _ := c.ParamsInt("channelId", 0)
+
+	if members, err := services.ListChannelMember(uint(channelId)); err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
+	} else {
+		return c.JSON(members)
+	}
+}
+
+func inviteChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	channelId, _ := c.ParamsInt("channelId", 0)
+
+	var data struct {
+		AccountName string `json:"account_name" validate:"required"`
+	}
+
+	if err := BindAndValidate(c, &data); err != nil {
+		return err
+	}
+
+	var channel models.Channel
+	if err := database.C.Where(&models.Channel{
+		BaseModel: models.BaseModel{ID: uint(channelId)},
+		AccountID: user.ID,
+	}).First(&channel).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	var account models.Account
+	if err := database.C.Where(&models.Account{
+		Name: data.AccountName,
+	}).First(&account).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	if err := services.InviteChannelMember(account, channel); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	} else {
+		return c.SendStatus(fiber.StatusOK)
+	}
+}
+
+func kickChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	channelId, _ := c.ParamsInt("channelId", 0)
+
+	var data struct {
+		AccountName string `json:"account_name" validate:"required"`
+	}
+
+	if err := BindAndValidate(c, &data); err != nil {
+		return err
+	}
+
+	var channel models.Channel
+	if err := database.C.Where(&models.Channel{
+		BaseModel: models.BaseModel{ID: uint(channelId)},
+		AccountID: user.ID,
+	}).First(&channel).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	var account models.Account
+	if err := database.C.Where(&models.Account{
+		Name: data.AccountName,
+	}).First(&account).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	if err := services.KickChannelMember(account, channel); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	} else {
+		return c.SendStatus(fiber.StatusOK)
+	}
+}

pkg/server/channels_api.go

@@ -0,0 +1,123 @@
+package server
+
+import (
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"git.solsynth.dev/hydrogen/messaging/pkg/services"
+	"github.com/gofiber/fiber/v2"
+)
+
+func getChannel(c *fiber.Ctx) error {
+	id, _ := c.ParamsInt("channelId", 0)
+
+	var channel models.Channel
+	if err := database.C.Where(&models.Channel{
+		BaseModel: models.BaseModel{ID: uint(id)},
+	}).First(&channel).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	return c.JSON(channel)
+}
+
+func listChannel(c *fiber.Ctx) error {
+	channels, err := services.ListChannel()
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.JSON(channels)
+}
+
+func listOwnedChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+
+	channels, err := services.ListChannelWithUser(user)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.JSON(channels)
+}
+
+func listAvailableChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+
+	channels, err := services.ListChannelIsAvailable(user)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.JSON(channels)
+}
+
+func createChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	if user.PowerLevel < 10 {
+		return fiber.NewError(fiber.StatusForbidden, "require power level 10 to create channels")
+	}
+
+	var data struct {
+		Name        string `json:"name" validate:"required"`
+		Description string `json:"description"`
+	}
+
+	if err := BindAndValidate(c, &data); err != nil {
+		return err
+	}
+
+	channel, err := services.NewChannel(user, data.Name, data.Description)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.JSON(channel)
+}
+
+func editChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	id, _ := c.ParamsInt("channelId", 0)
+
+	var data struct {
+		Name        string `json:"name" validate:"required"`
+		Description string `json:"description"`
+	}
+
+	if err := BindAndValidate(c, &data); err != nil {
+		return err
+	}
+
+	var channel models.Channel
+	if err := database.C.Where(&models.Channel{
+		BaseModel: models.BaseModel{ID: uint(id)},
+		AccountID: user.ID,
+	}).First(&channel).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	channel, err := services.EditChannel(channel, data.Name, data.Description)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.JSON(channel)
+}
+
+func deleteChannel(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+	id, _ := c.ParamsInt("channelId", 0)
+
+	var channel models.Channel
+	if err := database.C.Where(&models.Channel{
+		BaseModel: models.BaseModel{ID: uint(id)},
+		AccountID: user.ID,
+	}).First(&channel).Error; err != nil {
+		return fiber.NewError(fiber.StatusNotFound, err.Error())
+	}
+
+	if err := services.DeleteChannel(channel); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return c.SendStatus(fiber.StatusOK)
+}

pkg/server/startup.go

@@ -0,0 +1,101 @@
+package server
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"git.solsynth.dev/hydrogen/messaging/pkg/views"
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/cache"
+	"github.com/gofiber/fiber/v2/middleware/cors"
+	"github.com/gofiber/fiber/v2/middleware/filesystem"
+	"github.com/gofiber/fiber/v2/middleware/idempotency"
+	"github.com/gofiber/fiber/v2/middleware/logger"
+	jsoniter "github.com/json-iterator/go"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
+)
+
+var A *fiber.App
+
+func NewServer() {
+	A = fiber.New(fiber.Config{
+		DisableStartupMessage: true,
+		EnableIPValidation:    true,
+		ServerHeader:          "Hydrogen.Messaging",
+		AppName:               "Hydrogen.Messaging",
+		ProxyHeader:           fiber.HeaderXForwardedFor,
+		JSONEncoder:           jsoniter.ConfigCompatibleWithStandardLibrary.Marshal,
+		JSONDecoder:           jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal,
+		BodyLimit:             50 * 1024 * 1024,
+		EnablePrintRoutes:     viper.GetBool("debug.print_routes"),
+	})
+
+	A.Use(idempotency.New())
+	A.Use(cors.New(cors.Config{
+		AllowCredentials: true,
+		AllowMethods: strings.Join([]string{
+			fiber.MethodGet,
+			fiber.MethodPost,
+			fiber.MethodHead,
+			fiber.MethodOptions,
+			fiber.MethodPut,
+			fiber.MethodDelete,
+			fiber.MethodPatch,
+		}, ","),
+		AllowOriginsFunc: func(origin string) bool {
+			return true
+		},
+	}))
+
+	A.Use(logger.New(logger.Config{
+		Format: "${status} | ${latency} | ${method} ${path}\n",
+		Output: log.Logger,
+	}))
+
+	A.Get("/.well-known", getMetadata)
+
+	api := A.Group("/api").Name("API")
+	{
+		api.Get("/users/me", authMiddleware, getUserinfo)
+		api.Get("/users/:accountId", getOthersInfo)
+
+		api.Get("/attachments/o/:fileId", cache.New(cache.Config{
+			Expiration:   365 * 24 * time.Hour,
+			CacheControl: true,
+		}), readAttachment)
+		api.Post("/attachments", authMiddleware, uploadAttachment)
+		api.Delete("/attachments/:id", authMiddleware, deleteAttachment)
+
+		channels := api.Group("/channels").Name("Channels API")
+		{
+			channels.Get("/", listChannel)
+			channels.Get("/me", authMiddleware, listOwnedChannel)
+			channels.Get("/me/available", authMiddleware, listAvailableChannel)
+			channels.Get("/:channelId", getChannel)
+			channels.Get("/:channelId/members", listChannelMembers)
+			channels.Post("/", authMiddleware, createChannel)
+			channels.Post("/:channelId/invite", authMiddleware, inviteChannel)
+			channels.Post("/:channelId/kick", authMiddleware, kickChannel)
+			channels.Put("/:channelId", authMiddleware, editChannel)
+			channels.Delete("/:channelId", authMiddleware, deleteChannel)
+		}
+	}
+
+	A.Use("/", cache.New(cache.Config{
+		Expiration:   24 * time.Hour,
+		CacheControl: true,
+	}), filesystem.New(filesystem.Config{
+		Root:         http.FS(views.FS),
+		PathPrefix:   "dist",
+		Index:        "index.html",
+		NotFoundFile: "dist/index.html",
+	}))
+}
+
+func Listen() {
+	if err := A.Listen(viper.GetString("bind")); err != nil {
+		log.Fatal().Err(err).Msg("An error occurred when starting server...")
+	}
+}

pkg/server/users_api.go

@@ -0,0 +1,33 @@
+package server
+
+import (
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"github.com/gofiber/fiber/v2"
+)
+
+func getUserinfo(c *fiber.Ctx) error {
+	user := c.Locals("principal").(models.Account)
+
+	var data models.Account
+	if err := database.C.
+		Where(&models.Account{BaseModel: models.BaseModel{ID: user.ID}}).
+		First(&data).Error; err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
+	}
+
+	return c.JSON(data)
+}
+
+func getOthersInfo(c *fiber.Ctx) error {
+	accountId := c.Params("accountId")
+
+	var data models.Account
+	if err := database.C.
+		Where(&models.Account{Name: accountId}).
+		First(&data).Error; err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
+	}
+
+	return c.JSON(data)
+}

pkg/server/utils.go

@@ -0,0 +1,18 @@
+package server
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+)
+
+var validation = validator.New(validator.WithRequiredStructEnabled())
+
+func BindAndValidate(c *fiber.Ctx, out any) error {
+	if err := c.BodyParser(out); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	} else if err := validation.Struct(out); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	return nil
+}

pkg/server/well_known_api.go

@@ -0,0 +1,16 @@
+package server
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"github.com/spf13/viper"
+)
+
+func getMetadata(c *fiber.Ctx) error {
+	return c.JSON(fiber.Map{
+		"name":   viper.GetString("name"),
+		"domain": viper.GetString("domain"),
+		"components": fiber.Map{
+			"identity": viper.GetString("identity.endpoint"),
+		},
+	})
+}

pkg/services/accounts.go

@@ -0,0 +1,28 @@
+package services
+
+import (
+	"context"
+	"time"
+
+	"git.solsynth.dev/hydrogen/identity/pkg/grpc/proto"
+	"git.solsynth.dev/hydrogen/messaging/pkg/grpc"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"github.com/spf13/viper"
+)
+
+func NotifyAccount(user models.Account, subject, content string, links ...*proto.NotifyLink) error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	_, err := grpc.Notify.NotifyUser(ctx, &proto.NotifyRequest{
+		ClientId:     viper.GetString("identity.client_id"),
+		ClientSecret: viper.GetString("identity.client_secret"),
+		Subject:      subject,
+		Content:      content,
+		Links:        links,
+		RecipientId:  uint64(user.ID),
+		IsImportant:  false,
+	})
+
+	return err
+}

pkg/services/attachments.go

@@ -0,0 +1,127 @@
+package services
+
+import (
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"github.com/google/uuid"
+	"github.com/spf13/viper"
+)
+
+func GetAttachmentByID(id uint) (models.Attachment, error) {
+	var attachment models.Attachment
+	if err := database.C.Where(models.Attachment{
+		BaseModel: models.BaseModel{ID: id},
+	}).First(&attachment).Error; err != nil {
+		return attachment, err
+	}
+	return attachment, nil
+}
+
+func GetAttachmentByUUID(fileId string) (models.Attachment, error) {
+	var attachment models.Attachment
+	if err := database.C.Where(models.Attachment{
+		FileID: fileId,
+	}).First(&attachment).Error; err != nil {
+		return attachment, err
+	}
+	return attachment, nil
+}
+
+func GetAttachmentByHashcode(hashcode string) (models.Attachment, error) {
+	var attachment models.Attachment
+	if err := database.C.Where(models.Attachment{
+		Hashcode: hashcode,
+	}).First(&attachment).Error; err != nil {
+		return attachment, err
+	}
+	return attachment, nil
+}
+
+func NewAttachment(user models.Account, header *multipart.FileHeader, hashcode string) (models.Attachment, error) {
+	var attachment models.Attachment
+	existsAttachment, err := GetAttachmentByHashcode(hashcode)
+	if err != nil {
+		// Upload the new file
+		attachment = models.Attachment{
+			FileID:   uuid.NewString(),
+			Filesize: header.Size,
+			Filename: header.Filename,
+			Hashcode: hashcode,
+			Mimetype: "unknown/unknown",
+			Type:     models.AttachmentOthers,
+			AuthorID: user.ID,
+		}
+
+		// Open file
+		file, err := header.Open()
+		if err != nil {
+			return attachment, err
+		}
+		defer file.Close()
+
+		// Detect mimetype
+		fileHeader := make([]byte, 512)
+		_, err = file.Read(fileHeader)
+		if err != nil {
+			return attachment, err
+		}
+		attachment.Mimetype = http.DetectContentType(fileHeader)
+
+		switch strings.Split(attachment.Mimetype, "/")[0] {
+		case "image":
+			attachment.Type = models.AttachmentPhoto
+		case "video":
+			attachment.Type = models.AttachmentVideo
+		case "audio":
+			attachment.Type = models.AttachmentAudio
+		default:
+			attachment.Type = models.AttachmentOthers
+		}
+	} else {
+		// Instant upload, build link with the exists file
+		attachment = models.Attachment{
+			FileID:   existsAttachment.FileID,
+			Filesize: header.Size,
+			Filename: header.Filename,
+			Hashcode: hashcode,
+			Mimetype: existsAttachment.Mimetype,
+			Type:     existsAttachment.Type,
+			AuthorID: user.ID,
+		}
+	}
+
+	// Save into database
+	err = database.C.Save(&attachment).Error
+
+	return attachment, err
+}
+
+func DeleteAttachment(item models.Attachment) error {
+	var dupeCount int64
+	if err := database.C.
+		Where(&models.Attachment{Hashcode: item.Hashcode}).
+		Model(&models.Attachment{}).
+		Count(&dupeCount).Error; err != nil {
+		dupeCount = -1
+	}
+
+	if err := database.C.Delete(&item).Error; err != nil {
+		return err
+	}
+
+	if dupeCount != -1 && dupeCount <= 1 {
+		// Safe for deletion the physics file
+		basepath := viper.GetString("content")
+		fullpath := filepath.Join(basepath, item.FileID)
+
+		os.Remove(fullpath)
+	}
+
+	return nil
+}

pkg/services/auth.go

@@ -0,0 +1,71 @@
+package services
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"git.solsynth.dev/hydrogen/identity/pkg/grpc/proto"
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/grpc"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"gorm.io/gorm"
+)
+
+func LinkAccount(userinfo *proto.Userinfo) (models.Account, error) {
+	var account models.Account
+	if userinfo == nil {
+		return account, fmt.Errorf("remote userinfo was not found")
+	}
+	if err := database.C.Where(&models.Account{
+		ExternalID: uint(userinfo.Id),
+	}).First(&account).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			account = models.Account{
+				Name:         userinfo.Name,
+				Nick:         userinfo.Nick,
+				Avatar:       userinfo.Avatar,
+				Banner:       userinfo.Banner,
+				Description:  userinfo.GetDescription(),
+				EmailAddress: userinfo.Email,
+				PowerLevel:   0,
+				ExternalID:   uint(userinfo.Id),
+			}
+			return account, database.C.Save(&account).Error
+		}
+		return account, err
+	}
+
+	account.Name = userinfo.Name
+	account.Nick = userinfo.Nick
+	account.Avatar = userinfo.Avatar
+	account.Banner = userinfo.Banner
+	account.Description = userinfo.GetDescription()
+	account.EmailAddress = userinfo.Email
+
+	err := database.C.Save(&account).Error
+
+	return account, err
+}
+
+func Authenticate(atk, rtk string) (models.Account, string, string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	var err error
+	var user models.Account
+	reply, err := grpc.Auth.Authenticate(ctx, &proto.AuthRequest{
+		AccessToken:  atk,
+		RefreshToken: &rtk,
+	})
+	if err != nil {
+		return user, reply.GetAccessToken(), reply.GetRefreshToken(), err
+	} else if !reply.IsValid {
+		return user, reply.GetAccessToken(), reply.GetRefreshToken(), fmt.Errorf("invalid authorization context")
+	}
+
+	user, err = LinkAccount(reply.Userinfo)
+
+	return user, reply.GetAccessToken(), reply.GetRefreshToken(), err
+}

pkg/services/channels.go

@@ -0,0 +1,110 @@
+package services
+
+import (
+	"git.solsynth.dev/hydrogen/messaging/pkg/database"
+	"git.solsynth.dev/hydrogen/messaging/pkg/models"
+	"github.com/samber/lo"
+)
+
+func ListChannel() ([]models.Channel, error) {
+	var channels []models.Channel
+	if err := database.C.Find(&channels).Error; err != nil {
+		return channels, err
+	}
+
+	return channels, nil
+}
+
+func ListChannelWithUser(user models.Account) ([]models.Channel, error) {
+	var channels []models.Channel
+	if err := database.C.Where(&models.Channel{AccountID: user.ID}).Find(&channels).Error; err != nil {
+		return channels, err
+	}
+
+	return channels, nil
+}
+
+func ListChannelIsAvailable(user models.Account) ([]models.Channel, error) {
+	var channels []models.Channel
+	var members []models.ChannelMember
+	if err := database.C.Where(&models.ChannelMember{
+		AccountID: user.ID,
+	}).Find(&members).Error; err != nil {
+		return channels, err
+	}
+
+	idx := lo.Map(members, func(item models.ChannelMember, index int) uint {
+		return item.ChannelID
+	})
+
+	if err := database.C.Where("id IN ?", idx).Find(&channels).Error; err != nil {
+		return channels, err
+	}
+
+	return channels, nil
+}
+
+func NewChannel(user models.Account, name, description string) (models.Channel, error) {
+	channel := models.Channel{
+		Name:        name,
+		Description: description,
+		AccountID:   user.ID,
+		Members: []models.ChannelMember{
+			{AccountID: user.ID},
+		},
+	}
+
+	err := database.C.Save(&channel).Error
+
+	return channel, err
+}
+
+func ListChannelMember(channelId uint) ([]models.ChannelMember, error) {
+	var members []models.ChannelMember
+
+	if err := database.C.
+		Where(&models.ChannelMember{ChannelID: channelId}).
+		Preload("Account").
+		Find(&members).Error; err != nil {
+		return members, err
+	}
+
+	return members, nil
+}
+
+func InviteChannelMember(user models.Account, target models.Channel) error {
+	member := models.ChannelMember{
+		ChannelID: target.ID,
+		AccountID: user.ID,
+	}
+
+	err := database.C.Save(&member).Error
+
+	return err
+}
+
+func KickChannelMember(user models.Account, target models.Channel) error {
+	var member models.ChannelMember
+
+	if err := database.C.Where(&models.ChannelMember{
+		ChannelID: target.ID,
+		AccountID: user.ID,
+	}).First(&member).Error; err != nil {
+		return err
+	}
+
+	return database.C.Delete(&member).Error
+}
+
+func EditChannel(channel models.Channel, name, description string) (models.Channel, error) {
+	channel.Name = name
+	channel.Description = description
+
+	err := database.C.Save(&channel).Error
+
+	return channel, err
+}
+
+func DeleteChannel(channel models.Channel) error {
+	return database.C.Delete(&channel).Error
+}

pkg/services/mailer.go

@@ -0,0 +1,51 @@
+package services
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net/smtp"
+	"net/textproto"
+
+	"github.com/jordan-wright/email"
+	"github.com/spf13/viper"
+)
+
+func SendMail(target string, subject string, content string) error {
+	mail := &email.Email{
+		To:      []string{target},
+		From:    viper.GetString("mailer.name"),
+		Subject: subject,
+		Text:    []byte(content),
+		Headers: textproto.MIMEHeader{},
+	}
+	return mail.SendWithTLS(
+		fmt.Sprintf("%s:%d", viper.GetString("mailer.smtp_host"), viper.GetInt("mailer.smtp_port")),
+		smtp.PlainAuth(
+			"",
+			viper.GetString("mailer.username"),
+			viper.GetString("mailer.password"),
+			viper.GetString("mailer.smtp_host"),
+		),
+		&tls.Config{ServerName: viper.GetString("mailer.smtp_host")},
+	)
+}
+
+func SendMailHTML(target string, subject string, content string) error {
+	mail := &email.Email{
+		To:      []string{target},
+		From:    viper.GetString("mailer.name"),
+		Subject: subject,
+		HTML:    []byte(content),
+		Headers: textproto.MIMEHeader{},
+	}
+	return mail.SendWithTLS(
+		fmt.Sprintf("%s:%d", viper.GetString("mailer.smtp_host"), viper.GetInt("mailer.smtp_port")),
+		smtp.PlainAuth(
+			"",
+			viper.GetString("mailer.username"),
+			viper.GetString("mailer.password"),
+			viper.GetString("mailer.smtp_host"),
+		),
+		&tls.Config{ServerName: viper.GetString("mailer.smtp_host")},
+	)
+}

pkg/views/.eslintrc.cjs

@@ -0,0 +1,20 @@
+/* eslint-env node */
+require("@rushstack/eslint-patch/modern-module-resolution")
+
+module.exports = {
+  root: true,
+  extends: [
+    "plugin:vue/vue3-essential",
+    "eslint:recommended",
+    "@vue/eslint-config-typescript",
+    "@vue/eslint-config-prettier/skip-formatting"
+  ],
+  parserOptions: {
+    ecmaVersion: "latest"
+  },
+  rules: {
+    "vue/multi-word-component-names": "off",
+    "vue/valid-v-for": "off",
+    "vue/require-v-for-key": "off"
+  }
+}

pkg/views/.gitignore

@@ -0,0 +1,33 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.DS_Store
+dist
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+*.tsbuildinfo
+
+*.lockb
+*.lock

pkg/views/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "semi": false,
+  "tabWidth": 2,
+  "singleQuote": false,
+  "printWidth": 120,
+  "trailingComma": "none"
+}

pkg/views/.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "Vue.volar",
+    "Vue.vscode-typescript-vue-plugin",
+    "dbaeumer.vscode-eslint",
+    "esbenp.prettier-vscode"
+  ]
+}

pkg/views/README.md

@@ -0,0 +1,46 @@
+# views
+
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur) + [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin).
+
+## Type Support for `.vue` Imports in TS
+
+TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin) to make the TypeScript language service aware of `.vue` types.
+
+If the standalone TypeScript plugin doesn't feel fast enough to you, Volar has also implemented a [Take Over Mode](https://github.com/johnsoncodehk/volar/discussions/471#discussioncomment-1361669) that is more performant. You can enable it by the following steps:
+
+1. Disable the built-in TypeScript Extension
+   1. Run `Extensions: Show Built-in Extensions` from VSCode's command palette
+   2. Find `TypeScript and JavaScript Language Features`, right click and select `Disable (Workspace)`
+2. Reload the VSCode window by running `Developer: Reload Window` from the command palette.
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vitejs.dev/config/).
+
+## Project Setup
+
+```sh
+npm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+npm run dev
+```
+
+### Type-Check, Compile and Minify for Production
+
+```sh
+npm run build
+```
+
+### Lint with [ESLint](https://eslint.org/)
+
+```sh
+npm run lint
+```

pkg/views/embed.go

@@ -0,0 +1,6 @@
+package views
+
+import "embed"
+
+//go:embed all:dist
+var FS embed.FS

pkg/views/env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

pkg/views/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/xml+svg" href="/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Solarplaza</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

pkg/views/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "views",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "run-p type-check \"build-only {@}\" --",
+    "preview": "vite preview",
+    "build-only": "vite build",
+    "type-check": "vue-tsc --build --force",
+    "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
+    "format": "prettier --write src/"
+  },
+  "dependencies": {
+    "@fontsource/roboto": "^5.0.8",
+    "@mdi/font": "^7.4.47",
+    "@unocss/reset": "^0.58.5",
+    "dompurify": "^3.0.9",
+    "marked": "^12.0.0",
+    "pinia": "^2.1.7",
+    "universal-cookie": "^7.1.0",
+    "unocss": "^0.58.5",
+    "vue": "^3.4.15",
+    "vue-easy-lightbox": "next",
+    "vue-router": "^4.2.5",
+    "vuetify": "^3.5.7"
+  },
+  "devDependencies": {
+    "@rushstack/eslint-patch": "^1.3.3",
+    "@tsconfig/node20": "^20.1.2",
+    "@types/dompurify": "^3.0.5",
+    "@types/node": "^20.11.10",
+    "@unocss/preset-typography": "^0.58.5",
+    "@vitejs/plugin-vue": "^5.0.3",
+    "@vitejs/plugin-vue-jsx": "^3.1.0",
+    "@vue/eslint-config-prettier": "^8.0.0",
+    "@vue/eslint-config-typescript": "^12.0.0",
+    "@vue/tsconfig": "^0.5.1",
+    "eslint": "^8.49.0",
+    "eslint-plugin-vue": "^9.17.0",
+    "npm-run-all2": "^6.1.1",
+    "prettier": "^3.0.3",
+    "typescript": "~5.3.0",
+    "vite": "^5.0.11",
+    "vue-tsc": "^1.8.27"
+  }
+}

pkg/views/src/assets/utils.css

@@ -0,0 +1,15 @@
+html,
+body,
+#app,
+.v-application {
+  overflow: auto !important;
+  font-family: "Roboto Sans", ui-sans-serif, system-ui, sans-serif;
+}
+
+.no-scrollbar {
+  scrollbar-width: none;
+}
+
+.no-scrollbar::-webkit-scrollbar {
+  width: 0;
+}

pkg/views/src/index.vue

@@ -0,0 +1,5 @@
+<template>
+  <v-app>
+    <router-view />
+  </v-app>
+</template>

pkg/views/src/layouts/master.vue

@@ -0,0 +1,108 @@
+<template>
+  <v-navigation-drawer v-model="drawerOpen" color="grey-lighten-5" floating>
+    <div class="flex flex-col h-full">
+      <v-list class="border-b border-opacity-15 h-[64px]" style="border-bottom-width: thin">
+        <v-list-item :subtitle="username" :title="nickname">
+          <template #prepend>
+            <v-avatar icon="mdi-account-circle" :image="id.userinfo.data?.avatar" />
+          </template>
+          <template #append>
+            <v-menu v-if="id.userinfo.isLoggedIn">
+              <template #activator="{ props }">
+                <v-btn v-bind="props" icon="mdi-menu-down" size="small" variant="text" />
+              </template>
+
+              <v-list density="compact">
+                <v-list-item
+                  title="Solarpass"
+                  prepend-icon="mdi-passport-biometric"
+                  target="_blank"
+                  :href="passportUrl"
+                />
+              </v-list>
+            </v-menu>
+
+            <v-btn v-else icon="mdi-login-variant" size="small" variant="text" :href="signinUrl" />
+          </template>
+        </v-list-item>
+      </v-list>
+
+      <div class="flex-grow-1">
+        <!-- TODO Channel list -->
+      </div>
+    </div>
+  </v-navigation-drawer>
+
+  <v-app-bar height="64" color="primary" scroll-behavior="elevate" flat>
+    <div class="max-md:px-5 md:px-12 flex flex-grow-1 items-center">
+      <v-app-bar-nav-icon variant="text" @click.stop="toggleDrawer" />
+
+      <router-link :to="{ name: 'landing' }">
+        <h2 class="ml-2 text-lg font-500">Solarecho</h2>
+      </router-link>
+
+      <v-spacer />
+
+      <v-tooltip v-for="item in navigationMenu" :text="item.name" location="bottom">
+        <template #activator="{ props }">
+          <v-btn flat exact v-bind="props" :to="{ name: item.to }" size="small" :icon="item.icon" />
+        </template>
+      </v-tooltip>
+    </div>
+  </v-app-bar>
+
+  <v-main>
+    <router-view />
+  </v-main>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from "vue"
+import { useUserinfo } from "@/stores/userinfo"
+import { useWellKnown } from "@/stores/wellKnown"
+
+const id = useUserinfo()
+const navigationMenu = [{ name: "Landing", icon: "mdi-home", to: "landing" }]
+
+const username = computed(() => {
+  if (id.userinfo.isLoggedIn) {
+    return "@" + id.userinfo.data?.name
+  } else {
+    return "@vistor"
+  }
+})
+const nickname = computed(() => {
+  if (id.userinfo.isLoggedIn) {
+    return id.userinfo.data?.nick
+  } else {
+    return "Anonymous"
+  }
+})
+
+id.readProfiles()
+
+const meta = useWellKnown()
+
+const signinUrl = computed(() => {
+  return meta.wellKnown?.components?.identity + `/auth/sign-in?redirect_uri=${encodeURIComponent(location.href)}`
+})
+const passportUrl = computed(() => {
+  return meta.wellKnown?.components?.identity
+})
+
+meta.readWellKnown()
+
+const drawerOpen = ref(true)
+
+function toggleDrawer() {
+  drawerOpen.value = !drawerOpen.value
+}
+</script>
+
+<style scoped>
+.editor-fab {
+  position: fixed !important;
+  bottom: 16px;
+  right: 20px;
+}
+</style>

pkg/views/src/main.ts

@@ -0,0 +1,54 @@
+import "virtual:uno.css"
+
+import "./assets/utils.css"
+
+import { createApp } from "vue"
+import { createPinia } from "pinia"
+
+import "vuetify/styles"
+import { createVuetify } from "vuetify"
+import { md3 } from "vuetify/blueprints"
+import * as components from "vuetify/components"
+import * as labsComponents from "vuetify/labs/components"
+import * as directives from "vuetify/directives"
+
+import "@mdi/font/css/materialdesignicons.min.css"
+import "@fontsource/roboto/latin.css"
+import "@unocss/reset/tailwind.css"
+
+import index from "./index.vue"
+import router from "./router"
+
+const app = createApp(index)
+
+app.use(
+  createVuetify({
+    directives,
+    components: {
+      ...components,
+      ...labsComponents
+    },
+    blueprint: md3,
+    theme: {
+      defaultTheme: "original",
+      themes: {
+        original: {
+          colors: {
+            primary: "#4a5099",
+            secondary: "#2196f3",
+            accent: "#009688",
+            error: "#f44336",
+            warning: "#ff9800",
+            info: "#03a9f4",
+            success: "#4caf50"
+          }
+        }
+      }
+    }
+  })
+)
+
+app.use(createPinia())
+app.use(router)
+
+app.mount("#app")

pkg/views/src/router/index.ts

@@ -0,0 +1,21 @@
+import { createRouter, createWebHistory } from "vue-router"
+import MasterLayout from "@/layouts/master.vue"
+
+const router = createRouter({
+  history: createWebHistory(import.meta.env.BASE_URL),
+  routes: [
+    {
+      path: "/",
+      component: MasterLayout,
+      children: [
+        {
+          path: "/",
+          name: "landing",
+          component: () => import("@/views/landing.vue")
+        },
+      ]
+    }
+  ]
+})
+
+export default router

pkg/views/src/scripts/request.ts

@@ -0,0 +1,10 @@
+declare global {
+  interface Window {
+    __LAUNCHPAD_TARGET__?: string
+  }
+}
+
+export async function request(input: string, init?: RequestInit) {
+  const prefix = window.__LAUNCHPAD_TARGET__ ?? ""
+  return await fetch(prefix + input, init)
+}

pkg/views/src/stores/userinfo.ts

@@ -0,0 +1,56 @@
+import Cookie from "universal-cookie"
+import { defineStore } from "pinia"
+import { ref } from "vue"
+import { request } from "@/scripts/request"
+
+export interface Userinfo {
+  isReady: boolean
+  isLoggedIn: boolean
+  displayName: string
+  data: any
+}
+
+const defaultUserinfo: Userinfo = {
+  isReady: false,
+  isLoggedIn: false,
+  displayName: "Citizen",
+  data: null
+}
+
+export function getAtk(): string {
+  return new Cookie().get("identity_auth_key")
+}
+
+export function checkLoggedIn(): boolean {
+  return new Cookie().get("identity_auth_key")
+}
+
+export const useUserinfo = defineStore("userinfo", () => {
+  const userinfo = ref(defaultUserinfo)
+  const isReady = ref(false)
+
+  async function readProfiles() {
+    if (!checkLoggedIn()) {
+      isReady.value = true
+    }
+
+    const res = await request("/api/users/me", {
+      headers: { Authorization: `Bearer ${getAtk()}` }
+    })
+
+    if (res.status !== 200) {
+      return
+    }
+
+    const data = await res.json()
+
+    userinfo.value = {
+      isReady: true,
+      isLoggedIn: true,
+      displayName: data["nick"],
+      data: data
+    }
+  }
+
+  return { userinfo, isReady, readProfiles }
+})

pkg/views/src/stores/wellKnown.ts

@@ -0,0 +1,14 @@
+import { request } from "@/scripts/request"
+import { defineStore } from "pinia"
+import { ref } from "vue"
+
+export const useWellKnown = defineStore("well-known", () => {
+  const wellKnown = ref<any>(null)
+
+  async function readWellKnown() {
+    const res = await request("/.well-known")
+    wellKnown.value = await res.json()
+  }
+
+  return { wellKnown, readWellKnown }
+})

pkg/views/src/views/landing.vue

@@ -0,0 +1,3 @@
+<template>
+  <v-container>W.I.P</v-container>
+</template>

pkg/views/tsconfig.app.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "include": ["env.d.ts", "src/**/*", "src/**/*.vue"],
+  "exclude": ["src/**/__tests__/*"],
+  "compilerOptions": {
+    "composite": true,
+    "allowJs": true,
+    "checkJs": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

pkg/views/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.node.json"
+    },
+    {
+      "path": "./tsconfig.app.json"
+    }
+  ]
+}

pkg/views/tsconfig.node.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@tsconfig/node20/tsconfig.json",
+  "include": ["vite.config.*", "vitest.config.*", "cypress.config.*", "nightwatch.conf.*", "playwright.config.*"],
+  "compilerOptions": {
+    "composite": true,
+    "noEmit": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["node"]
+  }
+}

pkg/views/uno.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig, presetAttributify, presetTypography, presetUno } from "unocss"
+
+export default defineConfig({
+  presets: [presetAttributify(), presetTypography(), presetUno({ preflight: false })]
+})

pkg/views/vite.config.ts

@@ -0,0 +1,22 @@
+import { fileURLToPath, URL } from "node:url"
+
+import { defineConfig } from "vite"
+import vue from "@vitejs/plugin-vue"
+import vueJsx from "@vitejs/plugin-vue-jsx"
+import unocss from "unocss/vite"
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [vue(), vueJsx(), unocss()],
+  resolve: {
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url))
+    }
+  },
+  server: {
+    proxy: {
+      "/.well-known": "http://localhost:8447",
+      "/api": "http://localhost:8447"
+    }
+  }
+})