Skip to content

Router that virtually distributes inference across connected devices in the home.

Go
14.8 KB
Raw Blame
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"reflect"
	"slices"
	"strings"
	"testing"

	settings "nvpair-shared/enginesettings"
)

func TestGenericControlSourcesAndLaunchConstruction(t *testing.T) {
	for _, definition := range []string{
		`[{"value":"{server.port}","env":["SERVER_PORT","PORT_ALIAS"]},{"value":"{server.host}","env":["SERVER_HOST","HOST_ALIAS"]},{"value":"{cors.enabled}","flags":["--browser-access","-c"],"env":["BROWSER_ACCESS","CORS_ALIAS"]}]`,
		`[{"value":"{server.host}:{server.port}","flags":["--listen","-l"],"env":["LISTEN","LISTEN_ALIAS"]},{"value":"{cors.origins}","flags":["--origins","-o"],"env":["ORIGINS","ORIGIN_ALIAS"]}]`,
	} {
		t.Run(definition, func(t *testing.T) {
			e := settingsExecutor(t, true)
			rt := &settingsState(t, e).plat.Runtime
			if err := json.Unmarshal([]byte(definition), &rt.EditableLaunch.Controls); err != nil {
				t.Fatal(err)
			}
			if err := rt.EditableLaunch.validateControls(); err != nil {
				t.Fatal(err)
			}
			request := settingsRequest(t, e)
			request.Resolution = "launch"
			if rt.EditableLaunch.Controls[0].Value == "{server.port}" {
				request.Settings.LaunchText = "PORT_ALIAS=23456 HOST_ALIAS=127.0.0.1 CORS_ALIAS=false --future opaque"
			} else {
				request.Settings.LaunchText = "LISTEN_ALIAS=127.0.0.1:23456 ORIGIN_ALIAS=https://example.test -l127.0.0.1:23456 --future opaque"
			}
			preview := previewSettings(t, e, request)
			if len(preview.Errors) > 0 || preview.Conflict != nil {
				t.Fatalf("%+v", preview)
			}
			rt.LaunchArgs, rt.LaunchEnv = &preview.Args, &preview.Env
			launch, err := launchForState(settingsState(t, e), preview.Settings.ServerPort)
			if err != nil {
				t.Fatal(err)
			}
			if err := validateEffectiveLaunch(*rt, launch, "127.0.0.1", "23456"); err != nil {
				t.Fatal(err)
			}
			for _, control := range rt.EditableLaunch.Controls {
				if value, managed := control.managedValue("127.0.0.1", "23456"); managed {
					for _, env := range control.Env {
						if launch.Env[env] != value {
							t.Fatalf("managed alias %s=%q, want %q", env, launch.Env[env], value)
						}
					}
				}
			}
			if !slices.Equal(launch.Args[len(launch.Args)-2:], []string{"--future", "opaque"}) {
				t.Fatal("opaque arguments changed")
			}
			request.Settings.LaunchText = "BROWSER_ACCESS=true CORS_ALIAS=false"
			if rt.EditableLaunch.Controls[0].Value == "{server.host}:{server.port}" {
				request.Settings.LaunchText = "LISTEN=127.0.0.1:23456 LISTEN_ALIAS=0.0.0.0:23456"
			}
			if result := previewSettings(t, e, request); len(result.Errors) == 0 {
				t.Fatal("contradictory source aliases accepted")
			}
		})
	}
}

func TestSavedControlsCannotBypassLaunchValidation(t *testing.T) {
	for _, command := range []bool{false, true} {
		e := settingsExecutor(t, command)
		rt := settingsState(t, e).plat.Runtime
		request := settingsRequest(t, e)
		launch, err := launchForState(settingsState(t, e), request.Settings.ServerPort)
		if err != nil {
			t.Fatal(err)
		}
		if command {
			launch.Args = append(launch.Args, "-p0")
		} else {
			launch.Env["OLLAMA_ORIGINS"] = `"*"`
		}
		if err := validateEffectiveLaunch(rt, launch, "127.0.0.1", fmt.Sprint(request.Settings.ServerPort)); err == nil {
			t.Fatal("unsafe saved launch accepted")
		}
		if command {
			args := []string{"-p0"}
			rt.LaunchArgs = &args
		} else {
			env := []string{`OLLAMA_ORIGINS="*"`}
			rt.LaunchEnv = &env
		}
		settingsState(t, e).plat.Runtime = rt
		if state, err := e.LaunchSettings("fake"); err != nil || !state.Editable {
			t.Fatalf("saved settings must remain available for repair: %+v %v", state, err)
		}
		err = e.Start(context.Background(), "fake")
		if err == nil || !(strings.Contains(err.Error(), "server port") || strings.Contains(err.Error(), "CORS origins")) {
			t.Fatalf("Start did not reject the unsafe saved networking control: %v", err)
		}
	}
}

