streamaserver/streama

This system is a self-hosted media streaming platform, known as Streama, built on a Grails 3 backend and an AngularJS frontend. It enables users to organize and watch movies, TV shows, and generic videos, featuring a robust admin interface for content management, transcoding, and user reports. The application supports multi-profile viewing with child controls, synchronized playback via WebSockets, and automatic subtitle fetching, while providing Docker-based deployment and comprehensive localization.

21 changes.

The project underwent a major migration from Grails 2 to Grails 3, restructuring the backend architecture and replacing legacy Grails views with an AngularJS frontend. This period introduced significant new features including watchlists, genre management, and automatic subtitle fetching, while simultaneously removing obsolete controllers, services, and UI templates.

18 changes.

The project focused on expanding the administrative capabilities by introducing dedicated controllers, views, and services for managing media, reports, and transcoding tasks. Concurrently, the backend was refactored to standardize data exchange by migrating various domain views to GSON-based JSON serialization, while the frontend JavaScript architecture was reorganized to support these new features and improve maintainability.

10 changes.

This period focused on expanding the application's API surface by introducing new endpoints for player status, user activity, and watchlists, alongside a significant refactoring of JSON serialization into specialized services. Concurrently, the project modernized its infrastructure by adding Docker deployment support and LDAP authentication, while enhancing the user interface with customizable headers, footers, and profile management features.

New .gson view templates have been added to render JSON responses for the application, errors, and genre domain objects. The application index view now exposes system metadata (environment, versions, plugin counts) and lists active controllers and plugins. Error handling is standardized to the vnd.error format, returning UNPROCESSABLE\_ENTITY status with structured error details. Genre resources are now rendered via templates that support listing, showing, and partial rendering of individual genre entities.

grails-app/views/application, grails-app/views/errors, grails-app/views/genre · high confidence

This update introduces a complete password reset experience for users, including new views for requesting a reset link, setting a new password, and handling expired links, alongside new HTML email templates for password reset confirmations and content notifications. Additionally, the user invitation email template has been updated to dynamically use the configured base URL for the invitation link, ensuring correct routing regardless of deployment context.

grails-app/views/mail · high confidence

Users can now deploy the Streama application using Docker. This change introduces a Dockerfile that builds the application from the latest release JAR, a docker-compose configuration that orchestrates the Streama service with a MySQL 5.7 database and an Nginx reverse proxy, and the necessary Nginx configuration files to handle traffic and WebSocket connections.

docker · high confidence

The application's backend logic in the services layer has been significantly restructured and expanded. A new bulk creation service now automates media metadata matching from filenames using configurable regex patterns. Video playback is enhanced with an FFmpeg-based transcoding service that automatically converts browser-incompatible audio codecs (like AC3 or DTS) to AAC for seamless streaming. Subtitle management has been upgraded to support the new OpenSubtitles API v1 with integrated hash-based searching and SSRF-protected downloads. Additionally, the system now supports local file linking, profile-based viewing status tracking, and user activity logging with rotation.

grails-app/services/streama · high confidence

Added two new API controllers to expose player and application data. The PlayerController introduces a public endpoint to update viewing status (accepting a profile ID via header) and a video detail endpoint that renders video data using a specific JSON format. The ApiController provides an endpoint to retrieve the current Streama version (parsed into major, minor, and patch components) and a validation endpoint to check domain access.

grails-app/controllers/streama/api · high confidence

Added new GSP templates (\_userActivity.gson and index.gson) to provide structured JSON responses for user activity records. The index view exposes a list of user activities and a total count, while the partial view formats individual activity items to include user details (ID, username) and associated video metadata (poster, release date, episode/season info, and show details if applicable), excluding the full user object from the activity record itself.

grails-app/views/userActivity · high confidence

This update introduces LDAP integration for user authentication via the new LdapUserDetailsContextMapper, which maps LDAP directory entries to internal user profiles. It also migrates the subtitle service to the OpenSubtitles.com API v1, replacing the previous implementation with new response models (OpenSubtitlesApiResponse, SubtitlesRequest, etc.) to handle subtitle search and download. Additionally, security vulnerabilities related to path traversal in subtitle file handling are addressed through stricter validation in ZipHelper, and minor utility classes (ResultHelper, VideoHelper, VideoStatus) are added to support these changes.

