chore: Optimize pages

.gitignore

@@ -37,3 +37,5 @@ config/generated.go
 config/generat*.go
 config/initialization.dsl
 config/system_config.yml
+plugin/enterprise
+/plugin/enterprise/

Makefile

@@ -4,11 +4,12 @@ SHELL=/bin/bash
 APP_NAME := console
 APP_VERSION := 1.0.0_SNAPSHOT
 APP_CONFIG := $(APP_NAME).yml
-APP_EOLDate ?= "2026-12-31T10:10:10Z"
+APP_EOLDate ?= "2027-12-31T10:10:10Z"
 APP_STATIC_FOLDER := .public
 APP_STATIC_PACKAGE := public
 APP_UI_FOLDER := ui
 APP_PLUGIN_FOLDER := plugin
+GOBUILD_FLAGS += -trimpath
 
 # easyjson -all domain.go
 include ../framework/Makefile
@@ -45,6 +46,16 @@ web-lint:
 	@(cd web && npx eslint . --ext .js,.jsx,.ts,.tsx)
 	@echo "Linting complete."
 
+.PHONY: format format-ci
+format: format-ci
+
+format-ci:
+	@echo "formatting code"
+	@find . -type f -name '*.go' \
+		-not -path './vendor/*' \
+		-not -path './.git/*' \
+		-print0 | xargs -0 gofmt -w
+
 # Build the web app
 build-web:
 	@echo "Building the web app..."

common/info.go

@@ -0,0 +1,55 @@
+// Copyright (C) INFINI Labs & INFINI LIMITED.
+//
+// The INFINI Console is offered under the GNU Affero General Public License v3.0
+// and as commercial software.
+//
+// For commercial licensing, contact us at:
+//   - Website: infinilabs.com
+//   - Email: hello@infini.ltd
+//
+// Open Source licensed under AGPL V3:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package common
+
+import "infini.sh/framework/core/util"
+
+var allowedInstanceInfoKeys = []string{
+	"id",
+	"name",
+	"application",
+	"labels",
+	"tags",
+	"description",
+	"status",
+}
+
+func SanitizeInstanceInfoMap(payload util.MapStr) util.MapStr {
+	sanitized := util.MapStr{}
+	for _, key := range allowedInstanceInfoKeys {
+		if value, ok := payload[key]; ok {
+			sanitized[key] = value
+		}
+	}
+	return sanitized
+}
+
+func SanitizeInstanceInfoBytes(body []byte) ([]byte, error) {
+	payload := util.MapStr{}
+	err := util.FromJSONBytes(body, &payload)
+	if err != nil {
+		return nil, err
+	}
+	return util.MustToJSONBytes(SanitizeInstanceInfoMap(payload)), nil
+}

common/info_test.go

@@ -0,0 +1,37 @@
+package common
+
+import (
+	"testing"
+
+	"infini.sh/framework/core/util"
+)
+
+func TestSanitizeInstanceInfoMap(t *testing.T) {
+	payload := util.MapStr{
+		"id":          "node-1",
+		"name":        "console-a",
+		"application": util.MapStr{"name": "console"},
+		"endpoint":    "http://127.0.0.1:2900",
+		"host":        util.MapStr{"name": "host-a"},
+		"network":     util.MapStr{"ip": []string{"10.0.0.1"}},
+		"basic_auth":  util.MapStr{"username": "admin"},
+	}
+
+	sanitized := SanitizeInstanceInfoMap(payload)
+
+	if sanitized["id"] != "node-1" {
+		t.Fatalf("expected id to be preserved, got %v", sanitized["id"])
+	}
+	if _, ok := sanitized["endpoint"]; ok {
+		t.Fatalf("expected endpoint to be removed")
+	}
+	if _, ok := sanitized["host"]; ok {
+		t.Fatalf("expected host to be removed")
+	}
+	if _, ok := sanitized["network"]; ok {
+		t.Fatalf("expected network to be removed")
+	}
+	if _, ok := sanitized["basic_auth"]; ok {
+		t.Fatalf("expected basic_auth to be removed")
+	}
+}

common/log_redaction.go