func TestBundledLlamaCPPDisablesCORSByDefault(t *testing.T) {
	reg := loadWithOverrides(t, t.TempDir())
	manifest, ok := reg.Get("llamacpp")
	if !ok {
		t.Fatal("llama.cpp manifest not loaded")
	}
	for platform, config := range manifest.Platforms {
		t.Run(platform, func(t *testing.T) {
			e := settingsExecutor(t, false)
			graftPlatform(t, e, config)
			state, err := e.LaunchSettings("fake")
			if err != nil {
				t.Fatal(err)
			}
			got, err := launchCORSAssignments(state.LaunchText, config.Runtime.EditableLaunch)
			if err != nil {
				t.Fatal(err)
			}
			if want := []string{"cors.origins="}; !slices.Equal(got, want) {
				t.Fatalf("default CORS policy = %v, want %v", got, want)
			}
		})
	}
}

func TestBundledNetworkingControls(t *testing.T) {
	reg := loadWithOverrides(t, t.TempDir())
	// Adding a bundled engine requires an explicit networking review and cases.
	wantEngines := []string{"llamacpp", "lmstudio", "ollama"}
	names := reg.Names()
	slices.Sort(names)
	if !slices.Equal(names, wantEngines) {
		t.Fatalf("review networking controls for every bundled engine: %v", names)
	}
	for _, name := range names {
		manifest, _ := reg.Get(name)
		for platform, config := range manifest.Platforms {
			t.Run(name+"/"+platform, func(t *testing.T) {
				e := settingsExecutor(t, config.Runtime.modeOrDefault() == "command")
				graftPlatform(t, e, config)
				policy := config.Runtime.EditableLaunch
				if policy == nil {
					t.Fatal("missing reviewed networking controls")
				}
				var valid, invalid []string
				switch name {
				case "lmstudio":
					if !reflect.DeepEqual(policy.Controls, []LaunchControl{{Value: "{server.port}", Flags: []string{"--port", "-p"}}, {Value: "{server.host}", Flags: []string{"--bind"}, Env: []string{"LMS_SERVER_HOST"}}, {Value: "{cors.enabled}", Implicit: implicitLaunchValue("true"), Flags: []string{"--cors"}}}) {
						t.Fatal("incomplete LM Studio controls")
					}
					valid = []string{"--port 23456", "--port=23456", "-p 23456", "-p23456", "-p=23456", `"-p" "23456"`, "--port 23456 -p23456", "-- -p23456"}
					invalid = []string{"-p0", "-p65536", "-p", "-pno", "--port 23456 -p23457", "-vp23456", "-vp=23456", "--bind 0.0.0.0", "--bind=::", "LMS_SERVER_HOST=0.0.0.0", "--cors=false", "--cors=true", "--cors=", "-- --bind 0.0.0.0"}
				case "llamacpp":
					if !slices.Equal(policy.FixedArgs, []string{"--sleep-idle-seconds", "300"}) {
						t.Fatal("llama.cpp idle sleep policy is not fixed")
					}
					if !reflect.DeepEqual(policy.Controls, []LaunchControl{{Value: "{server.host}", Flags: []string{"--host"}}, {Value: "{server.port}", Flags: []string{"--port"}}, {Value: "{cors.origins}", Flags: []string{"--cors-origins"}}}) {
						t.Fatal("incomplete llama.cpp controls")
					}
					valid = []string{"--host 127.0.0.1 --port 23456", "--host=127.0.0.1 --port=23456", "--port 23456 --cors-origins https://example.test"}
					invalid = []string{"--host 0.0.0.0", "--host=::", "--port 0", "--port 65536", "--port", "--cors-origins=*", "--port 23456 --port 23457", "-- --host 0.0.0.0"}
				default:
					if !reflect.DeepEqual(policy.Controls, []LaunchControl{{Value: "{server.host}:{server.port}", Env: []string{"OLLAMA_HOST"}}, {Value: "{cors.origins}", Env: []string{"OLLAMA_ORIGINS"}}}) {
						t.Fatal("incomplete Ollama controls")
					}
					valid = []string{`OLLAMA_HOST="127.0.0.1:23456"`, `OLLAMA_HOST='127.0.0.1:23456'`, "OLLAMA_HOST=127.0.0.1:23456"}
					invalid = []string{"OLLAMA_HOST=0.0.0.0:23456", "OLLAMA_HOST=127.0.0.1:0", "OLLAMA_HOST=127.0.0.1:65536", `OLLAMA_ORIGINS='"*"'`, `OLLAMA_ORIGINS="'*'"`, `OLLAMA_ORIGINS='"http://*"'`, "OLLAMA_ORIGINS=http://localhost,*", "OLLAMA_HOST=127.0.0.1:23456 OLLAMA_HOST=0.0.0.0:23456"}
				}
				for _, text := range valid {
					p := settingsRequest(t, e)
					p.Settings.LaunchText, p.Resolution = text, "launch"
					preview := previewSettings(t, e, p)
					if len(preview.Errors) != 0 || preview.Conflict != nil || preview.Settings.ServerPort != 23456 {
						t.Fatalf("%q: %+v", text, preview)
					}
					p.Settings = preview.Settings
					again := previewSettings(t, e, p)
					if !reflect.DeepEqual(preview, again) {
						t.Fatalf("normalization not stable for %q", text)
					}
					if slices.Contains(preview.Args, "-p") || slices.Contains(preview.Args, "-p23456") {
						t.Fatal("managed alias escaped into user args")
					}
				}
				for _, text := range invalid {
					p := settingsRequest(t, e)
					p.Settings.LaunchText = text
					if result := previewSettings(t, e, p); len(result.Errors) == 0 {
						t.Fatalf("accepted %q: %+v", text, result)
					}
				}
				assertNoSettingsOverride(t, e)
			})
		}
	}
}

