Specif-ai MCP Server

{ "features": [ { "id": "US1", "name": "Manage All Integration Settings", "description": "Ability to configure, connect, and manage all linked integrations. In order to customize and control external app connections easily. As a user interested in sharing activity, I want the ability to connect, disconnect, and configure all connected services from a centralized interface. Acceptance Criteria: The interface must include a centralized 'Integration Settings' screen accessible via navigation. Each integration (e.g., Spotify, YouTube, Games) must be displayed with options to connect or disconnect. Include toggles to enable or disable specific aspects of sharing (e.g., activity visibility). Show confirmation modals to finalize disconnect actions. Provide error notifications and troubleshooting options if connection or disconnection fails.", "tasks": [ { "list": "Create centralized 'Integration Settings' screen UI", "acceptance": "Develop a React component named 'IntegrationSettings'. The component must render a centralized interface listing all integrations (e.g., Spotify, YouTube, Games). The list should include 'Connect' or 'Disconnect' buttons for each integration. Acceptance Criteria: The UI must match the provided mockup/design (if available). Each integration is displayed as a separate item with appropriate action buttons.", "id": "TASK1" }, { "list": "Implement React toggles for enabling/disabling sharing settings", "acceptance": "Add toggle components in the 'IntegrationSettings' UI, allowing users to enable or disable specific sharing options like 'activity visibility'. The toggles must display their current state and trigger events on change. Acceptance Criteria: Each integration item must include its respective toggles. Toggling a setting must correctly emit an event for backend data persistence.", "id": "TASK2" }, { "list": "Add confirmation modal for disconnect actions", "acceptance": "Integrate a React modal component triggered when a user clicks the 'Disconnect' button for an integration. The modal must confirm the action (e.g., 'Are you sure you want to disconnect Spotify?'). The confirmation modal must include 'Confirm' and 'Cancel' actions. Acceptance Criteria: Disconnect actions must display a modal before the action proceeds. Selecting 'Cancel' must dismiss the modal, while selecting 'Confirm' must trigger the backend API call.", "id": "TASK3" }, { "list": "Create Golang API endpoint to connect an integration", "acceptance": "Develop a backend API endpoint in Golang named '/integrations/connect'. The endpoint should accept a POST request with the integration identifier in the JSON body (e.g., integration_id). It must handle connection logic and return a success or failure response in JSON format. Acceptance Criteria: The API must validate the integration_id, persist the connection to the database, and return a 200 status code when successful, or a 400/500 status code with an error message upon failure.", "id": "TASK4" }, { "list": "Create Golang API endpoint to disconnect an integration", "acceptance": "Develop a backend API endpoint in Golang named '/integrations/disconnect'. The endpoint should accept a POST request with the integration identifier in the JSON body. It must handle disconnection logic and return a success or failure response in JSON format. Acceptance Criteria: The API must validate the integration_id, remove the connection from the database, and return a 200 status code when successful, or a 400/500 status code with an error message upon failure.", "id": "TASK5" }, { "list": "Implement Golang backend logic for updating sharing settings", "acceptance": "Develop a PUT API endpoint named '/integrations/settings' in Golang. The endpoint must update specific sharing preferences (e.g., activity visibility) for a particular integration. It should accept a JSON request with integration_id and updated settings. Acceptance Criteria: The API must validate inputs, persist the updated settings in the database, and return a 200 status code when successful, or a 400/500 status code with an error message upon failure.", "id": "TASK6" }, { "list": "Display error notifications in UI for API failures", "acceptance": "Add error handling logic to display notifications in the 'IntegrationSettings' UI when API calls fail (e.g., connection issues or invalid inputs). The messages must inform users of the issue and suggest retry or troubleshooting actions. Acceptance Criteria: Error notifications must be prominently displayed on the screen and match design guidelines. Notifications must trigger upon API failure and clear when retrying.", "id": "TASK7" }, { "list": "Integrate backend API with frontend connect/disconnect buttons", "acceptance": "Implement API integration in the React 'IntegrationSettings' component for 'Connect' and 'Disconnect' actions. Ensure proper error handling and UI updates based on API responses. Acceptance Criteria: Clicking 'Connect' or 'Disconnect' must trigger their respective API calls. Success must update the UI state to reflect the new connection status. Errors must display notifications.", "id": "TASK8" }, { "list": "Persist integration settings to AWS backend", "acceptance": "Ensure all integration settings (connection status, sharing preferences) persist in an AWS-hosted database. Implement database interactions in Golang APIs using AWS SDK or ORM. Acceptance Criteria: All integrations and their settings must be stored in the AWS backend in real-time on updates. Data consistency must be maintained during concurrent requests or errors.", "id": "TASK9" }, { "list": "Provide troubleshooting options for connection failures", "acceptance": "Add specific error messages and troubleshooting hints in the React UI for common connection issues (e.g., invalid API keys, network issues). Define error codes in Golang APIs and map them to clear UI messages. Acceptance Criteria: Users must see relevant and actionable troubleshooting tips when an API error occurs, with guidance to resolve common problems.", "id": "TASK10" } ] }, { "id": "US2", "name": "Activity Sharing for Spotify Integration", "description": "Ability to link and share Spotify activity. In order to showcase music being played in real time, as a Spotify user, I want my active listening session (e.g., current track and album art) to be shared and updated dynamically. Acceptance Criteria: Users can authenticate their Spotify account via the integrations screen. Include a toggle to enable or disable Spotify activity sharing. Display the current track, artist, and album art when sharing is enabled. Ensure activity updates are responsive but system-efficient. Handle errors like expired tokens with re-authentication prompts, and disable sharing temporarily if a failure occurs.", "tasks": [ { "list": "Create Spotify authentication endpoint in backend", "acceptance": "Implement a backend API endpoint in Golang to handle Spotify account authentication via OAuth. The endpoint must redirect users to the Spotify authentication URL and handle the OAuth callback to exchange the authorization code for an access token. Acceptance Criteria: The endpoint must store the received refresh token securely and return a success response to the frontend. Handle invalid or missing callback parameters with proper error handling.", "id": "TASK1" }, { "list": "Add integration toggle for Spotify in the frontend", "acceptance": "Implement a toggle UI component in React within the integrations screen. The toggle must allow users to enable or disable Spotify activity sharing. Acceptance Criteria: The toggle state must update based on user interaction and persist the state to the backend via an API call. Verify the toggle state fetches correctly when navigating back to the integrations screen.", "id": "TASK2" }, { "list": "Develop API endpoint to enable/disable Spotify activity sharing", "acceptance": "Implement a backend API endpoint in Golang to persist the user's sharing preferences (enabled or disabled). Acceptance Criteria: The endpoint must accept the toggle state (enabled/disabled) from the frontend, validate input, update the user's preferences in storage, and return a success response. Handle invalid data or storage failures with proper error responses.", "id": "TASK3" }, { "list": "Fetch and display currently playing track from Spotify API", "acceptance": "Implement a backend API endpoint in Golang to fetch the current track details (track name, artist, album art) of the authenticated user from Spotify's API. Acceptance Criteria: The endpoint must query Spotify's API using the stored access token, parse the response to extract the required fields, and return it to the frontend in JSON. Include token expiration validation and re-authentication prompts on failure.", "id": "TASK4" }, { "list": "Create UI component to display current track details", "acceptance": "Implement a React UI component to display the current track's name, artist, and album art dynamically when sharing is enabled. Acceptance Criteria: The component must pull data periodically from the backend and render changes without page refresh. Ensure error states such as 'No track playing' or API failure are displayed appropriately.", "id": "TASK5" }, { "list": "Implement backend logic for token refresh on expiration", "acceptance": "Incorporate token management logic in the backend API that automatically refreshes the Spotify access token upon expiration using the stored refresh token. Acceptance Criteria: The token refresh process must update the token storage, retry any ongoing fetch requests with the new token, and return an appropriate error if the refresh fails.", "id": "TASK6" }, { "list": "Optimize real-time Spotify activity updates in frontend", "acceptance": "Add a polling mechanism in the React frontend to periodically fetch the current track data from the backend only when Spotify sharing is enabled. Acceptance Criteria: Ensure updates happen dynamically while minimizing API calls (e.g., every 10 seconds). Stop polling when sharing is disabled or when the user navigates away from the UI.", "id": "TASK7" }, { "list": "Handle temporary disabling of Spotify sharing on backend errors", "acceptance": "Update the backend to detect errors (e.g., expired tokens, unreachable Spotify API), log them, and temporarily mark the sharing state as disabled. Acceptance Criteria: Ensure sharing remains disabled until the user re-authenticates, with appropriate error messages logged. Return the updated sharing state to the frontend via API.", "id": "TASK8" }, { "list": "Add error prompts and re-authentication flow in frontend", "acceptance": "Implement error handling in the React UI to notify users when sharing fails due to authentication errors. Provide an option to re-authenticate their Spotify account from the integrations screen. Acceptance Criteria: Ensure accurate detection of backend errors and seamless redirection to the Spotify OAuth flow upon re-authentication.", "id": "TASK9" }, { "list": "Write feature-specific unit tests and integration tests", "acceptance": "Develop unit tests in Golang for all backend API endpoints (authentication, fetch current track, toggle sharing) and React tests for UI components (toggle, current track display). Write integration tests to validate the end-to-end flow of Spotify activity sharing. Acceptance Criteria: Tests must cover all acceptance criteria, including error handling, edge cases, and correct API/Spotify integration functionality.", "id": "TASK10" } ] }, { "id": "US3", "name": "Activity Sharing for YouTube Integration", "description": "Ability to link and share YouTube activity. In order to highlight videos being watched or shared, as a YouTube user, I want my current video activity (e.g., 'watching now') to be shared seamlessly with privacy safeguards. Acceptance Criteria: Users can securely connect their YouTube account via OAuth from the integrations screen. Provide toggles to enable or disable 'watching now' and video link sharing. Hide private or restricted content during visibility sharing. Provide feedback notifications when a video link is successfully shared. Ensure error handling includes relevant notifications for OAuth failures and allow for account re-authentication.", "tasks": [ { "list": "Implement OAuth account connection for YouTube integration", "acceptance": "Create a new backend handler in Golang to initiate the OAuth flow for connecting a YouTube account from the integrations screen. Ensure the OAuth handler successfully exchanges authorization codes for access tokens and securely stores the tokens encrypted in AWS. Return relevant success and failure responses. Error scenarios must include handling invalid authorization codes, revoked tokens, and token expiration. Acceptance Criteria: 1. Users can initiate and complete OAuth connection with valid credentials. 2. Stored access tokens are encrypted and retrievable for secure API usage. 3. Error handling includes invalid tokens, revoked access, and expiration scenarios with appropriate error messages.", "id": "TASK1" }, { "list": "Create frontend React component for YouTube account connection", "acceptance": "Build a React component for the integrations screen, including a 'Connect YouTube' button. On click, initiate the OAuth flow and display visual feedback (e.g., loading spinner). Handle OAuth success and failure states by displaying user-friendly notifications. Acceptance Criteria: 1. A 'Connect YouTube' button is visible on the integrations screen. 2. Successful connections display a success notification. 3. Failures (invalid credentials, revoked tokens, etc.) render user-friendly error notifications.", "id": "TASK2" }, { "list": "Create backend API to enable/disable sharing toggles", "acceptance": "Develop a Golang API endpoint to update user preferences for 'watching now' and video link sharing toggles. Persist the toggle state securely in AWS. Ensure the endpoint includes input validation and returns success or failure responses based on the update outcome. Acceptance Criteria: 1. Backend API can update toggle state for 'watching now' and video link sharing preferences. 2. Input validation ensures valid state values (e.g., true/false). 3. Error handling includes invalid inputs or database errors, with relevant response codes and messages.", "id": "TASK3" }, { "list": "Develop frontend React component for sharing toggles", "acceptance": "Implement React toggle components in the integrations screen to enable or disable 'watching now' and video link sharing functionalities. Synchronize state with the backend API. Visual feedback should reflect toggle state and include error or success notifications for API updates. Acceptance Criteria: 1. Two independent toggle components are available on the integrations screen for 'watching now' and video link sharing. 2. Toggle changes are persisted by calling the backend API. 3. Success/failure notifications display based on responses from the API.", "id": "TASK4" }, { "list": "Implement video activity sharing logic with privacy safeguards", "acceptance": "Add Golang business logic to query the YouTube API and retrieve 'watching now' video activity for authenticated users. Filter results to exclude private or restricted content. Format and return safe data structures for further processing. Acceptance Criteria: 1. The backend can retrieve 'watching now' video activity for authenticated users via the YouTube API. 2. Query logic excludes private or restricted content. 3. Returned data includes video title, URL, and other safe-to-share metadata as per YouTube API response.", "id": "TASK5" }, { "list": "Develop API for sharing video links with feedback notifications", "acceptance": "Create a Golang API endpoint to share video links retrieved from 'watching now' activity. On a successful share, return a success notification response. Implement appropriate error handling, including scenarios like invalid video links or backend service errors. Acceptance Criteria: 1. Video links can be shared by authenticated users via the API. 2. Success responses include relevant notifications (e.g., 'Video shared successfully'). 3. Error handling includes invalid video links or service failures with descriptive error messages.", "id": "TASK6" }, { "list": "Provide frontend visual feedback for shared video links", "acceptance": "Update the UI to display notification messages when a video link is shared successfully or share fails due to an error. Notifications must clearly distinguish success from failure scenarios. Acceptance Criteria: 1. Notifications are displayed after video-sharing actions indicating success or failure. 2. Success messages clearly state when a video link is shared. 3. Error notifications clearly describe failure reasons (e.g., invalid link).", "id": "TASK7" }, { "list": "Implement error handling and re-authentication for OAuth failures", "acceptance": "Add backend functionality to handle OAuth-related failures, including token revocation, expiration, and invalid authorization codes. Implement a Golang endpoint to trigger re-authentication and refresh tokens when needed. Acceptance Criteria: 1. OAuth-related errors (token revocation, expiration, invalid tokens) are handled gracefully and logged. 2. Users are prompted to re-authenticate when tokens expire or become invalid. 3. Refresh logic successfully obtains new tokens when applicable.", "id": "TASK8" }, { "list": "Write unit tests for backend APIs and sharing logic", "acceptance": "Develop unit tests for the backend APIs and core Golang logic, testing all critical functionality such as OAuth connection, toggle state updates, video sharing, and privacy checks. Coverage should include success and failure scenarios. Acceptance Criteria: 1. Unit tests provide at least 90% code coverage of backend logic. 2. Tests cover success scenarios and edge cases (e.g., invalid OAuth tokens, restricted videos). 3. Tests validate business rules such as excluding private videos or formatting proper notifications.", "id": "TASK9" }, { "list": "Write integration tests for end-to-end feature behavior", "acceptance": "Create integration tests in a suitable testing framework to validate end-to-end behavior for connecting YouTube accounts, updating toggles, sharing activity, and handling errors. Test interaction between React frontend and Golang backend. Acceptance Criteria: 1. Integration tests validate end-to-end flows, including OAuth connection, toggle updates, and video-sharing actions. 2. Tests confirm that UI updates match backend changes. 3. All specified error scenarios are replicated and verified via integration tests.", "id": "TASK10" } ] }, { "id": "US4", "name": "Integration with Gameplay Streaming Platforms", "description": "Ability to link gameplay streaming services for live broadcast sharing. In order to attract engagement during live streams, as a gamer, I want to showcase my current game and stream session in real time. Acceptance Criteria: Users can authenticate popular platforms like Twitch and YouTube Gaming. Include toggles to enable or disable live activity visibility. Display active stream details like title and game name when sharing is enabled. Provide privacy options to stop sharing instantly. Offer error notifications if the connection or live stream fails and ensure that the interface reflects the current stream's status accurately.", "tasks": [ { "list": "Create backend API for user authentication with streaming platforms (Twitch, YouTube Gaming)", "acceptance": "Implement an endpoint in Golang to authenticate users with Twitch and YouTube Gaming using OAuth2. Save the access tokens securely after successful authentication. Handle input validation to ensure valid credentials are supplied. Error scenarios: invalid credentials, expired tokens, and API unavailability. Acceptance Criteria: Users can authorize their accounts with Twitch and YouTube Gaming, and access tokens are securely stored. Errors related to authentication are propagated back to the client with descriptive error messages.", "id": "TASK1" }, { "list": "Implement UI components for connecting and authenticating streaming platforms", "acceptance": "Create React components to allow users to connect their Twitch or YouTube Gaming accounts. Include buttons for each platform that initiates OAuth2 flows. Display appropriate error messages based on backend error responses. Acceptance Criteria: User interface displays Twitch and YouTube Gaming connection options. On failed connection, user sees clearly defined error messages corresponding to the issue. Successful connections are visually represented in the UI.", "id": "TASK2" }, { "list": "Develop backend service to toggle live activity visibility", "acceptance": "Create a Golang endpoint to update and persist a user's live activity visibility status (enabled/disabled). Validate input to ensure valid toggle values are provided. Acceptance Criteria: Toggling the live activity visibility updates the user’s configuration in the backend. Invalid input is rejected with an appropriate error code. The toggle state is accurately reflected in subsequent service calls.", "id": "TASK3" }, { "list": "Implement a toggle UI component for live activity visibility", "acceptance": "Add a React toggle component to control the live activity visibility state. Sync the toggle with the backend to reflect the current state and allow updates. Provide loading and error states for the toggle action. Acceptance Criteria: Users can toggle live activity sharing using a UI component that accurately reflects the backend state. Errors in syncing the toggle with the backend are displayed to the user.", "id": "TASK4" }, { "list": "Create backend logic to retrieve and display active stream details", "acceptance": "Develop a Golang endpoint to fetch stream details from the streaming platform APIs (e.g., stream title and game name). Ensure cached or live data accuracy. Handle cases where the user is not actively streaming or API calls fail. Acceptance Criteria: Active stream details (title and game name) are fetched from Twitch/YouTube Gaming APIs and returned. Errors like 'no active stream' or failed API requests are communicated back clearly.", "id": "TASK5" }, { "list": "Build a React component to display active stream details", "acceptance": "Create a React widget to display the active stream title and game name when sharing is enabled. Ensure the widget dynamically updates and is hidden when sharing is disabled. Handle error states for missing or invalid data. Acceptance Criteria: The active stream widget accurately displays the stream title and game name, updates dynamically, and is hidden when sharing is off. Errors in fetching stream details are displayed as a user-friendly message.", "id": "TASK6" }, { "list": "Develop backend endpoint to stop sharing live activity instantly", "acceptance": "Implement a Golang endpoint that allows users to instantly stop live activity sharing. Invalidate cached metadata related to the ongoing stream when sharing is stopped. Handle input validation and error cases. Acceptance Criteria: Users can stop live activity sharing instantly, and backend metadata is updated. Errors during this process (e.g., invalid requests or server errors) are communicated to the client.", "id": "TASK7" }, { "list": "Integrate UI control to stop sharing live stream immediately", "acceptance": "Add a control button in React that stops live sharing on user interaction. Sync the state with the backend to ensure successful stopping of live visibility. Display a confirmation message or error feedback as appropriate. Acceptance Criteria: Users can successfully stop sharing live activity through a UI control, and the state is accurately synced with the backend. Errors during this process are clearly shown to the user.", "id": "TASK8" }, { "list": "Implement error notifications for stream connection or failure scenarios", "acceptance": "Develop backend logic in Golang to detect and return detailed error messages in case of connection issues or live stream failures. Define clear error codes/patterns for common issues. Acceptance Criteria: Backend provides specific error responses for issues like API call failures, invalid data, and service unavailability. Error states are consistent and descriptive.", "id": "TASK9" }, { "list": "Create UI notification system for stream errors", "acceptance": "Implement a notification system in React to show error messages when users encounter issues with stream connections or live stream actions. Display detailed messages based on backend error responses. Acceptance Criteria: Error messages from the backend are clearly displayed in the UI with appropriate context (e.g., failed API call, invalid data). Errors are user-friendly and actionable.", "id": "TASK10" }, { "list": "Reflect current stream's status in the user interface", "acceptance": "Implement a dynamic UI feature in React to display the real-time status of the user's stream (active, inactive). Use a polling mechanism or WebSocket for status updates. Handle error states for inconsistent updates. Acceptance Criteria: The current stream status is accurately displayed on the UI and automatically refreshes in real-time. Error states (e.g., timeout, data inconsistencies) are appropriately shown to the user.", "id": "TASK11" } ] }, { "id": "US5", "name": "Notify Users About Integration Activities", "description": "Ability to inform users about integration-related actions and updates. In order to stay informed of changes or errors, as a regular user of integrations, I want to receive clear notifications about connection status, content visibility, and failures. Acceptance Criteria: Notify users with updates about successful connections, sharing activities, and disconnections via in-app banners or popups. Provide immediate error notifications for failed actions or required user follow-up (e.g., resolving expired tokens). Notifications must be dismissible to avoid repetition and appear in alignment with the app's overall design aesthetics.", "tasks": [ { "list": "Create 'Notification' component in React for in-app banners or popups", "acceptance": "Implement a React component for in-app notifications. Acceptance Criteria: The component must support display of success, error, and informational messages. Notifications must appear as banners or popups as specified in the design. Ensure consistency with the app's existing design aesthetics. Notifications must include a dismiss button to allow users to close them.", "id": "TASK1" }, { "list": "Integrate notification state management using Redux", "acceptance": "Set up notification-related state management using Redux. Acceptance Criteria: Add a Redux slice for notifications with fields for type (success/error/info), message content, and visibility status. Ensure appropriate actions and reducers are implemented for adding, updating, and dismissing notifications.", "id": "TASK2" }, { "list": "Implement API endpoint in Golang to trigger notifications", "acceptance": "Develop a REST API `/notifications` endpoint in Golang to handle notification data. Acceptance Criteria: The endpoint must accept a POST request containing notification type, message, and optional metadata fields. Validate input for the presence of required fields and appropriate data types. Return proper error responses for invalid input or server issues (e.g., 400 Bad Request for missing fields, 500 Internal Server Error for unexpected failures).", "id": "TASK3" }, { "list": "Implement backend logic to notify about connection status changes", "acceptance": "Add logic in Golang to detect and handle connection status changes. Acceptance Criteria: Detect events such as successful connections, sharing activities, and disconnections. Trigger appropriate calls to the `/notifications` endpoint with relevant notification details. Include connection-specific information in the message content, if applicable.", "id": "TASK4" }, { "list": "Implement backend logic to notify about integration errors", "acceptance": "Add error-handling logic in Golang for integration failures. Acceptance Criteria: Detect errors such as expired tokens or failed actions requiring user intervention. Trigger appropriate calls to the `/notifications` endpoint with error messages. Provide actionable content in the error message, such as required user steps for resolution.", "id": "TASK5" }, { "list": "Connect front-end React 'Notification' component to Redux state management", "acceptance": "Connect the React 'Notification' component to the Redux store. Acceptance Criteria: The component must listen to changes in the notification state and render notifications dynamically based on the state. Ensure dismiss functionality updates the Redux state appropriately to hide notifications.", "id": "TASK6" }, { "list": "Create a utility function for dismissing notifications in React", "acceptance": "Implement a reusable utility function in React to handle notification dismissal. Acceptance Criteria: The function must update the Redux state to hide the notification upon invocation. Ensure the dismissal action works for any notification type and does not affect unrelated state data.", "id": "TASK7" }, { "list": "Validate notification design alignment with existing application aesthetics", "acceptance": "Ensure that notification UI adheres to the app's design system. Acceptance Criteria: Review styles and layout of notifications against the app's design guidelines. Notifications must visually align and be non-intrusive. Acceptance of changes must be confirmed through a UI design review.", "id": "TASK8" }, { "list": "Write unit tests for Redux notification slice actions and reducers", "acceptance": "Develop unit tests for the Redux notification slice. Acceptance Criteria: Tests must cover all Redux actions and reducers for adding, updating, and dismissing notifications. Test cases must verify expected state changes and ensure proper handling of invalid inputs or states.", "id": "TASK9" }, { "list": "Write unit tests for the /notifications API endpoint", "acceptance": "Develop unit tests for the `/notifications` API endpoint in Golang. Acceptance Criteria: Tests must validate correct processing of valid notifications, appropriate error handling for missing fields, and correct response codes for various scenarios (e.g., 200 for success, 400 for bad input).", "id": "TASK10" }, { "list": "Write integration tests for end-to-end connection notifications", "acceptance": "Develop integration tests to validate notifications triggered by connection status changes. Acceptance Criteria: Simulate events such as successful connections, sharing activities, and disconnections. Ensure matching notifications are displayed in the UI and dismissed appropriately when closed.", "id": "TASK11" }, { "list": "Write integration tests for end-to-end error notifications", "acceptance": "Develop integration tests for user error notifications. Acceptance Criteria: Simulate integration failures such as expired tokens or other errors requiring user follow-up. Validate that error notifications appear correctly in the UI with actionable guidance. Ensure notifications are properly dismissible.", "id": "TASK12" } ] } ] }