src/main/groovy/streama · high confidence

A new Groovy trait, SimpleInstance, has been added to the codebase to provide a standardized way of converting domain objects into simplified map representations. This trait introduces methods like getSimpleInstance and getSimpleFromInstanceOrId, which allow callers to extract specific fields from an object instance or resolve an object by its ID. It supports flexible field selection via include/exclude options and handles nested property paths using a key-value syntax (e.g., 'parent.child'), making it easier to serialize complex entities for API responses or internal processing without exposing unnecessary data.

src/main/groovy/streama/traits · high confidence

The application introduces a suite of new AngularJS controllers to power the admin interface, including dedicated controllers for managing movies, TV shows, generic videos, and file storage. A new admin reports controller allows administrators to view, resolve, and unresolve user-submitted error reports with pagination and sorting. Additionally, a transcoding controller provides a UI to monitor and manage audio transcoding tasks, including probing files and clearing caches. These controllers also support bulk file deletion, genre administration, and the creation of media from local files.

grails-app/assets/javascripts/streama/controllers · high confidence

The admin interface now includes dedicated pages for managing user reports (with resolve/unresolve and filtering), custom genres, and a file manager that lists all uploaded files with options to filter by association and delete multiple items. Additionally, an audio transcoding page has been added for administrators to monitor FFmpeg status, manage the transcoding cache, and manually trigger transcoding for files with incompatible audio codecs.

grails-app/assets/javascripts/streama/templates · high confidence

A new \AssetSettingTagLib\ has been added to handle dynamic rendering of login screen assets and analytics. It introduces tags to render favicon links (\linkRelIconSetting\), images with optional alt text (\imgSetting\), and CSS background images (\cssBackgroundSetting\) by resolving settings that may reference uploaded files. Additionally, it adds a \googleAnalytics\ tag that injects the Google Analytics tracking script when enabled in the configuration.

grails-app/taglib · high confidence

This change introduces the \systaro.core\ Angular module, which provides a reusable \uisOwlCarousel\ directive for creating auto-playing image sliders with dot navigation, and a comprehensive set of custom Lodash mixins (such as \formatString\, \joinBy\, and \getterSetter\) to enhance string manipulation and data handling capabilities across the application.

grails-app/assets/javascripts/systaro · high confidence

Added new GSON template views for the watchlist feature: \_watchlistEntry.gson renders individual watchlist entries with detailed video, movie, generic video, episode, and TV show information, while listWatchlistEntries.gson provides a template for rendering a list of watchlist entries.

grails-app/views/watchlistEntry · high confidence

The repository has been initialized with the core application structure, including a Grails 3 backend and an AngularJS frontend. This change introduces the build system (Gradle wrapper replacing Grails 2 scripts), configuration files (application.yml, .editorconfig, .jshintrc), and dependency management (bower.json). It also establishes the development and release workflow by adding Travis CI configuration for automated builds and Docker image publishing, alongside essential project documentation such as the README, CHANGELOG, CONTRIBUTING guide, and security policy.

(repo-wide) · high confidence

The project's custom icon font has been regenerated to include new glyphs such as checkmarks, a baby icon, fast-forward and rewind buttons, and a Chromecast icon. This update adds new visual assets to the application's interface, allowing these specific icons to be used in the UI.

grails-app/assets/stylesheets/icomoon · high confidence

The \api-service\, \filters\, and \modal-service\ JavaScript files have been removed from the application. This eliminates the previous AngularJS-based HTTP client, utility filters (such as \padnumber\ and \secondsToDateTime\), and the centralized modal management service, indicating a shift away from this legacy client-side architecture.

grails-app/assets/javascripts/services · high confidence

