Router that virtually distributes inference across connected devices in the home.
Go
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package main
import (
"bytes"
"encoding/json"
"fmt"
"regexp"
"slices"
"strconv"
"strings"
"unicode/utf8"
)
// Launch bindings are strict even though unrelated manifest fields permit
// additive extensions: a misspelled security control must never be ignored.
func (p *EditableLaunch) UnmarshalJSON(data []byte) error {
type wire EditableLaunch
var decoded wire
decoder := json.NewDecoder(bytes.NewReader(data))
decoder.DisallowUnknownFields()
if err := decoder.Decode(&decoded); err != nil {
return err
}
*p = EditableLaunch(decoded)
return nil
}
func (control LaunchControl) flag() string {
if len(control.Flags) > 0 {
return control.Flags[0]
}
return ""
}
// A value template only binds known policy fields. It is not a shell template
// and never expands user text. Literal separators are regexp-escaped, and every
// captured field passes its policy validator before the value is reconstructed.
type launchBinding struct {
fields []string
literals []string
managed bool
localOnly bool
}
var bindingToken = regexp.MustCompile(`\{([^{}]+)\}`)
var launchFlagName = regexp.MustCompile(`^(?:-[a-zA-Z]|--[a-zA-Z0-9_-]+)$`)
func (control LaunchControl) binding() (launchBinding, error) {
binding := launchBinding{}
if !utf8.ValidString(control.Value) {
return binding, fmt.Errorf("invalid launch value template")
}
matches := bindingToken.FindAllStringSubmatchIndex(control.Value, -1)
if len(matches) == 0 {
return binding, fmt.Errorf("launch control value must bind a policy field")
}
seen, offset := map[string]bool{}, 0
for _, match := range matches {
literal, name := control.Value[offset:match[0]], control.Value[match[2]:match[3]]
field, known := launchFields[name]
if !known || seen[name] {
return binding, fmt.Errorf("unknown or repeated launch policy field %q", name)
}
if strings.ContainsAny(literal, "{}") || len(binding.fields) > 0 && literal == "" {
return binding, fmt.Errorf("launch fields require unambiguous literal separators")
}
managed := field.managed != nil
if len(binding.fields) > 0 && (binding.managed != managed || binding.localOnly != field.localOnly) {
return binding, fmt.Errorf("a launch control cannot mix fields with different ownership")
}
binding.managed, binding.localOnly = managed, field.localOnly
binding.fields = append(binding.fields, name)
binding.literals = append(binding.literals, literal)
seen[name], offset = true, match[1]
}
tail := control.Value[offset:]
if strings.ContainsAny(tail, "{}") {
return binding, fmt.Errorf("invalid launch value template")
}
binding.literals = append(binding.literals, tail)
if control.Implicit != nil {
if len(control.Flags) == 0 || binding.managed {
return binding, fmt.Errorf("implicit values require flags and cannot replace managed server fields")
}
if _, err := (&launchValues{}).acceptBinding(binding, *control.Implicit); err != nil {
return binding, fmt.Errorf("invalid implicit value: %w", err)
}
}
return binding, nil
}
func (control LaunchControl) localOnly() bool {
binding, err := control.binding()
return err == nil && binding.localOnly
}
func (p *EditableLaunch) environmentControl(name string) *LaunchControl {
for i := range p.Controls {
for _, alias := range p.Controls[i].Env {
if environmentKey(alias) == environmentKey(name) {
return &p.Controls[i]
}
}
}
return nil
}
func (p *EditableLaunch) validateControls() error {
flags, env, fields := map[string]bool{}, map[string]bool{}, map[string]bool{}
for _, control := range p.Controls {
binding, err := control.binding()
if err != nil {
return err
}
for _, name := range binding.fields {
fields[name] = true
}
if len(control.Flags)+len(control.Env) == 0 {
return fmt.Errorf("launch controls require a flag or environment source")
}
for _, name := range control.Flags {
if !launchFlagName.MatchString(name) || flags[name] {
return fmt.Errorf("invalid or duplicate networking option %q", name)
}
flags[name] = true
}
for _, name := range control.Env {
key := environmentKey(name)
if !validEnvironmentKey(name) || env[key] {
return fmt.Errorf("invalid or duplicate networking environment name")
}
env[key] = true
}
}
for name, field := range launchFields {
if field.managed != nil && !fields[name] {
return fmt.Errorf("editable launch controls must bind managed field %s", name)
}
}
return nil
}
// Match exact long/short names, equals values and attached short values. A short
// bundle containing a protected option is ambiguous without knowing all other
// vendor options' arities; reject it instead of guessing or letting it bypass us.
func (p *EditableLaunch) readControl(tokens []string, index int) (*LaunchControl, string, int, error) {
token := tokens[index]
for ci := range p.Controls {
control := &p.Controls[ci]
for _, name := range control.Flags {
value, attached := "", false
switch {
case token == name:
case strings.HasPrefix(token, name+"="):
value, attached = token[len(name)+1:], true
case len(name) == 2 && strings.HasPrefix(token, name) && len(token) > 2:
value, attached = token[2:], true
default:
continue
}
if control.Implicit != nil {
if attached {
return control, "", index, fmt.Errorf("this option does not take a value")
}
return control, *control.Implicit, index, nil
}
if !attached {
index++
if index >= len(tokens) {
return control, "", index, fmt.Errorf("a networking option is missing its value")
}
value = tokens[index]
}
return control, value, index, nil
}
}
if strings.HasPrefix(token, "-") && !strings.HasPrefix(token, "--") && len(token) > 2 {
for _, control := range p.Controls {
for _, name := range control.Flags {
if len(name) == 2 && strings.Contains(token[2:], name[1:]) {
return nil, "", index, fmt.Errorf("write managed short networking options separately, not in a short-option bundle")
}
}
}
}
return nil, "", index, nil
}
// All inputs use the same field-level normalization and conflict detection,
// whether they arrive as a flag, environment alias, or part of a combined value.
type launchValues struct {
host string
fields map[string]string
}
func (values *launchValues) accept(control *LaunchControl, value string) (string, error) {
binding, err := control.binding()
if err != nil {
return "", err
}
return values.acceptBinding(binding, value)
}
func (values *launchValues) acceptBinding(binding launchBinding, value string) (string, error) {
// Field grammars disambiguate formats such as port:IPv6-host; unconstrained
// greedy captures could split on a colon inside the host instead.
pattern := "(?s)^"
for i, name := range binding.fields {
pattern += regexp.QuoteMeta(binding.literals[i]) + "(" + launchFields[name].match(values.host) + ")"
}
compiled, err := regexp.Compile(pattern + regexp.QuoteMeta(binding.literals[len(binding.fields)]) + "$")
if err != nil {
return "", fmt.Errorf("invalid launch value template")
}
parts := compiled.FindStringSubmatch(value)
if parts == nil {
return "", fmt.Errorf("value does not match its declared launch format")
}
if values.fields == nil {
values.fields = map[string]string{}
}
output := ""
for i, name := range binding.fields {
field := launchFields[name]
normalized, err := field.normalize(parts[i+1], values.host)
if err != nil {
return "", err
}
key := normalized
if field.canonical != nil {
key = field.canonical(key)
}
if previous, exists := values.fields[name]; exists && previous != key {
return "", fmt.Errorf("conflicting values for %s", name)
}
values.fields[name] = key
output += binding.literals[i] + normalized
}
return output + binding.literals[len(binding.fields)], nil
}
func (control LaunchControl) managedValue(host, port string) (string, bool) {
binding, err := control.binding()
if err != nil || !binding.managed {
return "", false
}
output := ""
for i, name := range binding.fields {
output += binding.literals[i] + launchFields[name].managed(host, port)
}
return output + binding.literals[len(binding.fields)], true
}
func (values *launchValues) serverPort() int {
port, _ := strconv.Atoi(values.fields["server.port"])
return port
}
func (values *launchValues) localPolicy() []string {
out := []string{}
for name, value := range values.fields {
// Preserve presence, including false/empty: omission may restore an unsafe
// inherited or vendor default value.
if launchFields[name].localOnly {
out = append(out, name+"="+value)
}
}
slices.Sort(out)
return out
}
// Recheck the actual launch, including overrides saved by older PAIR versions.
// Display/preview resolution stays read-only and can still show those settings
// for repair; unsafe persisted aliases must never escape via a later Start.
func validateEffectiveLaunch(rt Runtime, command launchCommand, host, port string) error {
p := rt.EditableLaunch
if p == nil {
return nil
}
values := launchValues{host: host}
for name, value := range command.Env {
if control := p.environmentControl(name); control != nil {
if _, err := values.accept(control, value); err != nil {
return err
}
}
}
if len(command.Args) < len(p.FixedArgs) || !slices.Equal(command.Args[:len(p.FixedArgs)], p.FixedArgs) {
return fmt.Errorf("launch does not match its fixed startup arguments")
}
args := command.Args[len(p.FixedArgs):]
for i := 0; i < len(args); i++ {
control, value, last, err := p.readControl(args, i)
if err != nil {
return err
}
i = last
if control != nil {
if _, err := values.accept(control, value); err != nil {
return err
}
}
}
if values.serverPort() != 0 && strconv.Itoa(values.serverPort()) != port {
return fmt.Errorf("saved launch port does not match the managed server port")
}
return nil
}