Skip to content

Agent Mesh

mobile: carry labels as a map over the FFI, like the config file

Tomas Tormo426991ff2885
diff --git a/api/labels.go b/api/labels.go
index c216a5f6..73349c71 100644
--- a/api/labels.go
+++ b/api/labels.go
@@ -87,32 +87,6 @@ func ValidateLabels(labels map[string]string) error {
return nil
}
-// ParseLabels parses a comma-separated "key=value" list (the wire/CLI form of
-// a label set) into a label map; an empty string means no claims. Parsing is
-// syntax only — run the result through ValidateLabels.
-func ParseLabels(s string) (map[string]string, error) {
- if s == "" {
- return nil, nil
- }
- labels := make(map[string]string)
- for _, part := range strings.Split(s, ",") {
- part = strings.TrimSpace(part)
- if part == "" {
- continue
- }
- k, v, ok := strings.Cut(part, "=")
- if !ok {
- return nil, fmt.Errorf("invalid label %q: expected key=value", part)
- }
- key := strings.TrimSpace(k)
- if _, exists := labels[key]; exists {
- return nil, fmt.Errorf("duplicate label key %q", key)
- }
- labels[key] = strings.TrimSpace(v)
- }
- return labels, nil
-}
-
// A node declares its own labels when it enrols, so on its own a label is a
// claim rather than an attestation. A role's allowed_labels is what makes it
// one: the control plane only signs a label the operator said that role may
diff --git a/api/labels_test.go b/api/labels_test.go
index 9cf0c985..4ad2d80a 100644
--- a/api/labels_test.go
+++ b/api/labels_test.go
@@ -107,22 +107,3 @@ func TestValidateLabels_AllKeysValidStaysSorted(t *testing.T) {
t.Errorf("ValidateLabels(sorted happy path): unexpected error: %v", err)
}
}
-
-func TestParseLabels(t *testing.T) {
- labels, err := ParseLabels("region=eu-west-1, team = platform")
- if err != nil {
- t.Fatalf("ParseLabels failed: %v", err)
- }
- if labels["region"] != "eu-west-1" || labels["team"] != "platform" {
- t.Fatalf("unexpected labels: %v", labels)
- }
- if labels, err := ParseLabels(""); err != nil || labels != nil {
- t.Fatalf("empty string should yield no labels, got %v, %v", labels, err)
- }
- if _, err := ParseLabels("no-equals"); err == nil {
- t.Fatal("expected error for label without =")
- }
- if _, err := ParseLabels("k=a,k=b"); err == nil {
- t.Fatal("expected error for duplicate key")
- }
-}
diff --git a/mobile/sam-node-app/lib/main.dart b/mobile/sam-node-app/lib/main.dart
index 8fb19ba2..5b01d25f 100644
--- a/mobile/sam-node-app/lib/main.dart
+++ b/mobile/sam-node-app/lib/main.dart
@@ -85,7 +85,8 @@ class _NodeControlPageState extends State<NodeControlPage> {
String _refreshToken = '';
final _tokenController = TextEditingController(text: 'secret-token');
// Labels are attested at enrollment; changing them requires re-enrolling.
- // EnrollNode in the FFI writes them to this file; read back at launch.
+ // The field is saved here after a successful enrollment and read back at
+ // launch, like attenuation.json.
static const _labelsFile = 'labels';
final _labelsController = TextEditingController();
@@ -192,6 +193,42 @@ class _NodeControlPageState extends State<NodeControlPage> {
}
}
+ // The field keeps the CLI's old --labels wire format. Only the split lives
+ // here; the FFI validates keys and values with the CLI's rules.
+ Map<String, String> _parseLabels(String text) {
+ final labels = <String, String>{};
+ for (final part in text.split(',')) {
+ final entry = part.trim();
+ if (entry.isEmpty) continue;
+ final eq = entry.indexOf('=');
+ if (eq < 0) {
+ throw FormatException('invalid label "$entry": expected key=value');
+ }
+ labels[entry.substring(0, eq).trim()] = entry.substring(eq + 1).trim();
+ }
+ return labels;
+ }
+
+ // Reports a malformed field through _status and returns null so the
+ // caller can bail out before touching the FFI.
+ Map<String, String>? _labelsOrReport(String text, String failure) {
+ try {
+ return _parseLabels(text);
+ } on FormatException catch (e) {
+ setState(() => _status = '$failure: ${e.message}');
+ return null;
+ }
+ }
+
+ Future<void> _saveLabels(String dataDir, String text) async {
+ try {
+ await Directory(dataDir).create(recursive: true);
+ await File('$dataDir/$_labelsFile').writeAsString(text);
+ } catch (e) {
+ debugPrint('DEBUG: Failed to save labels: $e');
+ }
+ }
+
Future<void> _saveAttenuation(
String dataDir, Map<String, List<String>> attenuation) async {
try {
@@ -646,8 +683,11 @@ class _NodeControlPageState extends State<NodeControlPage> {
final controlPlaneText = _controlPlaneController.text;
final jwtText = _jwtController.text;
final labelsText = _labelsController.text.trim();
- final err = await _isolatedEnroll(
- dataDir, controlPlaneText, jwtText, true, labelsText, _refreshToken);
+ final labels = _labelsOrReport(labelsText, 'Enrollment failed');
+ if (labels == null) return;
+ final err = await _isolatedEnroll(dataDir, controlPlaneText, jwtText, true,
+ jsonEncode(labels), _refreshToken);
+ if (err == null) await _saveLabels(dataDir, labelsText);
setState(() {
if (err != null) {
@@ -662,15 +702,23 @@ class _NodeControlPageState extends State<NodeControlPage> {
// Silent path first: the refresh token saved at enrollment buys a JWT.
// Any failure (none saved, expired, revoked) falls back to the browser.
Future<void> _reEnroll() async {
+ final labelsText = _labelsController.text.trim();
+ final labels = _labelsOrReport(labelsText, 'Re-enroll failed');
+ if (labels == null) {
+ ScaffoldMessenger.of(context)
+ .showSnackBar(SnackBar(content: Text(_status)));
+ return;
+ }
setState(() {
_loggingIn = true;
_status = 'Re-enrolling...';
});
final appDir = await getApplicationDocumentsDirectory();
- final err = await _isolatedReEnroll(
- '${appDir.path}/sam_data', _labelsController.text.trim());
+ final dataDir = '${appDir.path}/sam_data';
+ final err = await _isolatedReEnroll(dataDir, jsonEncode(labels));
if (!mounted) return;
if (err == null) {
+ await _saveLabels(dataDir, labelsText);
setState(() {
_loggingIn = false;
_status = 'Re-enrolled';
@@ -737,6 +785,9 @@ class _NodeControlPageState extends State<NodeControlPage> {
Future<void> _startNode() async {
final appDir = await getApplicationDocumentsDirectory();
final dataDir = '${appDir.path}/sam_data';
+ final labels =
+ _labelsOrReport(_labelsController.text.trim(), 'Start failed');
+ if (labels == null) return;
// The embedded MCP backend must be listening before the node starts:
// services are declared in the start configuration and probed at startup,
@@ -783,7 +834,7 @@ class _NodeControlPageState extends State<NodeControlPage> {
'apiToken': _tokenController.text,
'allowLoopback': true,
'enableRelay': false,
- 'labels': _labelsController.text.trim(),
+ 'labels': labels,
'services': services,
if (attenuation.values.any((l) => l.isNotEmpty)) 'attenuation': attenuation,
});
diff --git a/mobile/sam-node-ffi/ffi/ffi.go b/mobile/sam-node-ffi/ffi/ffi.go
index ea844084..e0082d5a 100644
--- a/mobile/sam-node-ffi/ffi/ffi.go
+++ b/mobile/sam-node-ffi/ffi/ffi.go
@@ -56,11 +56,11 @@ type MobileConfig struct {
LogLevel string `json:"logLevel"`
DiscoveryInterval string `json:"discoveryInterval"`
ListenAddrs string `json:"listenAddrs"` // comma-separated
- // Labels are comma-separated key=value claims, the wire format of the
- // config file's labels map; they are attested only at enrollment.
- Labels string `json:"labels"`
- AllowLoopback bool `json:"allowLoopback"`
- EnableRelay bool `json:"enableRelay"`
+ // Labels mirror the config file's labels map. They are attested only at
+ // enrollment; a start re-announces them and re-enrollment re-sends them.
+ Labels map[string]string `json:"labels"`
+ AllowLoopback bool `json:"allowLoopback"`
+ EnableRelay bool `json:"enableRelay"`
// Services this node exposes, declared at start like the node config
// file's services block; there is no runtime registration.
Services []MobileService `json:"services,omitempty"`
@@ -91,18 +91,6 @@ func StartNode(configJSON string) error {
return fmt.Errorf("failed to parse config JSON: %w", err)
}
- labels, err := api.ParseLabels(config.Labels)
- if err != nil {
- return fmt.Errorf("invalid labels: %w", err)
- }
- // The app locks its labels field once enrolled, so an empty start config
- // reuses the labels the node enrolled with.
- if len(labels) == 0 {
- if labels, err = loadEnrolledLabels(config.DataDir); err != nil {
- return err
- }
- }
-
lvl := golog.LevelInfo
if config.LogLevel != "" {
if l, err := golog.LevelFromString(config.LogLevel); err == nil {
@@ -202,7 +190,7 @@ func StartNode(configJSON string) error {
nodeConfig, err := node.CompleteNodeConfig(api.NodeConfig{
Attenuation: config.Attenuation,
Services: services,
- Labels: labels,
+ Labels: config.Labels,
})
if err != nil {
_ = store.Close()
@@ -335,35 +323,28 @@ func GetNodeID() string {
return ""
}
-// labelsFile keeps the enrolled labels in the app's data directory. The CLI
-// has no equivalent: it re-reads them from its config file on every run.
-const labelsFile = "labels"
-
-func saveEnrolledLabels(dataDir, labels string) error {
- if err := os.WriteFile(filepath.Join(dataDir, labelsFile), []byte(labels), 0600); err != nil {
- return fmt.Errorf("failed to save labels: %w", err)
- }
- return nil
-}
-
-func loadEnrolledLabels(dataDir string) (map[string]string, error) {
- raw, err := os.ReadFile(filepath.Join(dataDir, labelsFile))
- if errors.Is(err, os.ErrNotExist) {
- return nil, nil
+// decodeLabels reads the JSON object the app sends for labels; an empty
+// string means none. Validation is the CLI's, so the errors match.
+func decodeLabels(jsonText string) (map[string]string, error) {
+ var labels map[string]string
+ if jsonText != "" {
+ if err := json.Unmarshal([]byte(jsonText), &labels); err != nil {
+ return nil, fmt.Errorf("invalid labels: %w", err)
+ }
}
- if err != nil {
- return nil, fmt.Errorf("failed to read labels: %w", err)
+ if err := api.ValidateLabels(labels); err != nil {
+ return nil, fmt.Errorf("invalid labels: %w", err)
}
- return api.ParseLabels(string(raw))
+ return labels, nil
}
-// EnrollNode enrolls a node. Labels are comma-separated key=value claims,
-// minted into the node's Biscuit here; changing them means enrolling again,
-// which reuses the stored key so the PeerID survives.
+// EnrollNode enrolls a node. Labels arrive as a JSON object and are minted
+// into the node's Biscuit here; changing them means enrolling again, which
+// reuses the stored key so the PeerID survives.
func EnrollNode(dataDir string, controlPlaneURL string, jwt string, allowLoopback bool, labels string, refreshToken string) error {
- parsedLabels, err := api.ParseLabels(labels)
+ parsedLabels, err := decodeLabels(labels)
if err != nil {
- return fmt.Errorf("invalid labels: %w", err)
+ return err
}
_ = os.MkdirAll(dataDir, 0700)
@@ -425,12 +406,6 @@ func EnrollNode(dataDir string, controlPlaneURL string, jwt string, allowLoopbac
return fmt.Errorf("enrollment failed: %w", err)
}
- // Saved only once the control plane accepted them, so a rejected
- // re-enrollment cannot leave this file ahead of the Biscuit.
- if err := saveEnrolledLabels(dataDir, labels); err != nil {
- return err
- }
-
if err := store.SaveControlPlaneURL(controlPlaneURL); err != nil {
return fmt.Errorf("failed to save control plane URL: %w", err)
}
@@ -573,9 +548,9 @@ func ReEnrollNode(dataDir string, labels string) error {
if activeNode != nil || unauthSrv != nil {
return errors.New("stop the node before re-enrolling")
}
- parsedLabels, err := api.ParseLabels(labels)
+ parsedLabels, err := decodeLabels(labels)
if err != nil {
- return fmt.Errorf("invalid labels: %w", err)
+ return err
}
store, err := node.NewStore(dataDir)
if err != nil {
@@ -596,5 +571,5 @@ func ReEnrollNode(dataDir string, labels string) error {
if err := meshNode.ReEnrollWithRefreshToken(context.Background()); err != nil {
return fmt.Errorf("re-enrollment failed: %w", err)
}
- return saveEnrolledLabels(dataDir, labels)
+ return nil
}
diff --git a/mobile/sam-node-ffi/ffi/ffi_test.go b/mobile/sam-node-ffi/ffi/ffi_test.go
index 28f1048a..52138435 100644
--- a/mobile/sam-node-ffi/ffi/ffi_test.go
+++ b/mobile/sam-node-ffi/ffi/ffi_test.go
@@ -108,16 +108,13 @@ func TestMobileFFILifecycle(t *testing.T) {
// 2. Mobile Enrollment
tmpDir := t.TempDir()
- err = EnrollNode(tmpDir, httpServer.URL, "dummy-jwt", true, "region=eu-west-1", "")
+ err = EnrollNode(tmpDir, httpServer.URL, "dummy-jwt", true, `{"region":"eu-west-1"}`, "")
if err != nil {
t.Fatalf("EnrollNode failed: %v", err)
}
if enrolledLabels["region"] != "eu-west-1" {
t.Fatalf("Expected label region=eu-west-1 in enroll request, got %v", enrolledLabels)
}
- if got, err := loadEnrolledLabels(tmpDir); err != nil || got["region"] != "eu-west-1" {
- t.Fatalf("Expected enrolled labels persisted for StartNode, got %v, %v", got, err)
- }
// 3. Mobile Node Start
cfg := MobileConfig{
@@ -127,7 +124,7 @@ func TestMobileFFILifecycle(t *testing.T) {
BindAddr: "127.0.0.1:0", // random free port
ApiToken: "test-token",
AllowLoopback: true,
- // No labels: StartNode must fall back to the enrolled ones.
+ Labels: map[string]string{"region": "eu-west-1"},
}
cfgBytes, _ := json.Marshal(cfg)
@@ -148,7 +145,7 @@ func TestMobileFFILifecycle(t *testing.T) {
}
func TestStartNodeRejectsInvalidLabels(t *testing.T) {
- if err := StartNode(`{"labels": "no-equals"}`); err == nil {
+ if err := StartNode(`{"labels": {"bad key!": "x"}}`); err == nil {
_ = StopNode()
t.Fatal("expected StartNode to reject invalid labels")
}
@@ -203,22 +200,6 @@ func TestMobileConfigDecodesAttenuation(t *testing.T) {
}
}
-// A rejected enrollment must not record labels the Biscuit does not carry.
-func TestEnrollNodeRejectedLeavesNoLabels(t *testing.T) {
- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- http.Error(w, "role grants no labels", http.StatusForbidden)
- }))
- defer srv.Close()
-
- dir := t.TempDir()
- if err := EnrollNode(dir, srv.URL, "dummy-jwt", true, "region=eu-west-1", ""); err == nil {
- t.Fatal("expected enrollment to fail")
- }
- if got, err := loadEnrolledLabels(dir); err != nil || got != nil {
- t.Fatalf("labels must not be persisted after a rejected enrollment, got %v, %v", got, err)
- }
-}
-
// Re-enrollment buys a JWT with the stored refresh token and re-attests the
// new labels under the same PeerID, with no browser involved.
func TestReEnrollNodeUsesStoredRefreshToken(t *testing.T) {
@@ -274,15 +255,12 @@ func TestReEnrollNodeUsesStoredRefreshToken(t *testing.T) {
}
_ = store.Close()
- if err := ReEnrollNode(dir, "region=us-east-1"); err != nil {
+ if err := ReEnrollNode(dir, `{"region":"us-east-1"}`); err != nil {
t.Fatalf("ReEnrollNode failed: %v", err)
}
if registered.Jwt != "fresh-jwt" || registered.PeerId != want.String() || registered.Labels["region"] != "us-east-1" {
t.Fatalf("unexpected enroll request: jwt=%q peer=%q labels=%v", registered.Jwt, registered.PeerId, registered.Labels)
}
- if got, err := loadEnrolledLabels(dir); err != nil || got["region"] != "us-east-1" {
- t.Fatalf("expected re-enrolled labels persisted, got %v, %v", got, err)
- }
store, err = node.NewStore(dir)
if err != nil {
t.Fatal(err)
@@ -293,7 +271,21 @@ func TestReEnrollNodeUsesStoredRefreshToken(t *testing.T) {
}
// Nothing saved means nothing to re-enroll with; the app opens the browser.
- if err := ReEnrollNode(t.TempDir(), "region=us-east-1"); err == nil {
+ if err := ReEnrollNode(t.TempDir(), `{"region":"us-east-1"}`); err == nil {
t.Fatal("expected re-enrollment without a refresh token to fail")
}
}
+
+func TestDecodeLabels(t *testing.T) {
+ if got, err := decodeLabels(""); err != nil || got != nil {
+ t.Fatalf("empty string should mean no labels, got %v, %v", got, err)
+ }
+ if got, err := decodeLabels(`{"region":"eu-west-1"}`); err != nil || got["region"] != "eu-west-1" {
+ t.Fatalf("unexpected labels %v, %v", got, err)
+ }
+ for _, bad := range []string{`not json`, `{"bad key!":"x"}`} {
+ if _, err := decodeLabels(bad); err == nil {
+ t.Fatalf("expected %q to be rejected", bad)
+ }
+ }
+}