kasy-cli 1.21.9 → 1.22.0

package/lib/scaffold/backends/api/patch/lib/core/data/api/storage_api.dart

@@ -4,7 +4,7 @@ import 'dart:typed_data';
 import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
 import 'package:kasy_kit/core/data/api/http_client.dart';
 import 'package:kasy_kit/core/data/entities/upload_result.dart';
-import 'package:kasy_kit/environnements.dart';
+import 'package:kasy_kit/environments.dart';
 import 'package:dio/dio.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:logger/logger.dart';

package/lib/scaffold/backends/api/patch/lib/core/data/entities/user_entity.dart

@@ -16,6 +16,11 @@ sealed class UserEntity with _$UserEntity {
     String? avatarPath,
     bool? onboarded,
     String? locale,
+    // Access-control role. null/absent = normal user; "admin" unlocks the admin
+    // console's server data. Server-only: your backend must NEVER let a client
+    // write this — return it from GET /users/{id} (and in the JWT) but reject any
+    // client attempt to set it.
+    String? role,
   }) = UserEntityData;
 
   const UserEntity._();

package/lib/scaffold/backends/api/patch/lib/{environnements.dart → environments.dart}

@@ -6,7 +6,7 @@ import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:kasy_kit/core/config/app_env.dart';
 import 'package:kasy_kit/core/states/user_state_notifier.dart';
 
-part 'environnements.freezed.dart';
+part 'environments.freezed.dart';
 
 
 