The legacy JavaScript controllers for the admin interface (including movie, show, and user management), the dashboard, file upload modals, and the video player have been removed from the application. This cleanup eliminates the old client-side logic for managing media libraries, user roles, and playback, indicating a shift to a different architectural approach for these features.

grails-app/assets/javascripts/controllers · high confidence

This release updates the project version to 1.11.1 and addresses the Log4Shell vulnerability by explicitly pinning Apache Log4j (log4j-api, log4j-core, log4j-to-slf4j) and Logback to version 2.17.1 and 1.2.8 respectively. The build configuration (build.gradle) has been restructured to use Grails 3.2.6 and Gradle 3.1, while also excluding a large number of non-video-related dependencies from the Tika parser to reduce the attack surface and build size. Additionally, several legacy frontend library manifest files (angular-sanitize, angular, bootstrap, ionicons, mousetrap) have been removed from the assets directory.

(dependencies) · high confidence

The Grails application entry point (Application.groovy) and the BootStrap initialization script have been relocated from the root grails-app/init directory into the streama package. This change organizes the core startup and database migration logic (such as creating default roles, users, and settings) within the application's main package structure.

grails-app/init · high confidence

The frontend application has been restructured to improve modularity and maintainability. The main application module and routing configuration have been moved from \streama-app.js\ into a dedicated \streama.core\ module, which now handles core services like \DomainServiceFactory\ and HTTP interceptors for context path resolution. Additionally, the JavaScript asset pipeline has been split into separate \vendor.js\ and \application.js\ manifests, replacing the previous single \application.js\ file to better organize third-party library dependencies (such as Angular, UI Router, and Bootstrap) from application-specific code.

grails-app/assets/javascripts · high confidence

The \adminEpisode\ directive, which previously handled episode editing, file management, and uploads within the admin interface, has been removed from the codebase. This change eliminates the client-side logic for managing episode files and video metadata in this specific component.

grails-app/assets/javascripts/directives · high confidence

This update introduces several new domain classes to support expanded platform features: GenericVideo for non-standard media, Genre for content categorization, WatchlistEntry for user collections, Profile for user-specific settings and child controls, UserActivity for tracking login and viewing history, NotificationQueue for managing alerts, and Report for user feedback. Existing models have been enhanced: Video now supports intro/outro skipping metadata and improved next-video suggestions; File gains support for external links, local files, and automatic audio transcoding for browser-incompatible codecs; TvShow and Episode models now include merged season/episode identifiers to fix 'next episode' logic and filtering; User model adds full name, favorite genres, and invitation links; and ViewingStatus now tracks active profiles and calculates completion percentages to determine if a video has ended. Additionally, Settings now support typed value parsing, and Role includes a display name.

grails-app/domain · high confidence

The application's localization layer has been significantly updated with new translation files for Catalan (CAT\_cat.js) and Chinese (CN\_zh.js), alongside refreshed translations for German (DE\_de.js), Danish (DK\_da.js), English (EN\_us.js), Spanish (ES\_es.js), and French (FR\_fr.js). These updates introduce support for new interface elements such as sub-profile management, session expiration warnings, and audio transcoding status messages, ensuring that users interacting with these languages see consistent and complete UI text across the dashboard, video player, and settings pages.

grails-app/assets/javascripts/streama/translations · high confidence

The application now uses dedicated GSON templates to serialize movie, video, and file data for the frontend. This change standardizes the JSON structure returned by the API, explicitly including fields such as media type, watchlist status, video status, poster image sources, and a separation of video files from subtitle files (SRT/VTT) in video objects. It also ensures that null values for subtitles do not cause rendering errors and provides a consistent format for file lists and individual file details.

grails-app/views/movie · high confidence

The login view has been completely rewritten to use AngularJS (ng-app, authController) and asset pipeline integration, replacing the previous static GSP structure. Users can now see a configurable logo and background via the Settings system, and the interface supports translations for labels and placeholders. New functionality includes a 'Forgot Password' link, a 'First Time Login Info' hint controlled by settings, and an alert for session expiration. The 'Remember Me' checkbox is now hidden but always sent in the background to fix session issues, and Google Analytics support has been added.

