A modern and easy to use dashboard. 80+ integrations. 20K+ icons built in. Authentication out of the box. No YAML, drag and drop configuration.
feat(dev): add Docker development CLI (#6495)
Thomas018f84f80dc9
diff --git a/AGENTS.md b/AGENTS.mdindex be1afe9fb..6c3d36da4 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -46,6 +46,8 @@ homarr/├── tooling/│ ├── typescript/ # Base tsconfig│ └── github/ # CI setup action+├── tools/+│ └── homarr-dev/ # Go CLI for local and PR Docker images├── development/ # Dev docker-compose (Redis, MySQL, PostgreSQL)├── e2e/ # E2E test specs└── Dockerfile # Multi-stage production build@@ -68,6 +70,9 @@ When modifying user-facing code, you MUST also update the corresponding document## Monorepo Commands- `pnpm dev` — Next.js app only+- `pnpm dev:cli -- dev` — run the developer CLI without installing a global binary+- `pnpm db:seed` — seed default database data explicitly+- `pnpm docker:dev:up` — start the Redis development service in the background- `pnpm dev:docs` — Docusaurus docs site only- `pnpm turbo build` — build all packages- `pnpm turbo build --filter=@homarr/docs` — build docs only@@ -81,3 +86,7 @@ When modifying user-facing code, you MUST also update the corresponding document- UI: Mantine (not Tailwind) — Tailwind is only used in docs app- Icons: @tabler/icons-react- Docs app can import from `@homarr/definitions` for shared types+- Run `pnpm dev:cli -- dev` to browse local `homarr:*` images and remote PR images.+- Run `pnpm dev:cli -- build <name>` from a Homarr checkout to build `homarr:<name>` with rebuild provenance.+- Run `pnpm dev:cli -- build --pr <number>` to build a PR locally from a temporary checkout.+- Run Go checks from `tools/homarr-dev` with `go test ./...` and `go vet ./...`.diff --git a/apps/docs/docs/advanced/command-line/development/index.mdx b/apps/docs/docs/advanced/command-line/development/index.mdxnew file mode 100644index 000000000..cdbffc29a--- /dev/null+++ b/apps/docs/docs/advanced/command-line/development/index.mdx@@ -0,0 +1,41 @@+# Developer Docker CLI++The host-side developer CLI builds and runs local Homarr images and pull-request previews. Run it directly from a checkout with `pnpm dev:cli -- ...`; no shell-specific setup script is required. It is separate from the recovery CLI included in production images.++To install an optional `homarr` binary, run `pnpm dev:cli:install` and make your Go bin directory available on `PATH`. GitHub CLI authentication is only needed for pull-request features.++## Browse development images++```bash+pnpm dev:cli --+```++The main screen combines local `homarr:*` images with open pull requests and their GHCR preview status. Select an image to start or stop it, use `R` to build a remote pull request locally in the background or rebuild a local image, or use `p` to force a remote preview pull. Press `d` to switch to the instance dashboard and `d` again to return without losing the browser state. The explicit `dev` and `dash` subcommands start on either screen.++A locally built PR image is folded into its remote PR row only when its recorded revision exactly matches the current GitHub head SHA. The row is marked `◆ local`, and starting it prefers that local image without a registry pull. Outdated local builds remain separate rows. Navigation and dashboard switching remain available during background builds.++## Build images++```bash+pnpm dev:cli -- build <name>+pnpm dev:cli -- build --pr <number> [name]+```++The first command builds the current checkout as `homarr:<name>`. The pull-request form uses a depth-one clone in a temporary directory and defaults to `homarr:pr-<number>` when `name` is omitted.++## Rebuild images++```bash+pnpm dev:cli -- rebuild <name>+```++Images built by this CLI record their source checkout, revision, and optional pull-request number. Rebuild uses that provenance to select the original checkout or create a fresh temporary pull-request checkout.++## Run images++```bash+homarr run <name>+homarr run --pr <number>+```++Add `--detach` to run in the background, `--demo` to enable demo data, or repeat `--env KEY=VALUE` to provide additional environment variables.diff --git a/apps/docs/docs/advanced/development/getting-started.mdx b/apps/docs/docs/advanced/development/getting-started.mdxindex 7c16813ba..e8f68ea6d 100644--- a/apps/docs/docs/advanced/development/getting-started.mdx+++ b/apps/docs/docs/advanced/development/getting-started.mdx@@ -17,8 +17,9 @@ This guide will help you set up your development environment to start contributi- **Node.js (lts)**: You can download it from the [official website](https://nodejs.org/).- **pnpm (latest)**: You can install it by running `npm install -g pnpm`.- **Git**: You can download it from the [official website](https://git-scm.com/).-- **Docker or Docker Desktop**: You can download it from the [official website](https://www.docker.com/).-- **A GitHub account**: You can create one on the [official website](https://github.com/).+- **Docker or Docker Desktop**: Required for the Redis service and the developer Docker CLI.+- **Go 1.25+**: Required only for the developer Docker CLI. You can download it from the [official website](https://go.dev/).+- **GitHub CLI**: Required only for pull-request image features. Install it from the [official website](https://cli.github.com/), then authenticate with `gh auth login`.### Setting up the project@@ -34,11 +35,11 @@ This guide will help you set up your development environment to start contributi4. Install the dependencies with `pnpm install`.-5. Start redis by running `pnpm run docker:dev`. This will run a docker-compose file with a redis service.+5. Create `.env` from `.env.example`. In a POSIX shell, run `cp .env.example .env`; in PowerShell, run `Copy-Item .env.example .env`. Set `DB_URL` to an absolute path for your SQLite file.-6. Copy the `.env.example` file to `.env` and replace `DB_URL` with the full path you want to use for the sqlite database file. For example `DB_URL='C:\\Dev\\homarr\\packages\\db\\db.sqlite'`+6. Start Redis in the background with `pnpm docker:dev:up` if your development workflow needs it.-7. Run the migrations to create the sqlite db file with `pnpm run db:migration:sqlite:run`.+7. Create or update the database with `pnpm db:migration:sqlite:run`. This also seeds the default data. To run the seed explicitly later, use `pnpm db:seed`.8. Start the development server with `pnpm dev` and wait for a message that says `✓ Ready in 10.7s`@@ -49,8 +50,15 @@ This guide will help you set up your development environment to start contributi#### During development- `pnpm dev`: Start the development server.+- `pnpm dev:cli -- dev`: Browse and run local images and remote pull-request images.+- `pnpm dev:cli -- build <name>`: Build the current checkout as `homarr:<name>`.+- `pnpm dev:cli -- build --pr <number>`: Build a pull request locally from a temporary checkout.+- `pnpm dev:cli -- rebuild <name>`: Rebuild a local image from its recorded checkout or pull request.+- `pnpm dev:cli:install`: Optionally install the developer CLI as a `homarr` binary.- `pnpm cli`: Run cli commands.- `pnpm db:migration:sqlite:run`: Run the migrations to create or update the sqlite db file.+- `pnpm db:seed`: Explicitly seed the default database data.+- `pnpm docker:dev:up`: Start the Redis development service in the background.- `pnpm db:migration:sqlite:generate`: Generate a new migration file for the sqlite db. Also works with `mysql`.- `pnpm db:studio`: Open a visual studio for the database.- `pnpm package:new`: Create a new package in the monorepo.@@ -63,6 +71,7 @@ This guide will help you set up your development environment to start contributi- `pnpm typecheck`: Run the typescript type checker.#### Building the project+- `pnpm build`: Build the project for production.-- `docker build -t homarr .`: Build a docker image for the project.-- `docker run -p 7575:7575 -e SECRET_ENCRYPTION_KEY='your_64_character_hex_string' homarr:latest`: Run the created docker image.\ No newline at end of file+- `pnpm dev:cli -- build <name>`: Build a `homarr:<name>` image and record its checkout for later rebuilds.+- `docker run -p 7575:7575 -e SECRET_ENCRYPTION_KEY='your_64_character_hex_string' homarr:<name>`: Run the created docker image.diff --git a/package.json b/package.jsonindex 42736863f..705cae439 100644--- a/package.json+++ b/package.json@@ -17,11 +17,15 @@"db:migration:postgresql:run": "pnpm -F db migration:postgresql:run","db:migration:sqlite:generate": "pnpm -F db migration:sqlite:generate","db:migration:sqlite:run": "pnpm -F db migration:sqlite:run",+ "db:seed": "pnpm -F db seed","db:push": "pnpm -F db push:sqlite","db:studio": "pnpm -F db studio","dev": "pnpm -F nextjs dev",+ "dev:cli": "go -C tools/homarr-dev run .",+ "dev:cli:install": "go -C tools/homarr-dev install .","dev:docs": "pnpm -F @homarr/docs dev","docker:dev": "docker compose -f ./development/development.docker-compose.yml up",+ "docker:dev:up": "docker compose -f ./development/development.docker-compose.yml up -d redis","format": "turbo format --continue -- --check","format:fix": "turbo format --continue","lint": "turbo lint --continue",diff --git a/tools/homarr-dev/README.md b/tools/homarr-dev/README.mdnew file mode 100644index 000000000..99fe89640--- /dev/null+++ b/tools/homarr-dev/README.md@@ -0,0 +1,103 @@+# Homarr Developer CLI++Build and launch local Homarr images and GHCR pull-request builds, then manage them from responsive terminal dashboards.++## Requirements++- Docker or OrbStack+- Go 1.25+ to build from source+- GitHub CLI authenticated with `gh auth login` for pull-request features++## Setup++```sh+pnpm install+```++Create `.env` from `.env.example` and set `DB_URL` to an absolute path for the SQLite file before running the migration. In a POSIX shell, use `cp .env.example .env`; in PowerShell, use `Copy-Item .env.example .env`.+Then run `pnpm db:migration:sqlite:run` to create or update the database. The migration command also seeds a new database. Use `pnpm db:seed` explicitly when you need to seed an existing database. Start Redis separately with `pnpm docker:dev:up` when it is needed.+The examples below use `pnpm dev:cli -- ...`, which works from POSIX shells and PowerShell. If you prefer a global command, install it with `pnpm dev:cli:install` and add your Go bin directory to `PATH`.++## Build++```sh+pnpm dev:cli -- build feature+pnpm dev:cli -- build --pr 6441+pnpm dev:cli -- rebuild feature+```++Checkout builds are tagged as `homarr:<name>`. The source checkout and revision are recorded on the image so `homarr rebuild` and the development dashboard can rebuild it later. PR builds use a temporary checkout and default to `homarr:pr-<number>`.++## Launch++```sh+pnpm dev:cli -- run dev+pnpm dev:cli -- run --detach dev+pnpm dev:cli -- run --pr 6441+pnpm dev:cli -- run --pr 6441 --demo+pnpm dev:cli -- run --env FOO=bar --env FEATURE=true dev+```++PR launches always pull the latest GHCR tag before starting. Local tags remain local.+The first launch generates a per-user encryption key in the OS config directory and reuses it for later launches. Set `HOMARR_DEV_SECRET_ENCRYPTION_KEY` to a 64-character hexadecimal key to override it.++The command reference below assumes the optional `homarr` installation. Without it, prefix each command with `pnpm dev:cli --` (for example, `pnpm dev:cli -- dev`).++## Commands++```text+homarr Interactive local and remote image browser+homarr dev Explicit alias for the main browser+homarr dash Start on the instance dashboard+homarr build <name> Build this checkout as homarr:<name>+homarr build --pr <number> Build a PR locally from a temporary checkout+homarr rebuild <name> Rebuild from recorded provenance+homarr list Script-friendly instance list+homarr logs <container> Follow logs+homarr open <container> Open in browser+homarr stop <container> Stop+homarr restart <container> Restart+homarr remove <container> Force-remove+homarr doctor Check Docker and optional CLI integrations+```++## Development Browser++```text+/ Filter by PR number, title, author, branch, CI, image, state, or port+↑/↓ or j/k Select+Enter or Space Start the matching local build, otherwise pull remote; stop when running+R Build a remote PR locally in the background or rebuild a local image+p Pull a remote PR image and redeploy, preserving port and volume+m Toggle demo mode for the next launch+o Open PR on GitHub+a Open running app+l Toggle inline logs for the selected running PR+f Follow or pause inline logs+Page Up/Down Scroll inline logs+b Show or hide bot PRs+r Refresh+d Switch to the instance dashboard+q Quit; during a pull, cancel it+```++Pull progress, layer completion, local build provenance, selected PR details, CI state, image availability, inline logs, and the final port remain inside the TUI.+Local PR images are folded into their remote PR row only when the recorded revision exactly matches the current GitHub head SHA. They are marked `◆ local` and preferred by Enter; outdated builds remain separate local rows. Navigation and the `d` dashboard toggle remain available while a local build runs.++## Instance Dashboard++```text+/ Filter by name, image, state, health, port, or URL+↑/↓ or j/k Select+l Toggle inline logs+f Follow or pause logs+Page Up/Down Scroll logs+s Stop+R Restart+x Remove with confirmation+o Open in browser+c Copy URL+r Refresh+d Switch to the development browser+q Quit+```diff --git a/tools/homarr-dev/go.mod b/tools/homarr-dev/go.modnew file mode 100644index 000000000..6a40e27cf--- /dev/null+++ b/tools/homarr-dev/go.mod@@ -0,0 +1,32 @@+module github.com/homarr-labs/homarr/tools/homarr-dev++go 1.25.0++require (+ charm.land/bubbles/v2 v2.1.1+ charm.land/bubbletea/v2 v2.0.8+ charm.land/lipgloss/v2 v2.0.5+ github.com/atotto/clipboard v0.1.4+ github.com/spf13/cobra v1.10.2+)++require (+ github.com/charmbracelet/colorprofile v0.4.3 // indirect+ github.com/charmbracelet/harmonica v0.2.0 // indirect+ github.com/charmbracelet/ultraviolet v0.0.0-20260703014108-f5a850f9c2b7 // indirect+ github.com/charmbracelet/x/ansi v0.11.7 // indirect+ github.com/charmbracelet/x/term v0.2.2 // indirect+ github.com/charmbracelet/x/termios v0.1.1 // indirect+ github.com/charmbracelet/x/windows v0.2.2 // indirect+ github.com/clipperhouse/displaywidth v0.11.0 // indirect+ github.com/clipperhouse/uax29/v2 v2.7.0 // indirect+ github.com/inconshreveable/mousetrap v1.1.0 // indirect+ github.com/lucasb-eyer/go-colorful v1.4.0 // indirect+ github.com/mattn/go-runewidth v0.0.24 // indirect+ github.com/muesli/cancelreader v0.2.2 // indirect+ github.com/rivo/uniseg v0.4.7 // indirect+ github.com/spf13/pflag v1.0.9 // indirect+ github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect+ golang.org/x/sync v0.21.0 // indirect+ golang.org/x/sys v0.46.0 // indirect+)diff --git a/tools/homarr-dev/go.sum b/tools/homarr-dev/go.sumnew file mode 100644index 000000000..cf4f9f13b--- /dev/null+++ b/tools/homarr-dev/go.sum@@ -0,0 +1,56 @@+charm.land/bubbles/v2 v2.1.1 h1:7r55WzBxpo/R3z98hGmY7KKPd3ET6vsf0Fb9sDHOV60=+charm.land/bubbles/v2 v2.1.1/go.mod h1:GE6M31gaWZVXzGw73OeuTTgy4lX+OtkH0E5ymnNsHxo=+charm.land/bubbletea/v2 v2.0.8 h1:SxTJMhCAI3lbPmy4SgX5LWZ24AdINr4I6UEqzZvYJuY=+charm.land/bubbletea/v2 v2.0.8/go.mod h1:2SkdgoTXluXJHOUwAoRlRXF/28vklb1rFl6GcgV1/ss=+charm.land/lipgloss/v2 v2.0.5 h1:kbNxgeeUOYv5J0YdpxFjfvf3dFvqH8Aci4zB6xqFtrY=+charm.land/lipgloss/v2 v2.0.5/go.mod h1:9oqhxt4yxIMe6q5A4kHr44DremZk7J9UNh74GlWa5nc=+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=+github.com/aymanbagabas/go-udiff v0.4.1 h1:OEIrQ8maEeDBXQDoGCbbTTXYJMYRCRO1fnodZ12Gv5o=+github.com/aymanbagabas/go-udiff v0.4.1/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=+github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=+github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=+github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=+github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=+github.com/charmbracelet/ultraviolet v0.0.0-20260703014108-f5a850f9c2b7 h1:3FmWoGNWK4STvqg0O0Aeav2T7rodWJAPeF0QpH+8gFw=+github.com/charmbracelet/ultraviolet v0.0.0-20260703014108-f5a850f9c2b7/go.mod h1:f/jRa757WUmaOZrbPspXymbg/GnbF+rwe4OLsG7aXYo=+github.com/charmbracelet/x/ansi v0.11.7 h1:kzv1kJvjg2S3r9KHo8hDdHFQLEqn4RBCb39dAYC84jI=+github.com/charmbracelet/x/ansi v0.11.7/go.mod h1:9qGpnAVYz+8ACONkZBUWPtL7lulP9No6p1epAihUZwQ=+github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f h1:pk6gmGpCE7F3FcjaOEKYriCvpmIN4+6OS/RD0vm4uIA=+github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f/go.mod h1:IfZAMTHB6XkZSeXUqriemErjAWCCzT0LwjKFYCZyw0I=+github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=+github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=+github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8JawjaNZY=+github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=+github.com/charmbracelet/x/windows v0.2.2 h1:IofanmuvaxnKHuV04sC0eBy/smG6kIKrWG2/jYn2GuM=+github.com/charmbracelet/x/windows v0.2.2/go.mod h1:/8XtdKZzedat74NQFn0NGlGL4soHB0YQZrETF96h75k=+github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=+github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=+github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=+github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=+github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=+github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=+github.com/mattn/go-runewidth v0.0.24 h1:cpokDiIn0MGnhdHwuWnJBITySJ20QyNGnY2kR/ay2DU=+github.com/mattn/go-runewidth v0.0.24/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=diff --git a/tools/homarr-dev/internal/docker/docker.go b/tools/homarr-dev/internal/docker/docker.gonew file mode 100644index 000000000..da5f2fa92--- /dev/null+++ b/tools/homarr-dev/internal/docker/docker.go@@ -0,0 +1,427 @@+package docker++import (+ "context"+ "crypto/rand"+ "encoding/hex"+ "encoding/json"+ "fmt"+ "io"+ "net"+ "os"+ "os/exec"+ "path/filepath"+ "strconv"+ "strings"+ "time"+)++const developmentEncryptionKeyEnv = "HOMARR_DEV_SECRET_ENCRYPTION_KEY"++type Container struct {+ ID string+ Name string+ Image string+ Status string+ Ports string+ State string+}++func (c Container) HostPort() string {+ for _, mapping := range strings.Split(c.Ports, ", ") {+ if strings.HasSuffix(mapping, "->7575/tcp") {+ parts := strings.Split(mapping, "->")+ left := parts[0]+ if i := strings.LastIndex(left, ":"); i >= 0 {+ return left[i+1:]+ }+ return left+ }+ }+ return ""+}++func (c Container) Running() bool {+ return c.State == "running"+}++func List() ([]Container, error) {+ out, err := exec.Command("docker", "ps", "-a",+ "--filter", "name=homarr",+ "--format", "{{json .}}").Output()+ if err != nil {+ return nil, err+ }++ var containers []Container+ for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {+ if line == "" {+ continue+ }+ var raw struct {+ ID string+ Names string+ Image string+ Status string+ Ports string+ State string+ }+ if err := json.Unmarshal([]byte(line), &raw); err != nil {+ continue+ }+ containers = append(containers, Container{+ ID: raw.ID,+ Name: raw.Names,+ Image: raw.Image,+ Status: raw.Status,+ Ports: raw.Ports,+ State: raw.State,+ })+ }+ filtered := containers[:0]+ for _, c := range containers {+ if c.Name == "homarr" || strings.HasPrefix(c.Name, "homarr_") {+ filtered = append(filtered, c)+ }+ }+ return filtered, nil+}++func FindFreePort(start int) int {+ if start > 65535 {+ return 0+ }+ used := usedDockerPorts()+ start = max(start, 1)+ for port := start; port <= 65535; port++ {+ if used[port] {+ continue+ }+ listener, err := net.Listen("tcp4", fmt.Sprintf("0.0.0.0:%d", port))+ if err == nil {+ _ = listener.Close()+ return port+ }+ }+ return 0+}++func usedDockerPorts() map[int]bool {+ out, err := exec.Command("docker", "ps", "--format", "{{.Ports}}").Output()+ if err != nil {+ return make(map[int]bool)+ }+ return parseUsedDockerPorts(out)+}++func parseUsedDockerPorts(out []byte) map[int]bool {+ used := make(map[int]bool)+ for _, line := range strings.Split(string(out), "\n") {+ for _, mapping := range strings.Split(line, ",") {+ left, _, found := strings.Cut(mapping, "->")+ if !found {+ continue+ }+ colon := strings.LastIndex(left, ":")+ if colon < 0 {+ continue+ }+ ports := strings.SplitN(strings.TrimSpace(left[colon+1:]), "-", 2)+ first, err := strconv.Atoi(ports[0])+ if err != nil {+ continue+ }+ last := first+ if len(ports) == 2 {+ if parsed, err := strconv.Atoi(ports[1]); err == nil {+ last = parsed+ }+ }+ for port := first; port <= last; port++ {+ used[port] = true+ }+ }+ }+ return used+}++func IsRunning(name string) bool {+ containers, _ := List()+ for _, c := range containers {+ if c.Name == name && c.Running() {+ return true+ }+ }+ return false+}++type StartOptions struct {+ Name string+ Image string+ Volume string+ HostPort int+ Env []string+ Platform string+ PullAlways bool+ Daemon bool+}++func Start(opts StartOptions) error {+ encryptionKey, err := developmentEncryptionKey()+ if err != nil {+ return err+ }++ if opts.PullAlways {+ cmd := PullCommand(opts.Image, opts.Platform)+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ if err := cmd.Run(); err != nil {+ return fmt.Errorf("pull %s: %w", opts.Image, err)+ }+ }++ _ = exec.Command("docker", "rm", "-f", opts.Name).Run()++ args := []string{"run", "--rm", "--name", opts.Name,+ "-e", "SECRET_ENCRYPTION_KEY=" + encryptionKey,+ }+ if opts.Platform != "" {+ args = append(args, "--platform", opts.Platform)+ }+ if opts.Daemon {+ args = append(args, "-d")+ } else {+ args = append(args, "-it")+ }+ for _, env := range opts.Env {+ args = append(args, "-e", env)+ }+ args = append(args,+ "-v", opts.Volume+":/appdata",+ "-v", "/var/run/docker.sock:/var/run/docker.sock:ro",+ "-p", fmt.Sprintf("%d:7575", opts.HostPort),+ opts.Image,+ )++ cmd := exec.Command("docker", args...)+ if opts.Daemon {+ out, err := cmd.CombinedOutput()+ if err != nil {+ return fmt.Errorf("%w: %s", err, cleanOutput(out))+ }+ return nil+ }+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ stderr := &tailBuffer{}+ cmd.Stderr = io.MultiWriter(os.Stderr, stderr)+ if err := cmd.Run(); err != nil {+ return fmt.Errorf("%w: %s", err, cleanOutput(stderr.data))+ }+ return nil+}++func developmentEncryptionKey() (string, error) {+ if key := os.Getenv(developmentEncryptionKeyEnv); key != "" {+ return validateDevelopmentEncryptionKey(key)+ }+ configDir, err := os.UserConfigDir()+ if err != nil {+ return "", fmt.Errorf("locate user config directory: %w", err)+ }+ return persistedDevelopmentEncryptionKey(configDir)+}++func persistedDevelopmentEncryptionKey(configDir string) (string, error) {+ dir := filepath.Join(configDir, "homarr-dev")+ path := filepath.Join(dir, "secret-encryption-key")+ if key, found, err := readDevelopmentEncryptionKey(path); found || err != nil {+ return key, err+ }++ if err := os.MkdirAll(dir, 0o700); err != nil {+ return "", fmt.Errorf("create development config directory: %w", err)+ }+ lockPath := path + ".lock"+ for attempts := 0; ; attempts++ {+ if err := os.Mkdir(lockPath, 0o700); err == nil {+ break+ } else if !os.IsExist(err) {+ return "", fmt.Errorf("lock development encryption key: %w", err)+ }+ if key, found, err := readDevelopmentEncryptionKey(path); found || err != nil {+ return key, err+ }+ if attempts == 99 {+ return "", fmt.Errorf("timed out waiting for development encryption key lock %q", lockPath)+ }+ time.Sleep(10 * time.Millisecond)+ }+ defer func() { _ = os.Remove(lockPath) }()++ if key, found, err := readDevelopmentEncryptionKey(path); found || err != nil {+ return key, err+ }+ keyBytes := make([]byte, 32)+ if _, err := rand.Read(keyBytes); err != nil {+ return "", fmt.Errorf("generate development encryption key: %w", err)+ }+ key := hex.EncodeToString(keyBytes)+ file, err := os.CreateTemp(dir, "secret-encryption-key-*.tmp")+ if err != nil {+ return "", fmt.Errorf("create development encryption key: %w", err)+ }+ tempPath := file.Name()+ defer func() { _ = os.Remove(tempPath) }()+ if _, err := file.WriteString(key + "\n"); err != nil {+ _ = file.Close()+ return "", fmt.Errorf("write development encryption key: %w", err)+ }+ if err := file.Close(); err != nil {+ return "", fmt.Errorf("close development encryption key: %w", err)+ }+ if err := os.Chmod(tempPath, 0o600); err != nil {+ return "", fmt.Errorf("secure development encryption key: %w", err)+ }+ if err := os.Rename(tempPath, path); err != nil {+ return "", fmt.Errorf("persist development encryption key: %w", err)+ }+ return key, nil+}++func readDevelopmentEncryptionKey(path string) (string, bool, error) {+ data, err := os.ReadFile(path)+ if os.IsNotExist(err) {+ return "", false, nil+ }+ if err != nil {+ return "", false, fmt.Errorf("read development encryption key: %w", err)+ }+ key, err := validateDevelopmentEncryptionKey(strings.TrimSpace(string(data)))+ return key, true, err+}++func validateDevelopmentEncryptionKey(key string) (string, error) {+ decoded, err := hex.DecodeString(key)+ if err != nil || len(decoded) != 32 {+ return "", fmt.Errorf("development encryption key must contain exactly 64 hexadecimal characters")+ }+ return key, nil+}++type tailBuffer struct {+ data []byte+}++func (b *tailBuffer) Write(p []byte) (int, error) {+ const limit = 32 * 1024+ b.data = append(b.data, p...)+ if len(b.data) > limit {+ b.data = b.data[len(b.data)-limit:]+ }+ return len(p), nil+}++func cleanOutput(out []byte) string {+ lines := strings.Split(strings.TrimSpace(string(out)), "\n")+ cleaned := make([]string, 0, len(lines))+ for _, line := range lines {+ line = strings.TrimSpace(line)+ if strings.HasPrefix(line, "WARNING: The requested image's platform") || isContainerID(line) {+ continue+ }+ if line != "" {+ cleaned = append(cleaned, line)+ }+ }+ return strings.Join(cleaned, "\n")+}++func isContainerID(value string) bool {+ if len(value) != 64 {+ return false+ }+ for _, r := range value {+ if !(r >= '0' && r <= '9') && !(r >= 'a' && r <= 'f') {+ return false+ }+ }+ return true+}++func PullCommand(image, platform string) *exec.Cmd {+ return PullCommandContext(context.Background(), image, platform)+}++func PullCommandContext(ctx context.Context, image, platform string) *exec.Cmd {+ args := []string{"pull"}+ if platform != "" {+ args = append(args, "--platform", platform)+ }+ args = append(args, image)+ cmd := exec.CommandContext(ctx, "docker", args...)+ if platform != "" {+ cmd.Env = append(os.Environ(), "DOCKER_DEFAULT_PLATFORM="+platform)+ }+ return cmd+}++func IsPortConflict(err error) bool {+ if err == nil {+ return false+ }+ message := strings.ToLower(err.Error())+ return strings.Contains(message, "port is already allocated") ||+ strings.Contains(message, "address already in use") ||+ strings.Contains(message, "failed programming external connectivity")+}++func Stop(name string) error {+ cmd := exec.Command("docker", "stop", name)+ out, err := cmd.CombinedOutput()+ if err != nil {+ return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))+ }+ return nil+}++func Restart(name string) error {+ cmd := exec.Command("docker", "restart", name)+ out, err := cmd.CombinedOutput()+ if err != nil {+ return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))+ }+ return nil+}++func Remove(name string) error {+ cmd := exec.Command("docker", "rm", "-f", name)+ out, err := cmd.CombinedOutput()+ if err != nil {+ return fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))+ }+ return nil+}++func CheckImage(image string) (bool, error) {+ cmd := exec.Command("docker", "manifest", "inspect", image)+ out, err := cmd.CombinedOutput()+ if err == nil {+ return true, nil+ }+ message := strings.ToLower(string(out))+ if strings.Contains(message, "manifest unknown") || strings.Contains(message, "no such manifest") {+ return false, nil+ }+ return false, fmt.Errorf("check image %s: %w: %s", image, err, strings.TrimSpace(string(out)))+}++func FollowLogs(name string) error {+ cmd := exec.Command("docker", "logs", "-f", "--tail", "100", name)+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd.Run()+}diff --git a/tools/homarr-dev/internal/docker/docker_test.go b/tools/homarr-dev/internal/docker/docker_test.gonew file mode 100644index 000000000..3422c703d--- /dev/null+++ b/tools/homarr-dev/internal/docker/docker_test.go@@ -0,0 +1,125 @@+package docker++import (+ "encoding/hex"+ "errors"+ "os"+ "path/filepath"+ "strings"+ "testing"+)++func TestContainerHostPort(t *testing.T) {+ c := Container{Ports: "0.0.0.0:7576->7575/tcp, [::]:7576->7575/tcp"}+ if got := c.HostPort(); got != "7576" {+ t.Fatalf("HostPort() = %q, want 7576", got)+ }+}++func TestIsPortConflict(t *testing.T) {+ for _, message := range []string{+ "Bind for 0.0.0.0:7575 failed: port is already allocated",+ "driver failed programming external connectivity on endpoint",+ } {+ if !IsPortConflict(errors.New(message)) {+ t.Fatalf("expected port conflict for %q", message)+ }+ }+ if IsPortConflict(errors.New("manifest unknown")) {+ t.Fatal("manifest error classified as port conflict")+ }+}++func TestParseUsedDockerPortsPreservesLineBoundaries(t *testing.T) {+ ports := parseUsedDockerPorts([]byte("6379/tcp\n0.0.0.0:7575->7575/tcp, [::]:7575->7575/tcp\n0.0.0.0:8000-8002->8000-8002/tcp\n"))+ for _, port := range []int{7575, 8000, 8001, 8002} {+ if !ports[port] {+ t.Fatalf("port %d was not detected", port)+ }+ }+}++func TestFindFreePortRejectsOutOfRangeStart(t *testing.T) {+ if port := FindFreePort(65536); port != 0 {+ t.Fatalf("port = %d, want 0", port)+ }+}++func TestDevelopmentEncryptionKeyUsesEnvironmentOverride(t *testing.T) {+ want := strings.Repeat("a", 64)+ t.Setenv(developmentEncryptionKeyEnv, want)+ got, err := developmentEncryptionKey()+ if err != nil {+ t.Fatal(err)+ }+ if got != want {+ t.Fatalf("key = %q, want environment value", got)+ }+}++func TestPersistedDevelopmentEncryptionKeyIsReused(t *testing.T) {+ configDir := t.TempDir()+ first, err := persistedDevelopmentEncryptionKey(configDir)+ if err != nil {+ t.Fatal(err)+ }+ second, err := persistedDevelopmentEncryptionKey(configDir)+ if err != nil {+ t.Fatal(err)+ }+ if first != second {+ t.Fatal("persisted key changed between reads")+ }+ decoded, err := hex.DecodeString(first)+ if err != nil || len(decoded) != 32 {+ t.Fatalf("generated key is not 32 bytes: %q", first)+ }+ info, err := os.Stat(filepath.Join(configDir, "homarr-dev", "secret-encryption-key"))+ if err != nil {+ t.Fatal(err)+ }+ if info.Mode().Perm() != 0o600 {+ t.Fatalf("key permissions = %o, want 600", info.Mode().Perm())+ }+}++func TestPersistedDevelopmentEncryptionKeyRejectsInvalidValue(t *testing.T) {+ configDir := t.TempDir()+ dir := filepath.Join(configDir, "homarr-dev")+ if err := os.Mkdir(dir, 0o700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(dir, "secret-encryption-key"), []byte("invalid\n"), 0o600); err != nil {+ t.Fatal(err)+ }+ if _, err := persistedDevelopmentEncryptionKey(configDir); err == nil {+ t.Fatal("expected invalid persisted key to fail")+ }+}++func TestPersistedDevelopmentEncryptionKeyConcurrentCreation(t *testing.T) {+ configDir := t.TempDir()+ type result struct {+ key string+ err error+ }+ results := make(chan result, 20)+ for range 20 {+ go func() {+ key, err := persistedDevelopmentEncryptionKey(configDir)+ results <- result{key: key, err: err}+ }()+ }+ var first string+ for range 20 {+ result := <-results+ if result.err != nil {+ t.Fatal(result.err)+ }+ if first == "" {+ first = result.key+ } else if result.key != first {+ t.Fatal("concurrent callers received different keys")+ }+ }+}diff --git a/tools/homarr-dev/internal/docker/images.go b/tools/homarr-dev/internal/docker/images.gonew file mode 100644index 000000000..cb4f16e66--- /dev/null+++ b/tools/homarr-dev/internal/docker/images.go@@ -0,0 +1,149 @@+package docker++import (+ "context"+ "encoding/json"+ "fmt"+ "io"+ "os"+ "os/exec"+ "path/filepath"+ "regexp"+ "strconv"+ "strings"+)++const (+ SourceLabel = "org.homarr.dev.source"+ RevisionLabel = "org.homarr.dev.revision"+ PRLabel = "org.homarr.dev.pr"+)++var tagPattern = regexp.MustCompile(`^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$`)++type Image struct {+ ID string+ Tag string+ Source string+ Revision string+ PRNumber int+}++func (image Image) Reference() string {+ return "homarr:" + image.Tag+}++type imageListRow struct {+ ID string+ Repository string+ Tag string+}++func parseImageList(output []byte) ([]Image, error) {+ images := make([]Image, 0)+ for _, line := range strings.Split(strings.TrimSpace(string(output)), "\n") {+ if line == "" {+ continue+ }+ var row imageListRow+ if err := json.Unmarshal([]byte(line), &row); err != nil {+ return nil, fmt.Errorf("parse local Docker image: %w", err)+ }+ if row.Repository == "homarr" && row.Tag != "<none>" {+ images = append(images, Image{ID: row.ID, Tag: row.Tag})+ }+ }+ return images, nil+}++func ListLocalImages(ctx context.Context) ([]Image, error) {+ out, err := exec.CommandContext(ctx, "docker", "image", "ls", "--filter", "reference=homarr:*", "--format", "{{json .}}").Output()+ if err != nil {+ return nil, fmt.Errorf("list local Homarr images: %w", err)+ }+ images, err := parseImageList(out)+ if err != nil {+ return nil, err+ }+ labelsByImage, err := inspectImageLabels(ctx, images)+ if err != nil {+ return nil, err+ }+ for index, labels := range labelsByImage {+ images[index].Source = labels[SourceLabel]+ images[index].Revision = labels[RevisionLabel]+ images[index].PRNumber, _ = strconv.Atoi(labels[PRLabel])+ }+ return images, nil+}++func inspectImageLabels(ctx context.Context, images []Image) ([]map[string]string, error) {+ if len(images) == 0 {+ return nil, nil+ }+ args := []string{"image", "inspect", "--format", "{{json .Config.Labels}}"}+ for _, image := range images {+ args = append(args, image.Reference())+ }+ out, err := exec.CommandContext(ctx, "docker", args...).Output()+ if err != nil {+ return nil, fmt.Errorf("inspect local Homarr images: %w", err)+ }+ lines := strings.Split(strings.TrimSpace(string(out)), "\n")+ if len(lines) != len(images) {+ return nil, fmt.Errorf("inspect returned %d images, expected %d", len(lines), len(images))+ }+ labelsByImage := make([]map[string]string, len(images))+ for index, line := range lines {+ labelsByImage[index] = make(map[string]string)+ if line == "null" {+ continue+ }+ if err := json.Unmarshal([]byte(line), &labelsByImage[index]); err != nil {+ return nil, fmt.Errorf("parse labels for %s: %w", images[index].Reference(), err)+ }+ }+ return labelsByImage, nil+}++type BuildOptions struct {+ Context string+ Tag string+ Source string+ Revision string+ PRNumber int+}++func BuildCommand(ctx context.Context, options BuildOptions) (*exec.Cmd, error) {+ if !tagPattern.MatchString(options.Tag) {+ return nil, fmt.Errorf("invalid image name %q", options.Tag)+ }+ contextPath, err := filepath.Abs(options.Context)+ if err != nil {+ return nil, fmt.Errorf("resolve build context: %w", err)+ }+ if info, err := os.Stat(filepath.Join(contextPath, "Dockerfile")); err != nil || info.IsDir() {+ return nil, fmt.Errorf("%s does not contain a Dockerfile", contextPath)+ }+ args := []string{"build", "--label", SourceLabel + "=" + options.Source, "--label", RevisionLabel + "=" + options.Revision}+ if options.PRNumber > 0 {+ args = append(args, "--label", fmt.Sprintf("%s=%d", PRLabel, options.PRNumber))+ }+ args = append(args, "-t", "homarr:"+options.Tag, ".")+ command := exec.CommandContext(ctx, "docker", args...)+ command.Dir = contextPath+ return command, nil+}++func BuildContext(ctx context.Context, options BuildOptions, stdout, stderr io.Writer) error {+ command, err := BuildCommand(ctx, options)+ if err != nil {+ return err+ }+ command.Stdout = stdout+ command.Stderr = stderr+ if err := command.Run(); err != nil {+ return fmt.Errorf("build homarr:%s: %w", options.Tag, err)+ }+ return nil+}diff --git a/tools/homarr-dev/internal/docker/images_test.go b/tools/homarr-dev/internal/docker/images_test.gonew file mode 100644index 000000000..559a9423a--- /dev/null+++ b/tools/homarr-dev/internal/docker/images_test.go@@ -0,0 +1,69 @@+package docker++import (+ "os"+ "testing"+)++func TestParseImageListFiltersHomarrTags(t *testing.T) {+ output := []byte("{\"ID\":\"sha256:1\",\"Repository\":\"homarr\",\"Tag\":\"dev\"}\n{\"ID\":\"sha256:2\",\"Repository\":\"other\",\"Tag\":\"dev\"}\n")+ images, err := parseImageList(output)+ if err != nil {+ t.Fatal(err)+ }+ if len(images) != 1 || images[0].Reference() != "homarr:dev" {+ t.Fatalf("images = %#v, want homarr:dev", images)+ }+}++func TestInspectImageLabelsWithNoImages(t *testing.T) {+ labels, err := inspectImageLabels(t.Context(), nil)+ if err != nil {+ t.Fatal(err)+ }+ if labels != nil {+ t.Fatalf("labels = %#v, want nil", labels)+ }+}++func TestBuildCommandIncludesProvenance(t *testing.T) {+ command, err := BuildCommand(t.Context(), BuildOptions{+ Context: "../../../..",+ Tag: "feature",+ Source: "/tmp/homarr",+ Revision: "abc123",+ PRNumber: 42,+ })+ if err != nil {+ t.Fatal(err)+ }+ want := []string{"docker", "build", "--label", SourceLabel + "=/tmp/homarr", "--label", RevisionLabel + "=abc123", "--label", PRLabel + "=42", "-t", "homarr:feature", "."}+ if len(command.Args) != len(want) {+ t.Fatalf("args = %v, want %v", command.Args, want)+ }+ for index := range want {+ if command.Args[index] != want[index] {+ t.Fatalf("args = %v, want %v", command.Args, want)+ }+ }+}++func TestListLocalImagesIntegration(t *testing.T) {+ wantTag := os.Getenv("HOMARR_TEST_LOCAL_IMAGE")+ if wantTag == "" {+ t.Skip("set HOMARR_TEST_LOCAL_IMAGE to a local homarr image tag")+ }+ images, err := ListLocalImages(t.Context())+ if err != nil {+ t.Fatal(err)+ }+ for _, image := range images {+ if image.Tag == wantTag {+ if image.Source == "" || image.Revision == "" {+ t.Fatalf("image %#v is missing provenance", image)+ }+ return+ }+ }+ t.Fatalf("homarr:%s was not discovered", wantTag)+}diff --git a/tools/homarr-dev/internal/gh/gh.go b/tools/homarr-dev/internal/gh/gh.gonew file mode 100644index 000000000..c4e61e6fe--- /dev/null+++ b/tools/homarr-dev/internal/gh/gh.go@@ -0,0 +1,199 @@+package gh++import (+ "context"+ "encoding/json"+ "fmt"+ "os/exec"+ "strings"+ "sync"+ "time"+)++const Repo = "homarr-labs/homarr"+const prCacheTTL = 5 * time.Minute++var prListCache = struct {+ sync.Mutex+ entries map[int]cachedPRs+}{entries: make(map[int]cachedPRs)}++type cachedPRs struct {+ prs []PR+ fetchedAt time.Time+}++func isBot(login string) bool {+ return strings.HasSuffix(login, "[bot]") || strings.HasPrefix(login, "app/")+}++type PR struct {+ Number int `json:"number"`+ Title string `json:"title"`+ Author string `json:"author"`+ HeadRef string `json:"headRefName"`+ HeadSHA string `json:"headRefOid"`+ CIState string `json:"ciState"`+ IsDraft bool `json:"isDraft"`+ UpdatedAt string `json:"updatedAt"`+}++type rawPR struct {+ Number int `json:"number"`+ Title string `json:"title"`+ IsDraft bool `json:"isDraft"`+ Author struct {+ Login string `json:"login"`+ } `json:"author"`+ HeadRefName string `json:"headRefName"`+ HeadRefOID string `json:"headRefOid"`+ UpdatedAt string `json:"updatedAt"`+ StatusCheckRollup []rawCheck `json:"statusCheckRollup"`+}++type rawCheck struct {+ Status string `json:"status"`+ Conclusion string `json:"conclusion"`+ State string `json:"state"`+}++func rollupState(checks []rawCheck) string {+ if len(checks) == 0 {+ return "NONE"+ }+ failed, pending := 0, 0+ for _, c := range checks {+ if c.State != "" {+ switch c.State {+ case "SUCCESS":+ case "PENDING", "EXPECTED":+ pending+++ default:+ failed+++ }+ continue+ }+ if c.Status != "COMPLETED" {+ pending+++ continue+ }+ switch c.Conclusion {+ case "SUCCESS", "SKIPPED", "NEUTRAL":+ default:+ failed+++ }+ }+ if failed > 0 {+ return "FAILURE"+ }+ if pending > 0 {+ return "PENDING"+ }+ return "SUCCESS"+}++func ListPRs(ctx context.Context, limit int, includeBots bool) ([]PR, error) {+ return listPRs(ctx, limit, includeBots, false)+}++func RefreshPRs(ctx context.Context, limit int, includeBots bool) ([]PR, error) {+ return listPRs(ctx, limit, includeBots, true)+}++func listPRs(ctx context.Context, limit int, includeBots, refresh bool) ([]PR, error) {+ cached, fetchedAt := cachedPRList(limit)+ if !refresh && !fetchedAt.IsZero() && time.Since(fetchedAt) < prCacheTTL {+ return filterPRs(cached, includeBots), nil+ }++ out, err := exec.CommandContext(ctx, "gh", "pr", "list",+ "--repo", Repo,+ "--state", "open",+ "--limit", fmt.Sprint(limit),+ "--json", "number,title,author,headRefName,headRefOid,updatedAt,isDraft,statusCheckRollup",+ ).CombinedOutput()+ if err != nil {+ err = commandError(err, out)+ if len(cached) > 0 {+ return filterPRs(cached, includeBots), fmt.Errorf("%w; showing cached PRs from %s", err, fetchedAt.Format(time.Kitchen))+ }+ return nil, err+ }++ var raws []rawPR+ if err := json.Unmarshal(out, &raws); err != nil {+ return nil, err+ }++ prs := make([]PR, 0, len(raws))+ for _, r := range raws {+ prs = append(prs, PR{+ Number: r.Number,+ Title: r.Title,+ Author: r.Author.Login,+ HeadRef: r.HeadRefName,+ HeadSHA: r.HeadRefOID,+ CIState: rollupState(r.StatusCheckRollup),+ IsDraft: r.IsDraft,+ UpdatedAt: r.UpdatedAt,+ })+ }+ storePRList(limit, prs)+ return filterPRs(prs, includeBots), nil+}++func cachedPRList(limit int) ([]PR, time.Time) {+ prListCache.Lock()+ defer prListCache.Unlock()+ entry := prListCache.entries[limit]+ return append([]PR(nil), entry.prs...), entry.fetchedAt+}++func storePRList(limit int, prs []PR) {+ prListCache.Lock()+ defer prListCache.Unlock()+ prListCache.entries[limit] = cachedPRs{prs: append([]PR(nil), prs...), fetchedAt: time.Now()}+}++func filterPRs(prs []PR, includeBots bool) []PR {+ filtered := make([]PR, 0, len(prs))+ for _, pr := range prs {+ if includeBots || !isBot(pr.Author) {+ filtered = append(filtered, pr)+ }+ }+ return filtered+}++func commandError(err error, output []byte) error {+ detail := strings.TrimSpace(string(output))+ if detail == "" {+ return err+ }+ return fmt.Errorf("%s: %w", detail, err)+}++func GetPR(ctx context.Context, number int) (*PR, error) {+ out, err := exec.CommandContext(ctx, "gh", "pr", "view", fmt.Sprint(number),+ "--repo", Repo,+ "--json", "number,title,author,headRefName,headRefOid,updatedAt,isDraft,statusCheckRollup",+ ).CombinedOutput()+ if err != nil {+ return nil, commandError(err, out)+ }++ var r rawPR+ if err := json.Unmarshal(out, &r); err != nil {+ return nil, err+ }+ return &PR{+ Number: r.Number,+ Title: r.Title,+ Author: r.Author.Login,+ HeadRef: r.HeadRefName,+ HeadSHA: r.HeadRefOID,+ CIState: rollupState(r.StatusCheckRollup),+ IsDraft: r.IsDraft,+ UpdatedAt: r.UpdatedAt,+ }, nil+}diff --git a/tools/homarr-dev/internal/gh/gh_test.go b/tools/homarr-dev/internal/gh/gh_test.gonew file mode 100644index 000000000..64e14e20c--- /dev/null+++ b/tools/homarr-dev/internal/gh/gh_test.go@@ -0,0 +1,91 @@+package gh++import (+ "errors"+ "os"+ "strings"+ "testing"+ "time"+)++func TestIsBot(t *testing.T) {+ tests := []struct {+ login string+ want bool+ }{+ {login: "app/homarr-renovate", want: true},+ {login: "dependabot[bot]", want: true},+ {login: "ajnart", want: false},+ }++ for _, test := range tests {+ if got := isBot(test.login); got != test.want {+ t.Errorf("isBot(%q) = %v, want %v", test.login, got, test.want)+ }+ }+}++func TestRollupStateHandlesChecksAndStatuses(t *testing.T) {+ tests := []struct {+ name string+ checks []rawCheck+ want string+ }{+ {name: "check success", checks: []rawCheck{{Status: "COMPLETED", Conclusion: "SUCCESS"}}, want: "SUCCESS"},+ {name: "status failure", checks: []rawCheck{{State: "FAILURE"}}, want: "FAILURE"},+ {name: "status pending", checks: []rawCheck{{State: "PENDING"}}, want: "PENDING"},+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ if got := rollupState(test.checks); got != test.want {+ t.Fatalf("rollupState() = %q, want %q", got, test.want)+ }+ })+ }+}++func TestCachedPRListFiltersBotsWithoutMutatingCache(t *testing.T) {+ limit := 9876+ storePRList(limit, []PR{{Number: 1, Author: "developer"}, {Number: 2, Author: "bot[bot]"}})++ prs, fetchedAt := cachedPRList(limit)+ if time.Since(fetchedAt) >= prCacheTTL {+ t.Fatal("new cache entry is already expired")+ }+ if filtered := filterPRs(prs, false); len(filtered) != 1 || filtered[0].Number != 1 {+ t.Fatalf("filtered PRs = %#v", filtered)+ }+ if unfiltered := filterPRs(prs, true); len(unfiltered) != 2 {+ t.Fatalf("unfiltered PR count = %d, want 2", len(unfiltered))+ }+}++func TestCommandErrorIncludesGitHubOutput(t *testing.T) {+ err := commandError(errors.New("exit status 1"), []byte("GraphQL: API rate limit exceeded\n"))+ if !strings.Contains(err.Error(), "API rate limit exceeded") {+ t.Fatalf("error = %q", err)+ }+}++func TestListPRsExcludesBotsIntegration(t *testing.T) {+ if os.Getenv("HOMARR_INTEGRATION_TEST") != "1" {+ t.Skip("set HOMARR_INTEGRATION_TEST=1 to query GitHub")+ }++ prs, err := ListPRs(t.Context(), 50, false)+ if err != nil {+ t.Fatal(err)+ }+ if len(prs) == 0 {+ t.Fatal("expected at least one human-authored open PR")+ }+ for _, pr := range prs {+ if isBot(pr.Author) {+ t.Fatalf("bot PR was not filtered: #%d by %s", pr.Number, pr.Author)+ }+ if pr.HeadSHA == "" {+ t.Fatalf("PR #%d has no head SHA", pr.Number)+ }+ }+}diff --git a/tools/homarr-dev/internal/platform/clipboard.go b/tools/homarr-dev/internal/platform/clipboard.gonew file mode 100644index 000000000..1dfdc7fdf--- /dev/null+++ b/tools/homarr-dev/internal/platform/clipboard.go@@ -0,0 +1,7 @@+package platform++import "github.com/atotto/clipboard"++func CopyText(value string) error {+ return clipboard.WriteAll(value)+}diff --git a/tools/homarr-dev/internal/platform/open.go b/tools/homarr-dev/internal/platform/open.gonew file mode 100644index 000000000..3be91d562--- /dev/null+++ b/tools/homarr-dev/internal/platform/open.go@@ -0,0 +1,28 @@+package platform++import (+ "fmt"+ "os/exec"+ "runtime"+)++func OpenURL(url string) error {+ name, args, err := openCommand(runtime.GOOS, url)+ if err != nil {+ return err+ }+ return exec.Command(name, args...).Start()+}++func openCommand(goos, url string) (string, []string, error) {+ switch goos {+ case "darwin":+ return "open", []string{url}, nil+ case "linux":+ return "xdg-open", []string{url}, nil+ case "windows":+ return "rundll32", []string{"url.dll,FileProtocolHandler", url}, nil+ default:+ return "", nil, fmt.Errorf("opening URLs is not supported on %s", goos)+ }+}diff --git a/tools/homarr-dev/internal/platform/open_test.go b/tools/homarr-dev/internal/platform/open_test.gonew file mode 100644index 000000000..413d9ee97--- /dev/null+++ b/tools/homarr-dev/internal/platform/open_test.go@@ -0,0 +1,25 @@+package platform++import "testing"++func TestOpenCommand(t *testing.T) {+ tests := []struct {+ goos string+ name string+ }{+ {goos: "darwin", name: "open"},+ {goos: "linux", name: "xdg-open"},+ {goos: "windows", name: "rundll32"},+ }+ for _, test := range tests {+ t.Run(test.goos, func(t *testing.T) {+ name, args, err := openCommand(test.goos, "https://example.com")+ if err != nil {+ t.Fatal(err)+ }+ if name != test.name || len(args) == 0 {+ t.Fatalf("command = %s %v", name, args)+ }+ })+ }+}diff --git a/tools/homarr-dev/internal/run/build.go b/tools/homarr-dev/internal/run/build.gonew file mode 100644index 000000000..de78fd291--- /dev/null+++ b/tools/homarr-dev/internal/run/build.go@@ -0,0 +1,105 @@+package run++import (+ "context"+ "fmt"+ "io"+ "os"+ "os/exec"+ "path/filepath"+ "strconv"+ "strings"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"+)++func BuildCurrentImage(tag, directory string) error {+ return buildCurrentImage(context.Background(), tag, directory, os.Stdout, os.Stderr)+}++func buildCurrentImage(ctx context.Context, tag, directory string, stdout, stderr io.Writer) error {+ root, revision, err := checkoutDetails(ctx, directory)+ if err != nil {+ return err+ }+ return docker.BuildContext(ctx, docker.BuildOptions{Context: root, Tag: tag, Source: root, Revision: revision}, stdout, stderr)+}++func BuildPRImage(number int, tag string) error {+ return buildPRImage(context.Background(), number, tag, os.Stdout, os.Stderr)+}++func buildPRImage(ctx context.Context, number int, tag string, stdout, stderr io.Writer) error {+ if number <= 0 {+ return fmt.Errorf("PR number must be positive")+ }+ temporaryRoot, err := os.MkdirTemp("", "homarr-pr-*")+ if err != nil {+ return fmt.Errorf("create temporary checkout: %w", err)+ }+ defer os.RemoveAll(temporaryRoot)++ checkout := filepath.Join(temporaryRoot, "homarr")+ clone := exec.CommandContext(ctx, "gh", prCloneArgs(checkout)...)+ clone.Stdout = stdout+ clone.Stderr = stderr+ if err := clone.Run(); err != nil {+ return fmt.Errorf("clone %s: %w", gh.Repo, err)+ }+ command := exec.CommandContext(ctx, "gh", "pr", "checkout", strconv.Itoa(number), "--detach")+ command.Dir = checkout+ command.Stdout = stdout+ command.Stderr = stderr+ if err := command.Run(); err != nil {+ return fmt.Errorf("checkout PR #%d: %w", number, err)+ }+ _, revision, err := checkoutDetails(ctx, checkout)+ if err != nil {+ return err+ }+ return docker.BuildContext(ctx, docker.BuildOptions{+ Context: checkout,+ Tag: tag,+ Source: fmt.Sprintf("https://github.com/%s/pull/%d", gh.Repo, number),+ Revision: revision,+ PRNumber: number,+ }, stdout, stderr)+}++func prCloneArgs(checkout string) []string {+ return []string{"repo", "clone", gh.Repo, checkout, "--", "--depth=1", "--filter=blob:none"}+}++func RebuildImage(image docker.Image) error {+ return RebuildImageContext(context.Background(), image, os.Stdout, os.Stderr)+}++func RebuildImageContext(ctx context.Context, image docker.Image, stdout, stderr io.Writer) error {+ if image.PRNumber > 0 {+ return buildPRImage(ctx, image.PRNumber, image.Tag, stdout, stderr)+ }+ if image.Source == "" {+ return fmt.Errorf("homarr:%s has no build source metadata", image.Tag)+ }+ if info, err := os.Stat(image.Source); err != nil || !info.IsDir() {+ return fmt.Errorf("build source %s is no longer available", image.Source)+ }+ return buildCurrentImage(ctx, image.Tag, image.Source, stdout, stderr)+}++func checkoutDetails(ctx context.Context, directory string) (root string, revision string, err error) {+ rootOutput, err := exec.CommandContext(ctx, "git", "-C", directory, "rev-parse", "--show-toplevel").CombinedOutput()+ if err != nil {+ return "", "", fmt.Errorf("find Homarr checkout: %w: %s", err, strings.TrimSpace(string(rootOutput)))+ }+ root = strings.TrimSpace(string(rootOutput))+ if _, err := os.Stat(filepath.Join(root, "Dockerfile")); err != nil {+ return "", "", fmt.Errorf("%s is not a Homarr checkout", root)+ }+ revisionOutput, err := exec.CommandContext(ctx, "git", "-C", root, "rev-parse", "HEAD").CombinedOutput()+ if err != nil {+ return "", "", fmt.Errorf("read checkout revision: %w: %s", err, strings.TrimSpace(string(revisionOutput)))+ }+ return root, strings.TrimSpace(string(revisionOutput)), nil+}diff --git a/tools/homarr-dev/internal/run/run.go b/tools/homarr-dev/internal/run/run.gonew file mode 100644index 000000000..a144ee3df--- /dev/null+++ b/tools/homarr-dev/internal/run/run.go@@ -0,0 +1,119 @@+package run++import (+ "context"+ "fmt"+ "os"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"+)++type Options struct {+ Context context.Context+ PR int+ Tag string+ Demo bool+ Env []string+ FetchTitle bool+ FindPort func(int) int+}++type Plan struct {+ Image string+ Name string+ Volume string+ Label string+ HostPort int+ Env []string+ Platform string+ Pull bool+ PRNumber int+}++func BuildPlan(opts Options) (*Plan, error) {+ p := &Plan{}+ ctx := opts.Context+ if ctx == nil {+ ctx = context.Background()+ }+ findPort := opts.FindPort+ if findPort == nil {+ findPort = docker.FindFreePort+ }++ if opts.PR > 0 {+ p.PRNumber = opts.PR+ p.Image = fmt.Sprintf("ghcr.io/homarr-labs/homarr-test:pr-%d", opts.PR)+ p.Name = fmt.Sprintf("homarr_pr_%d", opts.PR)+ p.Volume = fmt.Sprintf("homarr_pr_%d_data", opts.PR)+ p.Label = fmt.Sprintf("PR #%d", opts.PR)+ p.Pull = true+ p.Platform = "linux/amd64"+ if opts.FetchTitle {+ if pr, err := gh.GetPR(ctx, opts.PR); err == nil && pr.Title != "" {+ p.Label = fmt.Sprintf("PR #%d — %s", opts.PR, pr.Title)+ }+ }+ } else if opts.Tag != "" {+ p.Image = "homarr:" + opts.Tag+ p.Name = "homarr_" + opts.Tag+ p.Volume = "homarr_" + opts.Tag + "_data"+ p.Label = "tag: " + opts.Tag+ } else {+ return nil, fmt.Errorf("need a tag or --pr")+ }++ p.HostPort = findPort(7575)+ if p.HostPort == 0 {+ return nil, fmt.Errorf("no free host port is available")+ }+ p.Env = append(p.Env, opts.Env...)+ if opts.Demo {+ p.Env = append(p.Env, "DEMO_MODE=true", "UNSAFE_ENABLE_MOCK_INTEGRATION=true")+ p.Label += " (demo)"+ }+ return p, nil+}++func StartDetached(p *Plan) error {+ return start(p, true)+}++func StartForeground(p *Plan) error {+ return start(p, false)+}++func start(p *Plan, daemon bool) error {+ const attempts = 5+ for attempt := 0; attempt < attempts; attempt++ {+ err := docker.Start(docker.StartOptions{+ Name: p.Name,+ Image: p.Image,+ Volume: p.Volume,+ HostPort: p.HostPort,+ Env: p.Env,+ Platform: p.Platform,+ PullAlways: p.Pull && attempt == 0,+ Daemon: daemon,+ })+ if err == nil {+ return nil+ }+ if !docker.IsPortConflict(err) || attempt == attempts-1 {+ if docker.IsPortConflict(err) {+ return fmt.Errorf("unable to bind a host port after %d attempts; restart Docker or OrbStack: %w", attempts, err)+ }+ return err+ }+ previousPort := p.HostPort+ p.HostPort = docker.FindFreePort(p.HostPort + 1)+ if p.HostPort == 0 {+ return fmt.Errorf("no free host port is available: %w", err)+ }+ if !daemon {+ fmt.Fprintf(os.Stderr, "Port %d unavailable; retrying on %d.\n", previousPort, p.HostPort)+ }+ }+ return nil+}diff --git a/tools/homarr-dev/internal/run/run_test.go b/tools/homarr-dev/internal/run/run_test.gonew file mode 100644index 000000000..5bed7eac9--- /dev/null+++ b/tools/homarr-dev/internal/run/run_test.go@@ -0,0 +1,59 @@+package run++import (+ "os"+ "slices"+ "strconv"+ "testing"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+)++func TestPRPlanUsesAMD64(t *testing.T) {+ plan, err := BuildPlan(Options{PR: 1, FindPort: func(int) int { return 7575 }})+ if err != nil {+ t.Fatal(err)+ }+ if plan.Platform != "linux/amd64" {+ t.Fatalf("platform = %q, want linux/amd64", plan.Platform)+ }+}++func TestPRCloneIsShallow(t *testing.T) {+ args := prCloneArgs("/tmp/checkout")+ if !slices.Contains(args, "--depth=1") || !slices.Contains(args, "--filter=blob:none") {+ t.Fatalf("clone args = %v", args)+ }+}++func TestBuildPlanFailsWhenNoPortIsAvailable(t *testing.T) {+ _, err := BuildPlan(Options{Tag: "dev", FindPort: func(int) int { return 0 }})+ if err == nil {+ t.Fatal("expected no-free-port error")+ }+}++func TestStartPRIntegration(t *testing.T) {+ if os.Getenv("HOMARR_DOCKER_INTEGRATION_TEST") != "1" {+ t.Skip("set HOMARR_DOCKER_INTEGRATION_TEST=1 and HOMARR_TEST_PR=<number>")+ }+ pr, err := strconv.Atoi(os.Getenv("HOMARR_TEST_PR"))+ if err != nil || pr <= 0 {+ t.Fatal("HOMARR_TEST_PR must be a positive PR number")+ }++ plan, err := BuildPlan(Options{PR: pr})+ if err != nil {+ t.Fatal(err)+ }+ plan.Name += "_integration"+ plan.Volume += "_integration"+ defer docker.Remove(plan.Name)++ if err := StartDetached(plan); err != nil {+ t.Fatal(err)+ }+ if !docker.IsRunning(plan.Name) {+ t.Fatalf("container %s did not remain running", plan.Name)+ }+}diff --git a/tools/homarr-dev/internal/tui/app.go b/tools/homarr-dev/internal/tui/app.gonew file mode 100644index 000000000..1af605250--- /dev/null+++ b/tools/homarr-dev/internal/tui/app.go@@ -0,0 +1,122 @@+package tui++import (+ "charm.land/bubbles/v2/spinner"+ tea "charm.land/bubbletea/v2"+)++type appModel struct {+ dev prsModel+ dashboard dashModel+ showDashboard bool+ width int+ height int+}++func newAppModel(showDashboard bool) appModel {+ return appModel{dev: newPRsModel(), dashboard: newDashModel(), showDashboard: showDashboard}+}++func (m appModel) Init() tea.Cmd {+ if m.showDashboard {+ return m.dashboard.Init()+ }+ return m.dev.Init()+}++func (m appModel) canSwitch() bool {+ if m.showDashboard {+ return !m.dashboard.filtering+ }+ return !m.dev.filtering && !m.dev.pulling+}++func (m appModel) switchScreen() (tea.Model, tea.Cmd) {+ m.showDashboard = !m.showDashboard+ commands := make([]tea.Cmd, 0, 2)+ if m.width > 0 && m.height > 0 {+ resize := tea.WindowSizeMsg{Width: m.width, Height: m.height}+ if m.showDashboard {+ updated, command := m.dashboard.Update(resize)+ m.dashboard = updated.(dashModel)+ commands = append(commands, command)+ } else {+ updated, command := m.dev.Update(resize)+ m.dev = updated.(prsModel)+ commands = append(commands, command)+ }+ }+ if m.showDashboard {+ commands = append(commands, m.dashboard.Init())+ } else {+ commands = append(commands, m.dev.Init())+ }+ return m, tea.Batch(commands...)+}++func (m appModel) updateDev(msg tea.Msg) (appModel, tea.Cmd) {+ updated, command := m.dev.Update(msg)+ m.dev = updated.(prsModel)+ return m, command+}++func (m appModel) updateDashboard(msg tea.Msg) (appModel, tea.Cmd) {+ updated, command := m.dashboard.Update(msg)+ m.dashboard = updated.(dashModel)+ return m, command+}++func (m appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {+ if window, ok := msg.(tea.WindowSizeMsg); ok {+ m.width = window.Width+ m.height = window.Height+ m, devCommand := m.updateDev(msg)+ m, dashboardCommand := m.updateDashboard(msg)+ return m, tea.Batch(devCommand, dashboardCommand)+ }+ if key, ok := msg.(tea.KeyPressMsg); ok {+ if key.String() == "d" && m.canSwitch() {+ return m.switchScreen()+ }+ if m.showDashboard {+ return m.updateDashboard(msg)+ }+ return m.updateDev(msg)+ }++ switch msg.(type) {+ case prsLoadedMsg, imageCheckedMsg, prActionMsg, rebuildDoneMsg, runningRefreshedMsg, pullReadyMsg, pullEvent, spinner.TickMsg:+ return m.updateDev(msg)+ case tickMsg, actionMsg, rowsMsg:+ if m.showDashboard {+ return m.updateDashboard(msg)+ }+ return m, nil+ case prLogTickMsg:+ if !m.showDashboard {+ return m.updateDev(msg)+ }+ return m, nil+ case logsMsg:+ m, devCommand := m.updateDev(msg)+ m, dashboardCommand := m.updateDashboard(msg)+ return m, tea.Batch(devCommand, dashboardCommand)+ }+ if m.showDashboard {+ return m.updateDashboard(msg)+ }+ return m.updateDev(msg)+}++func (m appModel) View() tea.View {+ if m.showDashboard {+ return m.dashboard.View()+ }+ return m.dev.View()+}++func runApp(showDashboard bool) error {+ program := tea.NewProgram(newAppModel(showDashboard))+ _, err := program.Run()+ return err+}diff --git a/tools/homarr-dev/internal/tui/app_test.go b/tools/homarr-dev/internal/tui/app_test.gonew file mode 100644index 000000000..1112ebb29--- /dev/null+++ b/tools/homarr-dev/internal/tui/app_test.go@@ -0,0 +1,47 @@+package tui++import (+ "testing"++ tea "charm.land/bubbletea/v2"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"+)++func TestAppTogglePreservesDevelopmentState(t *testing.T) {+ m := newAppModel(false)+ m.dev.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 6502}}}++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))+ dashboard := updated.(appModel)+ if !dashboard.showDashboard {+ t.Fatal("d did not open the instance dashboard")+ }+ updated, _ = dashboard.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))+ development := updated.(appModel)+ if development.showDashboard || len(development.dev.rows) != 1 || development.dev.rows[0].pr.Number != 6502 {+ t.Fatalf("development state was not preserved: %#v", development.dev.rows)+ }+}++func TestAppToggleDoesNotInterceptFilterInput(t *testing.T) {+ m := newAppModel(false)+ m.dev.filtering = true+ m.dev.filter.Focus()++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))+ got := updated.(appModel)+ if got.showDashboard || got.dev.filter.Value() != "d" {+ t.Fatalf("filter input was intercepted: dashboard=%v filter=%q", got.showDashboard, got.dev.filter.Value())+ }+}++func TestAppCanOpenInstancesDuringBuild(t *testing.T) {+ m := newAppModel(false)+ m.dev.rebuilding = true++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: 'd', Text: "d"}))+ if !updated.(appModel).showDashboard {+ t.Fatal("background build blocked dashboard navigation")+ }+}diff --git a/tools/homarr-dev/internal/tui/dashboard.go b/tools/homarr-dev/internal/tui/dashboard.gonew file mode 100644index 000000000..5cfe2d496--- /dev/null+++ b/tools/homarr-dev/internal/tui/dashboard.go@@ -0,0 +1,415 @@+package tui++import (+ "context"+ "fmt"+ "os/exec"+ "strings"+ "time"++ "charm.land/bubbles/v2/table"+ "charm.land/bubbles/v2/textinput"+ "charm.land/bubbles/v2/viewport"+ tea "charm.land/bubbletea/v2"+ "charm.land/lipgloss/v2"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/platform"+)++var (+ titleStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212"))+ helpStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))+ logHeadSt = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))+ runningLegend = lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("● running")+ stoppedLegend = lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render("○ stopped")+)++type dashModel struct {+ table table.Model+ allRows []table.Row+ filter textinput.Model+ filtering bool+ logs viewport.Model+ showLogs bool+ follow bool+ status string+ confirmRemove string+ width int+ height int+}++type tickMsg time.Time+type actionMsg string+type rowsMsg []table.Row+type logsMsg struct {+ name string+ content string+}++func tick() tea.Cmd {+ return tea.Tick(3*time.Second, func(t time.Time) tea.Msg { return tickMsg(t) })+}++func fetchLogs(name string) tea.Cmd {+ return func() tea.Msg {+ if name == "" {+ return logsMsg{}+ }+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()+ out, err := exec.CommandContext(ctx, "docker", "logs", "--tail", "200", name).CombinedOutput()+ if err != nil {+ return logsMsg{name: name, content: "logs unavailable: " + err.Error()}+ }+ return logsMsg{name: name, content: string(out)}+ }+}++func loadRows() tea.Cmd {+ return func() tea.Msg { return rowsMsg(refreshRows()) }+}++func refreshRows() []table.Row {+ containers, _ := docker.List()+ rows := make([]table.Row, 0, len(containers))+ for _, c := range containers {+ port := c.HostPort()+ url := ""+ if port != "" && c.Running() {+ url = "http://localhost:" + port+ }+ state := "● " + c.State+ if !c.Running() {+ state = "○ " + c.State+ }+ img := strings.TrimPrefix(c.Image, "ghcr.io/homarr-labs/")+ rows = append(rows, table.Row{c.Name, state, img, port, url, c.Status})+ }+ return rows+}++func dashboardColumns(width int) []table.Column {+ nameWidth := 26+ imageWidth := 30+ urlWidth := 24+ if width < 100 {+ nameWidth = 22+ imageWidth = max(width-54, 18)+ urlWidth = 0+ }+ return []table.Column{+ {Title: "NAME", Width: nameWidth},+ {Title: "STATE", Width: 14},+ {Title: "IMAGE", Width: imageWidth},+ {Title: "PORT", Width: 6},+ {Title: "URL", Width: urlWidth},+ {Title: "STATUS", Width: 0},+ }+}++func newDashModel() dashModel {+ t := table.New(+ table.WithColumns(dashboardColumns(104)),+ table.WithFocused(true),+ table.WithHeight(10),+ table.WithWidth(104),+ )+ s := table.DefaultStyles()+ s.Header = s.Header.Bold(true)+ s.Selected = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("230")).Background(lipgloss.Color("57"))+ t.SetStyles(s)+ logs := viewport.New(viewport.WithWidth(104), viewport.WithHeight(12))+ logs.SoftWrap = true+ filter := textinput.New()+ filter.Prompt = "/ "+ filter.Placeholder = "filter name, image, port, state…"+ filter.SetWidth(50)+ styles := textinput.DefaultDarkStyles()+ styles.Focused.Prompt = styles.Focused.Prompt.Foreground(lipgloss.Color("212")).Bold(true)+ styles.Focused.Text = styles.Focused.Text.Foreground(lipgloss.Color("229"))+ filter.SetStyles(styles)+ return dashModel{table: t, filter: filter, logs: logs, showLogs: true, follow: true, width: 104, height: 30}+}++func (m *dashModel) applyFilter() {+ query := strings.ToLower(strings.TrimSpace(m.filter.Value()))+ if query == "" {+ m.table.SetRows(m.allRows)+ return+ }+ rows := make([]table.Row, 0, len(m.allRows))+ for _, row := range m.allRows {+ if strings.Contains(strings.ToLower(strings.Join(row, " ")), query) {+ rows = append(rows, row)+ }+ }+ m.table.SetRows(rows)+}++func (m dashModel) selected() string {+ row := m.table.SelectedRow()+ if len(row) == 0 {+ return ""+ }+ return row[0]+}++func (m dashModel) selectedPort() string {+ row := m.table.SelectedRow()+ if len(row) < 4 {+ return ""+ }+ return row[3]+}++func (m dashModel) Init() tea.Cmd {+ return tea.Batch(tick(), loadRows(), fetchLogs(m.selected()))+}++func (m dashModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {+ switch msg := msg.(type) {+ case tea.WindowSizeMsg:+ m.width = msg.Width+ m.height = msg.Height+ m.table.SetColumns(dashboardColumns(msg.Width))+ m.table.SetWidth(msg.Width)+ m.logs.SetWidth(msg.Width)+ m.filter.SetWidth(max(min(msg.Width-4, 60), 10))+ m.layout()+ return m, nil+ case tickMsg:+ return m, tea.Batch(tick(), loadRows())+ case rowsMsg:+ m.allRows = []table.Row(msg)+ m.applyFilter()+ return m, fetchLogs(m.selected())+ case logsMsg:+ if msg.name != "" && msg.name != m.selected() {+ return m, nil+ }+ m.logs.SetContent(strings.TrimRight(msg.content, "\n"))+ if m.follow {+ m.logs.GotoBottom()+ }+ return m, nil+ case actionMsg:+ m.status = string(msg)+ m.confirmRemove = ""+ return m, loadRows()+ case tea.KeyPressMsg:+ if m.filtering {+ switch msg.Key().Code {+ case tea.KeyEscape:+ m.filtering = false+ m.filter.Reset()+ m.filter.Blur()+ m.applyFilter()+ return m, fetchLogs(m.selected())+ case tea.KeyEnter:+ m.filtering = false+ m.filter.Blur()+ return m, fetchLogs(m.selected())+ }+ var cmd tea.Cmd+ m.filter, cmd = m.filter.Update(msg)+ m.applyFilter()+ return m, tea.Batch(cmd, fetchLogs(m.selected()))+ }+ name := m.selected()+ switch msg.Key().Code {+ case tea.KeyUp, tea.KeyKpUp:+ m.table.MoveUp(1)+ return m, fetchLogs(m.selected())+ case tea.KeyDown, tea.KeyKpDown:+ m.table.MoveDown(1)+ return m, fetchLogs(m.selected())+ case tea.KeyPgUp, tea.KeyKpPgUp:+ m.follow = false+ m.logs.PageUp()+ return m, nil+ case tea.KeyPgDown, tea.KeyKpPgDown:+ m.logs.PageDown()+ m.follow = m.logs.AtBottom()+ return m, nil+ }+ switch msg.String() {+ case "q", "ctrl+c", "esc":+ return m, tea.Quit+ case "l":+ m.showLogs = !m.showLogs+ m.layout()+ if m.showLogs {+ return m, fetchLogs(name)+ }+ return m, nil+ case "/":+ m.filtering = true+ return m, m.filter.Focus()+ case "f":+ m.follow = !m.follow+ if m.follow {+ m.logs.GotoBottom()+ }+ return m, nil+ case "s":+ if name != "" {+ m.status = "stopping " + name + "…"+ return m, func() tea.Msg {+ if err := docker.Stop(name); err != nil {+ return actionMsg("stop failed: " + err.Error())+ }+ return actionMsg("stopped " + name)+ }+ }+ case "x":+ if name != "" {+ if m.confirmRemove != name {+ m.confirmRemove = name+ m.status = "press x again to remove " + name+ return m, nil+ }+ m.status = "removing " + name + "…"+ return m, func() tea.Msg {+ if err := docker.Remove(name); err != nil {+ return actionMsg("remove failed: " + err.Error())+ }+ return actionMsg("removed " + name)+ }+ }+ case "R":+ if name != "" {+ m.status = "restarting " + name + "…"+ return m, func() tea.Msg {+ if err := docker.Restart(name); err != nil {+ return actionMsg("restart failed: " + err.Error())+ }+ return actionMsg("restarted " + name)+ }+ }+ case "o":+ if name != "" {+ if port := m.selectedPort(); port != "" {+ if err := platform.OpenURL("http://localhost:" + port); err != nil {+ m.status = "open failed: " + err.Error()+ }+ }+ }+ case "c":+ if name != "" {+ if port := m.selectedPort(); port != "" {+ url := "http://localhost:" + port+ if err := platform.CopyText(url); err != nil {+ m.status = "copy failed: " + err.Error()+ } else {+ m.status = "copied " + url+ }+ }+ }+ case "r":+ return m, loadRows()+ case "k":+ m.table.MoveUp(1)+ return m, fetchLogs(m.selected())+ case "j":+ m.table.MoveDown(1)+ return m, fetchLogs(m.selected())+ }+ }+ var cmd tea.Cmd+ m.table, cmd = m.table.Update(msg)+ return m, cmd+}++func (m *dashModel) layout() {+ available := m.height - 11+ if m.filtering || m.filter.Value() != "" {+ available -= 2+ }+ if !m.showLogs {+ m.table.SetHeight(max(available, 5))+ return+ }+ tableH := min(12, max(available/2, 5))+ m.table.SetHeight(tableH)+ logsH := available - tableH+ if logsH < 3 {+ logsH = 3+ }+ m.logs.SetHeight(logsH)+}++func (m dashModel) selectedDetailView() string {+ row := m.table.SelectedRow()+ if len(row) < 6 {+ return ""+ }+ title := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("229")).Render(row[0])+ meta := row[2] + " · " + row[1]+ if row[3] != "" {+ meta += " · port " + row[3]+ }+ if row[4] != "" {+ meta += " · " + row[4]+ }+ if row[5] != "" {+ meta += " · " + row[5]+ }+ return title + "\n" + helpStyle.Render(meta)+}++func (m dashModel) View() tea.View {+ var b strings.Builder+ running := 0+ for _, row := range m.allRows {+ if len(row) > 1 && strings.Contains(row[1], "running") {+ running+++ }+ }+ b.WriteString(titleStyle.Render("🦞 homarr instances") + " " + helpStyle.Render(fmt.Sprintf("%d total · %d running · %d shown", len(m.allRows), running, len(m.table.Rows()))))+ b.WriteString("\n\n")+ if m.filtering || m.filter.Value() != "" {+ b.WriteString(m.filter.View() + "\n\n")+ }+ if len(m.table.Rows()) == 0 {+ message := "no homarr containers — start one with `homarr run <tag>` or `homarr run --pr N`"+ if len(m.allRows) > 0 {+ message = "no instances match " + m.filter.Value()+ }+ b.WriteString(helpStyle.Render(" " + message + "\n"))+ } else {+ b.WriteString(m.table.View())+ b.WriteString("\n")+ }+ if detail := m.selectedDetailView(); detail != "" {+ b.WriteString("\n" + detail + "\n")+ }+ if m.showLogs && len(m.table.Rows()) > 0 {+ mode := "paused"+ if m.follow {+ mode = "following"+ }+ b.WriteString("\n" + logHeadSt.Render("── logs: "+m.selected()+" ("+mode+") ──") + "\n")+ b.WriteString(m.logs.View())+ }+ if m.status != "" {+ statusStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("42"))+ lower := strings.ToLower(m.status)+ if strings.Contains(lower, "fail") || strings.Contains(lower, "error") {+ statusStyle = statusStyle.Foreground(lipgloss.Color("196"))+ } else if strings.Contains(lower, "press x") {+ statusStyle = statusStyle.Foreground(lipgloss.Color("214"))+ }+ b.WriteString("\n" + statusStyle.Render(m.status))+ }+ b.WriteString("\n\n" + helpStyle.Render("/ filter · ↑/↓ select · l logs · f follow · pgup/pgdn scroll · s stop · R restart · x remove · o open · c copy URL · r refresh · d development · q quit"))+ b.WriteString("\n" + helpStyle.Render(runningLegend+" · "+stoppedLegend))+ v := tea.NewView(b.String())+ v.AltScreen = true+ v.WindowTitle = "🦞 Homarr instances"+ return v+}++func RunDashboard() error {+ return runApp(true)+}diff --git a/tools/homarr-dev/internal/tui/dashboard_test.go b/tools/homarr-dev/internal/tui/dashboard_test.gonew file mode 100644index 000000000..4456dc117--- /dev/null+++ b/tools/homarr-dev/internal/tui/dashboard_test.go@@ -0,0 +1,62 @@+package tui++import (+ "strings"+ "testing"++ "charm.land/bubbles/v2/table"+ tea "charm.land/bubbletea/v2"+)++func TestDashboardRendersRowsAndLogs(t *testing.T) {+ m := newDashModel()+ m.table.SetRows([]table.Row{{+ "homarr_pr_6441",+ "running",+ "homarr-test:pr-6441",+ "7575",+ "http://localhost:7575",+ "Up 2 minutes",+ }})+ m.logs.SetWidth(104)+ m.logs.SetHeight(5)+ m.logs.SetContent("server ready")++ got := m.View().Content+ for _, want := range []string{"homarr_pr_6441", "server ready"} {+ if !strings.Contains(got, want) {+ t.Fatalf("dashboard omitted %q: %q", want, got)+ }+ }+ if !m.View().AltScreen {+ t.Fatal("dashboard must use the alternate screen")+ }+}++func TestDashboardArrowNavigation(t *testing.T) {+ m := newDashModel()+ m.table.SetRows([]table.Row{+ {"homarr_first", "running", "homarr:first", "7575", "", "Up 1 minute"},+ {"homarr_second", "running", "homarr:second", "7576", "", "Up 1 minute"},+ })++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))+ got := updated.(dashModel).selected()+ if got != "homarr_second" {+ t.Fatalf("down arrow selected %q, want homarr_second", got)+ }+}++func TestDashboardIgnoresStaleLogs(t *testing.T) {+ m := newDashModel()+ m.table.SetRows([]table.Row{{"homarr_current", "running", "homarr:current", "7575", "", "Up 1 minute"}})+ m.logs.SetWidth(104)+ m.logs.SetHeight(5)+ m.logs.SetContent("current logs")++ updated, _ := m.Update(logsMsg{name: "homarr_old", content: "stale logs"})+ got := updated.(dashModel).View().Content+ if strings.Contains(got, "stale logs") || !strings.Contains(got, "current logs") {+ t.Fatalf("stale log result replaced current content: %q", got)+ }+}diff --git a/tools/homarr-dev/internal/tui/dev.go b/tools/homarr-dev/internal/tui/dev.gonew file mode 100644index 000000000..6a41d9d9a--- /dev/null+++ b/tools/homarr-dev/internal/tui/dev.go@@ -0,0 +1,1158 @@+package tui++import (+ "bufio"+ "context"+ "fmt"+ "os"+ "os/exec"+ "path/filepath"+ "strconv"+ "strings"+ "time"++ "charm.land/bubbles/v2/progress"+ "charm.land/bubbles/v2/spinner"+ "charm.land/bubbles/v2/table"+ "charm.land/bubbles/v2/textinput"+ "charm.land/bubbles/v2/viewport"+ tea "charm.land/bubbletea/v2"+ "charm.land/lipgloss/v2"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/platform"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/run"+)++const (+ ciOK = "✓"+ ciFail = "✗"+ ciPend = "●"+ ciNone = "–"+ imgYes = "✓"+ imgNo = "…"+ imgCheck = "?"+ imgError = "!"+ imgLocal = "◆"+ runMark = "▶"+ idleMark = " "+)++var (+ legendCIYes = lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render(ciOK)+ legendCINo = lipgloss.NewStyle().Foreground(lipgloss.Color("196")).Render(ciFail)+ legendCIPend = lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Render(ciPend)+ legendNone = lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(ciNone)+ legendImageYes = lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render(imgYes)+ legendImageNo = lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(imgNo)+ legendLocal = lipgloss.NewStyle().Foreground(lipgloss.Color("81")).Render(imgLocal)+)++type prRow struct {+ kind string+ pr gh.PR+ local docker.Image+ imageState string+ running bool+ port string+}++func (row prRow) hasCurrentLocalImage() bool {+ return row.kind == "remote" && row.local.Tag != "" && row.pr.HeadSHA != "" && row.local.Revision == row.pr.HeadSHA+}++type prsModel struct {+ table table.Model+ filter textinput.Model+ filtering bool+ pullView viewport.Model+ pulling bool+ pullLines []string+ pullLayers map[string]string+ pullProgress progress.Model+ pullCanceled bool+ pullEvents <-chan pullEvent+ pullPlan *run.Plan+ pullCancel context.CancelFunc+ rebuilding bool+ rebuildCancel context.CancelFunc+ logs viewport.Model+ showLogs bool+ followLogs bool+ logsName string+ spinner spinner.Model+ rows []prRow+ loading bool+ status string+ includeBots bool+ demo bool+ width int+ height int+ imageQueue []int+ imageActive int+ imageGen int+}++type prsLoadedMsg struct {+ prs []gh.PR+ images []docker.Image+ prErr error+ imgErr error+ refresh bool+}+type imageCheckedMsg struct {+ number int+ exists bool+ err error+ gen int+}+type prActionMsg struct {+ text string+}+type rebuildDoneMsg struct {+ image docker.Image+ err error+ canceled bool+ action string+}+type runningRefreshedMsg struct {+ rows []prRow+ generation int+}+type pullReadyMsg struct{}+type prLogTickMsg struct{}+type pullEvent struct {+ line string+ done bool+ err error+}++type outputTail struct {+ data []byte+}++func (tail *outputTail) Write(data []byte) (int, error) {+ const limit = 32 * 1024+ tail.data = append(tail.data, data...)+ if len(tail.data) > limit {+ tail.data = tail.data[len(tail.data)-limit:]+ }+ return len(data), nil+}++func (tail *outputTail) lastLine() string {+ lines := strings.FieldsFunc(string(tail.data), func(char rune) bool { return char == '\n' || char == '\r' })+ if len(lines) == 0 {+ return ""+ }+ return strings.TrimSpace(lines[len(lines)-1])+}++func splitDockerProgress(data []byte, atEOF bool) (advance int, token []byte, err error) {+ for i, b := range data {+ if b == '\n' || b == '\r' {+ return i + 1, data[:i], nil+ }+ }+ if atEOF && len(data) > 0 {+ return len(data), data, nil+ }+ return 0, nil, nil+}++func startPull(ctx context.Context, cmd *exec.Cmd, events chan<- pullEvent) tea.Cmd {+ return func() tea.Msg {+ reader, writer, err := os.Pipe()+ if err != nil {+ return pullEvent{done: true, err: err}+ }+ cmd.Stdout = writer+ cmd.Stderr = writer+ if err := cmd.Start(); err != nil {+ _ = reader.Close()+ _ = writer.Close()+ return pullEvent{done: true, err: err}+ }+ _ = writer.Close()+ go func() {+ defer close(events)+ defer reader.Close()+ scanner := bufio.NewScanner(reader)+ scanner.Split(splitDockerProgress)+ lastLine := ""+ for scanner.Scan() {+ line := strings.TrimSpace(scanner.Text())+ if line != "" {+ lastLine = line+ if ctx.Err() == nil && len(events) < cap(events)-1 {+ events <- pullEvent{line: line}+ }+ }+ }+ err := cmd.Wait()+ if err == nil {+ err = scanner.Err()+ } else {+ err = commandErrorWithDetail(err, lastLine)+ }+ events <- pullEvent{done: true, err: err}+ }()+ return pullReadyMsg{}+ }+}++func commandErrorWithDetail(err error, lastLine string) error {+ if lastLine == "" {+ return err+ }+ return fmt.Errorf("%w: %s", err, lastLine)+}++func waitPull(events <-chan pullEvent) tea.Cmd {+ return func() tea.Msg {+ event, ok := <-events+ if !ok {+ return nil+ }+ return event+ }+}++func prLogTick() tea.Cmd {+ return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return prLogTickMsg{} })+}++func loadDev(includeBots, refresh bool) tea.Cmd {+ return func() tea.Msg {+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)+ defer cancel()+ var prs []gh.PR+ var prErr error+ if refresh {+ prs, prErr = gh.RefreshPRs(ctx, 50, includeBots)+ } else {+ prs, prErr = gh.ListPRs(ctx, 50, includeBots)+ }+ images, imgErr := docker.ListLocalImages(ctx)+ return prsLoadedMsg{prs: prs, images: images, prErr: prErr, imgErr: imgErr, refresh: refresh}+ }+}++func checkImage(number, generation int) tea.Cmd {+ return func() tea.Msg {+ img := fmt.Sprintf("ghcr.io/homarr-labs/homarr-test:pr-%d", number)+ exists, err := docker.CheckImage(img)+ return imageCheckedMsg{number: number, exists: exists, err: err, gen: generation}+ }+}++func (m *prsModel) startImageChecks() tea.Cmd {+ const concurrency = 6+ cmds := make([]tea.Cmd, 0, concurrency)+ for m.imageActive < concurrency && len(m.imageQueue) > 0 {+ number := m.imageQueue[0]+ m.imageQueue = m.imageQueue[1:]+ m.imageActive+++ cmds = append(cmds, checkImage(number, m.imageGen))+ }+ return tea.Batch(cmds...)+}++func ciIcon(state string) string {+ switch state {+ case "SUCCESS":+ return ciOK+ case "FAILURE":+ return ciFail+ case "PENDING":+ return ciPend+ default:+ return ciNone+ }+}++func buildTableRows(rows []prRow) []table.Row {+ out := make([]table.Row, 0, len(rows))+ for _, r := range rows {+ mark := idleMark+ port := ""+ if r.running {+ mark = runMark+ port = r.port+ }+ img := imgCheck+ switch r.imageState {+ case "yes":+ img = imgYes+ case "no":+ img = imgNo+ case "error":+ img = imgError+ }+ if r.hasCurrentLocalImage() {+ img = imgLocal+ }+ source := "remote"+ ref := fmt.Sprint(r.pr.Number)+ title := r.pr.Title+ author := r.pr.Author+ ci := ciIcon(r.pr.CIState)+ if r.kind == "local" {+ source = "local"+ ref = r.local.Tag+ title = r.local.Reference()+ author = "untracked build"+ if r.local.Source != "" {+ author = filepath.Base(r.local.Source)+ }+ ci = ciNone+ } else if r.pr.IsDraft {+ title = "DRAFT · " + title+ }+ if len([]rune(title)) > 44 {+ title = string([]rune(title)[:43]) + "…"+ }+ out = append(out, table.Row{+ mark,+ source,+ ref,+ title,+ author,+ ci,+ img,+ port,+ })+ }+ return out+}++func developmentRows(prs []gh.PR, images []docker.Image, imageStates map[int]string) ([]prRow, []int) {+ rows := make([]prRow, 0, len(prs)+len(images))+ prIndexes := make(map[int]int, len(prs))+ queue := make([]int, 0, len(prs))+ for _, pr := range prs {+ imageState := imageStates[pr.Number]+ prIndexes[pr.Number] = len(rows)+ rows = append(rows, prRow{kind: "remote", pr: pr, imageState: imageState})+ }+ for _, image := range images {+ if index, exists := prIndexes[image.PRNumber]; exists && image.Revision != "" && image.Revision == rows[index].pr.HeadSHA {+ if rows[index].local.Tag == "" {+ rows[index].local = image+ }+ continue+ }+ rows = append(rows, prRow{kind: "local", local: image, imageState: "yes"})+ }+ for index := range rows {+ if rows[index].kind != "remote" || rows[index].imageState != "" {+ continue+ }+ if rows[index].hasCurrentLocalImage() {+ rows[index].imageState = "unchecked"+ continue+ }+ rows[index].imageState = "checking"+ queue = append(queue, rows[index].pr.Number)+ }+ return rows, queue+}++func prColumns(width int) []table.Column {+ authorWidth := 16+ portWidth := 6+ if width < 90 {+ authorWidth = 0+ }+ if width < 72 {+ portWidth = 0+ }+ titleWidth := max(min(width-60, 45), 18)+ return []table.Column{+ {Title: "", Width: 2},+ {Title: "SOURCE", Width: 8},+ {Title: "REF", Width: 12},+ {Title: "TITLE", Width: titleWidth},+ {Title: "AUTHOR", Width: authorWidth},+ {Title: "CI", Width: 3},+ {Title: "IMAGE", Width: 5},+ {Title: "PORT", Width: portWidth},+ }+}++func newPRsModel() prsModel {+ t := table.New(+ table.WithColumns(prColumns(110)),+ table.WithFocused(true),+ table.WithHeight(18),+ table.WithWidth(110),+ )+ s := table.DefaultStyles()+ s.Header = s.Header.Bold(true)+ s.Selected = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("230")).Background(lipgloss.Color("57"))+ t.SetStyles(s)++ sp := spinner.New()+ sp.Spinner = spinner.Dot+ filter := textinput.New()+ filter.Prompt = "/ "+ filter.Placeholder = "filter source, PR, image, title, author, branch, CI, port…"+ filter.SetWidth(65)+ filterStyles := textinput.DefaultDarkStyles()+ filterStyles.Focused.Prompt = filterStyles.Focused.Prompt.Foreground(lipgloss.Color("212")).Bold(true)+ filterStyles.Focused.Text = filterStyles.Focused.Text.Foreground(lipgloss.Color("229"))+ filter.SetStyles(filterStyles)+ pullView := viewport.New(viewport.WithWidth(110), viewport.WithHeight(7))+ pullView.SoftWrap = true+ pullView.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("250"))+ pullProgress := progress.New(progress.WithWidth(60), progress.WithColors(lipgloss.Color("212")))+ logs := viewport.New(viewport.WithWidth(110), viewport.WithHeight(7))+ logs.SoftWrap = true+ logs.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("250"))++ return prsModel{table: t, filter: filter, pullView: pullView, pullLayers: make(map[string]string), pullProgress: pullProgress, logs: logs, followLogs: true, spinner: sp, loading: true, status: "loading development images…", width: 110, height: 32}+}++func (m *prsModel) layout() {+ reserved := 12+ if m.filtering || m.filter.Value() != "" {+ reserved += 2+ }+ if m.pulling {+ reserved += 9+ }+ if m.showLogs {+ reserved += 9+ }+ m.table.SetHeight(max(m.height-reserved, 6))+ m.pullView.SetWidth(max(m.width-2, 20))+ m.pullView.SetHeight(7)+ m.pullProgress.SetWidth(max(min(m.width-12, 70), 20))+ m.logs.SetWidth(max(m.width-2, 20))+ m.logs.SetHeight(7)+}++func (m *prsModel) applyFilter() {+ rendered := buildTableRows(m.rows)+ query := strings.ToLower(strings.TrimSpace(m.filter.Value()))+ if query == "" {+ m.table.SetRows(rendered)+ return+ }+ rows := make([]table.Row, 0, len(rendered))+ for i, row := range m.rows {+ terms := []string{+ row.kind,+ fmt.Sprint(row.pr.Number),+ fmt.Sprintf("#%d", row.pr.Number),+ fmt.Sprintf("pr-%d", row.pr.Number),+ row.pr.Title,+ row.pr.Author,+ row.pr.HeadRef,+ row.pr.CIState,+ row.imageState,+ row.port,+ row.local.Tag,+ row.local.Source,+ row.local.Revision,+ }+ if row.pr.IsDraft {+ terms = append(terms, "draft")+ }+ if row.running {+ terms = append(terms, "running started")+ }+ if strings.Contains(strings.ToLower(strings.Join(terms, " ")), query) {+ rows = append(rows, rendered[i])+ }+ }+ m.table.SetRows(rows)+}++func (m prsModel) selectedRow() *prRow {+ selected := m.table.SelectedRow()+ if len(selected) < 3 {+ return nil+ }+ for i := range m.rows {+ if m.rows[i].kind == selected[1] && ((selected[1] == "remote" && fmt.Sprint(m.rows[i].pr.Number) == selected[2]) || (selected[1] == "local" && m.rows[i].local.Tag == selected[2])) {+ return &m.rows[i]+ }+ }+ return nil+}++func (m prsModel) selectedPR() *prRow {+ row := m.selectedRow()+ if row == nil || row.kind != "remote" {+ return nil+ }+ return row+}++func localBuildForRow(row prRow) (docker.Image, string, string) {+ if row.kind == "remote" {+ image := docker.Image{Tag: fmt.Sprintf("pr-%d", row.pr.Number), PRNumber: row.pr.Number}+ return image, "built", fmt.Sprintf("building PR #%d locally as %s…", row.pr.Number, image.Reference())+ }+ return row.local, "rebuilt", "rebuilding " + row.local.Reference() + "…"+}++func localPRPlan(row prRow, demo bool, findPort func(int) int) (*run.Plan, error) {+ plan, err := run.BuildPlan(run.Options{Context: context.Background(), Tag: row.local.Tag, Demo: demo, FindPort: findPort})+ if err != nil {+ return nil, err+ }+ plan.Name = fmt.Sprintf("homarr_pr_%d", row.pr.Number)+ plan.Volume = fmt.Sprintf("homarr_pr_%d_data", row.pr.Number)+ plan.Label = fmt.Sprintf("PR #%d · local %s", row.pr.Number, truncateText(row.pr.HeadSHA, 12))+ plan.PRNumber = row.pr.Number+ return plan, nil+}++func (m *prsModel) refreshSelectedLogs() tea.Cmd {+ row := m.selectedRow()+ if row == nil || !row.running {+ m.logsName = ""+ m.logs.SetContent("selected image is not running")+ return nil+ }+ name := fmt.Sprintf("homarr_pr_%d", row.pr.Number)+ if row.kind == "local" {+ name = "homarr_" + row.local.Tag+ }+ if name != m.logsName {+ m.logsName = name+ m.logs.SetContent("loading logs…")+ }+ return fetchLogs(name)+}++func (m *prsModel) beginPull(row prRow) tea.Cmd {+ plan, err := run.BuildPlan(run.Options{Context: context.Background(), PR: row.pr.Number, Demo: m.demo})+ if err != nil {+ m.status = err.Error()+ return nil+ }+ if row.running && row.port != "" {+ if port, err := strconv.Atoi(row.port); err == nil {+ plan.HostPort = port+ }+ }+ ctx, cancel := context.WithCancel(context.Background())+ events := make(chan pullEvent, 128)+ m.pulling = true+ m.pullPlan = plan+ m.pullCancel = cancel+ m.pullEvents = events+ m.pullLines = nil+ m.pullLayers = make(map[string]string)+ m.pullCanceled = false+ m.pullView.SetContent("")+ m.showLogs = false+ m.logsName = ""+ if row.running {+ m.status = fmt.Sprintf("pulling latest image and redeploying PR #%d…", row.pr.Number)+ } else {+ m.status = fmt.Sprintf("pulling latest image for PR #%d…", row.pr.Number)+ }+ m.layout()+ return tea.Batch(startPull(ctx, docker.PullCommandContext(ctx, plan.Image, plan.Platform), events), m.spinner.Tick)+}++func (m *prsModel) appendPullLine(line string) {+ const retainedLines = 40+ m.pullLines = append(m.pullLines, line)+ if len(m.pullLines) > retainedLines {+ m.pullLines = m.pullLines[len(m.pullLines)-retainedLines:]+ }+ m.pullView.SetContent(strings.Join(m.pullLines, "\n"))+ m.pullView.GotoBottom()+ parts := strings.SplitN(line, ":", 2)+ if len(parts) == 2 {+ layer := strings.TrimSpace(parts[0])+ if len(layer) == 12 {+ m.pullLayers[layer] = strings.TrimSpace(parts[1])+ }+ }+}++func (m prsModel) pullCompletion() (complete, total int, percent float64) {+ for _, state := range m.pullLayers {+ total+++ lower := strings.ToLower(state)+ if strings.Contains(lower, "pull complete") || strings.Contains(lower, "already exists") {+ complete+++ }+ }+ if total > 0 {+ percent = float64(complete) / float64(total)+ }+ return complete, total, percent+}++func (m prsModel) Init() tea.Cmd {+ return tea.Batch(loadDev(m.includeBots, false), m.spinner.Tick)+}++func refreshRunning(rows []prRow, generation int) tea.Cmd {+ return func() tea.Msg {+ containers, _ := docker.List()+ updated := append([]prRow(nil), rows...)+ for index, row := range updated {+ name := fmt.Sprintf("homarr_pr_%d", row.pr.Number)+ if row.kind == "local" {+ name = "homarr_" + row.local.Tag+ }+ row.running = false+ row.port = ""+ for _, container := range containers {+ if container.Name == name && container.Running() {+ row.running = true+ row.port = container.HostPort()+ }+ }+ updated[index] = row+ }+ return runningRefreshedMsg{rows: updated, generation: generation}+ }+}++func (m prsModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {+ switch msg := msg.(type) {+ case tea.WindowSizeMsg:+ m.width = msg.Width+ m.height = msg.Height+ m.table.SetColumns(prColumns(msg.Width))+ m.table.SetWidth(msg.Width)+ m.filter.SetWidth(max(min(msg.Width-4, 75), 10))+ m.layout()+ return m, nil+ case prsLoadedMsg:+ if msg.prErr != nil && msg.imgErr != nil {+ m.loading = false+ m.status = "failed to load development images: " + msg.prErr.Error() + "; " + msg.imgErr.Error()+ return m, nil+ }+ m.loading = false+ m.status = fmt.Sprintf("%d remote PRs · %d local images", len(msg.prs), len(msg.images))+ if msg.prErr != nil {+ m.status = "remote PRs unavailable: " + msg.prErr.Error()+ } else if msg.imgErr != nil {+ m.status = "local images unavailable: " + msg.imgErr.Error()+ }+ imageStates := make(map[int]string, len(m.rows))+ if !msg.refresh || msg.prErr != nil {+ for _, row := range m.rows {+ if row.kind == "remote" && (row.imageState == "yes" || row.imageState == "no") {+ imageStates[row.pr.Number] = row.imageState+ }+ }+ }+ m.rows, m.imageQueue = developmentRows(msg.prs, msg.images, imageStates)+ m.imageGen+++ m.imageActive = 0+ m.applyFilter()+ return m, tea.Batch(m.startImageChecks(), refreshRunning(m.rows, m.imageGen))+ case imageCheckedMsg:+ if msg.gen != m.imageGen {+ return m, nil+ }+ m.imageActive--+ for i, r := range m.rows {+ if r.pr.Number == msg.number {+ if msg.err != nil {+ m.rows[i].imageState = "error"+ m.status = msg.err.Error()+ } else if msg.exists {+ m.rows[i].imageState = "yes"+ } else {+ m.rows[i].imageState = "no"+ }+ }+ }+ m.applyFilter()+ return m, m.startImageChecks()+ case prActionMsg:+ m.status = msg.text+ return m, refreshRunning(m.rows, m.imageGen)+ case runningRefreshedMsg:+ if msg.generation != m.imageGen {+ return m, nil+ }+ m.rows = msg.rows+ m.applyFilter()+ return m, m.refreshSelectedLogs()+ case rebuildDoneMsg:+ m.rebuilding = false+ if m.rebuildCancel != nil {+ m.rebuildCancel()+ }+ m.rebuildCancel = nil+ m.loading = true+ action := msg.action+ if action == "" {+ action = "rebuilt"+ }+ if msg.canceled {+ m.status = action + " canceled"+ } else if msg.err != nil {+ m.status = action + " failed: " + msg.err.Error()+ } else {+ m.status = action + " " + msg.image.Reference()+ }+ return m, tea.Batch(loadDev(m.includeBots, true), m.spinner.Tick)+ case logsMsg:+ if !m.showLogs || msg.name == "" || msg.name != m.logsName {+ return m, nil+ }+ m.logs.SetContent(strings.TrimRight(msg.content, "\n"))+ if m.followLogs {+ m.logs.GotoBottom()+ }+ return m, nil+ case prLogTickMsg:+ if !m.showLogs {+ return m, nil+ }+ return m, tea.Batch(m.refreshSelectedLogs(), prLogTick())+ case pullReadyMsg:+ return m, waitPull(m.pullEvents)+ case pullEvent:+ if !msg.done {+ m.appendPullLine(msg.line)+ return m, waitPull(m.pullEvents)+ }+ m.pulling = false+ m.pullEvents = nil+ if m.pullCancel != nil {+ m.pullCancel()+ }+ m.pullCancel = nil+ m.layout()+ if msg.err != nil {+ if m.pullCanceled {+ m.status = "pull canceled"+ } else {+ m.status = "pull failed: " + msg.err.Error()+ }+ m.pullCanceled = false+ m.pullPlan = nil+ return m, nil+ }+ m.pullCanceled = false+ plan := m.pullPlan+ m.pullPlan = nil+ if plan == nil {+ return m, nil+ }+ for i := range m.rows {+ if m.rows[i].pr.Number == plan.PRNumber {+ m.rows[i].imageState = "yes"+ }+ }+ m.applyFilter()+ m.status = fmt.Sprintf("starting PR #%d…", plan.PRNumber)+ return m, func() tea.Msg {+ plan.Pull = false+ if err := run.StartDetached(plan); err != nil {+ return prActionMsg{"start failed: " + err.Error()}+ }+ return prActionMsg{fmt.Sprintf("started PR #%d → http://localhost:%d", plan.PRNumber, plan.HostPort)}+ }+ case spinner.TickMsg:+ var cmd tea.Cmd+ m.spinner, cmd = m.spinner.Update(msg)+ if m.loading || m.pulling || m.rebuilding {+ return m, cmd+ }+ return m, nil+ case tea.KeyPressMsg:+ if m.rebuilding {+ switch msg.String() {+ case "q", "ctrl+c", "esc":+ if m.rebuildCancel != nil {+ m.rebuildCancel()+ }+ m.status = "canceling rebuild…"+ return m, nil+ }+ }+ if m.pulling {+ switch msg.String() {+ case "q", "ctrl+c", "esc":+ if m.pullCancel != nil {+ m.pullCanceled = true+ m.pullCancel()+ }+ m.status = "canceling pull…"+ }+ return m, nil+ }+ if m.filtering {+ switch msg.Key().Code {+ case tea.KeyEscape:+ m.filtering = false+ m.filter.Reset()+ m.filter.Blur()+ m.applyFilter()+ m.layout()+ return m, nil+ case tea.KeyEnter:+ m.filtering = false+ m.filter.Blur()+ m.layout()+ return m, nil+ }+ var cmd tea.Cmd+ m.filter, cmd = m.filter.Update(msg)+ m.applyFilter()+ return m, cmd+ }+ switch msg.Key().Code {+ case tea.KeyUp, tea.KeyKpUp:+ m.table.MoveUp(1)+ return m, m.refreshSelectedLogs()+ case tea.KeyDown, tea.KeyKpDown:+ m.table.MoveDown(1)+ return m, m.refreshSelectedLogs()+ case tea.KeyPgUp, tea.KeyKpPgUp:+ if m.showLogs {+ m.followLogs = false+ m.logs.PageUp()+ }+ return m, nil+ case tea.KeyPgDown, tea.KeyKpPgDown:+ if m.showLogs {+ m.logs.PageDown()+ m.followLogs = m.logs.AtBottom()+ }+ return m, nil+ }+ switch msg.String() {+ case "q", "ctrl+c", "esc":+ return m, tea.Quit+ case "enter", "space":+ row := m.selectedRow()+ if row == nil {+ return m, nil+ }+ name := fmt.Sprintf("homarr_pr_%d", row.pr.Number)+ label := fmt.Sprintf("PR #%d", row.pr.Number)+ if row.kind == "local" {+ name = "homarr_" + row.local.Tag+ label = row.local.Reference()+ }+ if row.running {+ return m, func() tea.Msg {+ if err := docker.Stop(name); err != nil {+ return prActionMsg{"stop failed: " + err.Error()}+ }+ return prActionMsg{"stopped " + label}+ }+ }+ if row.kind == "remote" {+ if row.hasCurrentLocalImage() {+ plan, err := localPRPlan(*row, m.demo, nil)+ if err != nil {+ m.status = err.Error()+ return m, nil+ }+ m.status = fmt.Sprintf("starting PR #%d from local build…", row.pr.Number)+ return m, func() tea.Msg {+ if err := run.StartDetached(plan); err != nil {+ return prActionMsg{"start failed: " + err.Error()}+ }+ return prActionMsg{fmt.Sprintf("started PR #%d from local build → http://localhost:%d", row.pr.Number, plan.HostPort)}+ }+ }+ if row.imageState == "checking" {+ m.status = fmt.Sprintf("PR #%d image check is still in progress", row.pr.Number)+ return m, nil+ }+ return m, m.beginPull(*row)+ }+ plan, err := run.BuildPlan(run.Options{Context: context.Background(), Tag: row.local.Tag, Demo: m.demo})+ if err != nil {+ m.status = err.Error()+ return m, nil+ }+ return m, func() tea.Msg {+ if err := run.StartDetached(plan); err != nil {+ return prActionMsg{"start failed: " + err.Error()}+ }+ return prActionMsg{fmt.Sprintf("started %s → http://localhost:%d", label, plan.HostPort)}+ }+ case "r":+ m.loading = true+ m.status = "refreshing…"+ return m, tea.Batch(loadDev(m.includeBots, true), m.spinner.Tick)+ case "/":+ m.filtering = true+ m.layout()+ return m, m.filter.Focus()+ case "o":+ row := m.selectedPR()+ if row != nil {+ if err := platform.OpenURL(fmt.Sprintf("https://github.com/homarr-labs/homarr/pull/%d", row.pr.Number)); err != nil {+ m.status = "open failed: " + err.Error()+ }+ }+ case "a":+ row := m.selectedRow()+ if row != nil && row.running && row.port != "" {+ if err := platform.OpenURL("http://localhost:" + row.port); err != nil {+ m.status = "open failed: " + err.Error()+ }+ } else {+ m.status = "selected image is not running"+ }+ case "l":+ m.showLogs = !m.showLogs+ m.layout()+ if m.showLogs {+ m.followLogs = true+ return m, tea.Batch(m.refreshSelectedLogs(), prLogTick())+ }+ return m, nil+ case "f":+ if m.showLogs {+ m.followLogs = !m.followLogs+ if m.followLogs {+ m.logs.GotoBottom()+ }+ } else {+ m.status = "open logs with l first"+ }+ case "p":+ row := m.selectedPR()+ if row != nil {+ return m, m.beginPull(*row)+ } else {+ m.status = "pull is only available for remote PR images"+ }+ case "R":+ if m.rebuilding {+ m.status = "a local build is already running"+ return m, nil+ }+ row := m.selectedRow()+ if row == nil {+ m.status = "select an image to build"+ return m, nil+ }+ image, action, status := localBuildForRow(*row)+ ctx, cancel := context.WithCancel(context.Background())+ m.rebuilding = true+ m.rebuildCancel = cancel+ m.status = status+ rebuild := func() tea.Msg {+ output := &outputTail{}+ err := run.RebuildImageContext(ctx, image, output, output)+ if err != nil {+ err = commandErrorWithDetail(err, output.lastLine())+ }+ return rebuildDoneMsg{image: image, err: err, canceled: ctx.Err() != nil, action: action}+ }+ return m, tea.Batch(rebuild, m.spinner.Tick)+ case "m":+ m.demo = !m.demo+ if m.demo {+ m.status = "demo mode enabled for the next launch"+ } else {+ m.status = "demo mode disabled"+ }+ case "k":+ m.table.MoveUp(1)+ return m, m.refreshSelectedLogs()+ case "j":+ m.table.MoveDown(1)+ return m, m.refreshSelectedLogs()+ case "b":+ m.includeBots = !m.includeBots+ m.loading = true+ if m.includeBots {+ m.status = "refreshing (bots shown)…"+ } else {+ m.status = "refreshing (bots hidden)…"+ }+ return m, tea.Batch(loadDev(m.includeBots, false), m.spinner.Tick)+ }+ }+ var cmd tea.Cmd+ m.table, cmd = m.table.Update(msg)+ return m, cmd+}++func coloredCI(state string) string {+ switch state {+ case "SUCCESS":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("✓ success")+ case "FAILURE":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("196")).Render("✗ failed")+ case "PENDING":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Render("● pending")+ default:+ return lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render("– no checks")+ }+}++func coloredImage(state string) string {+ switch state {+ case "yes":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("✓ available")+ case "no":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render("… not built")+ case "error":+ return lipgloss.NewStyle().Foreground(lipgloss.Color("196")).Render("! check failed")+ default:+ return lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Render("? checking")+ }+}++func (m prsModel) selectedDetailView() string {+ row := m.selectedRow()+ if row == nil {+ return ""+ }+ if row.kind == "local" {+ source := row.local.Source+ if source == "" {+ source = "unknown source · rebuild unavailable"+ }+ meta := "local · " + source+ if row.local.Revision != "" {+ meta += " · " + truncateText(row.local.Revision, 12)+ }+ if row.local.PRNumber > 0 {+ meta += fmt.Sprintf(" · PR #%d", row.local.PRNumber)+ }+ if row.running {+ meta += " · " + lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("running on :"+row.port)+ }+ title := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("229")).Render(row.local.Reference())+ return title + "\n" + meta+ }+ branch := row.pr.HeadRef+ if branch == "" {+ branch = "unknown branch"+ }+ runSource := "run remote"+ if row.hasCurrentLocalImage() {+ runSource = "run local " + truncateText(row.local.Revision, 12)+ }+ meta := "@" + row.pr.Author + " · " + branch + " · CI " + coloredCI(row.pr.CIState) + " · " + runSource+ if !row.hasCurrentLocalImage() {+ meta += " · GHCR " + coloredImage(row.imageState)+ }+ if row.running {+ meta += " · " + lipgloss.NewStyle().Foreground(lipgloss.Color("42")).Render("running on :"+row.port)+ }+ title := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("229")).Render(fmt.Sprintf("#%d %s", row.pr.Number, row.pr.Title))+ return title + "\n" + meta+}++func truncateText(value string, length int) string {+ runes := []rune(value)+ if len(runes) <= length {+ return value+ }+ return string(runes[:length])+}++func (m prsModel) View() tea.View {+ var b strings.Builder+ header := titleStyle.Render("🦞 homarr development")+ if m.loading || m.rebuilding {+ header += " " + m.spinner.View()+ }+ running := 0+ remote := 0+ local := 0+ for _, row := range m.rows {+ if row.kind == "local" {+ local+++ } else {+ remote+++ if row.hasCurrentLocalImage() {+ local+++ }+ }+ if row.running {+ running+++ }+ }+ header += " " + helpStyle.Render(fmt.Sprintf("%d remote · %d local · %d running · %d shown", remote, local, running, len(m.table.Rows())))+ if m.demo {+ header += " " + lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("214")).Render("DEMO")+ }+ b.WriteString(header + "\n\n")+ if m.filtering || m.filter.Value() != "" {+ b.WriteString(m.filter.View() + "\n\n")+ }+ if len(m.table.Rows()) > 0 {+ b.WriteString(m.table.View() + "\n")+ } else if len(m.rows) > 0 {+ b.WriteString(helpStyle.Render("no development images match "+m.filter.Value()) + "\n")+ }+ if detail := m.selectedDetailView(); detail != "" {+ b.WriteString("\n" + detail + "\n")+ }+ if m.pulling {+ label := "Pulling image"+ if m.pullPlan != nil {+ label = fmt.Sprintf("Pulling PR #%d", m.pullPlan.PRNumber)+ }+ b.WriteString("\n" + lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("214")).Render(m.spinner.View()+" "+label) + "\n")+ complete, total, percent := m.pullCompletion()+ if total > 0 {+ b.WriteString(m.pullProgress.ViewAs(percent) + " " + helpStyle.Render(fmt.Sprintf("%d/%d layers", complete, total)) + "\n")+ }+ b.WriteString(m.pullView.View() + "\n")+ b.WriteString(helpStyle.Render("q/esc cancel download") + "\n")+ }+ if m.showLogs {+ mode := "paused"+ if m.followLogs {+ mode = "following"+ }+ name := m.logsName+ if name == "" {+ name = "selected image"+ }+ b.WriteString("\n" + logHeadSt.Render("── logs: "+name+" ("+mode+") ──") + "\n")+ b.WriteString(m.logs.View() + "\n")+ }+ if m.status != "" {+ statusStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("42"))+ lower := strings.ToLower(m.status)+ if strings.Contains(lower, "fail") || strings.Contains(lower, "error") || strings.Contains(lower, "cannot") {+ statusStyle = statusStyle.Foreground(lipgloss.Color("196"))+ } else if m.pulling || m.rebuilding || strings.Contains(lower, "starting") || strings.Contains(lower, "refreshing") {+ statusStyle = statusStyle.Foreground(lipgloss.Color("214"))+ }+ b.WriteString("\n" + statusStyle.Render(m.status))+ }+ botState := "bots hidden"+ if m.includeBots {+ botState = "bots shown"+ }+ if !m.pulling {+ b.WriteString("\n\n" + helpStyle.Render("/ filter · ↑/↓ select · enter start/stop · R build locally · p pull remote · m demo · o PR · a app"))+ b.WriteString("\n" + helpStyle.Render("b "+botState+" · r refresh · d instances · q quit"))+ b.WriteString("\n" + helpStyle.Render("l toggle logs · f follow · pgup/pgdn scroll"))+ if m.rebuilding {+ b.WriteString("\n" + helpStyle.Render("local build running in background · q/esc cancel build"))+ }+ }+ b.WriteString("\n" + helpStyle.Render("SOURCE: local Docker / remote GHCR · CI: "+legendCIYes+" pass "+legendCINo+" fail "+legendCIPend+" pending "+legendNone+" none · IMAGE: "+legendLocal+" local "+legendImageYes+" remote "+legendImageNo+" not built"))+ v := tea.NewView(b.String())+ v.AltScreen = true+ v.WindowTitle = "🦞 Homarr Development"+ return v+}++func RunDev() error {+ return runApp(false)+}diff --git a/tools/homarr-dev/internal/tui/dev_test.go b/tools/homarr-dev/internal/tui/dev_test.gonew file mode 100644index 000000000..ecd8d85bf--- /dev/null+++ b/tools/homarr-dev/internal/tui/dev_test.go@@ -0,0 +1,228 @@+package tui++import (+ "errors"+ "strings"+ "testing"++ tea "charm.land/bubbletea/v2"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/gh"+)++func TestPRTableRendersRows(t *testing.T) {+ m := newPRsModel()+ m.rows = []prRow{{+ kind: "remote",+ pr: gh.PR{Number: 6441, Title: "Human PR", Author: "ajnart", CIState: "SUCCESS"},+ imageState: "yes",+ }}+ m.table.SetRows(buildTableRows(m.rows))++ if got := m.View().Content; !strings.Contains(got, "Human PR") {+ t.Fatalf("table view omitted rows: %q", got)+ }+ if !m.View().AltScreen {+ t.Fatal("development browser must use the alternate screen")+ }+}++func TestPRTableArrowNavigation(t *testing.T) {+ m := newPRsModel()+ m.rows = []prRow{+ {kind: "remote", pr: gh.PR{Number: 1, Title: "First"}},+ {kind: "remote", pr: gh.PR{Number: 2, Title: "Second"}},+ }+ m.table.SetRows(buildTableRows(m.rows))++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))+ got := updated.(prsModel).table.SelectedRow()+ if len(got) < 3 || got[2] != "2" {+ t.Fatalf("down arrow selected %v, want PR 2", got)+ }+}++func TestPRImageChecksAreBounded(t *testing.T) {+ m := newPRsModel()+ prs := make([]gh.PR, 20)+ for i := range prs {+ prs[i] = gh.PR{Number: i + 1, Title: "PR"}+ }++ updated, cmd := m.Update(prsLoadedMsg{prs: prs})+ got := updated.(prsModel)+ if cmd == nil {+ t.Fatal("expected image check commands")+ }+ if got.imageActive != 6 || len(got.imageQueue) != 14 {+ t.Fatalf("active=%d queued=%d, want active=6 queued=14", got.imageActive, len(got.imageQueue))+ }+}++func TestPRLoadedReusesImageChecksUnlessRefreshIsForced(t *testing.T) {+ m := newPRsModel()+ m.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 1}, imageState: "yes"}}++ updated, _ := m.Update(prsLoadedMsg{prs: []gh.PR{{Number: 1}, {Number: 2}}})+ cached := updated.(prsModel)+ if cached.rows[0].imageState != "yes" || len(cached.imageQueue) != 0 || cached.imageActive != 1 {+ t.Fatalf("cached states were not reused: rows=%#v queue=%v active=%d", cached.rows, cached.imageQueue, cached.imageActive)+ }++ updated, _ = cached.Update(prsLoadedMsg{prs: []gh.PR{{Number: 1}, {Number: 2}}, refresh: true})+ refreshed := updated.(prsModel)+ if refreshed.rows[0].imageState != "checking" || refreshed.imageActive != 2 {+ t.Fatalf("forced refresh reused image states: rows=%#v active=%d", refreshed.rows, refreshed.imageActive)+ }+}++func TestDevelopmentRowsFoldCurrentLocalPRImage(t *testing.T) {+ prs := []gh.PR{{Number: 6502, HeadSHA: "current"}}+ images := []docker.Image{+ {Tag: "pr-6502", PRNumber: 6502, Revision: "current"},+ {Tag: "pr-6502-stale", PRNumber: 6502, Revision: "stale"},+ }++ rows, queue := developmentRows(prs, images, nil)+ if len(rows) != 2 || !rows[0].hasCurrentLocalImage() || rows[0].local.Tag != "pr-6502" {+ t.Fatalf("current image was not folded into PR row: %#v", rows)+ }+ if rows[1].kind != "local" || rows[1].local.Tag != "pr-6502-stale" {+ t.Fatalf("stale image should remain separate: %#v", rows[1])+ }+ if got := buildTableRows(rows)[0][6]; got != imgLocal {+ t.Fatalf("image marker = %q, want %q", got, imgLocal)+ }+ if len(queue) != 0 {+ t.Fatalf("current local image queued unnecessary registry checks: %v", queue)+ }+}++func TestLocalPRPlanUsesPRContainerIdentity(t *testing.T) {+ row := prRow{+ kind: "remote",+ pr: gh.PR{Number: 6502, HeadSHA: "abcdef1234567890"},+ local: docker.Image{Tag: "pr-6502", PRNumber: 6502, Revision: "abcdef1234567890"},+ }+ plan, err := localPRPlan(row, false, func(int) int { return 7575 })+ if err != nil {+ t.Fatal(err)+ }+ if plan.Image != "homarr:pr-6502" || plan.Name != "homarr_pr_6502" || plan.Volume != "homarr_pr_6502_data" || plan.Pull || plan.PRNumber != 6502 {+ t.Fatalf("unexpected local PR plan: %#v", plan)+ }+}++func TestRemotePRBuildUsesTemporaryPRWorkflow(t *testing.T) {+ image, action, status := localBuildForRow(prRow{kind: "remote", pr: gh.PR{Number: 6441}})+ if image.Tag != "pr-6441" || image.PRNumber != 6441 || action != "built" || !strings.Contains(status, "building PR #6441 locally") {+ t.Fatalf("image=%#v action=%q status=%q", image, action, status)+ }+}++func TestPRImageCheckInProgressDoesNotLaunch(t *testing.T) {+ m := newPRsModel()+ m.rows = []prRow{{kind: "remote", pr: gh.PR{Number: 6441, Title: "Pending image"}, imageState: "checking"}}+ m.table.SetRows(buildTableRows(m.rows))++ updated, cmd := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyEnter}))+ got := updated.(prsModel)+ if cmd != nil {+ t.Fatal("unavailable image returned a launch command")+ }+ if !strings.Contains(got.status, "still in progress") {+ t.Fatalf("status = %q, want launch rejection", got.status)+ }+}++func TestPullErrorIncludesLastDockerMessage(t *testing.T) {+ err := commandErrorWithDetail(errors.New("exit status 1"), "manifest unknown")+ if !strings.Contains(err.Error(), "manifest unknown") {+ t.Fatalf("pull error = %v", err)+ }+}++func TestOutputTailRetainsBuildFailure(t *testing.T) {+ tail := &outputTail{}+ _, _ = tail.Write([]byte("building\r\nERROR: Dockerfile not found\n"))+ if got := tail.lastLine(); got != "ERROR: Dockerfile not found" {+ t.Fatalf("last line = %q", got)+ }+}++func TestDevTableRendersLocalImageSource(t *testing.T) {+ m := newPRsModel()+ m.rows = []prRow{{+ kind: "local",+ local: docker.Image{Tag: "feature", Source: "/tmp/homarr", Revision: "abcdef1234567890"},+ imageState: "yes",+ }}+ m.table.SetRows(buildTableRows(m.rows))++ content := m.View().Content+ for _, want := range []string{"local", "homarr:feature", "/tmp/homarr", "abcdef123456"} {+ if !strings.Contains(content, want) {+ t.Fatalf("development view omitted %q: %q", want, content)+ }+ }+}++func TestRebuildCompletionRestoresLoadingState(t *testing.T) {+ m := newPRsModel()+ m.rebuilding = true+ image := docker.Image{Tag: "feature"}++ updated, cmd := m.Update(rebuildDoneMsg{image: image})+ got := updated.(prsModel)+ if got.rebuilding || !got.loading || got.status != "rebuilt homarr:feature" || cmd == nil {+ t.Fatalf("unexpected rebuild state: rebuilding=%v loading=%v status=%q", got.rebuilding, got.loading, got.status)+ }+}++func TestRebuildCanBeCanceled(t *testing.T) {+ m := newPRsModel()+ canceled := false+ m.rebuilding = true+ m.rebuildCancel = func() { canceled = true }++ updated, cmd := m.Update(tea.KeyPressMsg(tea.Key{Code: 'q'}))+ got := updated.(prsModel)+ if !canceled || cmd != nil || got.status != "canceling rebuild…" {+ t.Fatalf("cancel state: canceled=%v status=%q", canceled, got.status)+ }+}++func TestNavigationRemainsAvailableDuringBuild(t *testing.T) {+ m := newPRsModel()+ m.rebuilding = true+ m.rows = []prRow{+ {kind: "remote", pr: gh.PR{Number: 1}},+ {kind: "remote", pr: gh.PR{Number: 2}},+ }+ m.table.SetRows(buildTableRows(m.rows))++ updated, _ := m.Update(tea.KeyPressMsg(tea.Key{Code: tea.KeyDown}))+ selected := updated.(prsModel).table.SelectedRow()+ if len(selected) < 3 || selected[2] != "2" {+ t.Fatalf("build blocked navigation: %v", selected)+ }+}++func TestCompletedPullWithoutPlanDoesNotPanic(t *testing.T) {+ m := newPRsModel()+ m.pulling = true+ m.pullCancel = func() {}++ updated, cmd := m.Update(pullEvent{done: true})+ got := updated.(prsModel)+ if got.pulling || cmd != nil {+ t.Fatalf("pulling=%v cmd=%v", got.pulling, cmd)+ }+}++func TestTruncateTextPreservesUTF8(t *testing.T) {+ if got := truncateText("🦞homarr", 2); got != "🦞h" {+ t.Fatalf("truncateText() = %q", got)+ }+}diff --git a/tools/homarr-dev/main.go b/tools/homarr-dev/main.gonew file mode 100644index 000000000..2380e41bd--- /dev/null+++ b/tools/homarr-dev/main.go@@ -0,0 +1,301 @@+package main++import (+ "fmt"+ "os"+ "os/exec"+ "strings"++ "github.com/spf13/cobra"++ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/docker"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/platform"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/run"+ "github.com/homarr-labs/homarr/tools/homarr-dev/internal/tui"+)++var (+ flagDemo bool+ flagPR int+ flagEnv []string+ flagDetach bool+ flagBuildPR int+ runMain = tui.RunDev+)++func main() {+ if err := rootCmd.Execute(); err != nil {+ os.Exit(1)+ }+}++var rootCmd = &cobra.Command{+ Use: "homarr",+ Short: "Launch and manage Homarr Docker instances",+ SilenceUsage: true,+ Long: `Launch and manage Homarr Docker containers.++Start a local image, a PR test build from ghcr.io, browse open PRs,+or manage running instances from an interactive dashboard.++Examples:+ homarr run dev # launch local homarr:dev image+ homarr run --pr 6390 # launch remote PR test image+ homarr run --pr 6390 --demo # PR + demo mode+ homarr run -e FOO=bar dev # extra env vars+ homarr run --detach dev # start in background+ homarr dash # interactive instance dashboard+ homarr dev # browse remote PRs and local images+ homarr build feature # build this checkout as homarr:feature+ homarr build --pr 6390 # build PR #6390 locally as homarr:pr-6390+ homarr list # script-friendly instance list+ homarr logs homarr_pr_6390 # follow logs+ homarr doctor # check Docker and optional integrations`,+ Args: cobra.NoArgs,+ RunE: func(cmd *cobra.Command, args []string) error {+ return runMain()+ },+}++var dashCmd = &cobra.Command{+ Use: "dash",+ Short: "Interactive dashboard of running instances",+ RunE: func(cmd *cobra.Command, args []string) error {+ return tui.RunDashboard()+ },+}++var runCmd = &cobra.Command{+ Use: "run [tag]",+ Short: "Launch a local image or remote pull-request image",+ Args: cobra.MaximumNArgs(1),+ RunE: runLaunch,+}++var devCmd = &cobra.Command{+ Use: "dev",+ Short: "Browse remote PRs and local development images",+ RunE: func(cmd *cobra.Command, args []string) error {+ return tui.RunDev()+ },+}++var buildCmd = &cobra.Command{+ Use: "build [name]",+ Short: "Build a local Homarr image from this checkout or a pull request",+ Args: cobra.MaximumNArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ tag := ""+ if len(args) > 0 {+ tag = args[0]+ }+ if flagBuildPR < 0 {+ return fmt.Errorf("PR number must be positive")+ }+ if flagBuildPR > 0 {+ if tag == "" {+ tag = fmt.Sprintf("pr-%d", flagBuildPR)+ }+ return run.BuildPRImage(flagBuildPR, tag)+ }+ if tag == "" {+ return fmt.Errorf("image name is required when --pr is not set")+ }+ return run.BuildCurrentImage(tag, ".")+ },+}++var rebuildCmd = &cobra.Command{+ Use: "rebuild <name>",+ Short: "Rebuild a local image from its recorded checkout or pull request",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ images, err := docker.ListLocalImages(cmd.Context())+ if err != nil {+ return err+ }+ for _, image := range images {+ if image.Tag == args[0] || image.Reference() == args[0] {+ return run.RebuildImage(image)+ }+ }+ return fmt.Errorf("local image homarr:%s was not found", strings.TrimPrefix(args[0], "homarr:"))+ },+}++var logsCmd = &cobra.Command{+ Use: "logs <container>",+ Short: "Follow logs of a running instance",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ return docker.FollowLogs(args[0])+ },+}++var stopCmd = &cobra.Command{+ Use: "stop <container>",+ Short: "Stop a running instance",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ return docker.Stop(args[0])+ },+}++var restartCmd = &cobra.Command{+ Use: "restart <container>",+ Short: "Restart a running instance",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ return docker.Restart(args[0])+ },+}++var removeCmd = &cobra.Command{+ Use: "remove <container>",+ Short: "Force-remove an instance",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ return docker.Remove(args[0])+ },+}++var openCmd = &cobra.Command{+ Use: "open <container>",+ Short: "Open a running instance in the browser",+ Args: cobra.ExactArgs(1),+ RunE: func(cmd *cobra.Command, args []string) error {+ containers, err := docker.List()+ if err != nil {+ return err+ }+ for _, container := range containers {+ if container.Name != args[0] {+ continue+ }+ if !container.Running() {+ return fmt.Errorf("container %q is not running", args[0])+ }+ port := container.HostPort()+ if port == "" {+ return fmt.Errorf("container %q does not publish the Homarr port", args[0])+ }+ return platform.OpenURL("http://localhost:" + port)+ }+ return fmt.Errorf("container %q was not found", args[0])+ },+}++var listCmd = &cobra.Command{+ Use: "list",+ Aliases: []string{"ls"},+ Short: "List Homarr instances without opening the dashboard",+ RunE: func(cmd *cobra.Command, args []string) error {+ containers, err := docker.List()+ if err != nil {+ return err+ }+ if len(containers) == 0 {+ fmt.Println("No Homarr instances found.")+ return nil+ }+ fmt.Printf("%-28s %-10s %-7s %s\n", "NAME", "STATE", "PORT", "IMAGE")+ for _, container := range containers {+ fmt.Printf("%-28s %-10s %-7s %s\n", container.Name, container.State, container.HostPort(), container.Image)+ }+ return nil+ },+}++var doctorCmd = &cobra.Command{+ Use: "doctor",+ Short: "Check Docker and optional developer CLI integrations",+ RunE: func(cmd *cobra.Command, args []string) error {+ failed := false+ output, err := exec.Command("docker", "info", "--format", "{{.ServerVersion}}").CombinedOutput()+ if err != nil {+ failed = true+ fmt.Printf("✗ Docker daemon: %s\n", strings.TrimSpace(string(output)))+ } else {+ fmt.Printf("✓ Docker daemon: %s\n", strings.TrimSpace(string(output)))+ }++ if _, err := exec.LookPath("gh"); err != nil {+ fmt.Println("- GitHub CLI not found (optional; required for pull-request features)")+ } else if output, err := exec.Command("gh", "auth", "status").CombinedOutput(); err != nil {+ fmt.Printf("- GitHub CLI is not authenticated (optional; run `gh auth login` for pull-request features): %s\n", strings.TrimSpace(string(output)))+ } else {+ fmt.Println("✓ GitHub CLI authentication")+ }++ if _, err := exec.LookPath("homarr"); err != nil {+ fmt.Println("- homarr is not on PATH (optional; use `pnpm dev:cli -- ...` or run `pnpm dev:cli:install`)")+ } else {+ fmt.Println("✓ homarr is on PATH")+ }+ if failed {+ return fmt.Errorf("one or more checks failed")+ }+ return nil+ },+}++func init() {+ runCmd.Flags().BoolVarP(&flagDemo, "demo", "m", false, "Demo mode (mock integrations)")+ runCmd.Flags().IntVarP(&flagPR, "pr", "p", 0, "Launch PR test image from ghcr.io")+ runCmd.Flags().StringArrayVarP(&flagEnv, "env", "e", nil, "Extra env vars (repeatable, KEY=VALUE)")+ runCmd.Flags().BoolVar(&flagDetach, "detach", false, "Start in the background")+ buildCmd.Flags().IntVarP(&flagBuildPR, "pr", "p", 0, "Build a pull request in a temporary checkout")++ rootCmd.AddCommand(runCmd, dashCmd, devCmd, buildCmd, rebuildCmd, listCmd, logsCmd, stopCmd, restartCmd, removeCmd, openCmd, doctorCmd)+}++func runLaunch(cmd *cobra.Command, args []string) error {+ tag := ""+ if len(args) > 0 {+ tag = args[0]+ }+ if flagPR < 0 {+ return fmt.Errorf("PR number must be positive")+ }+ if flagPR > 0 && tag != "" {+ return fmt.Errorf("tag and --pr cannot be used together")+ }+ if flagPR == 0 && tag == "" {+ if err := cmd.Usage(); err != nil {+ return err+ }+ return fmt.Errorf("provide a tag or --pr")+ }++ plan, err := run.BuildPlan(run.Options{+ Context: cmd.Context(),+ PR: flagPR,+ Tag: tag,+ Demo: flagDemo,+ Env: flagEnv,+ FetchTitle: flagPR > 0,+ })+ if err != nil {+ return err+ }++ fmt.Printf("Starting Homarr (%s)\n", plan.Label)+ fmt.Printf(" Image : %s\n", plan.Image)+ fmt.Printf(" Container : %s\n", plan.Name)+ fmt.Printf(" Volume : %s\n", plan.Volume)+ fmt.Printf(" Port : %d:7575\n", plan.HostPort)+ fmt.Printf(" URL : http://localhost:%d\n", plan.HostPort)+ if plan.PRNumber > 0 {+ fmt.Printf(" PR : https://github.com/homarr-labs/homarr/pull/%d\n", plan.PRNumber)+ }+ fmt.Println()++ if flagDetach {+ if err := run.StartDetached(plan); err != nil {+ return err+ }+ fmt.Printf("Started in background: http://localhost:%d\n", plan.HostPort)+ return nil+ }+ return run.StartForeground(plan)+}diff --git a/tools/homarr-dev/main_test.go b/tools/homarr-dev/main_test.gonew file mode 100644index 000000000..1736d98b3--- /dev/null+++ b/tools/homarr-dev/main_test.go@@ -0,0 +1,51 @@+package main++import (+ "errors"+ "strings"+ "testing"+)++func TestRootCommandLaunchesDevelopmentDashboard(t *testing.T) {+ want := errors.New("dashboard started")+ previous := runMain+ t.Cleanup(func() { runMain = previous })+ runMain = func() error { return want }++ if err := rootCmd.RunE(rootCmd, nil); !errors.Is(err, want) {+ t.Fatalf("root command error = %v", err)+ }+}++func TestRunLaunchRejectsTagWithPR(t *testing.T) {+ previousPR := flagPR+ t.Cleanup(func() { flagPR = previousPR })+ flagPR = 42++ err := runLaunch(runCmd, []string{"feature"})+ if err == nil || !strings.Contains(err.Error(), "cannot be used together") {+ t.Fatalf("error = %v", err)+ }+}++func TestRunLaunchRejectsNegativePR(t *testing.T) {+ previousPR := flagPR+ t.Cleanup(func() { flagPR = previousPR })+ flagPR = -1++ err := runLaunch(runCmd, nil)+ if err == nil || !strings.Contains(err.Error(), "must be positive") {+ t.Fatalf("error = %v", err)+ }+}++func TestRunLaunchRejectsMissingImage(t *testing.T) {+ previousPR := flagPR+ t.Cleanup(func() { flagPR = previousPR })+ flagPR = 0++ err := runLaunch(runCmd, nil)+ if err == nil || !strings.Contains(err.Error(), "provide a tag or --pr") {+ t.Fatalf("error = %v", err)+ }+}