feat: add phone frequency controls and modularize codebase

2026-07-31 22:25:23 +08:00
parent 0af671b4ed
commit ca4f591a13
216 changed files with 41579 additions and 23694 deletions
@@ -0,0 +1,202 @@
+package main
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type declaration struct {
+	Name   string `json:"name"`
+	Kind   string `json:"kind"`
+	File   string `json:"file"`
+	SHA256 string `json:"sha256"`
+}
+
+type manifest struct {
+	Version      string        `json:"version"`
+	Source       string        `json:"source"`
+	Declarations []declaration `json:"declarations"`
+}
+
+var requiredFiles = []string{
+	"server.go",
+	"authentication.go",
+	"submit.go",
+	"sessions.go",
+	"delivery.go",
+	"acknowledgement.go",
+	"pending_recovery.go",
+	"protocol_log.go",
+	"transport.go",
+}
+
+var requiredTests = []string{
+	"TestInboundServerAuthenticatesAndSubmits",
+	"TestInboundServerForwardsLongMessageFragmentsWithoutUDHAndAcknowledgesEachSubmit",
+	"TestSubmitResponsePrecedesQueuedFailureReceipt",
+	"TestDailyLimitRejectsSubmitSynchronouslyWithoutPendingReceipt",
+	"TestInboundServerNegotiatesCMPP2AndUsesAuthenticatedAccountForSubmit",
+	"TestNormalizeInboundSubmitSupportsCMPP2AndCMPP3",
+	"TestDownstreamDeliveryRequiresAcknowledgement",
+	"TestReceiptLookupDoesNotFallbackToAccountBeforeSubmitMappingExists",
+	"TestDownstreamDeliveryReportsAckTimeout",
+	"TestRecoverPendingCandidatesWritesWaitingConnectionStatus",
+	"TestSubmitResponseProtocolLoggerEmitsActualPacketDirection",
+	"TestDownstreamDeliverProtocolLoggerEmitsReceiptPacket",
+}
+
+func main() {
+	root, err := os.Getwd()
+	must(err)
+	manifestPath := filepath.Join(root, "docs", "contracts", "inbound-r6-declarations.json")
+	payload, err := os.ReadFile(manifestPath)
+	must(err)
+	var contract manifest
+	must(json.Unmarshal(payload, &contract))
+	if contract.Version != "R6" {
+		fail("unexpected contract version %q", contract.Version)
+	}
+
+	inboundDir := filepath.Join(root, "gateway", "internal", "inbound")
+	actual := map[string]declaration{}
+	for _, name := range requiredFiles {
+		path := filepath.Join(inboundDir, name)
+		source, err := os.ReadFile(path)
+		must(err)
+		if !bytes.HasPrefix(source, []byte("package inbound")) {
+			fail("%s must remain in package inbound", name)
+		}
+		for _, item := range declarationsInFile(path, source) {
+			key := item.Kind + ":" + item.Name
+			if previous, exists := actual[key]; exists {
+				fail("duplicate declaration %s in %s and %s", key, previous.File, item.File)
+			}
+			actual[key] = item
+		}
+	}
+
+	for _, expected := range contract.Declarations {
+		key := expected.Kind + ":" + expected.Name
+		item, ok := actual[key]
+		if !ok {
+			fail("missing declaration %s expected in %s", key, expected.File)
+		}
+		if item.File != expected.File {
+			fail("%s moved to %s, expected %s", key, item.File, expected.File)
+		}
+		if item.SHA256 != expected.SHA256 {
+			fail("%s implementation changed: %s != %s", key, item.SHA256, expected.SHA256)
+		}
+	}
+
+	serverSource, err := os.ReadFile(filepath.Join(inboundDir, "server.go"))
+	must(err)
+	if lines := bytes.Count(serverSource, []byte{'\n'}); lines > 100 {
+		fail("stable server.go grew to %d lines", lines)
+	}
+	assertContains(serverSource, "func (s Server) ListenAndServe() error")
+	assertContains(serverSource, "s.handleLogin")
+	assertContains(serverSource, "s.handleSubmit")
+	assertContains(serverSource, "s.handleActivity")
+	assertContains(serverSource, "s.handleConnectionClosed")
+
+	controlSource, err := os.ReadFile(filepath.Join(root, "gateway", "internal", "control", "server.go"))
+	must(err)
+	for _, entry := range []string{
+		"inbound.DisconnectAccount(",
+		"inbound.PushReceiptWithResult(",
+		"inbound.PushUplinkWithResult(",
+	} {
+		assertContains(controlSource, entry)
+	}
+
+	var tests bytes.Buffer
+	for _, name := range []string{"server_test.go", "protocol_log_test.go", "presence_test.go", "recovery_test.go"} {
+		source, err := os.ReadFile(filepath.Join(inboundDir, name))
+		must(err)
+		tests.Write(source)
+	}
+	for _, test := range requiredTests {
+		assertContains(tests.Bytes(), "func "+test+"(")
+	}
+
+	fmt.Printf(
+		"R6 inbound facade verified: %d declarations across %d focused files; stable entries and %d critical tests preserved.\n",
+		len(contract.Declarations), len(requiredFiles), len(requiredTests),
+	)
+}
+
+func declarationsInFile(path string, source []byte) []declaration {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, path, source, parser.ParseComments)
+	must(err)
+	var result []declaration
+	for _, decl := range file.Decls {
+		if gen, ok := decl.(*ast.GenDecl); ok && gen.Tok == token.IMPORT {
+			continue
+		}
+		name, kind := declarationName(decl)
+		start := decl.Pos()
+		switch typed := decl.(type) {
+		case *ast.FuncDecl:
+			if typed.Doc != nil {
+				start = typed.Doc.Pos()
+			}
+		case *ast.GenDecl:
+			if typed.Doc != nil {
+				start = typed.Doc.Pos()
+			}
+		}
+		code := strings.TrimSpace(string(source[fset.Position(start).Offset:fset.Position(decl.End()).Offset]))
+		hash := sha256.Sum256([]byte(strings.ReplaceAll(code, "\r\n", "\n")))
+		result = append(result, declaration{
+			Name: name, Kind: kind, File: filepath.Base(path), SHA256: hex.EncodeToString(hash[:]),
+		})
+	}
+	return result
+}
+
+func declarationName(decl ast.Decl) (string, string) {
+	switch typed := decl.(type) {
+	case *ast.FuncDecl:
+		return typed.Name.Name, "func"
+	case *ast.GenDecl:
+		if len(typed.Specs) == 0 {
+			fail("empty declaration")
+		}
+		switch spec := typed.Specs[0].(type) {
+		case *ast.TypeSpec:
+			return spec.Name.Name, "type"
+		case *ast.ValueSpec:
+			return spec.Names[0].Name, strings.ToLower(typed.Tok.String())
+		}
+	}
+	fail("unsupported declaration %T", decl)
+	return "", ""
+}
+
+func assertContains(source []byte, fragment string) {
+	if !bytes.Contains(source, []byte(fragment)) {
+		fail("required invariant not found: %s", fragment)
+	}
+}
+
+func must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func fail(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, "R6 verification failed: "+format+"\n", args...)
+	os.Exit(1)
+}