grails-app/views/login · high confidence

The application's visual design has been significantly updated. A new profile selection interface has been introduced, featuring customizable avatar colors and a dedicated sub-profile management page. Genre browsing now uses a dedicated tag-based list style, and the dashboard has been enhanced with new release sliders and improved media item displays. The video player controls have been restyled, including a new subtitle size picker and improved overlay behaviors. Additionally, the login and authentication pages now support customizable background images, and the admin interface has received visual updates for media management and file uploads.

grails-app/assets/stylesheets · high confidence

The application backend has been significantly restructured and expanded with new capabilities. A new password reset flow allows users to recover accounts via email. The dashboard now features a 'Recommended for you' section based on favorite genres, alongside improved performance for listing shows and movies. A new watchlist feature enables users to save and manage movies and TV shows. Content management is enhanced with a new genre administration controller, a bulk IMDb ID fetcher, and a file manager with filtering options. Video playback is improved with FFmpeg-based audio transcoding for browser-incompatible codecs and OpenSubtitles integration for automatic subtitle fetching. Security is strengthened by removing the legacy TheTVDB dependency, fixing path traversal vulnerabilities in subtitle downloads, and allowing anonymous video consumption. The login process now supports anonymous access if configured, and user profiles can be managed with child profile restrictions.

grails-app/controllers/streama · high confidence

The application configuration has been migrated from the legacy Grails 2 structure (Config.groovy, DataSource.groovy, BuildConfig.groovy) to the Grails 3 standard (application.yml and application.groovy). This change introduces stricter Spring Security rules, restricting most content and API endpoints to authenticated users while allowing public access only to assets, login, and specific API info endpoints. It also enables CORS for API and player routes, configures a 'remember me' cookie for persistent sessions, and sets up Hibernate second-level caching. Additionally, the new configuration supports externalized database credentials via environment variables for Docker deployments and allows users to adjust storage and API keys through the UI rather than static config files.

grails-app/conf · high confidence

This change introduces a new set of Angular services in the \streama/services\ directory, including \apiService\ (centralizing HTTP endpoints for users, videos, reports, and transcoding), \mediaListService\ (handling pagination, sorting, and filtering for media lists), \modalService\ (standardizing modal dialogs), \playerService\ (managing video playback state and error reporting), \profileService\ (handling profile switching and language settings), \socketService\ (managing WebSocket connections for synchronized playback), and \filters.js\ (providing utility filters like time formatting). Additionally, the \uploadService\ has been refactored to use a \contextPath\ configuration instead of parsing the DOM for a base href, and it now accepts an error callback to handle upload failures with user-facing alerts.

grails-app/assets/javascripts/streama/services · high confidence

The application now includes dedicated GSP templates (\_user.gson, current.gson, index.gson) to control how user data is serialized to JSON for API consumers. The current user endpoint exposes specific role flags (isAdmin, isContentManager, isTrustedUser) and a configurable amountOfMediaEntries (defaulting to 10), while the general user view includes invitation links and authority details.

grails-app/views/user · high confidence

The main application view (index.gsp) has been significantly updated to support dynamic settings, including a customizable page title and favicon pulled from the Settings domain class. The layout now conditionally renders different headers for anonymous versus authenticated users, includes a footer template, and integrates Google Analytics. Additionally, new JSON error views (error.gson, notFound.gson) have been added to provide structured API responses for 500 and 404 errors, replacing the previous generic HTML error page (error.gsp). A new message.gsp view was also introduced to display success or informational messages with a link back to the dashboard.

grails-app/views · high confidence

The application now uses new template files for the header and footer, introducing significant changes to the user interface and layout. The main header (\_header.gsp) and anonymous header (\_header\_anonymous.gsp) now feature a fixed-top navigation bar with dynamic menu items that can be hidden via settings (such as dashboard sections, search, and help/FAQ links). A new profile selector dropdown allows users to switch between sub-profiles, including child profiles, and access user settings. The footer (\_footer.gsp) is now customizable, displaying a configurable version number and arbitrary HTML content defined in the settings, while a simplified header template (\_header\_simple.gsp) is also available for specific contexts.

