feat(auth)!: configured tokens ride SETUP and AUTH

dart/moq/lib/src/aliases.dart

@@ -16,6 +16,9 @@ import 'package:moq_ffi/moq_ffi.dart';
 /// A MoQ client: configure the TLS/bind knobs, then connect to a relay.
 typedef Client = MoqClient;
 
+/// The credentials a [Client] presents, replaceable while it runs.
+typedef Tokens = MoqTokens;
+
 /// A live pub/sub session with a relay, exposing publish and consume origins.
 typedef Session = MoqSession;
 

dart/moq/lib/src/client.dart

@@ -25,7 +25,7 @@ final class AnnounceOptions {
 /// the FFI's [MoqClientConfig].
 ///
 /// Every field is optional; a null keeps the native default. A value the native
-/// side cannot use fails [Moq.connect] with `MoqException.Config`.
+/// side cannot use fails [Moq.connect] with `ConfigMoqException`.
 final class ConnectOptions {
   /// Local socket address to bind, e.g. `0.0.0.0:0`.
   final String? bind;
@@ -34,6 +34,13 @@ final class ConnectOptions {
   /// Null offers every supported version, which [versions] lists.
   final List<String>? versions;
 
+  /// Credentials every dial presents. The first is the connection credential,
+  /// sent in SETUP and, while an offered version can't carry it there, the
+  /// URL's `?jwt=`; each other one widens the session's grant over in-band
+  /// AUTH. A URL that already carries `?jwt=` keeps it, and then every token
+  /// rides AUTH. Replace them before they expire through [Moq.tokens].
+  final List<String>? tokens;
+
   /// How long one connect may take, dial and handshake together; zero waits forever.
   final Duration? timeout;
 
@@ -69,6 +76,7 @@ final class ConnectOptions {
   const ConnectOptions({
     this.bind,
     this.versions,
+    this.tokens,
     this.timeout,
     this.race,
     this.resolutionDelay,
@@ -84,6 +92,7 @@ final class ConnectOptions {
   MoqClientConfig get _ffi => MoqClientConfig(
     bind: bind,
     versions: versions ?? const [],
+    tokens: tokens ?? const [],
     timeout: timeout,
     race: race,
     resolutionDelay: resolutionDelay,
@@ -242,6 +251,17 @@ final class Moq {
   /// on every reconnect.
   Auth auth() => session.auth();
 
+  /// The credentials every dial presents ([ConnectOptions.tokens]), to
+  /// replace while running.
+  ///
+  /// [Tokens.set_] replaces them, such as before the current ones expire: the
+  /// next dial presents them, and a live session with in-band AUTH presents
+  /// them at once, withdrawing each replaced token once its replacements are
+  /// answered, even when one is refused. After an authorization refusal the
+  /// client redials only if they changed. An empty token throws
+  /// `ConfigMoqException`.
+  Tokens tokens() => _client.tokens();
+
   /// Drain within one second, then stop the client.
   ///
   /// Explicit `moq-lite-07-wip` waits for the peer to receive finished tails; older

dart/moq/lib/src/server.dart

@@ -7,7 +7,7 @@ import 'version.dart';
 /// Everything [Server.listen] can be told.
 ///
 /// A value the native side cannot use fails [Server.listen] with
-/// `MoqException.Config`.
+/// `ConfigMoqException`.
 final class ListenOptions {
   /// Local socket address to listen on, e.g. `127.0.0.1:4443` or `[::]:443`.
   final String bind;

dart/moq_ffi/lib/src/moq.dart

@@ -8,9 +8,7 @@ import "dart:ffi";
 import "dart:io" show Platform, File, Directory;
 import "dart:isolate";
 import "dart:typed_data";
-
 import "package:ffi/ffi.dart";
-
 import "uniffi_runtime.dart";
 export "uniffi_runtime.dart";
 
@@ -3409,6 +3407,7 @@ class FfiConverterMoqBackoff {
 class MoqClientConfig {
   final String? bind;
   final List<String> versions;
+  final List<String> tokens;
   final Duration? timeout;
   final Duration? race;
   final Duration? resolutionDelay;
@@ -3423,6 +3422,7 @@ class MoqClientConfig {
   MoqClientConfig({
     this.bind = null,
     this.versions = const [],
+    this.tokens = const [],
     this.timeout = null,
     this.race = null,
     this.resolutionDelay = null,
@@ -3454,6 +3454,11 @@ class FfiConverterMoqClientConfig {
     );
     final versions = versions_lifted.value;
     new_offset += versions_lifted.bytesRead;
+    final tokens_lifted = FfiConverterSequenceString.read(
+      Uint8List.view(buf.buffer, new_offset),
+    );
+    final tokens = tokens_lifted.value;
+    new_offset += tokens_lifted.bytesRead;
     final timeout_lifted = FfiConverterOptionalDuration.read(
       Uint8List.view(buf.buffer, new_offset),
     );
@@ -3513,6 +3518,7 @@ class FfiConverterMoqClientConfig {
       MoqClientConfig(
         bind: bind,
         versions: versions,
+        tokens: tokens,
         timeout: timeout,
         race: race,
         resolutionDelay: resolutionDelay,
@@ -3533,6 +3539,7 @@ class FfiConverterMoqClientConfig {
     final total_length =
         FfiConverterOptionalString.allocationSize(value.bind) +
         FfiConverterSequenceString.allocationSize(value.versions) +
+        FfiConverterSequenceString.allocationSize(value.tokens) +
         FfiConverterOptionalDuration.allocationSize(value.timeout) +
         FfiConverterOptionalDuration.allocationSize(value.race) +
         FfiConverterOptionalDuration.allocationSize(value.resolutionDelay) +
@@ -3560,6 +3567,10 @@ class FfiConverterMoqClientConfig {
       value.versions,
       Uint8List.view(buf.buffer, new_offset),
     );
+    new_offset += FfiConverterSequenceString.write(
+      value.tokens,
+      Uint8List.view(buf.buffer, new_offset),
+    );
     new_offset += FfiConverterOptionalDuration.write(
       value.timeout,
       Uint8List.view(buf.buffer, new_offset),
@@ -3610,6 +3621,7 @@ class FfiConverterMoqClientConfig {
   static int allocationSize(MoqClientConfig value) {
     return FfiConverterOptionalString.allocationSize(value.bind) +
         FfiConverterSequenceString.allocationSize(value.versions) +
+        FfiConverterSequenceString.allocationSize(value.tokens) +
         FfiConverterOptionalDuration.allocationSize(value.timeout) +
         FfiConverterOptionalDuration.allocationSize(value.race) +
         FfiConverterOptionalDuration.allocationSize(value.resolutionDelay) +
@@ -13260,6 +13272,7 @@ class FfiConverterMoqServer {
 abstract class MoqClientInterface {
   void cancel();
   UniffiRustFuture<MoqSession> connect({required String url});
+  MoqTokens tokens();
 }
 
 final _MoqClientFinalizer = Finalizer<Pointer<Void>>((ptr) {
@@ -13323,6 +13336,17 @@ class MoqClient implements MoqClientInterface {
       moqExceptionErrorHandler,
     );
   }
+
+  MoqTokens tokens() {
+    return rustCallWithLifter(
+      (status) => uniffi_moq_ffi_fn_method_moqclient_tokens(
+        uniffiClonePointer(),
+        status,
+      ),
+      FfiConverterMoqTokens.lift,
+      null,
+    );
+  }
 }
 
 class FfiConverterMoqClient {
@@ -13546,6 +13570,78 @@ class FfiConverterMoqSession {
   }
 }
 
+abstract class MoqTokensInterface {
+  void set_({required List<String> tokens});
+}
+
+final _MoqTokensFinalizer = Finalizer<Pointer<Void>>((ptr) {
+  rustCall((status) => uniffi_moq_ffi_fn_free_moqtokens(ptr, status));
+});
+
+class MoqTokens implements MoqTokensInterface {
+  late final Pointer<Void> _ptr;
+  bool _isDisposed = false;
+  MoqTokens._(this._ptr) {
+    _MoqTokensFinalizer.attach(this, _ptr, detach: this);
+  }
+  factory MoqTokens.lift(Pointer<Void> ptr) {
+    return MoqTokens._(ptr);
+  }
+  Pointer<Void> uniffiClonePointer() {
+    if (_isDisposed) {
+      throw StateError("Object has already been disposed");
+    }
+    return rustCall(
+      (status) => uniffi_moq_ffi_fn_clone_moqtokens(_ptr, status),
+    );
+  }
+
+  void dispose() {
+    if (_isDisposed) {
+      return;
+    }
+    _isDisposed = true;
+    _MoqTokensFinalizer.detach(this);
+    rustCall((status) => uniffi_moq_ffi_fn_free_moqtokens(_ptr, status));
+  }
+
+  void set_({required List<String> tokens}) {
+    return rustCall((status) {
+      uniffi_moq_ffi_fn_method_moqtokens_set(
+        uniffiClonePointer(),
+        FfiConverterSequenceString.lower(tokens),
+        status,
+      );
+    }, moqExceptionErrorHandler);
+  }
+}
+
+class FfiConverterMoqTokens {
+  static MoqTokens lift(Pointer<Void> ptr) {
+    return MoqTokens.lift(ptr);
+  }
+
+  static Pointer<Void> lower(MoqTokens value) {
+    return value.uniffiClonePointer();
+  }
+
+  static int allocationSize(MoqTokens value) {
+    return 8;
+  }
+
+  static LiftRetVal<MoqTokens> read(Uint8List buf) {
+    final handle = buf.buffer.asByteData(buf.offsetInBytes).getInt64(0);
+    final pointer = Pointer<Void>.fromAddress(handle);
+    return LiftRetVal(MoqTokens.lift(pointer), 8);
+  }
+
+  static int write(MoqTokens value, Uint8List buf) {
+    final handle = lower(value);
+    buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, handle.address);
+    return 8;
+  }
+}
+
 abstract class MoqVideoConsumerInterface {
   void cancel();
   UniffiRustFuture<MoqVideoDecodedFrame?> next();
@@ -18800,6 +18896,14 @@ external Pointer<Void> uniffi_moq_ffi_fn_method_moqclient_connect(
   RustBuffer url,
 );
 
+@Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
+  assetId: _uniffiAssetId,
+)
+external Pointer<Void> uniffi_moq_ffi_fn_method_moqclient_tokens(
+  Pointer<Void> ptr,
+  Pointer<RustCallStatus> uniffiStatus,
+);
+
 @Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
   assetId: _uniffiAssetId,
 )
@@ -18900,6 +19004,31 @@ external RustBuffer uniffi_moq_ffi_fn_method_moqsession_stats(
   Pointer<RustCallStatus> uniffiStatus,
 );
 
+@Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
+  assetId: _uniffiAssetId,
+)
+external Pointer<Void> uniffi_moq_ffi_fn_clone_moqtokens(
+  Pointer<Void> handle,
+  Pointer<RustCallStatus> uniffiStatus,
+);
+
+@Native<Void Function(Pointer<Void>, Pointer<RustCallStatus>)>(
+  assetId: _uniffiAssetId,
+)
+external void uniffi_moq_ffi_fn_free_moqtokens(
+  Pointer<Void> handle,
+  Pointer<RustCallStatus> uniffiStatus,
+);
+
+@Native<Void Function(Pointer<Void>, RustBuffer, Pointer<RustCallStatus>)>(
+  assetId: _uniffiAssetId,
+)
+external void uniffi_moq_ffi_fn_method_moqtokens_set(
+  Pointer<Void> ptr,
+  RustBuffer tokens,
+  Pointer<RustCallStatus> uniffiStatus,
+);
+
 @Native<Pointer<Void> Function(Pointer<Void>, Pointer<RustCallStatus>)>(
   assetId: _uniffiAssetId,
 )
@@ -20012,6 +20141,9 @@ external int uniffi_moq_ffi_checksum_method_moqclient_cancel();
 @Native<Uint16 Function()>(assetId: _uniffiAssetId)
 external int uniffi_moq_ffi_checksum_method_moqclient_connect();
 
+@Native<Uint16 Function()>(assetId: _uniffiAssetId)
+external int uniffi_moq_ffi_checksum_method_moqclient_tokens();
+
 @Native<Uint16 Function()>(assetId: _uniffiAssetId)
 external int uniffi_moq_ffi_checksum_method_moqsession_auth();
 
@@ -20045,6 +20177,9 @@ external int uniffi_moq_ffi_checksum_method_moqsession_state_changed();
 @Native<Uint16 Function()>(assetId: _uniffiAssetId)
 external int uniffi_moq_ffi_checksum_method_moqsession_stats();
 
+@Native<Uint16 Function()>(assetId: _uniffiAssetId)
+external int uniffi_moq_ffi_checksum_method_moqtokens_set();
+
 @Native<Uint16 Function()>(assetId: _uniffiAssetId)
 external int uniffi_moq_ffi_checksum_method_moqvideoconsumer_cancel();
 
@@ -20744,6 +20879,9 @@ void _checkApiChecksums() {
   if (uniffi_moq_ffi_checksum_method_moqclient_connect() != 5016) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
+  if (uniffi_moq_ffi_checksum_method_moqclient_tokens() != 18102) {
+    throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
+  }
   if (uniffi_moq_ffi_checksum_method_moqsession_auth() != 1680) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
@@ -20777,6 +20915,9 @@ void _checkApiChecksums() {
   if (uniffi_moq_ffi_checksum_method_moqsession_stats() != 36396) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
+  if (uniffi_moq_ffi_checksum_method_moqtokens_set() != 58423) {
+    throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
+  }
   if (uniffi_moq_ffi_checksum_method_moqvideoconsumer_cancel() != 21122) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }

dart/moq_ffi/lib/src/uniffi_runtime.dart

@@ -8,7 +8,6 @@ import "dart:ffi";
 import "dart:io" show Platform, File, Directory;
 import "dart:isolate";
 import "dart:typed_data";
-
 import "package:ffi/ffi.dart";
 
 class UniffiInternalError implements Exception {
@@ -251,7 +250,6 @@ mixin FfiConverterPrimitive<T> on FfiConverter<T, T> {
   @override
   T lower(T value) => value;
 }
-
 Uint8List createUint8ListFromInt(int value) {
   int length = value.bitLength ~/ 8 + 1;
   if (length != 4 && length != 8) {

doc/bin/cli.md

@@ -43,8 +43,11 @@ moq <MoQ side> fetch <track> [options]
 ```
 
 The **MoQ side** goes first and attaches the process to the network:
-`--connect <url>` dials a relay (the path is the auth path, `?jwt=`
-carries a token), and `--broadcast <name>` names the broadcast. A process can
+`--connect <url>` dials a relay (the path is the auth path), `--connect-token`
+presents a token (repeat it to present several, see
+[Tokens](/bin/relay/auth#tokens)), and `--broadcast <name>` names the
+broadcast. A `?jwt=` in the URL still works, and is how a token reaches a
+relay that predates `--connect-token`. A process can
 instead host sessions with `--listen`, or both at once, admitting clients the
 way the relay does (see [Authentication](/bin/relay/auth)). Listening imports and
 exports share the relay's shutdown behavior: SIGINT or SIGTERM sends accepted
@@ -74,7 +77,7 @@ ffmpeg -re -i video.mp4 -c copy -f mpegts -pes_payload_size 0 -muxdelay 0 - | \
 moq --connect https://relay.example.com/anon --broadcast my-stream.hang export ts | ffplay -
 
 # With a token
-moq --connect "https://relay.example.com/rooms/1?jwt=$TOKEN" --broadcast alice.hang import ts
+moq --connect https://relay.example.com/rooms/1 --connect-token "$TOKEN" --broadcast alice.hang import ts
 ```
 
 ## Import