@@ -0,0 +1,81 @@
+package common
+
+import (
+	"net"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+var (
+	// urlInStringRegex matches http(s)://host:port or http(s)://host embedded in a longer string.
+	urlInStringRegex = regexp.MustCompile(`(https?://)([^/:"\s]+)(:[0-9]+)?`)
+	// dialTCPRegex matches "dial tcp host:port" patterns in Go network error messages.
+	dialTCPRegex = regexp.MustCompile(`(dial tcp )([^:"\s]+)(:[0-9]+)`)
+)
+
+// MaskLogError returns the error message with any embedded host/IP addresses redacted.
+func MaskLogError(err error) string {
+	if err == nil {
+		return "<nil>"
+	}
+	msg := err.Error()
+	msg = urlInStringRegex.ReplaceAllString(msg, "${1}***${3}")
+	msg = dialTCPRegex.ReplaceAllString(msg, "${1}***${3}")
+	return msg
+}
+
+func MaskLogToken(value string) string {
+	if value == "" {
+		return "<empty>"
+	}
+
+	if len(value) <= 4 {
+		return "***"
+	}
+
+	if len(value) <= 8 {
+		return value[:1] + "***" + value[len(value)-1:]
+	}
+
+	return value[:2] + "***" + value[len(value)-2:]
+}
+
+func MaskLogHost(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "<empty>"
+	}
+
+	_, port, err := net.SplitHostPort(value)
+	if err == nil {
+		return "***:" + port
+	}
+
+	return "***"
+}
+
+func MaskLogEndpoint(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "<empty>"
+	}
+
+	parsed, err := url.Parse(value)
+	if err == nil && parsed.Host != "" {
+		host := "***"
+		if port := parsed.Port(); port != "" {
+			host += ":" + port
+		}
+		if parsed.Scheme != "" {
+			return parsed.Scheme + "://" + host
+		}
+		return host
+	}
+
+	if strings.Contains(value, "://") {
+		return "***"
+	}
+
+	return MaskLogHost(value)
+}

common/log_redaction_test.go

@@ -0,0 +1,113 @@
+package common
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMaskLogError(t *testing.T) {
+	testCases := []struct {
+		name   string
+		input  string
+		expect string
+	}{
+		{
+			name:   "nil error",
+			input:  "",
+			expect: "<nil>",
+		},
+		{
+			name:   "url in get error",
+			input:  `request error: Get "http://192.168.3.8:8080/elasticsearch/node/_discovery": dial tcp 192.168.3.8:8080: connect: connection refused`,
+			expect: `request error: Get "http://***:8080/elasticsearch/node/_discovery": dial tcp ***:8080: connect: connection refused`,
+		},
+		{
+			name:   "https url",
+			input:  `Post "https://10.0.0.1:9200/_bulk": connection refused`,
+			expect: `Post "https://***:9200/_bulk": connection refused`,
+		},
+		{
+			name:   "no sensitive data",
+			input:  "index out of range",
+			expect: "index out of range",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.name == "nil error" {
+				if actual := MaskLogError(nil); actual != tc.expect {
+					t.Fatalf("unexpected result, got %q want %q", actual, tc.expect)
+				}
+				return
+			}
+			err := fmt.Errorf("%s", tc.input)
+			if actual := MaskLogError(err); actual != tc.expect {
+				t.Fatalf("unexpected masked error, got %q want %q", actual, tc.expect)
+			}
+		})
+	}
+}
+
+func TestMaskLogToken(t *testing.T) {
+	testCases := []struct {
+		name   string
+		input  string
+		expect string
+	}{
+		{name: "empty", input: "", expect: "<empty>"},
+		{name: "short", input: "abcd", expect: "***"},
+		{name: "medium", input: "abcdefgh", expect: "a***h"},
+		{name: "long", input: "d8de63bhalhmmus1n7k0", expect: "d8***k0"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if actual := MaskLogToken(tc.input); actual != tc.expect {
+				t.Fatalf("unexpected masked token, got %q want %q", actual, tc.expect)
+			}
+		})
+	}
+}
+
+func TestMaskLogHost(t *testing.T) {
+	testCases := []struct {
+		name   string
+		input  string
+		expect string
+	}{
+		{name: "empty", input: "", expect: "<empty>"},
+		{name: "ipv4 hostport", input: "127.0.0.1:9200", expect: "***:9200"},
+		{name: "ipv6 hostport", input: "[::1]:9200", expect: "***:9200"},
+		{name: "plain host", input: "node-1.internal", expect: "***"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if actual := MaskLogHost(tc.input); actual != tc.expect {
+				t.Fatalf("unexpected masked host, got %q want %q", actual, tc.expect)
+			}
+		})
+	}
+}
+
+func TestMaskLogEndpoint(t *testing.T) {
+	testCases := []struct {
+		name   string
+		input  string
+		expect string
+	}{
+		{name: "empty", input: "", expect: "<empty>"},
+		{name: "http endpoint", input: "http://192.168.3.185:8080", expect: "http://***:8080"},
+		{name: "https ipv6 endpoint", input: "https://[2001:db8::1]:9200", expect: "https://***:9200"},
+		{name: "host port", input: "127.0.0.1:9200", expect: "***:9200"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if actual := MaskLogEndpoint(tc.input); actual != tc.expect {
+				t.Fatalf("unexpected masked endpoint, got %q want %q", actual, tc.expect)
+			}
+		})
+	}
+}