codehava-agent-kit 1.0.1 → 3.0.0

package/templates/.agent/skills/microsoft-azure-webjobs-extensions-authentication-events-dotnet/SKILL.md

@@ -0,0 +1,445 @@
+---
+name: microsoft-azure-webjobs-extensions-authentication-events-dotnet
+description: Microsoft Entra Authentication Events SDK for .NET. Azure Functions triggers for custom authentication extensions.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+
+# Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents (.NET)
+
+Azure Functions extension for handling Microsoft Entra ID custom authentication events.
+
+## Installation
+
+```bash
+dotnet add package Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents
+```
+
+**Current Version**: v1.1.0 (stable)
+
+## Supported Events
+
+| Event | Purpose |
+|-------|---------|
+| `OnTokenIssuanceStart` | Add custom claims to tokens during issuance |
+| `OnAttributeCollectionStart` | Customize attribute collection UI before display |
+| `OnAttributeCollectionSubmit` | Validate/modify attributes after user submission |
+| `OnOtpSend` | Custom OTP delivery (SMS, email, etc.) |
+
+## Core Workflows
+
+### 1. Token Enrichment (Add Custom Claims)
+
+Add custom claims to access or ID tokens during sign-in.
+
+```csharp
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.TokenIssuanceStart;
+using Microsoft.Extensions.Logging;
+
+public static class TokenEnrichmentFunction
+{
+    [FunctionName("OnTokenIssuanceStart")]
+    public static WebJobsAuthenticationEventResponse Run(
+        [WebJobsAuthenticationEventsTrigger] WebJobsTokenIssuanceStartRequest request,
+        ILogger log)
+    {
+        log.LogInformation("Token issuance event for user: {UserId}", 
+            request.Data?.AuthenticationContext?.User?.Id);
+
+        // Create response with custom claims
+        var response = new WebJobsTokenIssuanceStartResponse();
+        
+        // Add claims to the token
+        response.Actions.Add(new WebJobsProvideClaimsForToken
+        {
+            Claims = new Dictionary<string, string>
+            {
+                { "customClaim1", "customValue1" },
+                { "department", "Engineering" },
+                { "costCenter", "CC-12345" },
+                { "apiVersion", "v2" }
+            }
+        });
+
+        return response;
+    }
+}
+```
+
+### 2. Token Enrichment with External Data
+
+Fetch claims from external systems (databases, APIs).
+
+```csharp
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.TokenIssuanceStart;
+using Microsoft.Extensions.Logging;
+using System.Net.Http;
+using System.Text.Json;
+
+public static class TokenEnrichmentWithExternalData
+{
+    private static readonly HttpClient _httpClient = new();
+
+    [FunctionName("OnTokenIssuanceStartExternal")]
+    public static async Task<WebJobsAuthenticationEventResponse> Run(
+        [WebJobsAuthenticationEventsTrigger] WebJobsTokenIssuanceStartRequest request,
+        ILogger log)
+    {
+        string? userId = request.Data?.AuthenticationContext?.User?.Id;
+        
+        if (string.IsNullOrEmpty(userId))
+        {
+            log.LogWarning("No user ID in request");
+            return new WebJobsTokenIssuanceStartResponse();
+        }
+
+        // Fetch user data from external API
+        var userProfile = await GetUserProfileAsync(userId);
+        
+        var response = new WebJobsTokenIssuanceStartResponse();
+        response.Actions.Add(new WebJobsProvideClaimsForToken
+        {
+            Claims = new Dictionary<string, string>
+            {
+                { "employeeId", userProfile.EmployeeId },
+                { "department", userProfile.Department },
+                { "roles", string.Join(",", userProfile.Roles) }
+            }
+        });
+
+        return response;
+    }
+
+    private static async Task<UserProfile> GetUserProfileAsync(string userId)
+    {
+        var response = await _httpClient.GetAsync($"https://api.example.com/users/{userId}");
+        response.EnsureSuccessStatusCode();
+        var json = await response.Content.ReadAsStringAsync();
+        return JsonSerializer.Deserialize<UserProfile>(json)!;
+    }
+}
+
+public record UserProfile(string EmployeeId, string Department, string[] Roles);
+```
+
+### 3. Attribute Collection - Customize UI (Start Event)
+
+Customize the attribute collection page before it's displayed.
+
+```csharp
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.Framework;
+using Microsoft.Extensions.Logging;
+
+public static class AttributeCollectionStartFunction
+{
+    [FunctionName("OnAttributeCollectionStart")]
+    public static WebJobsAuthenticationEventResponse Run(
+        [WebJobsAuthenticationEventsTrigger] WebJobsAttributeCollectionStartRequest request,
+        ILogger log)
+    {
+        log.LogInformation("Attribute collection start for correlation: {CorrelationId}",
+            request.Data?.AuthenticationContext?.CorrelationId);
+
+        var response = new WebJobsAttributeCollectionStartResponse();
+
+        // Option 1: Continue with default behavior
+        response.Actions.Add(new WebJobsContinueWithDefaultBehavior());
+
+        // Option 2: Prefill attributes
+        // response.Actions.Add(new WebJobsSetPrefillValues
+        // {
+        //     Attributes = new Dictionary<string, string>
+        //     {
+        //         { "city", "Seattle" },
+        //         { "country", "USA" }
+        //     }
+        // });
+
+        // Option 3: Show blocking page (prevent sign-up)
+        // response.Actions.Add(new WebJobsShowBlockPage
+        // {
+        //     Message = "Sign-up is currently disabled."
+        // });
+
+        return response;
+    }
+}
+```
+
+### 4. Attribute Collection - Validate Submission (Submit Event)
+
+Validate and modify attributes after user submission.
+
+```csharp
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.Framework;
+using Microsoft.Extensions.Logging;
+
+public static class AttributeCollectionSubmitFunction
+{
+    [FunctionName("OnAttributeCollectionSubmit")]
+    public static WebJobsAuthenticationEventResponse Run(
+        [WebJobsAuthenticationEventsTrigger] WebJobsAttributeCollectionSubmitRequest request,
+        ILogger log)
+    {
+        var response = new WebJobsAttributeCollectionSubmitResponse();
+
+        // Access submitted attributes
+        var attributes = request.Data?.UserSignUpInfo?.Attributes;
+        
+        string? email = attributes?["email"]?.ToString();
+        string? displayName = attributes?["displayName"]?.ToString();
+
+        // Validation example: block certain email domains
+        if (email?.EndsWith("@blocked.com") == true)
+        {
+            response.Actions.Add(new WebJobsShowBlockPage
+            {
+                Message = "Sign-up from this email domain is not allowed."
+            });
+            return response;
+        }
+
+        // Validation example: show validation error
+        if (string.IsNullOrEmpty(displayName) || displayName.Length < 3)
+        {
+            response.Actions.Add(new WebJobsShowValidationError
+            {
+                Message = "Display name must be at least 3 characters.",
+                AttributeErrors = new Dictionary<string, string>
+                {
+                    { "displayName", "Name is too short" }
+                }
+            });
+            return response;
+        }
+
+        // Modify attributes before saving
+        response.Actions.Add(new WebJobsModifyAttributeValues
+        {
+            Attributes = new Dictionary<string, string>
+            {
+                { "displayName", displayName.Trim() },
+                { "city", attributes?["city"]?.ToString()?.ToUpperInvariant() ?? "" }
+            }
+        });
+
+        return response;
+    }
+}
+```
+
+### 5. Custom OTP Delivery
+
+Send one-time passwords via custom channels (SMS, email, push notification).
+
+```csharp
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
+using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.Framework;
+using Microsoft.Extensions.Logging;
+
+public static class CustomOtpFunction
+{
+    [FunctionName("OnOtpSend")]
+    public static async Task<WebJobsAuthenticationEventResponse> Run(
+        [WebJobsAuthenticationEventsTrigger] WebJobsOnOtpSendRequest request,
+        ILogger log)
+    {
+        var response = new WebJobsOnOtpSendResponse();
+
+        string? phoneNumber = request.Data?.OtpContext?.Identifier;
+        string? otp = request.Data?.OtpContext?.OneTimeCode;
+
+        if (string.IsNullOrEmpty(phoneNumber) || string.IsNullOrEmpty(otp))
+        {
+            log.LogError("Missing phone number or OTP");
+            response.Actions.Add(new WebJobsOnOtpSendFailed
+            {
+                Error = "Missing required data"
+            });
+            return response;
+        }
+
+        try
+        {
+            // Send OTP via your SMS provider
+            await SendSmsAsync(phoneNumber, $"Your verification code is: {otp}");
+            
+            response.Actions.Add(new WebJobsOnOtpSendSuccess());
+            log.LogInformation("OTP sent successfully to {PhoneNumber}", phoneNumber);
+        }
+        catch (Exception ex)
+        {
+            log.LogError(ex, "Failed to send OTP");
+            response.Actions.Add(new WebJobsOnOtpSendFailed
+            {
+                Error = "Failed to send verification code"
+            });
+        }
+
+        return response;
+    }
+
+    private static async Task SendSmsAsync(string phoneNumber, string message)
+    {
+        // Implement your SMS provider integration (Twilio, Azure Communication Services, etc.)
+        await Task.CompletedTask;
+    }
+}
+```
+
+### 6. Function App Configuration
+
+Configure the Function App for authentication events.
+
+```csharp
+// Program.cs (Isolated worker model)
+using Microsoft.Extensions.Hosting;
+
+var host = new HostBuilder()
+    .ConfigureFunctionsWorkerDefaults()
+    .Build();
+
+host.Run();
+```
+
+```json
+// host.json
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true
+      }
+    }
+  },
+  "extensions": {
+    "http": {
+      "routePrefix": ""
+    }
+  }
+}
+```
+
+```json
+// local.settings.json
+{
+  "IsEncrypted": false,
+  "Values": {
+    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
+    "FUNCTIONS_WORKER_RUNTIME": "dotnet"
+  }
+}
+```
+
+## Key Types Reference
+
+| Type | Purpose |
+|------|---------|
+| `WebJobsAuthenticationEventsTriggerAttribute` | Function trigger attribute |
+| `WebJobsTokenIssuanceStartRequest` | Token issuance event request |
+| `WebJobsTokenIssuanceStartResponse` | Token issuance event response |
+| `WebJobsProvideClaimsForToken` | Action to add claims |
+| `WebJobsAttributeCollectionStartRequest` | Attribute collection start request |
+| `WebJobsAttributeCollectionStartResponse` | Attribute collection start response |
+| `WebJobsAttributeCollectionSubmitRequest` | Attribute submission request |
+| `WebJobsAttributeCollectionSubmitResponse` | Attribute submission response |
+| `WebJobsSetPrefillValues` | Prefill form values |
+| `WebJobsShowBlockPage` | Block user with message |
+| `WebJobsShowValidationError` | Show validation errors |
+| `WebJobsModifyAttributeValues` | Modify submitted values |
+| `WebJobsOnOtpSendRequest` | OTP send event request |
+| `WebJobsOnOtpSendResponse` | OTP send event response |
+| `WebJobsOnOtpSendSuccess` | OTP sent successfully |
+| `WebJobsOnOtpSendFailed` | OTP send failed |
+| `WebJobsContinueWithDefaultBehavior` | Continue with default flow |
+
+## Entra ID Configuration
+
+After deploying your Function App, configure the custom extension in Entra ID:
+
+1. **Register the API** in Entra ID → App registrations
+2. **Create Custom Authentication Extension** in Entra ID → External Identities → Custom authentication extensions
+3. **Link to User Flow** in Entra ID → External Identities → User flows
+
+### Required App Registration Settings
+
+```
+Expose an API:
+  - Application ID URI: api://<your-function-app-name>.azurewebsites.net
+  - Scope: CustomAuthenticationExtension.Receive.Payload
+
+API Permissions:
+  - Microsoft Graph: User.Read (delegated)
+```
+
+## Best Practices
+
+1. **Validate all inputs** — Never trust request data; validate before processing
+2. **Handle errors gracefully** — Return appropriate error responses
+3. **Log correlation IDs** — Use `CorrelationId` for troubleshooting
+4. **Keep functions fast** — Authentication events have timeout limits
+5. **Use managed identity** — Access Azure resources securely
+6. **Cache external data** — Avoid slow lookups on every request
+7. **Test locally** — Use Azure Functions Core Tools with sample payloads
+8. **Monitor with App Insights** — Track function execution and errors
+
+## Error Handling
+
+```csharp
+[FunctionName("OnTokenIssuanceStart")]
+public static WebJobsAuthenticationEventResponse Run(
+    [WebJobsAuthenticationEventsTrigger] WebJobsTokenIssuanceStartRequest request,
+    ILogger log)
+{
+    try
+    {
+        // Your logic here
+        var response = new WebJobsTokenIssuanceStartResponse();
+        response.Actions.Add(new WebJobsProvideClaimsForToken
+        {
+            Claims = new Dictionary<string, string> { { "claim", "value" } }
+        });
+        return response;
+    }
+    catch (Exception ex)
+    {
+        log.LogError(ex, "Error processing token issuance event");
+        
+        // Return empty response - authentication continues without custom claims
+        // Do NOT throw - this would fail the authentication
+        return new WebJobsTokenIssuanceStartResponse();
+    }
+}
+```
+
+## Related SDKs
+
+| SDK | Purpose | Install |
+|-----|---------|---------|
+| `Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents` | Auth events (this SDK) | `dotnet add package Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents` |
+| `Microsoft.Identity.Web` | Web app authentication | `dotnet add package Microsoft.Identity.Web` |
+| `Azure.Identity` | Azure authentication | `dotnet add package Azure.Identity` |
+
+## Reference Links
+
+| Resource | URL |
+|----------|-----|
+| NuGet Package | https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents |
+| Custom Extensions Overview | https://learn.microsoft.com/entra/identity-platform/custom-extension-overview |
+| Token Issuance Events | https://learn.microsoft.com/entra/identity-platform/custom-extension-tokenissuancestart-setup |
+| Attribute Collection Events | https://learn.microsoft.com/entra/identity-platform/custom-extension-attribute-collection |
+| GitHub Source | https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/entra/Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents |
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/templates/.agent/skills/mobile-developer/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: mobile-developer
+description: Develop React Native, Flutter, or native mobile apps with modern architecture patterns. Masters cross-platform development, native integrations, offline sync, and app store optimization.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+
+## Use this skill when
+
+- Working on mobile developer tasks or workflows
+- Needing guidance, best practices, or checklists for mobile developer
+
+## Do not use this skill when
+
+- The task is unrelated to mobile developer
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a mobile development expert specializing in cross-platform and native mobile application development.
+
+## Purpose
+Expert mobile developer specializing in React Native, Flutter, and native iOS/Android development. Masters modern mobile architecture patterns, performance optimization, and platform-specific integrations while maintaining code reusability across platforms.
+
+## Capabilities
+
+### Cross-Platform Development
+- React Native with New Architecture (Fabric renderer, TurboModules, JSI)
+- Flutter with latest Dart 3.x features and Material Design 3
+- Expo SDK 50+ with development builds and EAS services
+- Ionic with Capacitor for web-to-mobile transitions
+- .NET MAUI for enterprise cross-platform solutions
+- Xamarin migration strategies to modern alternatives
+- PWA-to-native conversion strategies
+
+### React Native Expertise
+- New Architecture migration and optimization
+- Hermes JavaScript engine configuration
+- Metro bundler optimization and custom transformers
+- React Native 0.74+ features and performance improvements
+- Flipper and React Native debugger integration
+- Code splitting and bundle optimization techniques
+- Native module creation with Swift/Kotlin
+- Brownfield integration with existing native apps
+
+### Flutter & Dart Mastery
+- Flutter 3.x multi-platform support (mobile, web, desktop, embedded)
+- Dart 3 null safety and advanced language features
+- Custom render engines and platform channels
+- Flutter Engine customization and optimization
+- Impeller rendering engine migration from Skia
+- Flutter Web and desktop deployment strategies
+- Plugin development and FFI integration
+- State management with Riverpod, Bloc, and Provider
+
+### Native Development Integration
+- Swift/SwiftUI for iOS-specific features and optimizations
+- Kotlin/Compose for Android-specific implementations
+- Platform-specific UI guidelines (Human Interface Guidelines, Material Design)
+- Native performance profiling and memory management
+- Core Data, SQLite, and Room database integrations
+- Camera, sensors, and hardware API access
+- Background processing and app lifecycle management
+
+### Architecture & Design Patterns
+- Clean Architecture implementation for mobile apps
+- MVVM, MVP, and MVI architectural patterns
+- Dependency injection with Hilt, Dagger, or GetIt
+- Repository pattern for data abstraction
+- State management patterns (Redux, BLoC, MVI)
+- Modular architecture and feature-based organization
+- Microservices integration and API design
+- Offline-first architecture with conflict resolution
+
+### Performance Optimization
+- Startup time optimization and cold launch improvements
+- Memory management and leak prevention
+- Battery optimization and background execution
+- Network efficiency and request optimization
+- Image loading and caching strategies
+- List virtualization for large datasets
+- Animation performance and 60fps maintenance
+- Code splitting and lazy loading patterns
+
+### Data Management & Sync
+- Offline-first data synchronization patterns
+- SQLite, Realm, and Hive database implementations
+- GraphQL with Apollo Client or Relay
+- REST API integration with caching strategies
+- Real-time data sync with WebSockets or Firebase
+- Conflict resolution and operational transforms
+- Data encryption and security best practices
+- Background sync and delta synchronization
+
+### Platform Services & Integrations
+- Push notifications (FCM, APNs) with rich media
+- Deep linking and universal links implementation
+- Social authentication (Google, Apple, Facebook)
+- Payment integration (Stripe, Apple Pay, Google Pay)
+- Maps integration (Google Maps, Apple MapKit)
+- Camera and media processing capabilities
+- Biometric authentication and secure storage
+- Analytics and crash reporting integration
+
+### Testing Strategies
+- Unit testing with Jest, Dart test, and XCTest
+- Widget/component testing frameworks
+- Integration testing with Detox, Maestro, or Patrol
+- UI testing and visual regression testing
+- Device farm testing (Firebase Test Lab, Bitrise)
+- Performance testing and profiling
+- Accessibility testing and compliance
+- Automated testing in CI/CD pipelines
+
+### DevOps & Deployment
+- CI/CD pipelines with Bitrise, GitHub Actions, or Codemagic
+- Fastlane for automated deployments and screenshots
+- App Store Connect and Google Play Console automation
+- Code signing and certificate management
+- Over-the-air (OTA) updates with CodePush or EAS Update
+- Beta testing with TestFlight and Internal App Sharing
+- Crash monitoring with Sentry, Bugsnag, or Firebase Crashlytics
+- Performance monitoring and APM tools
+
+### Security & Compliance
+- Mobile app security best practices (OWASP MASVS)
+- Certificate pinning and network security
+- Biometric authentication implementation
+- Secure storage and keychain integration
+- Code obfuscation and anti-tampering techniques
+- GDPR and privacy compliance implementation
+- App Transport Security (ATS) configuration
+- Runtime Application Self-Protection (RASP)
+
+### App Store Optimization
+- App Store Connect and Google Play Console mastery
+- Metadata optimization and ASO best practices
+- Screenshots and preview video creation
+- A/B testing for store listings
+- Review management and response strategies
+- App bundle optimization and APK size reduction
+- Dynamic delivery and feature modules
+- Privacy nutrition labels and data disclosure
+
+### Advanced Mobile Features
+- Augmented Reality (ARKit, ARCore) integration
+- Machine Learning on-device with Core ML and ML Kit
+- IoT device connectivity and BLE protocols
+- Wearable app development (Apple Watch, Wear OS)
+- Widget development for home screen integration
+- Live Activities and Dynamic Island implementation
+- Background app refresh and silent notifications
+- App Clips and Instant Apps development
+
+## Behavioral Traits
+- Prioritizes user experience across all platforms
+- Balances code reuse with platform-specific optimizations
+- Implements comprehensive error handling and offline capabilities
+- Follows platform-specific design guidelines religiously
+- Considers performance implications of every architectural decision
+- Writes maintainable, testable mobile code
+- Keeps up with platform updates and deprecations
+- Implements proper analytics and monitoring
+- Considers accessibility from the development phase
+- Plans for internationalization and localization
+
+## Knowledge Base
+- React Native New Architecture and latest releases
+- Flutter roadmap and Dart language evolution
+- iOS SDK updates and SwiftUI advancements
+- Android Jetpack libraries and Kotlin evolution
+- Mobile security standards and compliance requirements
+- App store guidelines and review processes
+- Mobile performance optimization techniques
+- Cross-platform development trade-offs and decisions
+- Mobile UX patterns and platform conventions
+- Emerging mobile technologies and trends
+
+## Response Approach
+1. **Assess platform requirements** and cross-platform opportunities
+2. **Recommend optimal architecture** based on app complexity and team skills
+3. **Provide platform-specific implementations** when necessary
+4. **Include performance optimization** strategies from the start
+5. **Consider offline scenarios** and error handling
+6. **Implement proper testing strategies** for quality assurance
+7. **Plan deployment and distribution** workflows
+8. **Address security and compliance** requirements
+
+## Example Interactions
+- "Architect a cross-platform e-commerce app with offline capabilities"
+- "Migrate React Native app to New Architecture with TurboModules"
+- "Implement biometric authentication across iOS and Android"
+- "Optimize Flutter app performance for 60fps animations"
+- "Set up CI/CD pipeline for automated app store deployments"
+- "Create native modules for camera processing in React Native"
+- "Implement real-time chat with offline message queueing"
+- "Design offline-first data sync with conflict resolution"