aliyundrive-webdav is a WebDAV server application that bridges WebDAV clients (like Infuse, nPlayer) with AliyunDrive (Alibaba Cloud Drive) storage. The system is built in Rust and uses the dav-server crate as its WebDAV foundation. Key functionality includes: authenticating with AliyunDrive via refresh tokens (obtained through command line, environment variables, or QR code login), translating WebDAV operations (PROPFIND, GET, PUT, etc.) to AliyunDrive API calls, implementing caching for directory listings to reduce API calls, handling file uploads via chunked resumable uploads, and providing automatic token refresh in the background. The architecture consists of modular components: cache (directory entry caching), drive (AliyunDrive API communication), login (QR code authentication flow), vfs (virtual file system layer), and webdav (server implementation and auth). External dependencies include the AliyunDrive API, reqwest, tokio, tracing, clap, moka, dashmap, serde, and optional TLS dependencies. The application is actively maintained with frequent commits, CI/CD pipelines for multi-platform builds, and support for Docker, Snap, OpenWrt, and systemd deployments.
This repository is the `luci-app-openclaw` package for OpenWrt routers, providing a complete web UI (via LuCI) and command-line management surface for the OpenClaw AI gateway. The system handles installation and lifecycle of a Node.js runtime and the OpenClaw npm package, configures AI model and messaging channel settings (Telegram, WeChat, etc.), manages device pairing approvals, offers an interactive terminal (xterm.js) via WebSocket, and supports backup/restore with atomic writes. The architecture is a monolithic OpenWrt plugin that integrates with procd for service management, UCI for configuration, and relies on external Node.js binaries plus the OpenClaw gateway software. The codebase exhibits strong engineering practices: a comprehensive contract-test suite with mutation testing, atomic configuration writes with pre-write backups, CSRF protection on all state-changing endpoints, a shell/JS menu engine for interactive configuration, and an upgrade state machine with rollback. It is actively maintained with frequent adjustments to upstream OpenClaw versions and security hardening.
OpenClash is an OpenWrt/LuCI application that turns a router's admin interface into a full Clash/Mihomo proxy management system. The production code is mostly Lua CBI/controller modules, view templates with embedded JavaScript, and shell/Ruby orchestration scripts. It manages subscription downloads, YAML config generation and overwrite, core binary updates, GeoIP/GeoSite/China-route database updates, DNS/firewall integration, streaming-unlock probe and selection, and optional OIX managed-service integration. It also bundles the MetaCubeXD and zashboard single-page dashboards for live proxy monitoring and connection inspection. Architecturally, the project is an OpenWrt package: UCI configuration, an init.d service, and watchdog/procd lifecycle management. The LuCI controller exposes around 80 JSON/AJAX actions and uses low-level nixio fork/poll/pipe helpers for streaming subprocess output. The backend repeatedly combines shell scripts with Ruby-based YAML parsing and mutation to handle Clash configuration. External dependencies are significant: GitHub releases/CDNs for core and GEO data, subconverter services, the OIX API, and several IP-info services. Hardcoded URLs, vendored minified dashboard bundles, and multi-language shell/Ruby/Lua/C tooling are the main technical-drift risks. This is not a data-research repository; the data handled is operational proxy/node/routing state rather than analyzable datasets. No automated test suite is apparent in the tree; quality comes from defensive shell patterns (flock locks, ETag caching, retry loops) and feature depth rather than automated verification. The most reusable pieces are YAML.rb's merge/encryption layer, the server_url share-link parser widget, and the controller's streaming subprocess helpers.
Podkop is an OpenWrt package for traffic routing using sing-box as the proxy core. It provides a LuCI web interface (TypeScript frontend compiled to JavaScript) with tabs for Settings, Sections (proxy/VPN/block/exclusion), Dashboard (real-time traffic via Clash API WebSocket), and Diagnostic (checks for DNS, sing-box, nftables, FakeIP). The backend consists of shell scripts: /usr/bin/podkop (main entry), /etc/init.d/podkop (procd init), and libraries in /usr/lib/podkop/ (constants.sh, nft.sh, helpers.sh, sing_box_config_manager.sh, etc.). It uses nftables for traffic marking and TPROXY, dnsmasq for DNS hijacking with FakeIP, and downloads community domain/subnet lists from GitHub. It supports proxy protocols: VLESS, Shadowsocks, Trojan, SOCKS, Hysteria2. The architecture is monolithic: the frontend communicates with the backend via shell commands (exec) and WebSocket to the Clash API. The backend manages sing-box configuration, nftables rules, and list updates via cron. Key entry points include install.sh (installation), /usr/bin/podkop (service management), and the LuCI view files. External dependencies include sing-box, jq, curl, nft, coreutils-base64, bind-dig, and the diagnostic endpoints (ip.podkop.fyi, fakeip.podkop.fyi). The system is in beta, with breaking changes possible; users are advised to clear LuCI cache on updates. The codebase demonstrates solid engineering with modular shell libraries, a well-structured TypeScript frontend with unit tests for validators, and CI/CD pipelines. However, it has some drift risks: hardcoded version requirements, compiled JS committed to the repository, and reliance on external services. The frontend includes reusable components such as a reactive store service, WebSocket manager, and composable validators.
This repository provides a transparent proxy package for OpenWrt using Mihomo (a clash-compatible rule-based proxy core) as the backend. It is a full LuCI application that allows users to configure proxy modes (redirect, TPROXY, TUN), manage subscriptions, define access control rules, and monitor logs through a web interface. The system is designed for OpenWrt ≥24.10 with firewall4 (nftables) and kernel ≥5.13. The architecture consists of three OpenWrt packages: `nikki` (main service and scripts), `mihomo-meta` (stable core), and `mihomo-alpha` (alpha variant). The service is managed via procd init script (`nikki.init`), which handles starting/stopping Mihomo, setting up routing rules and nftables tables, and scheduling tasks. Configuration is stored in UCI (OpenWrt's standard configuration system) and processed through a pipeline: UCI options → `mixin.uc` (ucode script) generates a JSON overlay → `yq` merges it with a base profile → final Mihomo config. Traffic interception rules are generated dynamically from a utpl template (`hijack.ut`) that produces nftables rulesets. Key entry points include the LuCI views (`app.js`, `profile.js`, `mixin.js`, `proxy.js`, `editor.js`, `log.js`) for web-based management, the init script for service lifecycle, and shell scripts for installation/upgrade. External dependencies are Mihomo core, `yq` for YAML processing, and standard OpenWrt tools (procd, nftables, ucode). The repository also includes a large hardcoded nftables set of Chinese IP prefixes (`geoip_cn.nft`) for bypassing mainland China traffic.
This is a LuCI application package for OpenWrt routers that provides a full web-based management interface for Clash/Mihomo proxy services. It handles the complete proxy lifecycle: service management via procd, transparent proxy setup (TPROXY/TUN/MIXED modes), DNS manipulation, firewall rule generation via nftables/iptables, subscription management, and a real-time log viewer. The package installs to /opt/clash/ and integrates deeply with OpenWrt's hotplug, UCI, and LuCI systems. A separate Vue-based SPA dashboard (zashboard) is bundled for advanced features like Tailscale management, network diagnostics (bandwidth tests, STUN NAT detection), and an embedded SSH terminal. The architecture is a classic OpenWrt package: shell scripts for service and firewall management (/etc/init.d/clash, /opt/clash/bin/clash-rules), LuCI JavaScript views for the admin UI (config, settings, rulesets, log), hotplug scripts for network events, and a vendored Ace editor for YAML editing. The firewall engine is the most substantial component — roughly 1400 lines of modular shell that generates nftables/iptables rules, manages subscription IP caches with locking, and auto-generates fake-IP whitelists from rule providers. The init script includes rollback logic that restores DNS/firewall state on failure, preventing bricked router connectivity. The repository is explicitly legacy: the README states active development has moved to SSClash-Go (a single static binary with built-in web UI). This repo receives bugfix maintenance only. Technical drift is medium — the vendored Ace editor is an old version (1.5.0), the shell scripts use fragile heuristics for YAML transformation, GitHub API calls for kernel downloads lack caching, and the dual configuration (config.yaml plus /opt/clash/settings) can confuse users. However, the CI pipeline is maintained and the package builds for current OpenWrt versions (both ipk and apk formats). For reuse, the most valuable components are the modular firewall engine pattern (nft/iptables abstraction with idempotent rule generation), the procd init script with rollback logic, and the LuCI view utilities (chunked file writing, service polling). These could be extracted for other OpenWrt proxy/VPN services with minimal modification. The repo serves as a solid reference for OpenWrt package structure, LuCI app development, and transparent proxy integration, though new projects should target the successor SSClash-Go instead.
This repository is a collection of LuCI applications (luci-app-*) for OpenWrt/iStoreOS, providing web-based management UIs for Docker services, system monitoring (netdata), and third-party tools (OpenClaw AI gateway, Sunpanel, mymind). It operates as an OpenWrt package feed: GitHub Actions workflows build IPK packages from the source tree, and a Go CLI tool (`forkapp`) clones and uploads LuCI apps to routers. The target platform is iStoreOS, with feeds configured from nas-packages and istore sources.