@bdayadev/flutter-ultra-mcp 1.11.6 → 1.12.0

package/skills/resolve-package-conflicts/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: resolve-package-conflicts
+description: Workflow for fixing package version conflicts. Use this when `pub get` fails due to incompatible package versions.
+---
+
+# Managing Dart Dependencies
+
+## Contents
+
+- [Core Concepts](#core-concepts)
+- [Version Constraints](#version-constraints)
+- [Workflow: Auditing Dependencies](#workflow-auditing-dependencies)
+- [Workflow: Upgrading Dependencies](#workflow-upgrading-dependencies)
+- [Workflow: Resolving Version Conflicts](#workflow-resolving-version-conflicts)
+- [Examples](#examples)
+
+## Core Concepts
+
+Dart enforces a strict single-version rule for dependencies: a project and all its transitive dependencies must resolve to a single, shared version of any given package.
+
+Understand the output columns of `dart pub outdated`:
+
+- **Current:** The version currently recorded in `pubspec.lock`.
+- **Upgradable:** The latest version allowed by the constraints in `pubspec.yaml`. `dart pub upgrade` resolves to this.
+- **Resolvable:** The absolute latest version that can be resolved when factoring in all other dependencies.
+- **Latest:** The latest published version of the package (excluding prereleases).
+
+## Version Constraints
+
+- **Use Caret Syntax:** Always use caret syntax (e.g., `^1.2.3`) for dependencies.
+- **Tighten Dev Dependencies:** Set the lower bound of `dev_dependencies` to the exact version currently used.
+- **Enforce Lockfiles in CI:** Use `dart pub get --enforce-lockfile` in CI/CD pipelines.
+
+## Workflow: Auditing Dependencies
+
+**Task Progress:**
+
+- [ ] Run `dart pub outdated`.
+- [ ] Review the **Upgradable** column.
+- [ ] Review the **Resolvable** column.
+- [ ] Identify any packages marked as retracted or discontinued.
+
+## Workflow: Upgrading Dependencies
+
+**Task Progress:**
+
+- [ ] **If updating to "Upgradable" versions:**
+  - [ ] Run `dart pub upgrade`.
+  - [ ] Run `dart pub upgrade --tighten` to update lower bounds.
+- [ ] **If updating to "Resolvable" versions (Major updates):**
+  - [ ] Manually edit `pubspec.yaml` to bump the version constraint.
+  - [ ] Run `dart pub upgrade` to resolve the new constraints.
+- [ ] **Feedback Loop:**
+  - [ ] Run `dart analyze` -> review errors -> fix breaking API changes.
+  - [ ] Run `dart test` -> review failures -> fix regressions.
+
+## Workflow: Resolving Version Conflicts
+
+**NEVER** delete the entire `pubspec.lock` file and run `dart pub get`. This causes uncontrolled upgrades across the entire dependency graph.
+
+**Task Progress:**
+
+- [ ] Open `pubspec.lock`.
+- [ ] Locate the specific YAML block for the conflicting or retracted package.
+- [ ] Delete ONLY that package's entry from the lockfile.
+- [ ] Run `dart pub get` to fetch the newest compatible version.
+- [ ] **Feedback Loop:**
+  - [ ] Run `dart pub deps` -> verify the dependency graph resolves correctly.
+  - [ ] If resolution fails, identify the transitive dependency causing the lock, update its constraint in `pubspec.yaml`, and retry.
+
+## Examples
+
+### Tightening Constraints
+
+**Input (`pubspec.yaml`):**
+
+```yaml
+dependencies:
+  http: ^0.13.0
+```
+
+**Command:**
+
+```bash
+dart pub upgrade --tighten http
+```
+
+**Output (`pubspec.yaml`):**
+
+```yaml
+dependencies:
+  http: ^0.13.5
+```
+
+### Surgical Lockfile Removal
+
+If `package_a` is retracted or locked in a conflict, remove only its block from `pubspec.lock`. Leave all other entries untouched. Run `dart pub get`.
+
+## Flutter Ultra Integration
+
+Investigate and resolve dependency conflicts:
+
+- `mcp__plugin_flutter_flutter-ultra-build__pub_get` — Run pub get to see the current resolution state
+- `mcp__plugin_flutter_flutter-ultra-build__pub_deps` — View the full dependency tree
+- `mcp__plugin_flutter_flutter-ultra-build__pub_outdated` — Check which packages are outdated
+- `mcp__plugin_flutter_flutter-ultra-build__pub_upgrade` — Attempt upgrade to resolve conflicts
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/run-static-analysis/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: run-static-analysis
+description: Execute `dart analyze` to identify warnings and errors, and use `dart fix --apply` to automatically resolve mechanical lint issues. Use during development to ensure code quality and before committing changes.
+---
+
+# Analyzing and Fixing Dart Code
+
+## Contents
+
+- [Analysis Configuration](#analysis-configuration)
+- [Diagnostic Suppression](#diagnostic-suppression)
+- [Workflow: Executing Static Analysis](#workflow-executing-static-analysis)
+- [Workflow: Applying Automated Fixes](#workflow-applying-automated-fixes)
+- [Examples](#examples)
+
+## Analysis Configuration
+
+Configure the Dart analyzer using the `analysis_options.yaml` file at the package root.
+
+- **Base Configuration:** Include a standard rule set (e.g., `package:lints/recommended.yaml` or `package:flutter_lints/flutter.yaml`).
+- **Strict Type Checks:** Enable `strict-casts: true`, `strict-inference: true`, and `strict-raw-types: true` under `analyzer: language:`.
+- **Linter Rules:** Enable or disable specific rules under `linter: rules:`. Do not mix list and map syntax in the same `rules` block.
+- **Formatter Configuration:** Configure `dart format` behavior under the `formatter:` node. Set `page_width` and `trailing_commas`.
+
+## Diagnostic Suppression
+
+- **File-level Exclusion:** Use `analyzer: exclude:` with glob patterns (e.g., `**/*.g.dart`).
+- **File-level Suppression:** Add `// ignore_for_file: <diagnostic_code>` at the top of a file.
+- **Line-level Suppression:** Add `// ignore: <diagnostic_code>` on the line above.
+
+## Workflow: Executing Static Analysis
+
+**Task Progress:**
+
+- [ ] 1. Verify `analysis_options.yaml` exists at the project root.
+- [ ] 2. Run the analyzer: `dart analyze <target_directory>`.
+- [ ] 3. Review the diagnostic output.
+- [ ] 4. If info-level issues must be treated as failures, append `--fatal-infos`.
+- [ ] 5. Resolve reported errors manually or proceed to Automated Fixes.
+
+## Workflow: Applying Automated Fixes
+
+**Task Progress:**
+
+- [ ] 1. Preview proposed changes: `dart fix --dry-run`.
+- [ ] 2. Review the proposed fixes.
+- [ ] 3. Apply the fixes: `dart fix --apply`.
+- [ ] 4. Format the modified code: `dart format .`.
+- [ ] 5. Run static analysis again to verify all diagnostics are resolved.
+
+## Examples
+
+### Comprehensive `analysis_options.yaml`
+
+```yaml
+include: package:flutter_lints/recommended.yaml
+
+analyzer:
+  exclude:
+    - '**/*.g.dart'
+    - 'lib/generated/**'
+  language:
+    strict-casts: true
+    strict-inference: true
+    strict-raw-types: true
+  errors:
+    todo: ignore
+    invalid_assignment: warning
+    missing_return: error
+
+linter:
+  rules:
+    avoid_shadowing_type_parameters: false
+    await_only_futures: true
+    use_super_parameters: true
+
+formatter:
+  page_width: 100
+  trailing_commas: preserve
+```
+
+### Inline Diagnostic Suppression
+
+```dart
+// ignore_for_file: unused_local_variable, dead_code
+
+void processData() {
+  // ignore: invalid_assignment
+  int x = '';
+
+  const y = 10; // ignore: constant_identifier_names
+}
+```
+
+## Flutter Ultra Integration
+
+Run analysis and auto-fix via flutter-ultra tools:
+
+- `mcp__plugin_flutter_flutter-ultra-build__analyze` — Run dart analyze with full diagnostics
+- `mcp__plugin_flutter_flutter-ultra-build__fix` — Apply dart fix --apply for automated lint fixes
+- `mcp__plugin_flutter_flutter-ultra-build__fix_preview` — Preview fixes before applying
+- `mcp__plugin_flutter_flutter-ultra-build__format` — Format code after fixes
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/setup-declarative-routing/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: setup-declarative-routing
+description: Configure `MaterialApp.router` using a package like `go_router` for advanced URL-based navigation. Use when developing web applications or mobile apps that require specific deep linking and browser history support.
+---
+
+# Implementing Routing and Deep Linking
+
+## Contents
+
+- [Core Concepts](#core-concepts)
+- [Workflow: Initializing the Application and Router](#workflow-initializing-the-application-and-router)
+- [Workflow: Configuring Platform Deep Linking](#workflow-configuring-platform-deep-linking)
+- [Workflow: Implementing Nested Navigation](#workflow-implementing-nested-navigation)
+- [Examples](#examples)
+
+## Core Concepts
+
+Use the `go_router` package for declarative routing in Flutter.
+
+- **GoRouter**: Central configuration object defining the route tree.
+- **GoRoute**: Maps a URL path to a Flutter screen.
+- **ShellRoute / StatefulShellRoute**: Wraps child routes in a persistent UI shell (e.g., `BottomNavigationBar`). `StatefulShellRoute` maintains state of parallel branches.
+- **Path URL Strategy**: Removes the default `#` from web URLs.
+
+## Workflow: Initializing the Application and Router
+
+### Task Progress
+
+- [ ] Create the Flutter application.
+- [ ] Add `go_router`: `flutter pub add go_router`.
+- [ ] Configure URL strategy with `usePathUrlStrategy()`.
+- [ ] Implement the `GoRouter` configuration.
+- [ ] Bind the router to `MaterialApp.router`.
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:flutter_web_plugins/url_strategy.dart';
+
+void main() {
+  usePathUrlStrategy();
+  runApp(const MyApp());
+}
+
+final GoRouter _router = GoRouter(
+  initialLocation: '/',
+  routes: [
+    GoRoute(
+      path: '/',
+      builder: (context, state) => const HomeScreen(),
+      routes: [
+        GoRoute(
+          path: 'details/:id',
+          builder: (context, state) => DetailsScreen(id: state.pathParameters['id']!),
+        ),
+      ],
+    ),
+  ],
+  errorBuilder: (context, state) => ErrorScreen(error: state.error),
+);
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp.router(routerConfig: _router, title: 'Routing App');
+  }
+}
+```
+
+## Workflow: Configuring Platform Deep Linking
+
+### Task Progress
+
+- [ ] Determine target platforms (iOS, Android, or both).
+- [ ] **Android:** Add intent filter to `AndroidManifest.xml` + host `assetlinks.json`.
+- [ ] **iOS:** Set `FlutterDeepLinkingEnabled` in `Info.plist` + add associated domain in entitlements + host `apple-app-site-association`.
+- [ ] Test via ADB (Android) or `xcrun simctl openurl` (iOS).
+
+## Workflow: Implementing Nested Navigation
+
+Use `StatefulShellRoute.indexedStack` to implement persistent shells with tab navigation.
+
+```dart
+final GoRouter _router = GoRouter(
+  initialLocation: '/home',
+  routes: [
+    StatefulShellRoute.indexedStack(
+      builder: (context, state, navigationShell) {
+        return ScaffoldWithNavBar(navigationShell: navigationShell);
+      },
+      branches: [
+        StatefulShellBranch(routes: [
+          GoRoute(path: '/home', builder: (context, state) => const HomeScreen()),
+        ]),
+        StatefulShellBranch(routes: [
+          GoRoute(path: '/settings', builder: (context, state) => const SettingsScreen()),
+        ]),
+      ],
+    ),
+  ],
+);
+```
+
+## Examples
+
+### Programmatic Navigation
+
+```dart
+context.go('/details/123');        // Replace current stack
+context.push('/details/123');      // Push onto stack
+context.goNamed('details', pathParameters: {'id': '123'});
+context.pop();
+```
+
+### Shell Widget Implementation
+
+```dart
+class ScaffoldWithNavBar extends StatelessWidget {
+  const ScaffoldWithNavBar({required this.navigationShell, super.key});
+  final StatefulNavigationShell navigationShell;
+
+  void _goBranch(int index) {
+    navigationShell.goBranch(index,
+      initialLocation: index == navigationShell.currentIndex);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: navigationShell,
+      bottomNavigationBar: NavigationBar(
+        selectedIndex: navigationShell.currentIndex,
+        onDestinationSelected: _goBranch,
+        destinations: const [
+          NavigationDestination(icon: Icon(Icons.home), label: 'Home'),
+          NavigationDestination(icon: Icon(Icons.settings), label: 'Settings'),
+        ],
+      ),
+    );
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+After configuring routes, test navigation in the running app:
+
+- `mcp__plugin_flutter_flutter-ultra-runtime__launch_app` — Launch the app to test routing
+- `mcp__plugin_flutter_flutter-ultra-browser__navigate` — Navigate to specific routes in the browser (web targets)
+- `mcp__plugin_flutter_flutter-ultra-runtime__screenshot` — Capture each route for visual verification
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors` — Check for routing errors (missing routes, redirect loops)
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/setup-localization/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: setup-localization
+description: Add `flutter_localizations` and `intl` dependencies, enable "generate true" in `pubspec.yaml`, and create an `l10n.yaml` configuration file. Use when initializing localization support for a new Flutter project.
+---
+
+# Internationalizing Flutter Applications
+
+## Contents
+
+- [Core Concepts](#core-concepts)
+- [Setup Workflow](#setup-workflow)
+- [Implementation Workflow](#implementation-workflow)
+- [Advanced Formatting](#advanced-formatting)
+- [Examples](#examples)
+
+## Core Concepts
+
+Flutter handles i18n/l10n via `flutter_localizations` and `intl`. Uses App Resource Bundle (`.arb`) files compiled into a generated `AppLocalizations` class for type-safe access.
+
+## Setup Workflow
+
+- [ ] 1. Add dependencies to `pubspec.yaml`.
+- [ ] 2. Enable the `generate` flag.
+- [ ] 3. Create the `l10n.yaml` configuration file.
+- [ ] 4. Configure `MaterialApp` or `CupertinoApp`.
+
+### 1. Add Dependencies
+
+```bash
+flutter pub add flutter_localizations --sdk=flutter
+flutter pub add intl:any
+```
+
+### 2. Enable Code Generation
+
+```yaml
+# pubspec.yaml
+flutter:
+  generate: true
+```
+
+### 3. Create Configuration File
+
+```yaml
+# l10n.yaml
+arb-dir: lib/l10n
+template-arb-file: app_en.arb
+output-localization-file: app_localizations.dart
+synthetic-package: true
+```
+
+### 4. Configure App Entry Point
+
+```dart
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_gen/gen_l10n/app_localizations.dart';
+
+return MaterialApp(
+  localizationsDelegates: const [
+    AppLocalizations.delegate,
+    GlobalMaterialLocalizations.delegate,
+    GlobalWidgetsLocalizations.delegate,
+    GlobalCupertinoLocalizations.delegate,
+  ],
+  supportedLocales: const [Locale('en'), Locale('es')],
+  home: const MyHomePage(),
+);
+```
+
+## Implementation Workflow
+
+### 1. Define ARB Files
+
+**Template (`lib/l10n/app_en.arb`):**
+
+```json
+{
+  "helloWorld": "Hello World!",
+  "@helloWorld": {
+    "description": "The conventional newborn programmer greeting"
+  }
+}
+```
+
+**Other locales (`lib/l10n/app_es.arb`):**
+
+```json
+{
+  "helloWorld": "!Hola Mundo!"
+}
+```
+
+### 2. Generate Localization Classes
+
+```bash
+flutter pub get
+```
+
+### 3. Consume Localized Strings
+
+```dart
+Text(AppLocalizations.of(context)!.helloWorld)
+```
+
+## Advanced Formatting
+
+### Placeholders
+
+```json
+"hello": "Hello {userName}",
+"@hello": {
+  "placeholders": {
+    "userName": { "type": "String", "example": "Bob" }
+  }
+}
+```
+
+### Plurals
+
+```json
+"nWombats": "{count, plural, =0{no wombats} =1{1 wombat} other{{count} wombats}}",
+"@nWombats": {
+  "placeholders": { "count": { "type": "num", "format": "compact" } }
+}
+```
+
+### Selects
+
+```json
+"pronoun": "{gender, select, male{he} female{she} other{they}}",
+"@pronoun": {
+  "placeholders": { "gender": { "type": "String" } }
+}
+```
+
+## Examples
+
+### Complete Widget Implementation
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter_gen/gen_l10n/app_localizations.dart';
+
+class GreetingWidget extends StatelessWidget {
+  final String userName;
+  final int notificationCount;
+
+  const GreetingWidget({
+    super.key,
+    required this.userName,
+    required this.notificationCount,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context)!;
+    return Column(children: [
+      Text(l10n.hello(userName)),
+      Text(l10n.nWombats(notificationCount)),
+    ]);
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+Generate and validate localization files with these tools:
+
+- `mcp__plugin_flutter_flutter-ultra-build__flutter_gen_l10n` — Generate localization Dart code from ARB files
+- `mcp__plugin_flutter_flutter-ultra-build__list_missing_translations` — Find missing translation keys across locales
+- `mcp__plugin_flutter_flutter-ultra-build__arb_add_key` — Add a new translation key to all ARB files
+- `mcp__plugin_flutter_flutter-ultra-build__arb_diff` — Compare ARB files to find drift between locales
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/use-http-package/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: use-http-package
+description: Use the `http` package to execute GET, POST, PUT, or DELETE requests. Use when you need to fetch from or send data to a REST API.
+---
+
+# Implementing Flutter Networking
+
+## Contents
+
+- [Configuration & Permissions](#configuration--permissions)
+- [Request Execution & Response Handling](#request-execution--response-handling)
+- [Background Parsing](#background-parsing)
+- [Workflow: Executing Network Operations](#workflow-executing-network-operations)
+- [Examples](#examples)
+
+## Configuration & Permissions
+
+1. Add the `http` package: `flutter pub add http`
+2. Import: `import 'package:http/http.dart' as http;`
+3. **Android**: Add `<uses-permission android:name="android.permission.INTERNET" />` to `AndroidManifest.xml`.
+4. **macOS**: Add `com.apple.security.network.client` = `true` to both entitlements files.
+
+## Request Execution & Response Handling
+
+- **URIs:** Always use `Uri.parse('your_url')`.
+- **Headers:** Inject via the `headers` parameter map.
+- **Payloads:** For POST/PUT, encode body with `jsonEncode()`.
+- **Status Validation:** Treat `200 OK` (GET/PUT/DELETE) and `201 CREATED` (POST) as success.
+- **Error Handling:** Throw explicit exceptions on non-success codes. Never return `null`.
+- **Deserialization:** `jsonDecode(response.body)` then map to model's `fromJson`.
+
+## Background Parsing
+
+For large payloads (>16ms parse time), use `compute()` from `package:flutter/foundation.dart` to parse in a background isolate. The parsing function must be top-level or static.
+
+## Workflow: Executing Network Operations
+
+**Task Progress:**
+
+- [ ] 1. Define strongly typed Dart model with `fromJson`.
+- [ ] 2. Implement network request method returning `Future<Model>`.
+- [ ] 3. Apply conditional logic:
+  - **GET**: Append query parameters to URI.
+  - **POST/PUT**: Set `Content-Type: application/json; charset=UTF-8`, attach `jsonEncode` body.
+  - **DELETE**: Return empty model instance on success.
+- [ ] 4. Validate `statusCode` and throw `Exception` on failure.
+- [ ] 5. Integrate into UI using `FutureBuilder`.
+- [ ] 6. Handle `snapshot.hasData`, `snapshot.hasError`, default to `CircularProgressIndicator`.
+- [ ] 7. Run app -> trigger request -> review console for exceptions -> fix.
+
+## Examples
+
+### Fetching and Parsing in the Background
+
+```dart
+import 'dart:convert';
+import 'dart:io';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+
+List<Photo> parsePhotos(String responseBody) {
+  final parsed = (jsonDecode(responseBody) as List<Object?>)
+      .cast<Map<String, Object?>>();
+  return parsed.map<Photo>(Photo.fromJson).toList();
+}
+
+Future<List<Photo>> fetchPhotos() async {
+  final response = await http.get(
+    Uri.parse('https://jsonplaceholder.typicode.com/photos'),
+    headers: {
+      HttpHeaders.authorizationHeader: 'Bearer your_token_here',
+      HttpHeaders.acceptHeader: 'application/json',
+    },
+  );
+
+  if (response.statusCode == 200) {
+    return compute(parsePhotos, response.body);
+  } else {
+    throw Exception('Failed to load photos. Status: ${response.statusCode}');
+  }
+}
+
+class Photo {
+  final int id;
+  final String title;
+  final String thumbnailUrl;
+
+  const Photo({required this.id, required this.title, required this.thumbnailUrl});
+
+  factory Photo.fromJson(Map<String, dynamic> json) {
+    return Photo(
+      id: json['id'] as int,
+      title: json['title'] as String,
+      thumbnailUrl: json['thumbnailUrl'] as String,
+    );
+  }
+}
+
+class PhotoGallery extends StatefulWidget {
+  const PhotoGallery({super.key});
+  @override
+  State<PhotoGallery> createState() => _PhotoGalleryState();
+}
+
+class _PhotoGalleryState extends State<PhotoGallery> {
+  late Future<List<Photo>> _futurePhotos;
+
+  @override
+  void initState() {
+    super.initState();
+    _futurePhotos = fetchPhotos();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return FutureBuilder<List<Photo>>(
+      future: _futurePhotos,
+      builder: (context, snapshot) {
+        if (snapshot.hasData) {
+          final photos = snapshot.data!;
+          return ListView.builder(
+            itemCount: photos.length,
+            itemBuilder: (context, index) => ListTile(
+              leading: Image.network(photos[index].thumbnailUrl),
+              title: Text(photos[index].title),
+            ),
+          );
+        } else if (snapshot.hasError) {
+          return Center(child: Text('Error: ${snapshot.error}'));
+        }
+        return const Center(child: CircularProgressIndicator());
+      },
+    );
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+Monitor and debug HTTP calls in the running app:
+
+- `mcp__plugin_flutter_flutter-ultra-runtime__start_http_capture` — Start capturing HTTP traffic
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_http_events` — View captured HTTP requests and responses
+- `mcp__plugin_flutter_flutter-ultra-runtime__stop_http_capture` — Stop HTTP capture
+- `mcp__plugin_flutter_flutter-ultra-runtime__get_runtime_errors` — Check for unhandled HTTP exceptions
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.