grails-app/views/templates · high confidence

The main application layout has been updated to include a new Settings menu, a header search bar, and a genre browser dropdown. The header now displays a logo image instead of text, shows the application version (v1.0.1), and includes a loading spinner. Navigation links are now role-specific, with separate entries for Admin and Content Manager roles, and the user profile menu has been expanded to include Help and Profile Settings. A new non-Angular layout template has also been added to support vendor and application asset separation.

grails-app/views/layouts · high confidence

The public invite page now uses a dedicated layout with proper asset loading and a dynamic page title from settings. The password entry form has been updated with clearer placeholder text (e.g., 'Password (min. 6 Characters)'), and validation logic now correctly scopes to the view model (vm.valid) to prevent potential scope issues. Additionally, the page now explicitly handles invalid or expired invite links by displaying a 'Your link is not valid anymore' message, replacing the previous behavior that may have caused browser issues or confusing states.

grails-app/views/invite · high confidence

The Dash view templates for JSON serialization have been restructured to improve modularity and data consistency. New reusable templates (\_episode.gson and \_viewingStatus.gson) now handle the rendering of individual episodes and viewing statuses, with the latter explicitly distinguishing between movies, generic videos, and TV episodes to include specific metadata like intro/outro times for episodes. The list endpoints (listContinueWatching and listEpisodesForShow) have been updated to use these new templates, ensuring that the 'Continue Watching' list includes a total count and that episode lists are rendered consistently.

grails-app/views/dash · high confidence

The monolithic MarshallerService has been split into specialized services (MediaDetailMarshallerService and PlayerMarshallerService) to provide context-specific JSON structures for the UI. The new player marshaller now exposes detailed playback metadata, including intro/outro timestamps, viewing status per profile, and 'next episode' or 'next video' suggestions, while the media detail marshaller provides episode counts and file lists. This separation ensures the player receives only the data it needs for streaming and navigation, improving API efficiency and clarity for client-side consumption.

grails-app/services/streama/marshallers · high confidence

This change introduces a major refactor of the video player and admin directives to enhance code maintainability and user experience. The video player now checks video availability via a HEAD request before playback and supports FFmpeg audio transcoding for browser-incompatible codecs, displaying a progress bar while transcoding. It also adds fast-forward/rewind buttons, customizable subtitle sizing, and auto-loading of the first subtitle based on user settings. The admin episode directive now properly handles video file uploads and highlights the current episode in the list. Additionally, new directives for dashboard media items, progress bars, and video images have been added, along with a WYSIWYG editor for content creation.

grails-app/assets/javascripts/streama/directives · high confidence

The application has removed several legacy web configuration files and tag libraries from the \web-app/WEB-INF\ directory, including \applicationContext.xml\, \sitemesh.xml\, and JSP taglib definitions for JSTL (\c.tld\, \fmt.tld\), Grails (\grails.tld\), and Spring (\spring.tld\, \spring-form.tld\). The \grails-wrapper.properties\ file has also been deleted. Additionally, the internationalization files have been updated: a generic \typeMismatch\ message was added to \messages.properties\, and several validation error messages in \messages\_pt\_BR.properties\ were corrected for grammar and consistency.

grails-app/i18n, web-app, wrapper · high confidence

The legacy HTML templates for the admin interface (movie and show lists and details), the main dashboard, the video player, and the movie/show typeahead search components have been deleted. This removes the previous UI structures for managing media libraries, browsing the dashboard, and searching for content, indicating a shift to a new implementation for these areas.

grails-app/assets/javascripts/streama-app · high confidence

The application no longer includes the Mousetrap plugins for bind-dictionary, global-bind, pause, and record. Users can no longer bind multiple key combinations in a single call, create global shortcuts that work inside input fields, pause/unpause shortcut handling, or record keyboard sequences for playback.

(repo-wide) · high confidence

