LosslessSwitcher is a macOS menu bar application that automatically adjusts the audio output device's sample rate and bit depth to match the lossless track currently playing in Apple Music. It works by reading system logs (OSLog) from Music.app and CoreAudio subsystems to detect the current track's sample rate, then uses CoreAudio APIs via the SimplyCoreAudio library to switch the output device's format. The app is not sandboxed because it requires access to system logs and the ability to modify audio device properties. It is built with SwiftUI and uses Combine for event-driven updates. The architecture includes a SwiftUI app entry point (QualityApp.swift), a legacy NSApplicationDelegate for menu bar management and permissions checking, an Observable class (MenuBarController) that owns the OutputDevices and MediaRemoteController, and parser utilities for extracting sample rate and bit depth from console entries. A user can also configure a custom script to run when the sample rate changes. The code demonstrates modern Swift patterns but is tightly coupled to macOS-specific frameworks and the Apple Music ecosystem.
This repository implements a GitHub Action that cancels previous workflow runs that are not completed (queued or in_progress) for a given workflow. The action is written in TypeScript and bundled using vercel/ncc for distribution. It processes inputs to determine which workflows to target, handles various GitHub events (push, pull_request, workflow_run), and uses the GitHub API via @actions/github to query and cancel workflow runs based on configurable conditions like ignoring SHA, canceling all but the latest, filtering by status, or force canceling. The architecture is a single source file (src/index.ts) that collects context from the GitHub Actions environment, resolves target workflows, lists relevant runs, applies filters, and cancels matching runs. The action demonstrates proper error handling, logging, and use of the GitHub Actions toolkit, making it a reliable tool for managing workflow concurrency.
Certimate is a self-hosted SSL certificate automation tool that manages the full lifecycle of TLS certificates: issuance via ACME protocol, deployment to a vast array of cloud providers (CDN, WAF, load balancers, object storage, hosting panels), and notification via chat bots and email. The system is a single-binary application with an embedded PocketBase backend (SQLite) and a React frontend. The backend is written in a Go-like language and exposes REST APIs for managing certificates, workflows, and settings. The frontend provides a visual workflow designer for creating automation pipelines with nodes for ACME issuance, deployment, upload, monitoring, and notification. Architecture: The application is built around a plugin-style provider architecture. Core interfaces (Deployer, Certmgr, Notifier, ACMEChallenger) are implemented by dozens of providers for different cloud services. A workflow engine executes directed acyclic graphs of nodes, with support for conditions, try/catch, delays, and parallel branches. The system uses PocketBase for persistence, cron-based scheduling, and admin authentication. The UI is built with React, Ant Design, and a flow editor library. Key entry points: main.go (CLI entry), cmd/serve_*.go (server startup), internal/rest/handlers/ (REST endpoints), internal/workflow/engine/ (workflow execution), internal/certacme/ (ACME client), internal/certmgmt/deployers/ (deployment registry), internal/notify/ (notification service). Data flows: User configures access credentials and workflows via UI. Workflows are scheduled via cron and executed by the engine, which calls ACME challengers to issue certificates, then deployers to install them, and notifiers to send alerts. Certificate and workflow state is persisted in PocketBase. External dependencies: PocketBase for storage and admin auth, lego (go-acme) for ACME protocol, dozens of cloud provider SDKs (Alibaba, AWS, Tencent, Huawei, etc.), and various third-party APIs for DNS challenges and deployment. The project also includes trimmed/patched copies of several SDKs to reduce dependency footprint.
This is a Node.js CLI application (Docker containerized) that automatically logs into the Epic Games Store using device code authentication (OAuth2 device grant), discovers currently free games (weekly promotions and general store discounts), validates ownership via Epic's GraphQL APIs, and sends actionable checkout links to the user through a variety of notification channels (email, Discord, Telegram, Pushover, Gotify, Slack, Home Assistant, Bark, Ntfy, Apprise, webhook, and local browser open). The application uses Puppeteer with a stealth plugin to simulate a browser session for cookie management and authenticated API calls. It runs on a configurable cron schedule, with optional run-on-startup and one-shot modes. It includes a lightweight Express web server to handle device code login redirects and optionally exposes itself via localtunnel for remote accessibility. Configuration is JSON/JSON5 with full class-validator based schema validation and environment variable fallbacks.
This repository is a full-stack self-hosted media download manager and library preparation layer centered on yt-dlp. The backend is implemented in Python using aiohttp, SQLite (via SQLAlchemy), and includes a structured feature-based architecture (auth, presets, tasks, conditions, downloads, streaming, notifications, ytdlp integration). The frontend is a Nuxt 3 / Vue 3 single-page application with comprehensive i18n support. Core capabilities include automated download scheduling with cron-like task definitions, conditional filtering, Cloudflare challenge solving, real-time WebSocket updates, streaming via on-the-fly HLS transcoding with hardware acceleration fallback, and a browser extension for quick URL submission. The codebase demonstrates good engineering practices: event bus for decoupled communication, singleton-based service containers, repository pattern for data access, custom migration framework, and extensive async test coverage. Notable external dependencies are yt-dlp (core downloader), ffmpeg (transcoding), curl_cffi (impersonation), and apprise (notifications). While the architecture is modular and well-organized, there is some code duplication across CRUD repositories and migration files, and tight coupling to yt-dlp internals via custom patches. The project is actively maintained with frequent commits, a large test suite, and clear containerization support.
Magic Areas is a Home Assistant custom integration that turns HA's area registry into an occupancy-aware automation layer. In production it listens to entity states across configured areas, computes presence from motion sensors, device trackers, and occupancy binary sensors, manages clear timers and secondary states (dark, sleep, extended), and publishes derived entities: area presence binary sensors, smart light/fan/cover/media groups, aggregate sensors, and feature-override switches. It is event-driven and tightly coupled to Home Assistant internals: the area/entity registries, dispatcher, event bus, async timers, and group entities.
PiPiClaw is a cross-platform AI agent application that enables users to interact with local and remote systems via natural language commands. It features a built-in web UI for remote control, scheduled task management, file operations, command execution, and a skill system for extending capabilities. The application is designed to be lightweight and portable, utilizing .NET 10.0 AOT compilation to produce a single binary of approximately 2MB. It maintains conversation history and long-term memory with embeddings for context-aware interactions.
ruby-nmap is a Ruby library that provides programmatic access to the nmap network scanning tool. It consists of two main components: 1) A command-line interface builder (Nmap::Command) that allows Ruby programs to configure and execute nmap scans with full access to nmap's options through a Ruby DSL, and 2) An XML parser (Nmap::XML) that converts nmap's XML output into navigable Ruby objects representing hosts, ports, services, OS detection results, and script output. The library acts as a bridge between Ruby applications and the nmap executable, handling the complexity of command-line argument construction and XML parsing while providing an idiomatic Ruby interface. The project is actively maintained with recent commits, comprehensive test coverage, and support for multiple Ruby versions.
This repository provides a set of command-line tools (gvm-cli, gvm-script, gvm-pyshell) for remotely controlling Greenbone Vulnerability Management (GVM) installations via the Greenbone Management Protocol (GMP) and Open Scanner Protocol (OSP). The tools allow administrators to send raw XML commands, execute Python scripts that interact with the GMP/OSP API, and run an interactive Python shell with pre-configured connection objects. The architecture is modular: a parser module handles argument parsing and connection creation, a config module reads user configuration, a helper module provides utilities like authentication prompting and table formatting, and separate modules implement each CLI tool. The primary data flow is from the user (via CLI arguments or script) through the connection layer to the GVM daemon, with responses returned as XML or formatted output. External dependencies include the python-gvm library for protocol handling, and optionally SSH keys for SSH connections. The codebase is well-structured with clear separation of concerns, comprehensive test coverage, and extensive example scripts demonstrating common administrative tasks such as listing tasks, creating targets, exporting reports, and managing alerts. The project follows semantic versioning, uses modern Python packaging with pyproject.toml and uv, and includes CI/CD pipelines for testing, linting, and deployment to PyPI and container registries. While primarily a management tool, it also includes reusable components like a table formatter, connection factory, and authentication helper that could be extracted for other projects.
This repository is a TypeScript monorepo for an AI-powered autonomous web browsing agent called 'open-browser'. It consists of three packages: core library (open-browser), CLI (@open-browser/cli), and sandbox (@open-browser/sandbox). The core library orchestrates an agent loop that uses Playwright to control a Chromium browser, extracts DOM state via CDP, sends it to an LLM (OpenAI, Anthropic, Google) which decides actions in structured JSON, and executes those actions via a CommandExecutor. The system supports vision screenshots, extended thinking, compact mode, planning, evaluation, replay recording, and MCP server integration. The CLI provides commands for running agents, interactive sessions, and direct browser manipulation. The sandbox provides resource-limited execution. Key entry points include the Agent class, Viewport browser session, CommandExecutor, and BridgeServer. External dependencies include Playwright, Vercel AI SDK, Zod, Turndown, and various LLM provider SDKs. The architecture follows a modular monorepo with clear separation of concerns, event-driven communication via EventHub, and a guard/watchdog pattern for browser lifecycle management. The codebase demonstrates strong engineering practices with extensive use of Zod schemas for structured outputs, a command catalog pattern, and comprehensive telemetry and cost tracking.
AutoPy is a cross-platform GUI automation library implemented in Rust and exposed to Python through PyO3. It provides programmatic control of the mouse and keyboard, screen capture, bitmap pixel inspection, and color detection. The library abstracts over Windows, macOS, and X11 backends, so the same Python API works across desktop platforms. It is distributed as a Python extension module built with maturin/setuptools-rust and is also usable as a Rust crate.
This is a Claude Code plugin that enables scheduling recurring and one-time tasks using native OS schedulers (launchd on macOS, crontab on Linux, Task Scheduler on Windows). Users describe tasks in natural language (e.g., 'every weekday at 9am review yesterday's code'), and the plugin converts that to cron expressions, registers the task with the OS scheduler, and executes `claude -p "prompt"` at the scheduled time. It supports autonomous execution with `--dangerously-skip-permissions`, git worktree isolation for tasks that modify code (creates a branch, runs Claude, commits and pushes changes), and provides commands to list, remove, run, and view logs of scheduled tasks. The architecture is modular: platform-specific scheduler implementations inherit from a base class, cron parsing and humanization are separate utilities, and execution history is stored as JSONL files. The codebase demonstrates strong security awareness with shell escaping, input validation via Zod schemas, and careful handling of user-provided values in generated shell scripts.
AutoFilterer is a .NET library that automatically generates LINQ expressions from Data Transfer Objects (DTOs) for filtering, sorting, and pagination on IQueryable collections. It is designed to be compatible with OpenAPI 3.0 specifications, unlike oData or GraphQL. The core architecture revolves around filter DTOs that inherit from FilterBase or its derivatives (PaginationFilterBase, OrderableFilterBase). Properties in these DTOs are decorated with attributes (e.g., StringFilterOptions, OperatorComparison, CompareTo) or use special types (StringFilter, OperatorFilter<T>, Range<T>) to define filtering rules. The library builds expression trees at runtime and applies them via the ApplyFilter extension method. It also provides a Swagger integration package (AutoFilterer.Swagger) to expose filter parameters in Swagger UI, and a source generator (AutoFilterer.Generators) to automatically create filter DTOs from entity classes. The codebase is well-structured with clear separation of concerns: abstractions (IFilter, IFilterableType), attributes, types, extensions, and a dynamic filter variant. It includes comprehensive unit tests, benchmark tests, and a sandbox application demonstrating usage with a Northwind database. The library targets netstandard2.0, netstandard2.1, and net9.0, making it broadly compatible. While the core library is mature and actively maintained, some ancillary packages (e.g., Swagger integration) use slightly outdated dependencies (Swashbuckle 5.x), and the documentation has some TODO sections. Overall, it is a solid, reusable filtering framework with high craftsmanship in expression tree manipulation.
This repository is a monorepo of 'skills' for the Minis AI assistant platform, designed to extend the assistant's capabilities with domain-specific workflows, API integrations, and automation scripts. Each skill is a self-contained directory with a SKILL.md (instruction set for the AI), executable scripts (Python/shell), reference documentation, and evaluation test cases. The skills cover a wide range of tasks: social media management (Weibo, Twitter/X, Xiaohongshu, Telegram, Bilibili), media processing (YouTube downloader, PDF conversion, TTS, image generation), financial data retrieval (US/Korea/China stocks, fund flows), productivity (Notion API, todoocard e-paper, whenpeak energy prediction), video composition (HyperFrames framework), and system utilities (Android dev environment, Cloudflare DNS, qBittorrent). The architecture is modular and agent-driven: the AI selects a skill based on user intent, reads its SKILL.md, and invokes the provided scripts via shell_execute. Output is typically JSON for machine consumption. The codebase demonstrates strong engineering practices with structured skill definitions, evaluation frameworks, and reusable patterns like cookie-based auth, SQLite message stores, and deterministic animation analysis. However, many skills depend on reverse-engineered or unofficial APIs, hardcoded paths tied to the Minis iOS environment, and external tools (ffmpeg, pandoc, typst), introducing maintenance and portability risks.
Linus Dashboard is a Home Assistant custom integration that auto-generates a plug-and-play Lovelace dashboard from the entity, device, area, and floor registries. The frontend is a TypeScript strategy that dynamically builds views, chips, cards, and popups based on device class and domain, while the Python backend creates nested group entities (area → floor → global) for each domain, aggregates numeric sensors, and provides a configuration flow for exclusions and embedded dashboards. It integrates optionally with Magic Areas and Linus Brain for entity resolution, falling back to native registry data. The system is bilingual (EN/FR) and heavily automated with release scripts, CI workflows, and a fake-house test environment. Architecturally, the project is a hybrid: a Python backend following Home Assistant component patterns and a TypeScript frontend built with Rspack, relying on external cards (Mushroom, Browser Mod, Card Mod, Swipe Card, Stack-in-Card). Core engineering patterns include abstract base classes (AbstractCard, AbstractChip, AbstractView), factory classes with dynamic imports, a central Helper class that acts as a registry cache, and memoization/performance profiling utilities. The backend uses a shared NestedGroupMixin to build hierarchical entity groups and pure aggregation logic in aggregate.py. The codebase is well-tested with Vitest and pytest, and includes extensive documentation and release automation, but also suffers from a large god object (Helper.ts >1600 lines), duplicated platform boilerplate, vendored minified third-party bundles, and partial French localization. It is actively maintained with recent commits, a responsive issue tracker, and regular beta/stable release cycles.
This repository provides a deprecated GitHub Action that automatically updates release notes (Markdown files) with new entries from merged pull requests. It is a Docker-based action that runs on `pull_request_target` or `workflow_dispatch` events, fetches PR details via the GitHub API using PyGithub, and modifies a `release-notes.md` file by inserting a templated message under a configurable header. The core logic includes support for label-based sections, custom Jinja2 templates, skip labels, and retry logic for race conditions during git push. The codebase also includes a companion CLI tool (`scripts/prepare_release.py`) for automating version bumps and release note preparation. The action has been deprecated by the maintainer in favor of a dedicated GitHub App, but the code remains functional and well-maintained.
HASSL (Home Assistant Simple Scripting Language) is a domain-specific language compiler that translates human-readable .hassl scripts into YAML automation packages for Home Assistant. The compiler parses the DSL using Lark, builds an AST, performs semantic analysis (including alias resolution, import handling, template expansion, and schedule validation), and generates multiple YAML files (helpers, scripts, sync automations, rule automations, schedule sensors) that can be directly loaded into Home Assistant. The architecture follows a classic compiler pipeline: parsing → transformation → analysis → code generation, with clear separation between modules. The system supports modular packages with imports, public/private exports, rule templates, time-based schedules (including sunrise/sunset, weekday/weekend/holiday windows), event-driven conditions (button presses, event entities), loop-safe context tracking, and rule arming. The CLI tool `hasslc` compiles single files or directories, automatically resolving cross-package dependencies. The codebase includes a comprehensive test suite (32 tests) covering parsing, IR generation, and YAML output. While primarily an application, the repository also includes developer tooling such as an Emacs major mode for the DSL and utility scripts for Home Assistant entity discovery. The compiler is implemented in Python with minimal external dependencies (lark-parser, jinja2, pyyaml) and is designed for extensibility.
AutoClicker is a Windows desktop application built with WPF for automating mouse clicks. It allows users to configure click interval, mouse button, click type, repeat mode, and click position (current cursor or a specified location). The application runs in the system tray and can be controlled via configurable hotkeys (default F6, F7, F8) or through the GUI. Settings are persisted to a JSON file in the user's AppData directory. The architecture separates concerns into UI (Views), data models (Models), utility functions (Utils), and command bindings (Commands).
This repository provides a comprehensive, modular set of Bash scripts to automate the installation and configuration of Apache Guacamole—an open-source remote desktop gateway. The primary orchestrator '1-setup.sh' handles interactive prompts and silent install variables to deploy Guacamole server and client from source, integrate MySQL/MariaDB as the backend database, set up Nginx as a reverse proxy, and optionally configure TLS (self-signed or Let's Encrypt), multi-factor authentication (TOTP, Duo, LDAP), and extra UI features like quick-connect and session recording storage. The scripts are well-structured with extensive error checking, logging, distro-specific workarounds, and support for modular post-install add-ons. Though not a library for reuse, the code demonstrates solid shell scripting craftsmanship, security hardening (fail2ban integration, firewall rules), and separation of concerns. The repository serves as a turnkey deployment toolkit for production-grade Guacamole environments.
UFO (UI-Focused agent) and Galaxy constitute a multi-agent AI framework for automating GUI-based tasks across Windows, Linux, and mobile platforms. The system uses LLM-driven agents (AppAgent, HostAgent, ConstellationAgent) that interact with desktop applications via UI automation (UIA, COM) and execute distributed task workflows modeled as DAGs (task constellations). It includes a client-server architecture with WebSocket-based Agent Interaction Protocol (AIP), MCP tool servers, a configurable RAG knowledge substrate, and a Web UI (React+FastAPI) for real-time monitoring and control. The framework is primarily an application with strong research elements: it supports trajectory analysis, evaluation agents, demonstration learning, and configurable LLM backends (OpenAI, Claude, Gemini, DeepSeek, Ollama).