func TestNetworkingControlAliasesAreEngineIndependent(t *testing.T) {
	e := settingsExecutor(t, true)
	p := settingsState(t, e).plat.Runtime.EditableLaunch
	p.Controls = []LaunchControl{
		{Value: "{server.port}", Flags: []string{"--listener-port", "--http-port", "-x"}},
		{Value: "{server.host}", Flags: []string{"--listener-address", "--address", "-b"}},
		{Value: "{cors.origins}", Flags: []string{"--origins", "--browser-origins", "-o"}},
		{Value: "{cors.enabled}", Implicit: implicitLaunchValue("true"), Flags: []string{"--browser-access", "--allow-browser", "-c"}},
	}

	for _, text := range []string{"--http-port=23456 -b127.0.0.1 -ohttps://example.test", "-x23456 --address=127.0.0.1 --browser-origins=https://example.test"} {
		request := settingsRequest(t, e)
		request.Settings.LaunchText = text
		request.Resolution = "launch"
		result := previewSettings(t, e, request)
		if len(result.Errors) != 0 || result.Settings.ServerPort != 23456 || !slices.Equal(result.Args, []string{"--origins", "https://example.test"}) {
			t.Fatalf("%q: %+v", text, result)
		}
	}
	for _, text := range []string{"--address=0.0.0.0", "-b0.0.0.0", "--browser-origins=*", "-o*", "-vc", "-vohttps://example.test", "-ohttps://one.test --origins=https://two.test"} {
		request := settingsRequest(t, e)
		request.Settings.LaunchText = text
		if result := previewSettings(t, e, request); len(result.Errors) == 0 {
			t.Fatalf("accepted %q", text)
		}
	}
}

func TestCORSCanonicalization(t *testing.T) {
	for _, text := range []string{`"*"`, `'*'`, `" * "`, `"http://*"`, "http://*:80", "*://*", "https://example.test,*", "https://foo*", "https://*.*", "https://example.test/path", "https://[email protected]", "https://example.test?query", "https://example.test#fragment", "https://example.test:65536", `https://example.test\anything`} {
		if _, err := normalizeCORSOrigins(text); err == nil {
			t.Errorf("accepted %q", text)
		}
	}
	for _, value := range []struct{ input, want string }{
		{`"https://Example.Test"`, "https://example.test"},
		{" https://example.test/ , http://localhost:* ", "https://example.test,http://localhost:*"},
		{"https://*.example.test", "https://*.example.test"},
		{"http://[::1]:1234", "http://[::1]:1234"},
		{"", ""},
	} {
		got, err := normalizeCORSOrigins(value.input)
		if err != nil || got != value.want {
			t.Errorf("%q: %q %v", value.input, got, err)
		}
	}
}