@@ -40,9 +40,6 @@ sealed class Environment with _$Environment {
     /// (only if you want to use in-app purchases with RevenueCat)
     String? revenueCatIOSApiKey,
 
-    /// RevenueCat Web Billing API key (rcb_xxx or rcb_sb_xxx)
-    /// (only if you want to use subscriptions on web)
-    String? revenueCatWebApiKey,
 
     /// this is used to open the app store page of your app for reviews
     String? appStoreId,
@@ -76,9 +73,6 @@ sealed class Environment with _$Environment {
     /// (only if you want to use in-app purchases with RevenueCat)
     String? revenueCatIOSApiKey,
 
-    /// RevenueCat Web Billing API key (rcb_xxx or rcb_sb_xxx)
-    /// (only if you want to use subscriptions on web)
-    String? revenueCatWebApiKey,
 
     /// only if you want to use ads
     String? androidInterstitialAdUnitId,
@@ -116,7 +110,6 @@ sealed class Environment with _$Environment {
           appStoreId: '',
           revenueCatAndroidApiKey: AppEnv.rcAndroidApiKey,
           revenueCatIOSApiKey: AppEnv.rcIosApiKey,
-          revenueCatWebApiKey: AppEnv.rcWebApiKey,
           mixpanelToken: AppEnv.mixpanelToken,
           authenticationMode: AuthenticationMode.authRequired,
         );
@@ -127,7 +120,6 @@ sealed class Environment with _$Environment {
           appStoreId: AppEnv.appStoreId,
           revenueCatAndroidApiKey: AppEnv.rcAndroidApiKey,
           revenueCatIOSApiKey: AppEnv.rcIosApiKey,
-          revenueCatWebApiKey: AppEnv.rcWebApiKey,
           sentryDsn: AppEnv.sentryDsn,
           mixpanelToken: AppEnv.mixpanelToken,
           authenticationMode: AuthenticationMode.authRequired,
@@ -142,8 +134,8 @@ sealed class Environment with _$Environment {
       revenueCatIOSApiKey != null && revenueCatIOSApiKey!.isNotEmpty,
     TargetPlatform.android =>
       revenueCatAndroidApiKey != null && revenueCatAndroidApiKey!.isNotEmpty,
-    _ => kIsWeb &&
-        (revenueCatWebApiKey != null && revenueCatWebApiKey!.isNotEmpty),
+    // RevenueCat is mobile-only; web/desktop are never RevenueCat-configured.
+    _ => false,
   };
 }
 

package/lib/scaffold/backends/api/patch/lib/features/ai_chat/api/ai_chat_api.dart

@@ -0,0 +1,108 @@
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_conversation_entity.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_message_entity.dart';
+
+final aiChatApiProvider = Provider<AiChatApi>(
+  (ref) => AiChatApi(client: ref.read(httpClientProvider)),
+);
+
+/// REST endpoints expected on your backend (the server identifies the user via
+/// the Authorization: Bearer token injected automatically by HttpClient):
+///
+///   GET    /ai-conversations                       → `List<AiChatConversationEntity>`
+///   POST   /ai-conversations                       → creates + returns one conversation
+///   DELETE /ai-conversations/{id}                  → deletes a conversation + its messages
+///   GET    /ai-conversations/{id}/messages         → `List<AiChatMessageEntity>` (oldest first)
+///   POST   /ai-conversations/{id}/messages         → saves one message
+///
+/// Conversations are returned most-recently-updated first, with the last
+/// message denormalized (`last_message_role` / `last_message_content`).
+class AiChatApi {
+  final HttpClient _client;
+  final Logger _logger = Logger();
+
+  AiChatApi({required HttpClient client}) : _client = client;
+
+  // ---------------------------------------------------------------------------
+  // Conversations
+  // ---------------------------------------------------------------------------
+
+  /// Returns the user's conversations, most recently updated first.
+  Future<List<AiChatConversationEntity>> loadConversations(
+    String userId,
+  ) async {
+    try {
+      final response = await _client.get('/ai-conversations');
+      final list = response.data as List<dynamic>;
+      return list
+          .map(
+            (e) =>
+                AiChatConversationEntity.fromJson(e as Map<String, dynamic>),
+          )
+          .toList();
+    } on DioException catch (e) {
+      _logger.e('Failed to load conversations: $e');
+      return [];
+    }
+  }
+
+  /// Creates an empty conversation and returns it (with its generated id).
+  Future<AiChatConversationEntity> createConversation(String userId) async {
+    final response = await _client.post('/ai-conversations');
+    return AiChatConversationEntity.fromJson(
+      response.data as Map<String, dynamic>,
+    );
+  }
+
+  /// Deletes a conversation (and its messages) on the server.
+  Future<void> deleteConversation(String userId, String conversationId) async {
+    try {
+      await _client.delete('/ai-conversations/$conversationId');
+    } catch (e) {
+      _logger.e('Failed to delete conversation: $e');
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Messages
+  // ---------------------------------------------------------------------------
+
+  /// Returns all messages in a conversation, oldest first.
+  Future<List<AiChatMessageEntity>> loadMessages(
+    String userId,
+    String conversationId,
+  ) async {
+    try {
+      final response = await _client.get(
+        '/ai-conversations/$conversationId/messages',
+      );
+      final list = response.data as List<dynamic>;
+      return list
+          .map((e) => AiChatMessageEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      _logger.e('Failed to load AI messages: $e');
+      return [];
+    }
+  }
+
+  /// Persists a message in a conversation via POST. The server is expected to
+  /// update the conversation's denormalized last-message fields + timestamp.
+  Future<void> saveMessage(
+    String userId,
+    String conversationId,
+    AiChatMessageEntity message,
+  ) async {
+    try {
+      await _client.post(
+        '/ai-conversations/$conversationId/messages',
+        data: message.toJson(),
+      );
+    } catch (e) {
+      _logger.e('Failed to persist AI message: $e');
+    }
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/ai_chat/api/ai_chat_conversation_entity.dart

@@ -0,0 +1,51 @@
+/// REST mapping for a single AI chat conversation.
+///
+/// The last message is denormalized onto the conversation so the list can be
+/// rendered from one request (no need to fetch each conversation's messages
+/// just to show a preview + timestamp).
+class AiChatConversationEntity {
+  final String id;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+
+  /// Role of the most recent message ('user' or 'assistant'), or null when the
+  /// conversation has no messages yet.
+  final String? lastMessageRole;
+
+  /// Content of the most recent message, or null when empty.
+  final String? lastMessageContent;
+
+  const AiChatConversationEntity({
+    required this.id,
+    required this.createdAt,
+    required this.updatedAt,
+    this.lastMessageRole,
+    this.lastMessageContent,
+  });
+
+  bool get isEmpty => lastMessageContent == null;
+
+  AiChatConversationEntity copyWith({
+    DateTime? updatedAt,
+    String? lastMessageRole,
+    String? lastMessageContent,
+  }) {
+    return AiChatConversationEntity(
+      id: id,
+      createdAt: createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+      lastMessageRole: lastMessageRole ?? this.lastMessageRole,
+      lastMessageContent: lastMessageContent ?? this.lastMessageContent,
+    );
+  }
+
+  factory AiChatConversationEntity.fromJson(Map<String, dynamic> json) {
+    return AiChatConversationEntity(
+      id: json['id'] as String,
+      createdAt: DateTime.parse(json['created_at'] as String),
+      updatedAt: DateTime.parse(json['updated_at'] as String),
+      lastMessageRole: json['last_message_role'] as String?,
+      lastMessageContent: json['last_message_content'] as String?,
+    );
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/{llm_chat/api/llm_chat_message_entity.dart → ai_chat/api/ai_chat_message_entity.dart}

@@ -1,19 +1,19 @@
-/// REST API response mapping for a single LLM chat message.
-class LlmChatMessageEntity {
+/// REST API response mapping for a single AI chat message.
+class AiChatMessageEntity {
   final String? id;
   final String role; // 'user' or 'assistant'
   final String content;
   final DateTime createdAt;
 
-  const LlmChatMessageEntity({
+  const AiChatMessageEntity({
     this.id,
     required this.role,
     required this.content,
     required this.createdAt,
   });
 
-  factory LlmChatMessageEntity.fromJson(Map<String, dynamic> json) {
-    return LlmChatMessageEntity(
+  factory AiChatMessageEntity.fromJson(Map<String, dynamic> json) {
+    return AiChatMessageEntity(
       id: json['id'] as String?,
       role: json['role'] as String,
       content: json['content'] as String,

package/lib/scaffold/backends/api/patch/lib/features/{llm_chat/providers/llm_chat_notifier.dart → ai_chat/providers/ai_chat_notifier.dart}

@@ -6,8 +6,9 @@ import 'package:kasy_kit/core/config/app_env.dart';
 import 'package:kasy_kit/core/data/api/http_client.dart';
 import 'package:kasy_kit/core/states/translations.dart';
 import 'package:kasy_kit/core/states/user_state_notifier.dart';
-import 'package:kasy_kit/features/llm_chat/api/llm_chat_api.dart';
-import 'package:kasy_kit/features/llm_chat/api/llm_chat_message_entity.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_api.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_message_entity.dart';
+import 'package:kasy_kit/features/ai_chat/providers/ai_conversations_notifier.dart';
 import 'package:logger/logger.dart';
 
 /// Maximum number of recent messages sent to the AI as context.
@@ -34,39 +35,39 @@ class ChatMessage {
   factory ChatMessage.assistant(String content) =>
       ChatMessage(role: 'assistant', content: content);
 
-  factory ChatMessage.fromEntity(LlmChatMessageEntity entity) =>
+  factory ChatMessage.fromEntity(AiChatMessageEntity entity) =>
       ChatMessage(role: entity.role, content: entity.content);
 
-  LlmChatMessageEntity toEntity() => LlmChatMessageEntity(
+  AiChatMessageEntity toEntity() => AiChatMessageEntity(
     role: role,
     content: content,
     createdAt: DateTime.now(),
   );
 }
 
-/// UI state for the LLM chat screen.
-class LlmChatState {
+/// UI state for the AI chat screen.
+class AiChatState {
   final List<ChatMessage> messages;
 
-  /// True while the HTTP request to the LLM backend is in-flight.
+  /// True while the HTTP request to the AI backend is in-flight.
   final bool isReplying;
 
   /// True once the first SSE chunk has been received.
   /// While true the last message in [messages] is the partial assistant reply.
   final bool streamingStarted;
 
-  const LlmChatState({
+  const AiChatState({
     required this.messages,
     this.isReplying = false,
     this.streamingStarted = false,
   });
 
-  LlmChatState copyWith({
+  AiChatState copyWith({
     List<ChatMessage>? messages,
     bool? isReplying,
     bool? streamingStarted,
   }) {
-    return LlmChatState(
+    return AiChatState(
       messages: messages ?? this.messages,
       isReplying: isReplying ?? this.isReplying,
       streamingStarted: streamingStarted ?? this.streamingStarted,
@@ -74,39 +75,54 @@ class LlmChatState {
   }
 }
 
-/// Manages LLM chat state: loads history from the backend on init,
+/// Manages AI chat state: loads history from the backend on init,
 /// persists each message, and streams the assistant reply word-by-word via SSE.
-final llmChatNotifierProvider =
-    AsyncNotifierProvider<LlmChatNotifier, LlmChatState>(LlmChatNotifier.new);
+final aiChatNotifierProvider =
+    AsyncNotifierProvider<AiChatNotifier, AiChatState>(AiChatNotifier.new);
 
-class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
+class AiChatNotifier extends AsyncNotifier<AiChatState> {
   final Logger _logger = Logger();
 
+  /// The conversation a reply is currently streaming into. Used to ignore UI
+  /// updates if the user switches conversations mid-stream (the reply is still
+  /// persisted to the right conversation, just not shown on the wrong one).
+  String? _streamingConversationId;
+
+  bool get _streamStillActive =>
+      ref.read(selectedConversationIdProvider) == _streamingConversationId;
+
   @override
-  Future<LlmChatState> build() async {
+  Future<AiChatState> build() async {
+    final conversationId = ref.watch(selectedConversationIdProvider);
     final userId = ref.read(userStateNotifierProvider).user.idOrNull;
-    if (userId == null) return const LlmChatState(messages: []);
+    if (conversationId == null || userId == null) {
+      return const AiChatState(messages: []);
+    }
 
     try {
-      final entities = await ref.read(llmChatApiProvider).loadMessages(userId);
-      return LlmChatState(
+      final entities = await ref
+          .read(aiChatApiProvider)
+          .loadMessages(userId, conversationId);
+      return AiChatState(
         messages: entities.map(ChatMessage.fromEntity).toList(),
       );
     } catch (e) {
-      _logger.e('Failed to load LLM chat history: $e');
+      _logger.e('Failed to load AI chat history: $e');
       // Graceful fallback: start fresh if the backend is unavailable.
-      return const LlmChatState(messages: []);
+      return const AiChatState(messages: []);
     }
   }
 
   /// Adds the user message to the conversation, persists it, then streams
   /// the assistant reply chunk-by-chunk via SSE, updating state on each token.
   Future<void> sendMessage(String prompt) async {
+    final conversationId = ref.read(selectedConversationIdProvider);
     final current = switch (state) {
       AsyncData(:final value) => value,
       _ => null,
     };
-    if (current == null || current.isReplying) return;
+    if (conversationId == null || current == null || current.isReplying) return;
+    _streamingConversationId = conversationId;
 
     final userMsg = ChatMessage.user(prompt);
     state = AsyncData(
@@ -117,26 +133,29 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
       ),
     );
 
-    _persistMessage(userMsg);
+    _persistMessage(userMsg, conversationId);
 
     // Pass only the last _kMaxContextMessages messages to the AI.
     // The full history is still stored in the DB for the user to read.
-    final allMessages = (state as AsyncData<LlmChatState>).value.messages;
+    final allMessages = (state as AsyncData<AiChatState>).value.messages;
     final history = allMessages.length > _kMaxContextMessages
         ? allMessages.sublist(allMessages.length - _kMaxContextMessages)
         : allMessages;
-    await _requestReplyStream(history);
+    await _requestReplyStream(history, conversationId);
   }
 
   // ---------------------------------------------------------------------------
   // SSE streaming
   // ---------------------------------------------------------------------------
 
-  Future<void> _requestReplyStream(List<ChatMessage> history) async {
-    final t = ref.read(translationsProvider).llm_chat;
-    final String llmChatEndpoint = AppEnv.llmChatEndpoint;
+  Future<void> _requestReplyStream(
+    List<ChatMessage> history,
+    String conversationId,
+  ) async {
+    final t = ref.read(translationsProvider).ai_chat;
+    final String aiChatEndpoint = AppEnv.aiChatEndpoint;
 
-    if (llmChatEndpoint.isEmpty) {
+    if (aiChatEndpoint.isEmpty) {
       _finalizeAssistantMessage(t.error_not_configured);
       return;
     }
@@ -160,7 +179,7 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
 
     try {
       final response = await dio.post<ResponseBody>(
-        llmChatEndpoint,
+        aiChatEndpoint,
         data: {
           'message': history.last.content,
           'history': history
@@ -201,7 +220,7 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
       // Persist the complete assistant reply once the stream ends.
       final fullContent = contentBuffer.toString();
       if (fullContent.isNotEmpty) {
-        _persistMessage(ChatMessage.assistant(fullContent));
+        _persistMessage(ChatMessage.assistant(fullContent), conversationId);
       } else {
         // Stream ended with no content (e.g. error event)
         _finalizeAssistantMessage(t.error_no_reply);
@@ -213,19 +232,21 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
         AsyncData(:final value) => value,
         _ => null,
       };
-      if (latest != null) {
+      if (latest != null && _streamStillActive) {
         state = AsyncData(
           latest.copyWith(isReplying: false, streamingStarted: false),
         );
       }
     } catch (error) {
-      _logger.e('LLM chat stream failed: $error');
+      _logger.e('AI chat stream failed: $error');
       _finalizeAssistantMessage(t.error_network);
     }
   }
 
   /// Called on every incoming SSE token to update the last assistant bubble.
   void _appendStreamingChunk(String partialContent) {
+    // Ignore chunks if the user navigated to another conversation mid-stream.
+    if (!_streamStillActive) return;
     final current = switch (state) {
       AsyncData(:final value) => value,
       _ => null,
@@ -243,22 +264,24 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
         : [...msgs, ChatMessage.assistant(partialContent)];
 
     state = AsyncData(
-      LlmChatState(messages: newMsgs, isReplying: true, streamingStarted: true),
+      AiChatState(messages: newMsgs, isReplying: true, streamingStarted: true),
     );
   }
 
   /// Replaces (or appends) the assistant bubble with [content] and marks
   /// the reply as finished. Used for error messages and empty-stream fallback.
   void _finalizeAssistantMessage(String content) {
+    // Ignore if the user navigated to another conversation mid-stream.
+    if (!_streamStillActive) return;
     final current = switch (state) {
       AsyncData(:final value) => value,
-      _ => const LlmChatState(messages: []),
+      _ => const AiChatState(messages: []),
     };
     final msgs = current.messages;
     final newMsgs = current.streamingStarted
         ? [...msgs.sublist(0, msgs.length - 1), ChatMessage.assistant(content)]
         : [...msgs, ChatMessage.assistant(content)];
-    state = AsyncData(LlmChatState(messages: newMsgs));
+    state = AsyncData(AiChatState(messages: newMsgs));
   }
 
   // ---------------------------------------------------------------------------
@@ -304,14 +327,24 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
   // Persistence
   // ---------------------------------------------------------------------------
 
-  void _persistMessage(ChatMessage message) {
+  void _persistMessage(ChatMessage message, String conversationId) {
     final userId = ref.read(userStateNotifierProvider).user.idOrNull;
     if (userId == null) return;
+    final entity = message.toEntity();
     ref
-        .read(llmChatApiProvider)
-        .saveMessage(userId, message.toEntity())
+        .read(aiChatApiProvider)
+        .saveMessage(userId, conversationId, entity)
         .catchError((e) {
           _logger.e('Failed to persist message: $e');
         });
+    // Keep the conversation list preview + ordering in sync.
+    ref
+        .read(aiConversationsNotifierProvider.notifier)
+        .touch(
+          conversationId,
+          role: message.role,
+          content: message.content,
+          at: entity.createdAt,
+        );
   }
 }

package/lib/scaffold/backends/api/patch/lib/features/authentication/api/authentication_api.dart

@@ -135,7 +135,7 @@ class HttpAuthenticationApi implements AuthenticationApi {
       }
       rethrow;
     }
-    final googleAuth = await googleUser.authentication;
+    final googleAuth = googleUser.authentication;
     throw UnimplementedError('''
     ❌ You must edit lib/features/authentication/api/authentication_api.dart
     to send the Oauth2 token result to your backend.
@@ -228,7 +228,7 @@ class HttpAuthenticationApi implements AuthenticationApi {
       }
       rethrow;
     }
-    final googleAuth = await googleUser.authentication;
+    final googleAuth = googleUser.authentication;
     throw UnimplementedError(
       '❌ Send the tokens to your backend to merge the guest account.\n'
       '   idToken: ${googleAuth.idToken}\n'

package/lib/scaffold/backends/api/patch/lib/features/feedbacks/api/feature_request_api.dart

@@ -14,6 +14,10 @@ final featureRequestApiProvider = Provider<FeatureRequestApi>(
 ///   GET  /feature-requests              → `List<FeatureRequestEntity>` (only active)
 ///   POST /feature-requests              body: {title, description} → 201 Created
 ///     Server creates with active: false and stores title/description in all locales.
+///
+/// Admin (server MUST verify role == "admin", else 403):
+///   GET   /admin/feature-requests       → `List<FeatureRequestEntity>` (active + hidden)
+///   PATCH /admin/feature-requests/{id}  body: {active} | {title, description}
 class FeatureRequestApi {
   final HttpClient _client;
 
@@ -49,4 +53,54 @@ class FeatureRequestApi {
       throw ApiError(code: 0, message: '$e: $s');
     }
   }
+
+  /// Admin: every request (active + hidden), highest-voted first.
+  /// Expected: GET /admin/feature-requests (server gates on role == "admin").
+  Future<List<FeatureRequestEntity>> getAll() async {
+    try {
+      final response = await _client.get('/admin/feature-requests');
+      final list = response.data as List<dynamic>;
+      return list
+          .map((e) => FeatureRequestEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+
+  /// Admin: toggle whether a request is visible (and votable) to users.
+  /// Expected: PATCH /admin/feature-requests/{id} body {active} (admin-gated).
+  Future<void> setActive(String id, bool active) async {
+    try {
+      await _client.patch(
+        '/admin/feature-requests/$id',
+        data: {'active': active},
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+
+  /// Admin: update the localized title/description maps (en/pt/es).
+  /// Expected: PATCH /admin/feature-requests/{id} body {title, description}.
+  Future<void> updateTexts({
+    required String id,
+    required Map<String, String> title,
+    required Map<String, String> description,
+  }) async {
+    try {
+      await _client.patch(
+        '/admin/feature-requests/$id',
+        data: {'title': title, 'description': description},
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
 }