The application's frontend JavaScript has been reorganized into distinct modules (streama, streamaPublic, streama.interceptor, streama.routes, streama.run) to improve maintainability. A key behavioral change is the introduction of profile-specific language settings: the system now loads user profiles from local storage, allows switching between sub-profiles, and automatically applies the selected profile's language preference via the translation service. Additionally, the routing configuration has been updated to support new admin pages for reports and genres, and the interceptor now attaches the current profile ID to HTTP requests.

grails-app/assets/javascripts/streama · high confidence

The TV Show view layer has been converted from legacy templates to gson-based JSON responses. This change updates the index, show, save, and update endpoints to return structured JSON data for the TV Show model, enabling the frontend to handle rendering and state updates via JavaScript rather than server-side HTML generation.

grails-app/views/tvShow · high confidence

Added new Groovy Server Pages (GSP) templates to serialize NotificationQueue objects into JSON format. The \_notificationQueue partial handles individual items, including movie details (poster, title, release date) and TV show details (poster, name, first air date) when available. The index and show templates use this partial to render lists and single items respectively, enabling proper display of media information in the notification queue interface.

grails-app/views/notificationQueue · high confidence

The episode views (\_episode, index, show) have been converted to .gson templates to return structured JSON responses. The show view specifically exposes video files, subtitles, viewing status, and the next episode ID, addressing issues where video sources were not loading or images were broken.

grails-app/views/episode · high confidence

Added unit tests for domain constraints, service logic, and security hardening; Removed empty placeholder unit tests.

The project now includes a Gradle wrapper properties file that configures the build to use Gradle version 3.1. This ensures consistent build environments across development and CI systems by downloading the specific distribution from the official Gradle services URL.

gradle · high confidence

The project has removed the bundled copies of the alertify, angular-sanitize, and angular-ui-router libraries from the assets directory. This reduces the number of client-side dependencies included in the application.

grails-app/assets · high confidence

The frontend asset library has been updated to newer versions of core dependencies, specifically upgrading Angular from v1.4.10 to v1.4.12 and angular-sanitize from an older version to v1.7.8. This change also introduces new components including Autolinker.js for automatic URL and email linking, angular-local-storage for browser storage management, and angular-bootstrap v2.4.0 for UI widgets like accordions and modals. Additionally, angular-mocks and angular-resource have been updated to v1.4.12 to support testing and RESTful service interactions.

grails-app/assets/bower · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 32 → 31 (-1.3)
• Rubric changed (rubric-2026.09.12 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 36 → 28 (-8.0)
• Architecture 98 → 83 (-15.6)
• Maturity 61 → 61 (-0.0)
• Readiness 21 → 22 (+1.0)
• Security 74 → 68 (-5.7)
• Accessibility 28 → 28 (-0.1)

• Off-boarding risk: anonymized user #1

• (anonymous) (cognitive 102) (grails-app/assets/javascripts/streama/directives/streama-video-player-directive.js)
• (anonymous) (cognitive 103) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 114) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 116) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 125) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 130) (grails-app/assets/bower/jquery-ui/jquery-ui.js)
• (anonymous) (cognitive 16) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 16) (grails-app/assets/bower/jquery-ui/jquery-ui.js)
• (anonymous) (cognitive 16) (grails-app/assets/bower/jquery-ui/jquery-ui.js)
• (anonymous) (cognitive 16) (grails-app/assets/bower/owl.carousel/owl.carousel.js)
• (anonymous) (cognitive 162) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 17) (grails-app/assets/javascripts/streama/controllers/settings-users-ctrl.js)
• (anonymous) (cognitive 18) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 18) (grails-app/assets/bower/owl.carousel/owl.carousel.js)
• (anonymous) (cognitive 18) (grails-app/assets/javascripts/streama/controllers/modal-media-detail-ctrl.js)
• (anonymous) (cognitive 19) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 19) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 20) (grails-app/assets/bower/angular/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 22) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• (anonymous) (cognitive 22) (grails-app/assets/bower/angular-bootstrap/ui-bootstrap-tpls.js)
• …and 425 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

streamaserver/streama was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.