func TestRemoteCORSUsesCanonicalPolicyAndAuthoritativePreview(t *testing.T) {
	for _, command := range []bool{false, true} {
		t.Run(fmt.Sprint(command), func(t *testing.T) {
			e := settingsExecutor(t, command)
			request := settingsRequest(t, e)
			changed := "OLLAMA_ORIGINS=https://example.test"
			if command {
				changed = "--cors"
			}
			request.Settings.LaunchText = changed
			request.PreserveCORS = true
			if _, err := e.PreviewLaunch(request); err == nil {
				t.Fatal("authoritative preview allowed a remote CORS change")
			}
			request.PreserveCORS = false
			if _, err := e.ConfigureLaunch(context.Background(), settings.Configure{Engine: "fake", Settings: request.Settings}, func() error { return nil }); err != nil {
				t.Fatal(err)
			}
			request = settingsRequest(t, e)
			if command {
				request.Settings.LaunchText = "--cors --cors"
			} else {
				request.Settings.LaunchText = `OLLAMA_ORIGINS='"https://EXAMPLE.test/"'`
			}
			request.PreserveCORS = true
			if _, err := e.PreviewLaunch(request); err != nil {
				t.Fatalf("equivalent policy rejected: %v", err)
			}
			request.Settings.LaunchText = ""
			if _, err := e.PreviewLaunch(request); err == nil {
				t.Fatal("remote removal changed policy")
			}
		})
	}
}

// Removing a disabling override may restore permissive inherited/default values.
func TestRemoteCORSCannotRemoveExplicitDisablingValues(t *testing.T) {
	for _, kind := range []string{"cors.enabled", "cors.origins"} {
		t.Run(kind, func(t *testing.T) {
			e := settingsExecutor(t, true)
			policy := settingsState(t, e).plat.Runtime.EditableLaunch
			policy.Controls = append(policy.Controls, LaunchControl{Value: "{" + kind + "}", Env: []string{"BROWSER_POLICY"}})
			request := settingsRequest(t, e)
			request.Settings.LaunchText = "BROWSER_POLICY=false"
			if kind == "cors.origins" {
				request.Settings.LaunchText = "BROWSER_POLICY="
			}
			if _, err := e.ConfigureLaunch(context.Background(), settings.Configure{Engine: "fake", Settings: request.Settings}, func() error { return nil }); err != nil {
				t.Fatal(err)
			}
			request = settingsRequest(t, e)
			request.PreserveCORS = true
			if _, err := e.PreviewLaunch(request); err != nil {
				t.Fatalf("unchanged policy rejected: %v", err)
			}
			request.Settings.LaunchText = ""
			if _, err := e.PreviewLaunch(request); err == nil {
				t.Fatal("remote removal of disabling override accepted")
			}
		})
	}
}

func TestNetworkingManifestRejectsAmbiguousDeclarations(t *testing.T) {
	for _, controls := range [][]LaunchControl{
		{{Value: "{server.port}"}},
		{{Value: "{server.port}", Flags: []string{"--port"}}, {Value: "{server.host}", Flags: []string{"--port"}}},
		{{Value: "{server.port}", Flags: []string{"--port", "--port"}}},
		{{Value: "{server.port}", Flags: []string{"--port", "-p"}}, {Value: "{cors.enabled}", Implicit: implicitLaunchValue("true"), Flags: []string{"-p"}}},
		{{Value: "{server.port}", Env: []string{"PORT"}}, {Value: "{server.host}", Env: []string{"PORT"}}},
		{{Value: "{cors.enabled}", Implicit: implicitLaunchValue("true"), Flags: []string{"--cors=true"}}},
		{{Value: "{unknown}", Flags: []string{"--x"}}},
		{{Value: "{cors.enabled}", Implicit: implicitLaunchValue("true"), Env: []string{"CORS"}}},
		{{Value: "{server.port}", Flags: []string{"--port"}}},
	} {
		policy := EditableLaunch{Controls: controls}
		if err := policy.validateControls(); err == nil {
			t.Errorf("accepted %+v", policy)
		}
	}

}

func FuzzCORSNormalization(f *testing.F) {
	for _, seed := range []string{`"*"`, "https://*.example.test", "http://localhost:*", "https://example.test"} {
		f.Add(seed)
	}
	f.Fuzz(func(t *testing.T, value string) {
		got, err := normalizeCORSOrigins(value)
		if err != nil {
			return
		}
		again, err := normalizeCORSOrigins(got)
		if err != nil || again != got {
			t.Fatalf("unstable normalization: %q -> %q -> %q", value, got, again)
		}
		if strings.ContainsAny(got, "\"'") {
			t.Fatal("literal quote survives CORS validation")
		}
	})
}

func implicitLaunchValue(value string) *string { return &value }