arozos-mirror/src/agi.go

package main

import (
	"net/http"
	"path/filepath"
	"strconv"
	"time"

	agi "imuslab.com/arozos/mod/agi"
	"imuslab.com/arozos/mod/email"
	"imuslab.com/arozos/mod/git"
	"imuslab.com/arozos/mod/notification"
	prout "imuslab.com/arozos/mod/prouter"
	"imuslab.com/arozos/mod/utils"
)

var (
	AGIGateway  *agi.Gateway
	mailBackend *email.Manager //Mail client backend, closed on shutdown
)

func AGIInit() {
	//Create the version control backend used by the AGI git library and the
	//GitApp WebApp. A failure here only disables git support, so the rest of
	//the gateway still starts.
	gitManager, err := git.NewManager(git.Options{
		Database:     sysdb,
		KeyStorePath: filepath.Join("./system", "git"),
		Logger:       systemWideLogger,
	})
	if err != nil {
		systemWideLogger.PrintAndLog("AGI", "Git support disabled", err)
		gitManager = nil
	}

	//Create the mail client backend used by the AGI email library and the Mail
	//WebApp. It keeps its own database and key under ./system/mail, so the
	//shared AGI database helpers can never reach anyone's mail accounts.
	emailManager, err := email.NewManager(email.Options{
		DataDir: filepath.Join("./system", "mail"),
		Notify: func(username string, title string, message string) {
			sendUserNotification(&notification.NotificationPayload{
				ID:        "mail-" + strconv.FormatInt(time.Now().UnixNano(), 10),
				Title:     title,
				Message:   message,
				Receiver:  []string{username},
				Sender:    "Mail",
				Priority:  notification.PriorityHigh,
				Timestamp: time.Now().Unix(),
			})
		},
	})
	if err != nil {
		systemWideLogger.PrintAndLog("AGI", "Mail support disabled", err)
		emailManager = nil
	}
	mailBackend = emailManager

	//Create new AGI Gateway object
	gw, err := agi.NewGateway(agi.AgiSysInfo{
		BuildVersion:          build_version,
		InternalVersion:       internal_version,
		LoadedModule:          moduleHandler.GetModuleNameList(),
		ReservedTables:        []string{"auth", "permisson", "register", "desktop"},
		ModuleRegisterParser:  moduleHandler.RegisterModuleFromAGI,
		ExtIconRegisterParser: moduleHandler.RegisterExtIcon,
		ModuleListProvider:    moduleHandler.GetModuleListJSONForUser,
		PackageManager:        packageManager,
		Logger:                systemWideLogger,
		UserHandler:           userHandler,
		StartupRoot:           "./web",
		ActivateScope:         []string{"./web", "./subservice"},
		FileSystemRender:      thumbRenderHandler,
		ShareManager:          shareManager,
		NightlyManager:        nightlyManager,
		MeetRoomManager:       meetRoomManager,
		SharedSpaceManager:    sharedSpaceManager,
		GitManager:            gitManager,
		EmailManager:          emailManager,
		TempFolderPath:        *tmp_directory,
		NotificationSender:    sendUserNotification,
	})
	if err != nil {
		systemWideLogger.PrintAndLog("AGI", "AGI Gateway Initialization Failed", err)
	}

	//Register user request handler endpoint
	http.HandleFunc("/system/ajgi/interface", func(w http.ResponseWriter, r *http.Request) {
		//Require login check
		authAgent.HandleCheckAuth(w, r, func(w http.ResponseWriter, r *http.Request) {
			//API Call from actual human users
			thisuser, _ := gw.Option.UserHandler.GetUserInfoFromRequest(w, r)
			gw.InterfaceHandler(w, r, thisuser)
		})
	})

	//Register external API request handler endpoint
	http.HandleFunc("/api/ajgi/interface", func(w http.ResponseWriter, r *http.Request) {
		//Check if token exists
		token, err := utils.PostPara(r, "token")
		if err != nil {
			w.WriteHeader(http.StatusUnauthorized)
			w.Write([]byte("401 - Unauthorized (token is empty)"))
			return
		}

		//Validate Token
		if authAgent.TokenValid(token) {
			//Valid
			thisUsername, err := gw.Option.UserHandler.GetAuthAgent().GetTokenOwner(token)
			if err != nil {
				systemWideLogger.PrintAndLog("AGI", "Unable to validate token owner", err)
				w.WriteHeader(http.StatusInternalServerError)
				w.Write([]byte("500 - Internal Server Error"))
				return
			}
			thisuser, _ := gw.Option.UserHandler.GetUserInfoFromUsername(thisUsername)
			gw.APIHandler(w, r, thisuser)
		} else {
			w.WriteHeader(http.StatusUnauthorized)
			w.Write([]byte("401 - Unauthorized (Invalid / expired token)"))
			return
		}

	})

	http.HandleFunc("/api/ajgi/exec", gw.HandleAgiExecutionRequestWithToken)

	// external AGI related function
	externalAGIRouter := prout.NewModuleRouter(prout.RouterOption{
		ModuleName:  "ARZ Serverless",
		AdminOnly:   false,
		UserHandler: userHandler,
		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
			errorHandlePermissionDenied(w, r)
		},
	})
	externalAGIRouter.HandleFunc("/api/ajgi/listExt", gw.ListExternalEndpoint)
	externalAGIRouter.HandleFunc("/api/ajgi/addExt", gw.AddExternalEndPoint)
	externalAGIRouter.HandleFunc("/api/ajgi/rmExt", gw.RemoveExternalEndPoint)
	externalAGIRouter.HandleFunc("/api/ajgi/stats", gw.GetEndpointStats)

	AGIGateway = gw
}