From 418c7822774093434d436d4e7178640b30c3f1ca Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 14:21:52 +0530 Subject: [PATCH 01/28] feat: add Ferro operator console --- .github/workflows/ci.yml | 97 +++ .github/workflows/release.yml | 35 ++ .gitignore | 5 + .golangci.yml | 65 ++ .goreleaser.yaml | 49 ++ CHANGELOG.md | 80 +++ CONTRIBUTING.md | 15 + LICENSE | 201 ++++++ Makefile | 7 + README.md | 227 ++++++- cmd/fakegw/main.go | 62 ++ cmd/ferro/main.go | 34 + docs/demo.gif | Bin 0 -> 389044 bytes go.mod | 38 ++ go.sum | 76 +++ internal/api/client.go | 263 ++++++++ internal/api/client_test.go | 205 ++++++ internal/api/endpoints.go | 54 ++ internal/api/endpoints_test.go | 213 +++++++ internal/api/keys.go | 134 ++++ internal/api/keys_test.go | 230 +++++++ internal/api/logs.go | 256 ++++++++ internal/api/logs_test.go | 484 ++++++++++++++ internal/api/services.go | 135 ++++ internal/api/services_test.go | 190 ++++++ internal/api/sse.go | 379 +++++++++++ internal/api/sse_test.go | 521 +++++++++++++++ internal/api/status.go | 210 +++++++ internal/api/status_test.go | 347 ++++++++++ internal/api/types.go | 88 +++ internal/command/chat.go | 285 +++++++++ internal/command/chat_test.go | 411 ++++++++++++ internal/command/keys.go | 198 ++++++ internal/command/keys_test.go | 182 ++++++ internal/command/logs.go | 330 ++++++++++ internal/command/logs_test.go | 326 ++++++++++ internal/command/models.go | 40 ++ internal/command/output.go | 197 ++++++ internal/command/output_test.go | 218 +++++++ internal/command/providers.go | 103 +++ internal/command/root.go | 207 ++++++ internal/command/root_test.go | 217 +++++++ internal/command/services.go | 305 +++++++++ internal/command/services_test.go | 365 +++++++++++ internal/command/status.go | 64 ++ internal/command/status_test.go | 137 ++++ internal/config/config.go | 150 +++++ internal/config/config_test.go | 97 +++ internal/fixture/handler.go | 908 +++++++++++++++++++++++++++ internal/fixture/handler_test.go | 619 ++++++++++++++++++ internal/fixture/keys.go | 284 +++++++++ internal/fixture/state.go | 37 ++ internal/fixture/stream.go | 163 +++++ internal/fixture/wire.go | 148 +++++ internal/table/format.go | 65 ++ internal/table/plugins.go | 53 ++ internal/table/table.go | 52 ++ internal/table/table_test.go | 137 ++++ internal/tui/app.go | 859 +++++++++++++++++++++++++ internal/tui/app_test.go | 528 ++++++++++++++++ internal/tui/composer.go | 389 ++++++++++++ internal/tui/composer_test.go | 352 +++++++++++ internal/tui/home.go | 397 ++++++++++++ internal/tui/home_test.go | 421 +++++++++++++ internal/tui/keys.go | 720 +++++++++++++++++++++ internal/tui/keys_test.go | 392 ++++++++++++ internal/tui/logs.go | 495 +++++++++++++++ internal/tui/logs_test.go | 440 +++++++++++++ internal/tui/modal.go | 275 ++++++++ internal/tui/modal_test.go | 179 ++++++ internal/tui/msgs.go | 544 ++++++++++++++++ internal/tui/panetitle_probe_test.go | 41 ++ internal/tui/playground.go | 656 +++++++++++++++++++ internal/tui/playground_test.go | 614 ++++++++++++++++++ internal/tui/theme/theme.go | 196 ++++++ internal/tui/theme/theme_test.go | 82 +++ internal/tui/transcript.go | 168 +++++ internal/tui/transcript_test.go | 104 +++ internal/tui/verbs_cobra_test.go | 80 +++ internal/version/version.go | 19 + itest/itest_test.go | 459 ++++++++++++++ scripts/check-module-boundary.sh | 15 + scripts/smoke.sh | 48 ++ scripts/with-gateway.sh | 99 +++ 84 files changed, 19568 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/ci.yml create mode 100644 .github/workflows/release.yml create mode 100644 .golangci.yml create mode 100644 .goreleaser.yaml create mode 100644 CHANGELOG.md create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 cmd/fakegw/main.go create mode 100644 cmd/ferro/main.go create mode 100644 docs/demo.gif create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/api/client.go create mode 100644 internal/api/client_test.go create mode 100644 internal/api/endpoints.go create mode 100644 internal/api/endpoints_test.go create mode 100644 internal/api/keys.go create mode 100644 internal/api/keys_test.go create mode 100644 internal/api/logs.go create mode 100644 internal/api/logs_test.go create mode 100644 internal/api/services.go create mode 100644 internal/api/services_test.go create mode 100644 internal/api/sse.go create mode 100644 internal/api/sse_test.go create mode 100644 internal/api/status.go create mode 100644 internal/api/status_test.go create mode 100644 internal/api/types.go create mode 100644 internal/command/chat.go create mode 100644 internal/command/chat_test.go create mode 100644 internal/command/keys.go create mode 100644 internal/command/keys_test.go create mode 100644 internal/command/logs.go create mode 100644 internal/command/logs_test.go create mode 100644 internal/command/models.go create mode 100644 internal/command/output.go create mode 100644 internal/command/output_test.go create mode 100644 internal/command/providers.go create mode 100644 internal/command/root.go create mode 100644 internal/command/root_test.go create mode 100644 internal/command/services.go create mode 100644 internal/command/services_test.go create mode 100644 internal/command/status.go create mode 100644 internal/command/status_test.go create mode 100644 internal/config/config.go create mode 100644 internal/config/config_test.go create mode 100644 internal/fixture/handler.go create mode 100644 internal/fixture/handler_test.go create mode 100644 internal/fixture/keys.go create mode 100644 internal/fixture/state.go create mode 100644 internal/fixture/stream.go create mode 100644 internal/fixture/wire.go create mode 100644 internal/table/format.go create mode 100644 internal/table/plugins.go create mode 100644 internal/table/table.go create mode 100644 internal/table/table_test.go create mode 100644 internal/tui/app.go create mode 100644 internal/tui/app_test.go create mode 100644 internal/tui/composer.go create mode 100644 internal/tui/composer_test.go create mode 100644 internal/tui/home.go create mode 100644 internal/tui/home_test.go create mode 100644 internal/tui/keys.go create mode 100644 internal/tui/keys_test.go create mode 100644 internal/tui/logs.go create mode 100644 internal/tui/logs_test.go create mode 100644 internal/tui/modal.go create mode 100644 internal/tui/modal_test.go create mode 100644 internal/tui/msgs.go create mode 100644 internal/tui/panetitle_probe_test.go create mode 100644 internal/tui/playground.go create mode 100644 internal/tui/playground_test.go create mode 100644 internal/tui/theme/theme.go create mode 100644 internal/tui/theme/theme_test.go create mode 100644 internal/tui/transcript.go create mode 100644 internal/tui/transcript_test.go create mode 100644 internal/tui/verbs_cobra_test.go create mode 100644 internal/version/version.go create mode 100644 itest/itest_test.go create mode 100755 scripts/check-module-boundary.sh create mode 100755 scripts/smoke.sh create mode 100755 scripts/with-gateway.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..9d2b431 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,97 @@ +name: CI + +on: + push: + branches: ["main"] + pull_request: + branches: ["main"] + workflow_call: + schedule: + - cron: "0 4 * * 1" + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +permissions: + contents: read + +jobs: + boundary: + name: HTTP boundary intact + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + persist-credentials: false + - run: ./scripts/check-module-boundary.sh + + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: go.mod + - uses: golangci/golangci-lint-action@ba0d7d2ec06a0ea1cb5fa41b2e4a3ab91d21278a # v9 + with: + version: v2.11.4 + + security: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: go.mod + - run: go run golang.org/x/vuln/cmd/govulncheck@v1.3.0 ./... + + test: + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: go.mod + - run: go mod verify + - run: go vet ./... + - run: go test -race ./... + - run: go build ./cmd/ferro + + integration: + name: Contract vs AI Gateway ${{ matrix.gateway_ref }} + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + gateway_ref: ["v1.4.2", "main"] + steps: + - name: Check out gateway-cli + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + path: gateway-cli + persist-credentials: false + - name: Check out AI Gateway + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + repository: ferro-labs/ai-gateway + ref: ${{ matrix.gateway_ref }} + path: ai-gateway + persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: gateway-cli/go.mod + - run: ./scripts/with-gateway.sh + working-directory: gateway-cli + env: + FERRO_GATEWAY_SOURCE: ${{ github.workspace }}/ai-gateway diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..09d9642 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,35 @@ +name: Release + +on: + push: + tags: ["v*"] + +permissions: {} + +jobs: + ci: + permissions: + contents: read + uses: ./.github/workflows/ci.yml + + release: + name: GoReleaser + needs: ci + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + fetch-depth: 0 + persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: go.mod + - uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7.0.0 + with: + distribution: goreleaser + version: "2.17.1" + args: release --clean + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore index aaadf73..93b83c9 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,8 @@ go.work.sum # Editor/IDE # .idea/ # .vscode/ + +# Local builds +/ferro +/fakegw +/dist/ diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 0000000..4db6c43 --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,65 @@ +version: "2" + +run: + timeout: 5m + +linters: + enable: + - bodyclose + - copyloopvar + - depguard + - dupl + - errcheck + - errorlint + - goconst + - gocritic + - gocyclo + - gosec + - govet + - ineffassign + - maintidx + - misspell + - noctx + - nolintlint + - prealloc + - revive + - staticcheck + - unconvert + - unparam + - unused + + settings: + depguard: + rules: + main: + deny: + - pkg: gopkg.in/yaml.v3 + desc: use go.yaml.in/yaml/v3 + - pkg: github.com/ferro-labs/ai-gateway/config + desc: &http-only gateway-cli communicates with AI Gateway over HTTP only + - { pkg: github.com/ferro-labs/ai-gateway/internal, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/mcp, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/models, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/observability, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/pkg, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/plugin, desc: *http-only } + - { pkg: github.com/ferro-labs/ai-gateway/providers, desc: *http-only } + dupl: + threshold: 150 + gocyclo: + min-complexity: 30 + nolintlint: + require-explanation: true + require-specific: true + allow-unused: false + + exclusions: + rules: + - path: _test\.go + linters: [dupl, errorlint, goconst, unparam] + - path: _test\.go + linters: [staticcheck] + text: SA5011 + - path: internal/command/output\.go + linters: [gosec] + text: G115 diff --git a/.goreleaser.yaml b/.goreleaser.yaml new file mode 100644 index 0000000..60f8e1e --- /dev/null +++ b/.goreleaser.yaml @@ -0,0 +1,49 @@ +# GoReleaser for the standalone ferro operator console. +version: 2 +project_name: ferro +dist: dist + +builds: + - id: ferro + main: ./cmd/ferro + binary: ferro + env: [CGO_ENABLED=0] + goos: [linux, darwin, windows] + goarch: [amd64, arm64] + ldflags: + - -s -w + - -X github.com/ferro-labs/gateway-cli/internal/version.Version={{.Version}} + - -X github.com/ferro-labs/gateway-cli/internal/version.Commit={{.ShortCommit}} + - -X github.com/ferro-labs/gateway-cli/internal/version.Date={{.Date}} + +# cmd/fakegw is a development tool (a fake gateway for testing the CLI without +# a server). It is excluded by omission — builds are listed explicitly above. +# Do not add a build entry for it. + +archives: + - formats: [tar.gz] + name_template: "ferro_{{ .Version }}_{{ .Os }}_{{ .Arch }}" + format_overrides: + - goos: windows + formats: [zip] + files: + - src: README.md + dst: README.md + - src: CHANGELOG.md + dst: CHANGELOG.md + - src: LICENSE + dst: LICENSE + +checksum: + name_template: checksums.txt + +release: + name_template: "Ferro CLI v{{ .Version }}" + +changelog: + use: git + filters: + include: + - "^feat" + - "^fix" + - "^perf" diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..620e6a4 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,80 @@ +# Changelog + +All notable changes to **Ferro Operator Console**, the scriptable CLI and +interactive TUI for Ferro Labs AI Gateway. The binary it installs is `ferro`. + +The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and +this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## v0.1.0 — 2026-08-14 + +First standalone release. The project ships a single binary, `ferro`, carrying +two surfaces over one HTTP client: scriptable commands and a full-screen +operations console. Requires AI Gateway v1.4.2 or later. + +### Added + +- **Standalone distribution** from repository `ferro-labs/gateway-cli` and Go + module `github.com/ferro-labs/gateway-cli`. +- **Scriptable commands**, all honouring `--format table|json|yaml`: `status`, + `models`, `providers`, `mcp`, `plugins`, `services`, `sessions`, `audit`, + `keys list|get|create|rotate|revoke`, `logs list|stats|tail`, `chat`, and + `version`. +- **Full-screen console** on bare `ferro` at a TTY: a framed layout with a + connection header, a providers/services left rail, target and traffic + summaries, a bounded command transcript, and a command composer with + completion, ghost hints, history, and reverse search (`ctrl+r`). Screens: + Home, Request logs, Keys, Playground. +- **Request-log tail** — a since-cursor follower with deduplication and + exponential backoff, in both `logs tail` and the console's logs screen, with + filters for time, model, provider, stage, and credential. +- **Key management** with derived state (`active` / `expired` / `revoked`) from + `revoked_at`, `expires_at`, and `active`; a create wizard and + typed-confirmation rotate and revoke in the console. +- **Playground** — streaming chat with batched rendering, `/model` and + `/clear`, and a metadata line carrying usage plus route and cost when the + gateway can supply them. +- **Connection profiles** at `os.UserConfigDir()/ferro/config.yaml`, holding + connection details only. Resolution precedence — URL: `--gateway-url` > + `FERRO_URL` > `profile.url` > `http://localhost:8080`; key: `FERRO_API_KEY` > + `profile.api_key_env` deref > `MASTER_KEY`. Credentials never enter process + arguments or shell history through a flag. +- **Persistent flags** `--gateway-url`, `--profile`, `--format`, `--ascii`; + `NO_COLOR` support alongside TTY and `TERM=dumb` detection. + +### Fixed + +- Request-log tails now drain every bounded page before advancing their cursor, + preventing bursts larger than one page from being skipped. +- Silent chat connections now end with a structured stream-timeout error, and + interrupted JSON or YAML chats emit their partial document before exiting. +- Playground action notes are excluded from model history, prompt history is + retained only for recognized commands, and long sessions remain bounded. +- Key actions entered on a newly opened console wait for the current key list, + so names and selections resolve against fresh gateway state. +- Stale profile selections now fail with a clear error instead of silently + falling back to the local gateway URL. + +### Contracts + +- stdout is the machine channel; narrative, warnings, and errors go to stderr, + so `--format json` output is always safe to pipe. +- Exit codes are the API: `status` exits 1 only when the gateway is unreachable; + a reachable-but-degraded gateway exits 0 and prints its degraded state. +- Redirects are surfaced, never followed; a non-2xx response is always a + failure; an empty 2xx body where a payload was expected is an error; 503 is + decoded rather than errored only where degraded-state bodies are the contract. +- Secrets from `keys create` and `keys rotate` are shown exactly once, on + stdout, and never enter the console transcript or command history. +- Absent measurements render `-`, never `0`. Endpoints the gateway does not + serve (404 / 501) disable a panel with a hint instead of ending the command. +- The console holds no durable state; everything re-derives from the API. + +### Notes + +- The console's gateway-version slot renders `—`: the gateway does not serve its + version over HTTP. +- The traffic panel and streaming route attribution are derived from the request + log, and render as unavailable when no request-log store is configured. +- Not in this release: the config viewer / history / rollback screen, the + provider capability matrix, the doctor checklist, and the init wizard. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..16eed70 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,15 @@ +# Contributing + +Ferro Operator Console is a standalone Go module. Keep the runtime boundary +with AI Gateway HTTP-only; do not import packages from the gateway module. + +Before opening a change, run: + +```bash +./scripts/check-module-boundary.sh +go vet ./... +go test -race ./... +golangci-lint run ./... +``` + +For contract changes, run `FERRO_GATEWAY_SOURCE=/path/to/ai-gateway make itest`. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..cb45450 --- /dev/null +++ b/Makefile @@ -0,0 +1,7 @@ +.PHONY: build test lint fake itest smoke +build: ; go build -o ferro ./cmd/ferro +test: ; go test -race ./... +lint: ; golangci-lint run ./... +fake: ; go run ./cmd/fakegw +itest: ; ./scripts/with-gateway.sh +smoke: build ; ./scripts/smoke.sh diff --git a/README.md b/README.md index b2f9c72..2cbb0e8 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,225 @@ -# ai-gateway-cli -Operator Console - a scriptable CLI and interactive TUI for Ferro Labs AI Gateway +# Ferro Operator Console + +**A scriptable CLI and interactive TUI for the [Ferro Labs AI Gateway](https://github.com/ferro-labs/ai-gateway).** +One static binary that is both a scriptable CLI and a full-screen terminal +console — health, request logs, API keys, and a live playground, without +opening a browser. + +![ferro-cli console demo](docs/demo.gif) + +`ferro-cli` ships a single binary named **`ferro`**. Run it with a verb and it +behaves like any other Unix tool — `ferro status`, `ferro keys list`, +`ferro logs tail` — with clean stdout you can pipe into `jq`. Run it bare on a +terminal and it opens the console above. + +Every console view has a scriptable twin. The console is a lens, never the only +door. + +--- + +## Install + +```bash +go install github.com/ferro-labs/gateway-cli/cmd/ferro@v0.1.0 +``` + +Or download a release archive — `ferro___.tar.gz` (`.zip` on +Windows) — from the releases titled **Ferro CLI vX.Y.Z**, with `checksums.txt` +alongside. Linux, macOS, and Windows on amd64 and arm64. No runtime, no +dependencies: it is a single static binary. + +Works with **AI Gateway v1.4.2 or later**. + +> A withdrawn nested module also used v0.1.0 at +> `github.com/ferro-labs/ai-gateway/cli`. This standalone module has a distinct +> version namespace. Install only from `github.com/ferro-labs/gateway-cli`. + +| Console release | Distribution | AI Gateway compatibility | +|---|---|---| +| v0.1.x | `github.com/ferro-labs/gateway-cli` | v1.4.2+ | + +`ferro` is optional operator tooling for a running gateway. It is not part of +the gateway runtime and does not replace `ferrogw serve`, `ferrogw init`, or +offline `ferrogw validate`. + +## Quickstart + +```bash +export FERRO_URL=http://localhost:8080 +export FERRO_API_KEY=fgw_... # or let it fall back to MASTER_KEY + +ferro status # health in one line +ferro # the console (needs a terminal) +ferro status --format json | jq . # stdout is always pure machine output +``` + +## Commands + +Every list and get honours `--format json|yaml`. + +| Command | What it does | +|---|---| +| `ferro` | Opens the console. On a pipe it refuses and points at `--help`. | +| `ferro status` | State, URL, latency, targets, providers, models, MCP, auth. | +| `ferro models` | Models the gateway routes — id, owner, mode, context window, capabilities. | +| `ferro providers` | Providers with status, circuit state, model count, and message. | +| `ferro mcp` | MCP tool servers — ready, required, last error. | +| `ferro plugins` | Configured plugins merged with the build's catalog, including fail-open. | +| `ferro services` | MCP, plugin, session, and audit availability in one report. | +| `ferro sessions` | Active operator sessions — subject, scopes, created, last seen, expires. | +| `ferro audit` | Audit trail. `--action --actor --outcome --since --limit`. | +| `ferro keys list` | Keys — name, masked secret, scopes, expiry, last used, uses, state. | +| `ferro keys get ` | One key, as structured output. | +| `ferro keys create` | `--name` (required), `--scope admin\|read_only`, `--expires-in`. | +| `ferro keys rotate ` | Mint a new secret; the previous one stops authenticating at once. | +| `ferro keys revoke ` | Immediate and irreversible. | +| `ferro logs list` | Request log — time, trace, provider, model, stage, duration, cost, tokens. | +| `ferro logs stats` | Totals, errors, tokens, cost, and latency percentiles over a window. | +| `ferro logs tail` | Follow the log. Poll-based, deduped, plain lines; Ctrl-C exits clean. | +| `ferro chat "" --model ` | Streaming completion. Answer to stdout, usage to stderr. | +| `ferro version` | Version, commit, build date. Works with no gateway. | + +**Persistent flags:** `--gateway-url`, `--profile`, `--format table|json|yaml`, +`--ascii` (use `[OK] [X] [!] [-]` instead of `✓ ✗ ! ·`), and +`--insecure-http` (explicitly allow plaintext HTTP to a non-loopback gateway). + +## Configuration + +| Variable | Effect | +|---|---| +| `FERRO_URL` | Gateway base URL. Default `http://localhost:8080`. | +| `FERRO_API_KEY` | Bearer credential sent to the gateway. | +| `MASTER_KEY` | Last-resort credential fallback. | +| `NO_COLOR` | Any value suppresses ANSI. (Also off under `TERM=dumb` or a non-TTY stdout.) | + +```text +URL: --gateway-url > FERRO_URL > profile.url > http://localhost:8080 +key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY +``` + +**There is deliberately no credential flag.** Command-line arguments show up in +process listings and shell history, so credentials are environment-only. +Remote gateways require HTTPS by default because admin data and bearer +credentials must not cross a network in plaintext. Plain HTTP remains enabled +for loopback development; private-network HTTP requires `--insecure-http` on +each invocation. + +### Profiles + +`ferro-cli` stores **connection profiles only**, never gateway data, at +`os.UserConfigDir()/ferro/config.yaml` (`~/.config/ferro/config.yaml` on Linux). +A missing file is not an error. + +```yaml +current_profile: prod +profiles: + - name: prod + url: https://gw.example.com + api_key_env: PROD_KEY # the NAME of an env var, never the secret + - name: local + url: http://localhost:8080 +``` + +Select one with `--profile local`. A profile names the environment variable +holding its credential; the credential itself never touches the file. + +## The console + +`↵ run · tab complete · ↑ history · ctrl+r search · ? help · esc home · ctrl+c quit` + +Four persistent regions: a header carrying identity and connection state, a left +rail answering *what is connected*, a main frame answering *what happened*, and a +command composer that is the only navigation surface — there is no tab row. + +Type ordinary commands (`status`, `logs --since 15m --model claude-*`, +`keys create`) or slash aliases (`/logs`, `/keys`, `/playground`). `?` on an +empty composer prints the verb tree without destroying the transcript. + +| Screen | Contents | +|---|---| +| **Home** | Bounded command transcript, rendered by the same formatting code the scriptable verbs use. | +| **Request logs** | Live tail with filters and a per-row detail pane that resolves a credential id to its key name. | +| **Keys** | Key table with derived state, a create wizard, and typed-confirmation rotate and revoke. | +| **Playground** | Streaming chat with `/model` and `/clear`, and a metadata line carrying route, latency, tokens, and cost. | + +Layout adapts to width: ≥110 columns gets the mark, rail, and panels; 80–109 +collapses the rail into a compact status frame; below 80 leaves output and the +composer. Nothing is ever clipped mid-border. + +## Contracts worth relying on + +These are tested behaviours, not aspirations. + +- **stdout is the machine channel.** Narrative, warnings, and errors go to + stderr, so `ferro --format json | jq` only ever sees JSON. +- **Exit codes are the API.** `ferro status` exits **1 only when the gateway is + unreachable**. A reachable-but-degraded gateway exits **0** and prints its + degraded state — so `ferro status || alert` pages on outages, not brownouts. +- **Secrets are shown exactly once.** `keys create` and `keys rotate` print the + new secret once, on stdout, because the gateway stores only a hash. It never + reaches the console transcript or the command history. +- **Missing is not zero.** An absent measurement renders `-`, never `0`. When + `/readyz` reports no targets, you get `-`, because "none configured" and + "yours are dead" are different answers and the gateway only sent one of them. +- **Redirects are refused, never followed.** A bearer token is never replayed to + whatever host a redirect names; the target is surfaced as a hint instead. +- **A missing feature degrades one screen.** A 404 or 501 — no request-log + store, sessions disabled — disables that panel with a note rather than + ending the command or the app. +- **Colour never carries state alone.** Every status also has a glyph or text, + so the full ladder holds: console → `NO_COLOR` → non-TTY plain text → + `--format json`. +- **Nothing is cached on disk.** Everything re-derives from the API on each poll. + +### Known gaps in v0.1.0 + +Stated plainly, because the console shows them rather than inventing values: + +- The header reads `gateway —`: the gateway does not serve its own version over + HTTP yet. +- The traffic panel renders `—` without a request-log store, since it derives + from log statistics. +- Streaming responses carry no provider on the wire, so a chat's route is + resolved afterwards by matching the response's request id against the request + log — and is absent when no log store is configured. Usage still renders. +- The playground renders answers as word-wrapped plain text rather than + formatted markdown. Streaming, batching, and the metadata line are unaffected. +- Not in this release: the config viewer, the capability matrix, the doctor + checklist, and the init wizard. Their gateway endpoints exist; the screens + do not. + +## Development + +This repository versions independently from AI Gateway. HTTP is the only +runtime boundary: this module imports no gateway package and does not depend on +the gateway module. Wire shapes are copied, never imported, and CI enforces the +boundary. + +```bash +make fake # fake gateway (cmd/fakegw) on :8080 +make build # go build -o ferro ./cmd/ferro +make test # go test -race ./... +make lint # golangci-lint run ./... +make itest # contract suite against ../ai-gateway or FERRO_GATEWAY_SOURCE +``` + +`make fake` is the loop to use almost always. It serves the gateway's HTTP +contract from fixtures, so the whole CLI and console can be developed with **no +gateway, no provider credentials, and no network**: + +```bash +make fake & +FERRO_URL=http://localhost:8080 FERRO_API_KEY=fgw_test go run ./cmd/ferro +``` + +`cmd/fakegw` takes `--addr`, `--degraded`, `--no-providers`, `--no-log-store`, +and `--no-auth` to reproduce failure states a healthy gateway will not show you +on demand. It is a development tool and is never in a release build. + +`make itest` is the acceptance loop: it builds `ferrogw` from a separate AI +Gateway checkout, boots it, runs the contract suite, and tears it down. The fake +proves the CLI is internally correct; only this proves the contract is real. + +## License + +Apache 2.0 — see [`LICENSE`](LICENSE). diff --git a/cmd/fakegw/main.go b/cmd/fakegw/main.go new file mode 100644 index 0000000..a03f511 --- /dev/null +++ b/cmd/fakegw/main.go @@ -0,0 +1,62 @@ +// Command fakegw serves deterministic gateway responses for local CLI use. +package main + +import ( + "flag" + "fmt" + "net/http" + "os" + "strings" + "time" + + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +func main() { + addr := flag.String("addr", ":8080", "listen address") + degraded := flag.Bool("degraded", false, "healthy gateway in trouble: 200 with a half-open circuit and one unroutable target") + noProviders := flag.Bool("no-providers", false, "no credential configured: /health 503 no_providers, /readyz 503 not_ready") + noAuth := flag.Bool("no-auth", false, "accept unauthenticated admin requests") + noLogs := flag.Bool("no-log-store", false, "501 the log endpoints, as a gateway without a store does") + flag.Parse() + + s := fixture.Default() + // Two independent axes, as on the real gateway: a circuit does not make + // /health non-200, and only an empty provider set does. + s.Degraded, s.NoProviders = *degraded, *noProviders + s.NoLogStore, s.ChatDelay = *noLogs, 60*time.Millisecond + s.RequireAuth = !*noAuth + + fmt.Fprintf(os.Stderr, "fakegw on %s — key: %s\n", *addr, s.AcceptKey) + // A bare ":8080" needs a host prepended; "127.0.0.1:8101" already has one. + host := *addr + if strings.HasPrefix(host, ":") { + host = "localhost" + host + } + fmt.Fprintf(os.Stderr, " FERRO_URL=http://%s FERRO_API_KEY=%s go run ./cmd/ferro\n", host, s.AcceptKey) + srv := &http.Server{ + Addr: *addr, + Handler: fixture.Handler(s), + // ReadHeaderTimeout is the Slowloris bound — a client that opens a + // connection and dribbles headers forever is cut off here — and + // ReadTimeout bounds the body after it. Neither can cut a stream + // short: net/http clears the read deadline the moment the request + // body is consumed (connReader.startBackgroundRead), which is before + // the first SSE frame is written. + ReadHeaderTimeout: 10 * time.Second, + ReadTimeout: 30 * time.Second, + // WriteTimeout is deliberately zero. It bounds the WHOLE response, and + // this server's chat surface is SSE: a finite value would cut a stream + // off mid-flight and, worse, do it silently — the client sees a + // truncated stream with no error frame and no [DONE], which is exactly + // the failure the playground dev loop exists to make visible. Nothing + // is given up by leaving it off, because the Slowloris vector + // ReadHeaderTimeout covers is the one G114 is about. + WriteTimeout: 0, + IdleTimeout: 120 * time.Second, + } + if err := srv.ListenAndServe(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} diff --git a/cmd/ferro/main.go b/cmd/ferro/main.go new file mode 100644 index 0000000..f4df0f3 --- /dev/null +++ b/cmd/ferro/main.go @@ -0,0 +1,34 @@ +// Command ferro is the operator console for the Ferro Labs AI Gateway. +// +// It talks to the gateway only over HTTP and does not import gateway packages. +package main + +import ( + "context" + "os" + "os/signal" + "syscall" + + "github.com/charmbracelet/fang" + + "github.com/ferro-labs/gateway-cli/internal/command" +) + +func main() { + if err := run(); err != nil { + os.Exit(1) // fang has already rendered the error + } +} + +// run owns every deferred cleanup, because os.Exit runs none of them. With the +// signal context built directly in main, the os.Exit(1) on a failed command +// skipped `defer stop()` entirely, so the SIGINT handler signal.NotifyContext +// installs was never released on the error path. +func run() error { + // SIGINT cancels in-flight requests and long-running tails cleanly rather + // than killing the process mid-write. + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + + return fang.Execute(ctx, command.NewRoot()) +} diff --git a/docs/demo.gif b/docs/demo.gif new file mode 100644 index 0000000000000000000000000000000000000000..8862ba823081ae2d84acf4382d3fffafaf231e1c GIT binary patch literal 389044 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
MkN$nk+Zsh#_3C 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 z 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�PpEoV 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

-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

`Qf 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

Ku_Jr*XwxJAf$ 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�?yQSbKFx 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⁣leqmRxpQZOr>GhUAp5Vo-K@FVw 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�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 KR-XtAX#58QQ!{q} literal 0 HcmV?d00001 diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..7c1dc4b --- /dev/null +++ b/go.mod @@ -0,0 +1,38 @@ +module github.com/ferro-labs/gateway-cli + +go 1.25.13 + +require ( + charm.land/bubbletea/v2 v2.0.8 + charm.land/lipgloss/v2 v2.0.5 + github.com/charmbracelet/fang v1.0.0 + github.com/charmbracelet/x/ansi v0.11.7 + github.com/spf13/cobra v1.10.2 + go.yaml.in/yaml/v3 v3.0.5 + golang.org/x/term v0.45.0 +) + +require ( + github.com/charmbracelet/colorprofile v0.4.3 // indirect + github.com/charmbracelet/ultraviolet v0.0.0-20260703014108-f5a850f9c2b7 // indirect + github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444 // 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/muesli/mango v0.1.0 // indirect + github.com/muesli/mango-cobra v1.2.0 // indirect + github.com/muesli/mango-pflag v0.1.0 // indirect + github.com/muesli/roff v0.1.0 // 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.47.0 // indirect + golang.org/x/text v0.39.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..850f70b --- /dev/null +++ b/go.sum @@ -0,0 +1,76 @@ +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/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/fang v1.0.0 h1:jESBY40agJOlLYnnv9jE0mLqDGTxEk0hkOnx7YGyRlQ= +github.com/charmbracelet/fang v1.0.0/go.mod h1:P5/DNb9DddQ0Z0dbc0P3ol4/ix5Po7Ofr2KMBfAqoCo= +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/charmtone v0.0.0-20250603201427-c31516f43444 h1:IJDiTgVE56gkAGfq0lBEloWgkXMk4hl/bmuPoicI4R0= +github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444/go.mod h1:T9jr8CzFpjhFVHjNjKwbAD7KwBNyFnj2pntAO7F2zw0= +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/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +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/muesli/mango v0.1.0 h1:DZQK45d2gGbql1arsYA4vfg4d7I9Hfx5rX/GCmzsAvI= +github.com/muesli/mango v0.1.0/go.mod h1:5XFpbC8jY5UUv89YQciiXNlbi+iJgt29VDC5xbzrLL4= +github.com/muesli/mango-cobra v1.2.0 h1:DQvjzAM0PMZr85Iv9LIMaYISpTOliMEg+uMFtNbYvWg= +github.com/muesli/mango-cobra v1.2.0/go.mod h1:vMJL54QytZAJhCT13LPVDfkvCUJ5/4jNUKF/8NC2UjA= +github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe7Sg= +github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0= +github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8= +github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +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/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +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= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +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.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/text v0.39.0 h1:UbZz4pLOvn600D6Oh6GGEI6VAmndrEBLv8/6BEXzyus= +golang.org/x/text v0.39.0/go.mod h1:3UwRclnC2g0TU9x8PZiyfOajCd1zaUNHF9cvqcQZ+ZM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/api/client.go b/internal/api/client.go new file mode 100644 index 0000000..397b1b5 --- /dev/null +++ b/internal/api/client.go @@ -0,0 +1,263 @@ +// Package api provides the HTTP, JSON, and SSE client used by ferro. +// It centralizes redirect refusal, non-2xx errors unless an endpoint tolerates +// them, empty-response refusal when a payload is expected, and uniform error +// envelope decoding. +package api + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net" + "net/http" + "net/url" + "path" + "slices" + "strings" + "time" +) + +const ( + // DefaultTimeout bounds a single request/response exchange. SSE uses a + // separate no-timeout client with context cancellation instead. + DefaultTimeout = 15 * time.Second + maxBody = 4 << 20 +) + +// Client is a gateway HTTP client. Every endpoint method in this package +// funnels through the unexported do method, which owns the safety contracts. +type Client struct { + base *url.URL + apiKey string + hc *http.Client + userAgent string + streamIdleTimeout time.Duration + allowInsecureHTTP bool +} + +// Option customizes a Client at construction time. +type Option func(*Client) + +// WithTimeout overrides DefaultTimeout for this client's requests, including +// the response-header bound enforced by the shared transport. +func WithTimeout(d time.Duration) Option { + return func(c *Client) { + c.hc.Timeout = d + if tr, ok := c.hc.Transport.(*http.Transport); ok { + clone := tr.Clone() + clone.ResponseHeaderTimeout = d + c.hc.Transport = clone + } + } +} + +// WithStreamIdleTimeout overrides the maximum time a chat stream may remain +// silent. A non-positive duration disables the client-side idle bound. +func WithStreamIdleTimeout(d time.Duration) Option { + return func(c *Client) { c.streamIdleTimeout = d } +} + +// WithUserAgent overrides the User-Agent header sent on every request. +func WithUserAgent(ua string) Option { return func(c *Client) { c.userAgent = ua } } + +// WithInsecureHTTP permits plaintext HTTP to a non-loopback gateway. It must +// be an explicit operator choice because bearer credentials and admin data are +// otherwise exposed to the network. +func WithInsecureHTTP() Option { return func(c *Client) { c.allowInsecureHTTP = true } } + +// New builds a Client for the gateway at rawURL, authenticating with apiKey +// (empty means send no Authorization header). +func New(rawURL, apiKey string, opts ...Option) (*Client, error) { + u, err := url.Parse(strings.TrimRight(rawURL, "/")) + if err != nil || u.Scheme == "" || u.Host == "" || u.Hostname() == "" { + return nil, fmt.Errorf("invalid gateway URL %q (want e.g. http://localhost:8080)", rawURL) + } + if u.Scheme != "http" && u.Scheme != "https" { + return nil, fmt.Errorf("invalid gateway URL %q: scheme must be http or https", rawURL) + } + if u.User != nil { + return nil, fmt.Errorf("invalid gateway URL %q: credentials belong in environment variables, not URL userinfo", rawURL) + } + // do builds every request's path and query from this base, so a query + // string here is either silently dropped or silently replaced, and a + // fragment never leaves the process at all. Neither reading produces the + // request the operator wrote — the same reason the gateway refuses a query + // or fragment in a provider base URL. + if u.RawQuery != "" || u.ForceQuery || u.Fragment != "" { + return nil, fmt.Errorf("invalid gateway URL %q: a gateway URL carries no query string or fragment (each request builds its own)", rawURL) + } + c := &Client{ + base: u, + apiKey: apiKey, + hc: &http.Client{ + Timeout: DefaultTimeout, + Transport: func() http.RoundTripper { + tr := http.DefaultTransport.(*http.Transport).Clone() + tr.ResponseHeaderTimeout = DefaultTimeout + return tr + }(), + // Redirects are surfaced, never followed: a bearer token must not + // replay to whatever host a redirect names. + CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }, + }, + userAgent: "ferro-cli", + streamIdleTimeout: DefaultStreamIdleTimeout, + } + for _, o := range opts { + o(c) + } + if u.Scheme == "http" && !isLoopbackHost(u.Hostname()) && !c.allowInsecureHTTP { + return nil, fmt.Errorf("refusing plaintext HTTP to non-loopback gateway %q; use HTTPS or explicitly pass --insecure-http", u.Host) + } + return c, nil +} + +func isLoopbackHost(host string) bool { + host = strings.TrimSuffix(strings.ToLower(host), ".") + if host == "localhost" || strings.HasSuffix(host, ".localhost") { + return true + } + ip := net.ParseIP(host) + return ip != nil && ip.IsLoopback() +} + +// BaseURL returns the gateway URL this client talks to. +func (c *Client) BaseURL() string { return c.base.String() } + +// resolveURL builds the absolute URL for endpoint path p against c.base. It +// is the one join every request goes through — do and StreamChat both call +// it — so a path-prefixed base cannot resolve to two different URLs for the +// same endpoint depending on which caller built the request. +func (c *Client) resolveURL(p string) *url.URL { + u := *c.base + u.Path = path.Join(c.base.Path, p) + return &u +} + +// Error is a non-2xx (or refused-redirect) response from the gateway. +// +// The name follows net/url's Error: a package-level struct named Error that +// carries an Error() method is the standard shape for this, and it reads at +// the call site as api.Error rather than the stuttering api.APIError. +type Error struct { + Status int + Message string + Type string + Code string + RedirectTo string +} + +func (e *Error) Error() string { + if e.RedirectTo != "" { + return fmt.Sprintf("HTTP %d redirect to %s refused — credentials are never replayed to another host (usual cause: an ingress upgrading http to https; point --gateway-url at the target)", e.Status, e.RedirectTo) + } + if e.Code != "" { + return fmt.Sprintf("HTTP %d %s: %s", e.Status, e.Code, e.Message) + } + return fmt.Sprintf("HTTP %d: %s", e.Status, e.Message) +} + +// IsNotSupported reports whether an optional endpoint is absent on this +// gateway build (older version or feature disabled): screens degrade, the +// app never terminates on it. +func IsNotSupported(err error) bool { + var ae *Error + return errors.As(err, &ae) && (ae.Status == http.StatusNotFound || ae.Status == http.StatusNotImplemented) +} + +// IsUnauthorized reports whether the gateway refused the credential, as +// opposed to failing for any other reason. +// +// It exists so a caller degrading on an admin-only endpoint can say which +// happened. "No admin credential accepted" is a specific claim, and answering +// it to a timeout or a 500 sends the reader to check a credential that was +// never the problem. +func IsUnauthorized(err error) bool { + var ae *Error + return errors.As(err, &ae) && + (ae.Status == http.StatusUnauthorized || ae.Status == http.StatusForbidden) +} + +type doOpts struct { + tolerate []int // status codes decoded as success (e.g. 503 for /health) +} + +func (c *Client) do(ctx context.Context, method, p string, q url.Values, in, out any, o doOpts) (int, error) { + u := c.resolveURL(p) + if q != nil { + u.RawQuery = q.Encode() + } + var body io.Reader + if in != nil { + b, err := json.Marshal(in) + if err != nil { + return 0, fmt.Errorf("encode request: %w", err) + } + body = bytes.NewReader(b) + } + req, err := http.NewRequestWithContext(ctx, method, u.String(), body) + if err != nil { + return 0, err + } + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", c.userAgent) + if in != nil { + req.Header.Set("Content-Type", "application/json") + } + if c.apiKey != "" { + req.Header.Set("Authorization", "Bearer "+c.apiKey) + } + resp, err := c.hc.Do(req) + if err != nil { + return 0, fmt.Errorf("gateway unreachable at %s: %w", c.BaseURL(), err) + } + defer func() { _ = resp.Body.Close() }() + + if resp.StatusCode >= 300 && resp.StatusCode < 400 { + return resp.StatusCode, &Error{ + Status: resp.StatusCode, + Message: "redirect refused", + RedirectTo: resp.Header.Get("Location"), + } + } + raw, err := io.ReadAll(io.LimitReader(resp.Body, maxBody)) + if err != nil { + return resp.StatusCode, fmt.Errorf("read response: %w", err) + } + ok := resp.StatusCode >= 200 && resp.StatusCode < 300 + if !ok && !slices.Contains(o.tolerate, resp.StatusCode) { + return resp.StatusCode, decodeAPIError(resp.StatusCode, raw) + } + if out == nil { + return resp.StatusCode, nil + } + if len(raw) == 0 { + return resp.StatusCode, &Error{Status: resp.StatusCode, + Message: fmt.Sprintf("HTTP %d with an empty response body, expected a payload", resp.StatusCode)} + } + if err := json.Unmarshal(raw, out); err != nil { + return resp.StatusCode, fmt.Errorf("decode response: %w", err) + } + return resp.StatusCode, nil +} + +func decodeAPIError(status int, raw []byte) *Error { + e := &Error{Status: status, Message: strings.TrimSpace(string(raw))} + var env struct { + Error struct { + Message string `json:"message"` + Type string `json:"type"` + Code string `json:"code"` + } `json:"error"` + } + if json.Unmarshal(raw, &env) == nil && env.Error.Message != "" { + e.Message, e.Type, e.Code = env.Error.Message, env.Error.Type, env.Error.Code + } + if e.Message == "" { + e.Message = http.StatusText(status) + } + return e +} diff --git a/internal/api/client_test.go b/internal/api/client_test.go new file mode 100644 index 0000000..b9a6bba --- /dev/null +++ b/internal/api/client_test.go @@ -0,0 +1,205 @@ +package api + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" +) + +func TestBearerHeaderSentAndOmitted(t *testing.T) { + var got string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got = r.Header.Get("Authorization") + writeJSON(t, w, http.StatusOK, `{}`) + })) + defer srv.Close() + + c, _ := New(srv.URL, "fgw_secret") + var out map[string]any + if _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}); err != nil { + t.Fatal(err) + } + if got != "Bearer fgw_secret" { + t.Fatalf("want bearer header, got %q", got) + } + + c2, _ := New(srv.URL, "") + if _, err := c2.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}); err != nil { + t.Fatal(err) + } + if got != "" { + t.Fatalf("empty key must send no Authorization header, got %q", got) + } +} + +func TestRedirectRefusedNeverFollowed(t *testing.T) { + var followed atomic.Int32 + target := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { + followed.Add(1) + })) + defer target.Close() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + http.Redirect(w, r, target.URL+"/steal", http.StatusFound) + })) + defer srv.Close() + + c, _ := New(srv.URL, "fgw_secret") + var out map[string]any + _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) + var apiErr *Error + if !errors.As(err, &apiErr) || apiErr.Status != http.StatusFound { + t.Fatalf("want api.Error 302, got %v", err) + } + if !strings.Contains(apiErr.RedirectTo, target.URL) { + t.Fatalf("error must surface the redirect target, got %+v", apiErr) + } + if followed.Load() != 0 { + t.Fatal("redirect was followed — bearer token would have replayed") + } +} + +func TestEmpty2xxWithExpectedPayloadIsError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) // no body + })) + defer srv.Close() + c, _ := New(srv.URL, "") + var out map[string]any + _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) + if err == nil || !strings.Contains(err.Error(), "empty response body") { + t.Fatalf("want empty-2xx refusal, got %v", err) + } +} + +func Test204WithNilDestIsSuccess(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusNoContent) + })) + defer srv.Close() + c, _ := New(srv.URL, "") + if _, err := c.do(context.Background(), http.MethodDelete, "/x", nil, nil, nil, doOpts{}); err != nil { + t.Fatalf("204 with nil dest must succeed: %v", err) + } +} + +func TestErrorEnvelopeDecoded(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusUnauthorized, + `{"error":{"message":"bad key","type":"authentication_error","code":"unauthorized"}}`) + })) + defer srv.Close() + c, _ := New(srv.URL, "fgw_bad") + var out map[string]any + _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) + var apiErr *Error + if !errors.As(err, &apiErr) || apiErr.Message != "bad key" || apiErr.Type != "authentication_error" { + t.Fatalf("envelope not decoded: %v", err) + } +} + +func TestTolerated503DecodesBody(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusServiceUnavailable, + `{"status":"not_ready","reason":"no routable targets"}`) + })) + defer srv.Close() + c, _ := New(srv.URL, "") + var out struct { + Status string `json:"status"` + Reason string `json:"reason"` + } + status, err := c.do(context.Background(), http.MethodGet, "/readyz", nil, nil, &out, doOpts{tolerate: []int{503}}) + if err != nil || status != 503 || out.Reason != "no routable targets" { + t.Fatalf("tolerated 503 must decode: status=%d out=%+v err=%v", status, out, err) + } +} + +func TestNewRejectsUnusableGatewayURLs(t *testing.T) { + // A query or a fragment is refused rather than dropped: do builds the path + // and the query of every request, so neither could survive, and deleting + // the part that cannot work is the same defect one step quieter. + for _, raw := range []string{ + "", "localhost:8080", "http://", "https://:8443", "://nope", + "ftp://localhost:8080", + "http://localhost:8080?token=abc", + "http://localhost:8080/v1?a=b", + "http://localhost:8080#frag", + "http://localhost:8080/?", + "https://u:p@gw.example.com", + "http://gw.example.com:8080", + } { + if c, err := New(raw, ""); err == nil { + t.Fatalf("New(%q) must fail, got a client for %q", raw, c.BaseURL()) + } + } + // Local HTTP is safe for development; remote gateways must use TLS unless + // the operator explicitly acknowledges the risk. + for _, raw := range []string{ + "http://localhost:8080", "http://localhost.:8080", + "http://127.0.0.1:8080", "http://[::1]:8080", + "https://gw.example.com/ferro/", + } { + if _, err := New(raw, ""); err != nil { + t.Fatalf("New(%q) must succeed: %v", raw, err) + } + } + if _, err := New("http://gateway.internal:8080", "fgw_secret", WithInsecureHTTP()); err != nil { + t.Fatalf("explicit insecure HTTP opt-in must succeed: %v", err) + } +} + +// TestNewNormalizesBaseURL pins the exact form BaseURL() returns for every +// accepted input. do and StreamChat both build requests by joining an +// endpoint path onto this string (do via resolveURL's path.Join, StreamChat +// via the same resolveURL call), so a trailing slash surviving here is what +// would put a double slash on every request path, streaming included. +func TestNewNormalizesBaseURL(t *testing.T) { + tests := []struct { + raw string + want string + }{ + {"http://localhost:8080", "http://localhost:8080"}, + {"http://localhost:8080/", "http://localhost:8080"}, + // The load-bearing case: a path-prefixed base must lose its trailing + // slash, or concatenating "/v1/chat/completions" onto it doubles up. + {"https://gw.example.com/ferro/", "https://gw.example.com/ferro"}, + {"https://gw.example.com/ferro", "https://gw.example.com/ferro"}, + } + for _, tt := range tests { + c, err := New(tt.raw, "") + if err != nil { + t.Fatalf("New(%q): %v", tt.raw, err) + } + if got := c.BaseURL(); got != tt.want { + t.Errorf("New(%q).BaseURL() = %q, want %q", tt.raw, got, tt.want) + } + if strings.HasSuffix(c.BaseURL(), "/") { + t.Errorf("New(%q).BaseURL() = %q must never carry a trailing slash", tt.raw, c.BaseURL()) + } + } +} + +func TestIsNotSupported(t *testing.T) { + if !IsNotSupported(&Error{Status: 501}) || !IsNotSupported(&Error{Status: 404}) || IsNotSupported(&Error{Status: 500}) { + t.Fatal("IsNotSupported must be exactly {404, 501}") + } +} + +func TestWithTimeoutUpdatesClientAndHeaderBounds(t *testing.T) { + c, err := New("http://localhost:8080", "", WithTimeout(3*time.Second)) + if err != nil { + t.Fatal(err) + } + tr, ok := c.hc.Transport.(*http.Transport) + if !ok { + t.Fatalf("transport type = %T", c.hc.Transport) + } + if c.hc.Timeout != 3*time.Second || tr.ResponseHeaderTimeout != 3*time.Second { + t.Fatalf("timeouts diverged: client=%s header=%s", c.hc.Timeout, tr.ResponseHeaderTimeout) + } +} diff --git a/internal/api/endpoints.go b/internal/api/endpoints.go new file mode 100644 index 0000000..9451c49 --- /dev/null +++ b/internal/api/endpoints.go @@ -0,0 +1,54 @@ +package api + +import ( + "context" + "net/http" +) + +// Health reads the unauthenticated GET /health. A 503 is a report, not a +// failure — the body names which providers are down — so it is decoded and the +// HTTP status is returned alongside for the caller to act on. +func (c *Client) Health(ctx context.Context) (*HealthReport, int, error) { + var out HealthReport + status, err := c.do(ctx, http.MethodGet, "/health", nil, nil, &out, + doOpts{tolerate: []int{http.StatusServiceUnavailable}}) + if err != nil { + return nil, status, err + } + return &out, status, nil +} + +// Ready reads the unauthenticated GET /readyz. As with Health, a 503 carries +// the reason and is decoded rather than raised. +func (c *Client) Ready(ctx context.Context) (*ReadyReport, int, error) { + var out ReadyReport + status, err := c.do(ctx, http.MethodGet, "/readyz", nil, nil, &out, + doOpts{tolerate: []int{http.StatusServiceUnavailable}}) + if err != nil { + return nil, status, err + } + return &out, status, nil +} + +// AdminHealth reads GET /admin/health, which answers 200 for any authenticated +// caller. A 401/403 therefore means the credential, not the gateway, is the +// problem — callers use that to decide what they may display. +func (c *Client) AdminHealth(ctx context.Context) (*AdminHealth, error) { + var out AdminHealth + if _, err := c.do(ctx, http.MethodGet, "/admin/health", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// Models lists GET /v1/models, unwrapping the {"object":"list","data":[…]} +// envelope. +func (c *Client) Models(ctx context.Context) ([]Model, error) { + var out struct { + Data []Model `json:"data"` + } + if _, err := c.do(ctx, http.MethodGet, "/v1/models", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return out.Data, nil +} diff --git a/internal/api/endpoints_test.go b/internal/api/endpoints_test.go new file mode 100644 index 0000000..95b8c72 --- /dev/null +++ b/internal/api/endpoints_test.go @@ -0,0 +1,213 @@ +package api + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "testing" +) + +// testClient builds a Client against a stub, failing the test on a bad URL. +func testClient(t *testing.T, base, key string) *Client { + t.Helper() + c, err := New(base, key) + if err != nil { + t.Fatalf("New(%q): %v", base, err) + } + return c +} + +// writeJSON is the stub-side body writer; status 0 means 200. +func writeJSON(t *testing.T, w http.ResponseWriter, status int, body string) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if status != 0 && status != http.StatusOK { + w.WriteHeader(status) + } + if _, err := w.Write([]byte(body)); err != nil { + t.Errorf("stub write: %v", err) + } +} + +// gatewayStub is the healthy-gateway fixture shared by the endpoint and status +// tests. admin=false makes /admin/health answer 401 for every caller. +func gatewayStub(t *testing.T, admin bool) *httptest.Server { + t.Helper() + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[ + {"name":"anthropic","status":"available","circuit":"closed","models":412}, + {"name":"openai","status":"available","circuit":"half_open","models":1104}]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready", + "providers":[{"name":"anthropic","circuit":"closed"}], + "targets":[{"name":"anthropic-primary","routable":true},{"name":"openai-primary","routable":false}], + "mcp_servers":[{"name":"filesystem","ready":true,"required":false},{"name":"search","ready":false,"required":false}]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, r *http.Request) { + if !admin || r.Header.Get("Authorization") != "Bearer fgw_ok" { + writeJSON(t, w, http.StatusUnauthorized, + `{"error":{"message":"unauthorized","type":"authentication_error","code":"unauthorized"}}`) + return + } + writeJSON(t, w, 200, `{"status":"healthy", + "providers":[{"name":"anthropic","status":"healthy","models":412}, + {"name":"openai","status":"degraded","models":1104,"message":"rate limited"}], + "components":[{"name":"API","status":"healthy"}], + "mcp_servers":[{"name":"search","ready":false,"required":false,"last_error":"dial tcp: refused"}], + "scopes":["admin"]}`) + }) + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, r *http.Request) { + if r.Header.Get("Authorization") == "" { + writeJSON(t, w, http.StatusUnauthorized, `{"error":{"message":"unauthorized","type":"authentication_error"}}`) + return + } + writeJSON(t, w, 200, `{"object":"list","data":[ + {"id":"claude-sonnet-4-6","object":"model","created":0,"owned_by":"anthropic","capabilities":["streaming","vision"],"context_window":200000}, + {"id":"gpt-5.1","object":"model","created":0,"owned_by":"openai"}]}`) + }) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + return srv +} + +func TestHealthDecodesAndPath(t *testing.T) { + var path string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path = r.URL.Path + writeJSON(t, w, 200, `{"status":"ok","providers":[{"name":"openai","status":"available","circuit":"open","models":7}]}`) + })) + defer srv.Close() + + h, status, err := testClient(t, srv.URL, "").Health(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/health" { + t.Fatalf("want GET /health, got %q", path) + } + if status != 200 || h.Status != "ok" || len(h.Providers) != 1 || + h.Providers[0].Circuit != "open" || h.Providers[0].Models != 7 { + t.Fatalf("bad decode: status=%d %+v", status, h) + } +} + +func TestHealthTolerates503(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusServiceUnavailable, `{"status":"no_providers","providers":[]}`) + })) + defer srv.Close() + + h, status, err := testClient(t, srv.URL, "").Health(context.Background()) + if err != nil { + t.Fatalf("503 must decode, not error: %v", err) + } + if status != http.StatusServiceUnavailable || h.Status != "no_providers" { + t.Fatalf("bad tolerated 503: status=%d %+v", status, h) + } +} + +func TestReadyDecodesNotReady503(t *testing.T) { + var path string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path = r.URL.Path + writeJSON(t, w, http.StatusServiceUnavailable, `{"status":"not_ready","reason":"no routable targets"}`) + })) + defer srv.Close() + + rep, status, err := testClient(t, srv.URL, "").Ready(context.Background()) + if err != nil { + t.Fatalf("503 readyz must decode: %v", err) + } + if path != "/readyz" { + t.Fatalf("want GET /readyz, got %q", path) + } + if status != http.StatusServiceUnavailable || rep.Status != "not_ready" || rep.Reason != "no routable targets" { + t.Fatalf("bad decode: status=%d %+v", status, rep) + } + // Optional collections stay nil rather than becoming empty non-nil slices. + if rep.Targets != nil || rep.MCPServers != nil || rep.Providers != nil { + t.Fatalf("absent optional fields must stay nil: %+v", rep) + } +} + +func TestReadyDecodesFullBody(t *testing.T) { + srv := gatewayStub(t, true) + rep, status, err := testClient(t, srv.URL, "").Ready(context.Background()) + if err != nil || status != 200 { + t.Fatalf("status=%d err=%v", status, err) + } + if len(rep.Targets) != 2 || rep.Targets[0].Name != "anthropic-primary" || !rep.Targets[0].Routable || + rep.Targets[1].Routable { + t.Fatalf("targets decode: %+v", rep.Targets) + } + if len(rep.MCPServers) != 2 || !rep.MCPServers[0].Ready || rep.MCPServers[1].Ready { + t.Fatalf("mcp decode: %+v", rep.MCPServers) + } + if len(rep.Providers) != 1 || rep.Providers[0].Circuit != "closed" { + t.Fatalf("providers decode: %+v", rep.Providers) + } +} + +func TestAdminHealthDecodesAndPropagates401(t *testing.T) { + srv := gatewayStub(t, true) + + ah, err := testClient(t, srv.URL, "fgw_ok").AdminHealth(context.Background()) + if err != nil { + t.Fatal(err) + } + if ah.Status != "healthy" || len(ah.Providers) != 2 || ah.Providers[1].Message != "rate limited" || + len(ah.Components) != 1 || len(ah.Scopes) != 1 || ah.Scopes[0] != "admin" { + t.Fatalf("bad decode: %+v", ah) + } + if len(ah.MCPServers) != 1 || ah.MCPServers[0].LastError == "" { + t.Fatalf("admin mcp servers carry last_error: %+v", ah.MCPServers) + } + + _, err = testClient(t, srv.URL, "fgw_bad").AdminHealth(context.Background()) + var ae *Error + if !errors.As(err, &ae) || ae.Status != http.StatusUnauthorized { + t.Fatalf("401 must propagate as api.Error: %v", err) + } +} + +func TestModelsUnwrapsEnvelope(t *testing.T) { + var path string + srv := gatewayStub(t, true) + c := testClient(t, srv.URL, "fgw_ok") + c.hc.Transport = pathRecorder{&path} + + models, err := c.Models(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/v1/models" { + t.Fatalf("want GET /v1/models, got %q", path) + } + if len(models) != 2 || models[0].ID != "claude-sonnet-4-6" || models[0].OwnedBy != "anthropic" || + len(models[0].Capabilities) != 2 || models[0].ContextWindow != 200000 { + t.Fatalf("bad decode: %+v", models) + } + // Absent optional fields decode to zero values, not errors. + if models[1].ContextWindow != 0 || models[1].Capabilities != nil || models[1].Deprecated { + t.Fatalf("optional model fields must be zero: %+v", models[1]) + } +} + +func TestModelsUnauthorized(t *testing.T) { + srv := gatewayStub(t, true) + _, err := testClient(t, srv.URL, "").Models(context.Background()) + if !errors.As(err, new(*Error)) { + t.Fatalf("want api.Error, got %v", err) + } +} + +// pathRecorder captures the request path without changing transport behavior. +type pathRecorder struct{ path *string } + +func (p pathRecorder) RoundTrip(r *http.Request) (*http.Response, error) { + *p.path = r.URL.Path + return http.DefaultTransport.RoundTrip(r) +} diff --git a/internal/api/keys.go b/internal/api/keys.go new file mode 100644 index 0000000..0a6e9aa --- /dev/null +++ b/internal/api/keys.go @@ -0,0 +1,134 @@ +package api + +import ( + "context" + "fmt" + "net/http" + "net/url" + "time" +) + +// Key is one /admin/keys row. Key is masked (head8…tail4) on every read; +// the full secret appears exactly once, in the CreateKey and RotateKey +// responses, and the gateway then keeps only a hash of it. +type Key struct { + ID string `json:"id"` + Key string `json:"key"` + Name string `json:"name"` + Scopes []string `json:"scopes"` + CreatedAt time.Time `json:"created_at"` + RevokedAt *time.Time `json:"revoked_at,omitempty"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` + RotatedAt *time.Time `json:"rotated_at,omitempty"` + LastUsedAt *time.Time `json:"last_used_at,omitempty"` + UsageCount int64 `json:"usage_count"` + Active bool `json:"active"` +} + +// KeyCreateRequest is the POST /admin/keys body. +// +// Scopes is always sent explicitly. A scope-less request is NOT granted admin: +// the gateway's key store applies defaultScopes and mints a least-privilege +// read_only key. ferro sends one anyway so the scope a key carries is the +// operator's stated choice rather than whatever the server's default happens +// to be in the version it is talking to. +type KeyCreateRequest struct { + Name string `json:"name"` + Scopes []string `json:"scopes"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` +} + +// The three states KeyState derives, and the value the gateway confirms a +// revocation with. +const ( + KeyStateActive = "active" + KeyStateExpired = "expired" + KeyStateRevoked = "revoked" +) + +// KeyState derives the state column the gateway does not serve: there is no +// state or revoked field on the wire, only revoked_at, expires_at and active. +// +// Expiry must be read from expires_at, never from active. The gateway clears +// active in exactly one place — Revoke, which stamps revoked_at in the same +// write, on both the memory and SQL stores — so a key that has merely expired +// is still served as active:true with revoked_at:null and a past expires_at. +// Deriving "expired" from !active therefore never fired for a real expired +// key, and reported it as active: the one answer that matters here, on a +// surface an operator reads to decide whether a credential still works. +// model.KeyIsUsable is the authority and checks all three independently. +func KeyState(k Key) string { + switch { + case k.RevokedAt != nil: + return KeyStateRevoked + case k.ExpiresAt != nil && time.Now().After(*k.ExpiresAt): + return KeyStateExpired + case !k.Active: + // Not reachable from a gateway that only clears active in Revoke, but + // if one ever serves it, the key authenticates nothing — and "revoked" + // is the administrative reading, where "expired" would name a deadline + // that has not passed. + return KeyStateRevoked + default: + return KeyStateActive + } +} + +// Keys lists GET /admin/keys, which answers with a bare array — no {"data":…} +// envelope, unlike every other admin list. +func (c *Client) Keys(ctx context.Context) ([]Key, error) { + var out []Key + if _, err := c.do(ctx, http.MethodGet, "/admin/keys", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return out, nil +} + +// Key reads one key by id. +func (c *Client) Key(ctx context.Context, id string) (*Key, error) { + var out Key + if _, err := c.do(ctx, http.MethodGet, keyPath(id), nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// CreateKey creates a key. The returned Key carries the full secret in Key, +// and this is the only response that ever will. +func (c *Client) CreateKey(ctx context.Context, req KeyCreateRequest) (*Key, error) { + var out Key + if _, err := c.do(ctx, http.MethodPost, "/admin/keys", nil, req, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// RotateKey issues a new secret for an existing key. The previous secret stops +// authenticating immediately, and the new one is returned once. +func (c *Client) RotateKey(ctx context.Context, id string) (*Key, error) { + var out Key + if _, err := c.do(ctx, http.MethodPost, keyPath(id)+"/rotate", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// RevokeKey revokes a key immediately and irreversibly. The gateway confirms +// with {"status":"revoked"}; anything else is reported as a failure rather +// than assumed to have worked. +func (c *Client) RevokeKey(ctx context.Context, id string) error { + var out struct { + Status string `json:"status"` + } + if _, err := c.do(ctx, http.MethodPost, keyPath(id)+"/revoke", nil, nil, &out, doOpts{}); err != nil { + return err + } + if out.Status != KeyStateRevoked { + return fmt.Errorf("gateway did not confirm revocation of %s (status %q)", id, out.Status) + } + return nil +} + +// keyPath escapes the id so a caller-supplied value cannot climb out of +// /admin/keys via path traversal. +func keyPath(id string) string { return "/admin/keys/" + url.PathEscape(id) } diff --git a/internal/api/keys_test.go b/internal/api/keys_test.go new file mode 100644 index 0000000..54cb055 --- /dev/null +++ b/internal/api/keys_test.go @@ -0,0 +1,230 @@ +package api + +import ( + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +// keysStub serves the /admin/keys surface and records the last request body. +func keysStub(t *testing.T, lastBody *string, lastPath *string) *httptest.Server { + t.Helper() + record := func(r *http.Request) { + *lastPath = r.URL.Path + if r.Body == nil { + return + } + b, err := io.ReadAll(r.Body) + if err != nil { + t.Errorf("read body: %v", err) + } + *lastBody = string(b) + } + mux := http.NewServeMux() + // Deliberately a BARE ARRAY — /admin/keys is the one list endpoint with no + // {"data":…} envelope. + mux.HandleFunc("GET /admin/keys", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `[ + {"id":"k1","key":"fgw_head8...il4","name":"ci","scopes":["read_only"], + "created_at":"2026-08-01T10:00:00Z","expires_at":"2026-09-01T10:00:00Z", + "last_used_at":"2026-08-08T09:00:00Z","usage_count":42,"active":true}, + {"id":"k2","key":"fgw_dead8...ad4","name":"old","scopes":["admin"], + "created_at":"2026-07-01T10:00:00Z","revoked_at":"2026-07-20T10:00:00Z", + "usage_count":0,"active":false}]`) + }) + mux.HandleFunc("GET /admin/keys/{id}", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `{"id":"k1","key":"fgw_head8...il4","name":"ci","scopes":["read_only"], + "created_at":"2026-08-01T10:00:00Z","usage_count":42,"active":true}`) + }) + mux.HandleFunc("POST /admin/keys", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, http.StatusCreated, `{"id":"k9","key":"fgw_fullsecret000","name":"ci", + "scopes":["read_only"],"created_at":"2026-08-08T10:00:00Z","usage_count":0,"active":true}`) + }) + mux.HandleFunc("POST /admin/keys/{id}/rotate", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `{"id":"k1","key":"fgw_rotatedsecret","name":"ci","scopes":["read_only"], + "created_at":"2026-08-01T10:00:00Z","rotated_at":"2026-08-08T10:00:00Z","usage_count":42,"active":true}`) + }) + mux.HandleFunc("POST /admin/keys/{id}/revoke", func(w http.ResponseWriter, r *http.Request) { + record(r) + if r.PathValue("id") == "k404" { + writeJSON(t, w, http.StatusNotFound, `{"error":{"message":"key not found","type":"not_found_error"}}`) + return + } + if r.PathValue("id") == "kweird" { + writeJSON(t, w, 200, `{"status":"queued"}`) + return + } + writeJSON(t, w, 200, `{"status":"revoked"}`) + }) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + return srv +} + +func TestKeysDecodesBareArray(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + + keys, err := testClient(t, srv.URL, "fgw_ok").Keys(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/admin/keys" { + t.Fatalf("want GET /admin/keys, got %q", path) + } + if len(keys) != 2 { + t.Fatalf("want 2 keys, got %d", len(keys)) + } + k := keys[0] + if k.ID != "k1" || k.Name != "ci" || k.UsageCount != 42 || !k.Active || + len(k.Scopes) != 1 || k.Scopes[0] != "read_only" { + t.Fatalf("bad decode: %+v", k) + } + if k.ExpiresAt == nil || !k.ExpiresAt.Equal(time.Date(2026, 9, 1, 10, 0, 0, 0, time.UTC)) { + t.Fatalf("expires_at must decode to a pointer: %+v", k.ExpiresAt) + } + if k.RevokedAt != nil || k.RotatedAt != nil { + t.Fatalf("absent timestamps must stay nil: %+v", k) + } + if keys[1].RevokedAt == nil { + t.Fatal("revoked_at must decode") + } +} + +func TestKeyStateIsDerived(t *testing.T) { + ts := time.Now() + past := ts.Add(-24 * time.Hour) + future := ts.Add(24 * time.Hour) + cases := []struct { + name string + key Key + want string + }{ + {"active", Key{Active: true}, "active"}, + {"active with an expiry still ahead", Key{Active: true, ExpiresAt: &future}, "active"}, + // The shape a real expired key actually has. The gateway clears active + // only in Revoke, so an expired-but-not-revoked key is served + // active:true with revoked_at:null — this case is the whole reason + // KeyState reads expires_at, and it reported "active" until it did. + {"expired", Key{Active: true, ExpiresAt: &past}, "expired"}, + {"revoked", Key{Active: false, RevokedAt: &ts}, "revoked"}, + // revoked wins even if the gateway still reports the key active. + {"revoked beats active", Key{Active: true, RevokedAt: &ts}, "revoked"}, + // A key can be both; revoked is the more specific answer. + {"revoked beats expired", Key{Active: false, RevokedAt: &ts, ExpiresAt: &past}, "revoked"}, + // Not a shape the gateway serves, but it authenticates nothing, and + // "expired" would name a deadline that has not passed. + {"inactive without a revocation", Key{Active: false}, "revoked"}, + } + for _, tc := range cases { + if got := KeyState(tc.key); got != tc.want { + t.Errorf("%s: KeyState = %q, want %q", tc.name, got, tc.want) + } + } +} + +func TestKeyGetByID(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + + k, err := testClient(t, srv.URL, "fgw_ok").Key(context.Background(), "k1") + if err != nil { + t.Fatal(err) + } + if path != "/admin/keys/k1" { + t.Fatalf("want GET /admin/keys/k1, got %q", path) + } + if k.ID != "k1" { + t.Fatalf("bad decode: %+v", k) + } +} + +func TestCreateKeyAlwaysSendsScopes(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + + exp := time.Date(2026, 9, 8, 10, 0, 0, 0, time.UTC) + k, err := testClient(t, srv.URL, "fgw_ok").CreateKey(context.Background(), + KeyCreateRequest{Name: "ci", Scopes: []string{"read_only"}, ExpiresAt: &exp}) + if err != nil { + t.Fatal(err) + } + if path != "/admin/keys" { + t.Fatalf("want POST /admin/keys, got %q", path) + } + var sent map[string]any + if err := json.Unmarshal([]byte(body), &sent); err != nil { + t.Fatalf("request body is not JSON: %q", body) + } + scopes, ok := sent["scopes"].([]any) + if !ok || len(scopes) == 0 { + // The gateway defaults a scope-less request to read_only, not admin. + // ferro still always sends one, so the scope is the operator's choice + // rather than a server default that can differ between versions. + t.Fatalf("scopes must always be sent: %q", body) + } + if got, _ := sent["expires_at"].(string); got != "2026-09-08T10:00:00Z" { + t.Fatalf("expires_at must be RFC3339: %q", body) + } + if k.Key != "fgw_fullsecret000" { + t.Fatalf("create must return the full secret once: %+v", k) + } +} + +func TestCreateKeyOmitsAbsentExpiry(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + + if _, err := testClient(t, srv.URL, "fgw_ok").CreateKey(context.Background(), + KeyCreateRequest{Name: "ci", Scopes: []string{"admin"}}); err != nil { + t.Fatal(err) + } + if strings.Contains(body, "expires_at") { + t.Fatalf("no expiry means the field is omitted, not null: %q", body) + } +} + +func TestRotateKeyReturnsNewSecret(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + + k, err := testClient(t, srv.URL, "fgw_ok").RotateKey(context.Background(), "k1") + if err != nil { + t.Fatal(err) + } + if path != "/admin/keys/k1/rotate" { + t.Fatalf("want POST /admin/keys/k1/rotate, got %q", path) + } + if k.Key != "fgw_rotatedsecret" || k.RotatedAt == nil { + t.Fatalf("rotate must return the new secret and rotated_at: %+v", k) + } +} + +func TestRevokeKey(t *testing.T) { + var body, path string + srv := keysStub(t, &body, &path) + c := testClient(t, srv.URL, "fgw_ok") + + if err := c.RevokeKey(context.Background(), "k1"); err != nil { + t.Fatal(err) + } + if path != "/admin/keys/k1/revoke" { + t.Fatalf("want POST /admin/keys/k1/revoke, got %q", path) + } + // A 200 that does not say "revoked" is not a revocation. + if err := c.RevokeKey(context.Background(), "kweird"); err == nil { + t.Fatal("an unexpected status must not be reported as success") + } + if err := c.RevokeKey(context.Background(), "k404"); err == nil { + t.Fatal("a 404 must propagate") + } +} diff --git a/internal/api/logs.go b/internal/api/logs.go new file mode 100644 index 0000000..613230a --- /dev/null +++ b/internal/api/logs.go @@ -0,0 +1,256 @@ +package api + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "net/url" + "slices" + "strconv" + "time" +) + +// LogEntry is one row of GET /admin/logs. The three measurements are pointers +// because the gateway sends null for "not measured" — a request that failed +// before it reached a provider, or one served by a provider with no price in +// the catalog. Collapsing null into 0 would render as a real zero-cost, +// zero-latency request. +type LogEntry struct { + TraceID string `json:"trace_id"` + Stage string `json:"stage"` + Model string `json:"model"` + APIKeyID string `json:"api_key_id"` + Provider string `json:"provider"` + PromptTokens int `json:"prompt_tokens"` + CompletionTokens int `json:"completion_tokens"` + TotalTokens int `json:"total_tokens"` + ErrorMessage string `json:"error_message"` + CreatedAt time.Time `json:"created_at"` + DurationMs *float64 `json:"duration_ms"` + TTFTMs *float64 `json:"ttft_ms"` + CostUSD *float64 `json:"cost_usd"` +} + +// LogsQuery filters GET /admin/logs. Only non-zero fields are sent: an empty +// value is not the same as an absent one on every parameter, and sending one +// can narrow the listing server-side. +// +// APIKeyID accepts the gateway's "none" sentinel (rows with no credential), +// which is passed through untouched. +type LogsQuery struct { + Limit int + Offset int + Since time.Time + Model string + Provider string + Stage string + APIKeyID string +} + +func (q LogsQuery) values() url.Values { + v := url.Values{} + if q.Limit > 0 { + v.Set("limit", strconv.Itoa(q.Limit)) + } + if q.Offset > 0 { + v.Set("offset", strconv.Itoa(q.Offset)) + } + if !q.Since.IsZero() { + v.Set("since", q.Since.UTC().Format(time.RFC3339)) + } + for k, s := range map[string]string{ + "model": q.Model, "provider": q.Provider, "stage": q.Stage, "api_key_id": q.APIKeyID, + } { + if s != "" { + v.Set(k, s) + } + } + return v +} + +// LogsPage is one page of GET /admin/logs. +type LogsPage struct { + Data []LogEntry `json:"data"` + Summary struct { + TotalEntries int `json:"total_entries"` + ReturnedEntries int `json:"returned_entries"` + } `json:"summary"` +} + +// Percentiles is one latency distribution. The gateway sends null for the +// whole block when nothing was measured, so callers hold it by pointer. +type Percentiles struct { + P50 float64 `json:"p50"` + P95 float64 `json:"p95"` + P99 float64 `json:"p99"` + Max float64 `json:"max"` + Mean float64 `json:"mean"` + Count int `json:"count"` +} + +// LogStats is GET /admin/logs/stats. The by_* breakdowns stay raw: their value +// shape is not part of any contract ferro renders, and decoding them would +// invent one. +type LogStats struct { + Summary struct { + TotalEntries int `json:"total_entries"` + ErrorEntries int `json:"error_entries"` + TotalTokens int `json:"total_tokens"` + PromptTokens int `json:"prompt_tokens"` + CompletionTokens int `json:"completion_tokens"` + CostUSD float64 `json:"cost_usd"` + UnpricedRequests int `json:"unpriced_requests"` + } `json:"summary"` + LatencyMs *Percentiles `json:"latency_ms"` + TTFTMs *Percentiles `json:"ttft_ms"` + ByProvider map[string]json.RawMessage `json:"by_provider"` + ByModel map[string]json.RawMessage `json:"by_model"` + TopErrors []struct { + Message string `json:"message"` + Count int `json:"count"` + } `json:"top_errors"` +} + +// Logs reads a page of the request log. A gateway with no log store configured +// answers 501, for which IsNotSupported reports true. +func (c *Client) Logs(ctx context.Context, q LogsQuery) (*LogsPage, error) { + var out LogsPage + if _, err := c.do(ctx, http.MethodGet, "/admin/logs", q.values(), nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// LogStats reads the pre-aggregated request-log statistics: totals, error +// counts and latency percentiles the CLI would otherwise have to compute from +// a full page walk. The stats endpoint supports time, model, provider, and +// stage filters; paging and credential filters are intentionally omitted. +func (c *Client) LogStats(ctx context.Context, filter LogsQuery) (*LogStats, error) { + var out LogStats + q := LogsQuery{Since: filter.Since, Model: filter.Model, Provider: filter.Provider, Stage: filter.Stage}.values() + if _, err := c.do(ctx, http.MethodGet, "/admin/logs/stats", q, nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// ParseSince reads a --since value: a Go duration ("15m", "2h") meaning that +// long ago, or an absolute RFC3339 timestamp. A signed duration is read as the +// same span into the past — a future cursor is never what was meant. +func ParseSince(s string) (time.Time, error) { + if d, err := time.ParseDuration(s); err == nil { + if d < 0 { + d = -d + } + return time.Now().Add(-d), nil + } + t, err := time.Parse(time.RFC3339, s) + if err != nil { + return time.Time{}, fmt.Errorf("invalid since %q: want a duration (15m, 2h) or an RFC3339 timestamp", s) + } + return t, nil +} + +// followDedupeWindow bounds the ring of already-emitted row keys. +// +// The window is row-count based rather than time based. It covers the maximum +// bounded page drain so a boundary row cannot be evicted during one poll. +const ( + maxFollowPages = 32 + maxFollowLimit = 200 + followDedupeWindow = maxFollowPages * maxFollowLimit +) + +// Follower turns the paged /admin/logs listing into a tail: each Poll advances +// a since-cursor and returns only rows not seen before. +// +// It is not safe for concurrent use — one Follower belongs to one tail loop. +type Follower struct { + c *Client + q LogsQuery + cursor time.Time + seen map[string]struct{} + order []string // FIFO eviction for the dedupe ring +} + +// NewFollower starts a tail at q.Since (zero means the gateway's own default +// window). +func NewFollower(c *Client, q LogsQuery) *Follower { + if q.Limit <= 0 { + q.Limit = 100 + } else if q.Limit > maxFollowLimit { + q.Limit = maxFollowLimit + } + return &Follower{c: c, q: q, cursor: q.Since, seen: make(map[string]struct{})} +} + +// dedupeKey identifies a row. A trace has one row per pipeline stage, so the +// stage is part of the identity; the timestamp separates a retried trace id. +func dedupeKey(e LogEntry) string { + return e.TraceID + "/" + e.Stage + "/" + e.CreatedAt.UTC().Format(time.RFC3339Nano) +} + +// ErrFollowTruncated reports that one poll drained maxFollowPages without +// reaching the end of its window. The rows returned alongside it are complete +// and the cursor has advanced past them, so the next poll resumes instead of +// re-draining the same window: a sustained burst slows the tail down, it never +// stops it. What is lost is the older end of that one window — the gateway +// lists newest first, so the pages the bound cut off are the oldest ones. +var ErrFollowTruncated = fmt.Errorf( + "request-log poll exceeded the %d-page safety bound; older rows in this window were skipped — narrow the filters or use a shorter interval", + maxFollowPages) + +// Poll fetches rows since the cursor and returns the unseen ones in ascending +// created_at order. +// +// On a fetch error the cursor is left untouched, so a transient failure +// re-fetches the same window rather than skipping the rows that landed during +// it. The cursor is also second-granular while created_at is not, so the +// boundary row is re-fetched by design and dropped by the dedupe ring — the +// safe direction. +// +// ErrFollowTruncated is the one error returned with rows: they are valid and +// the cursor moved, so a caller that renders them loses nothing. +func (f *Follower) Poll(ctx context.Context) ([]LogEntry, error) { + q := f.q + q.Since = f.cursor + rows := make([]LogEntry, 0, q.Limit) + baseOffset := q.Offset + drained := false + for pageNo := 0; pageNo < maxFollowPages; pageNo++ { + q.Offset = baseOffset + pageNo*q.Limit + page, err := f.c.Logs(ctx, q) + if err != nil { + return nil, err + } + rows = append(rows, page.Data...) + if len(page.Data) < q.Limit || q.Offset+len(page.Data) >= page.Summary.TotalEntries { + drained = true + break + } + } + slices.SortStableFunc(rows, func(a, b LogEntry) int { return a.CreatedAt.Compare(b.CreatedAt) }) + + fresh := rows[:0] + for _, e := range rows { + k := dedupeKey(e) + if _, dup := f.seen[k]; dup { + continue + } + f.seen[k] = struct{}{} + f.order = append(f.order, k) + if len(f.order) > followDedupeWindow { + delete(f.seen, f.order[0]) + f.order = f.order[1:] + } + fresh = append(fresh, e) + if e.CreatedAt.After(f.cursor) { + f.cursor = e.CreatedAt + } + } + if !drained { + return fresh, ErrFollowTruncated + } + return fresh, nil +} diff --git a/internal/api/logs_test.go b/internal/api/logs_test.go new file mode 100644 index 0000000..1024b11 --- /dev/null +++ b/internal/api/logs_test.go @@ -0,0 +1,484 @@ +package api + +import ( + "context" + "errors" + "fmt" + "net/http" + "net/http/httptest" + "net/url" + "strconv" + "strings" + "sync" + "testing" + "time" +) + +func TestLogsDecodesNullMeasurements(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"data":[ + {"trace_id":"t1","stage":"after_request","model":"gpt-5.1","api_key_id":"k1","provider":"openai", + "prompt_tokens":10,"completion_tokens":20,"total_tokens":30,"error_message":"", + "created_at":"2026-08-08T10:00:01Z","duration_ms":812.5,"ttft_ms":210.25,"cost_usd":0.0042}, + {"trace_id":"t2","stage":"on_error","model":"gpt-5.1","api_key_id":"","provider":"", + "prompt_tokens":0,"completion_tokens":0,"total_tokens":0,"error_message":"upstream unavailable", + "created_at":"2026-08-08T10:00:02Z","duration_ms":null,"ttft_ms":null,"cost_usd":null}], + "summary":{"total_entries":2,"returned_entries":2}}`) + })) + defer srv.Close() + + page, err := testClient(t, srv.URL, "fgw_ok").Logs(context.Background(), LogsQuery{}) + if err != nil { + t.Fatal(err) + } + if page.Summary.TotalEntries != 2 || page.Summary.ReturnedEntries != 2 || len(page.Data) != 2 { + t.Fatalf("bad page: %+v", page) + } + a := page.Data[0] + if a.DurationMs == nil || *a.DurationMs != 812.5 || a.TTFTMs == nil || a.CostUSD == nil || *a.CostUSD != 0.0042 { + t.Fatalf("measured row lost its values: %+v", a) + } + if a.PromptTokens != 10 || a.TotalTokens != 30 || a.Provider != "openai" { + t.Fatalf("bad decode: %+v", a) + } + b := page.Data[1] + // null is "not measured" — it must NOT collapse into 0, which would render + // as a real zero-cost, zero-latency request. + if b.DurationMs != nil || b.TTFTMs != nil || b.CostUSD != nil { + t.Fatalf("null measurements must decode to nil: %+v", b) + } + if b.ErrorMessage != "upstream unavailable" { + t.Fatalf("bad decode: %+v", b) + } +} + +func TestLogsQueryEncoding(t *testing.T) { + var got url.Values + var path string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got, path = r.URL.Query(), r.URL.Path + writeJSON(t, w, 200, `{"data":[],"summary":{"total_entries":0,"returned_entries":0}}`) + })) + defer srv.Close() + c := testClient(t, srv.URL, "fgw_ok") + + since := time.Date(2026, 8, 8, 10, 0, 0, 0, time.UTC) + if _, err := c.Logs(context.Background(), LogsQuery{ + Limit: 50, Offset: 100, Since: since, + Model: "gpt-5.1", Provider: "openai", Stage: "all", APIKeyID: "none", + }); err != nil { + t.Fatal(err) + } + if path != "/admin/logs" { + t.Fatalf("want GET /admin/logs, got %q", path) + } + want := url.Values{ + "limit": {"50"}, "offset": {"100"}, "since": {"2026-08-08T10:00:00Z"}, + "model": {"gpt-5.1"}, "provider": {"openai"}, "stage": {"all"}, + // "none" is the gateway's sentinel for credential-less rows: passed + // through untouched, never interpreted. + "api_key_id": {"none"}, + } + if fmt.Sprint(got) != fmt.Sprint(want) { + t.Fatalf("query = %v, want %v", got, want) + } + + // A zero query sends no filters at all — an empty value would narrow the + // listing server-side on some parameters. + if _, err := c.Logs(context.Background(), LogsQuery{}); err != nil { + t.Fatal(err) + } + if len(got) != 0 { + t.Fatalf("zero query must send no parameters, got %v", got) + } +} + +func TestLogs501IsNotSupported(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusNotImplemented, + `{"error":{"message":"request log store not configured","type":"server_error"}}`) + })) + defer srv.Close() + + _, err := testClient(t, srv.URL, "fgw_ok").Logs(context.Background(), LogsQuery{}) + if err == nil || !IsNotSupported(err) { + t.Fatalf("a 501 must be detectable as unsupported, got %v", err) + } +} + +func TestLogStatsDecodes(t *testing.T) { + var got url.Values + var path string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got, path = r.URL.Query(), r.URL.Path + writeJSON(t, w, 200, `{ + "summary":{"total_entries":1200,"error_entries":13,"total_tokens":90000,"prompt_tokens":60000, + "completion_tokens":30000,"cost_usd":1.2345,"unpriced_requests":4}, + "latency_ms":{"p50":210,"p95":980.5,"p99":1400,"max":2200,"mean":320.25,"count":1200}, + "ttft_ms":null, + "by_stage":{"after_request":{"count":1187}}, + "by_provider":{"openai":{"count":900}}, + "by_model":{"gpt-5.1":{"count":900}}, + "top_errors":[{"message":"upstream unavailable","count":9}], + "series":{}}`) + })) + defer srv.Close() + + since := time.Date(2026, 8, 8, 9, 55, 0, 0, time.UTC) + st, err := testClient(t, srv.URL, "fgw_ok").LogStats(context.Background(), LogsQuery{ + Since: since, Model: "gpt-5.1", Provider: "openai", Stage: "on_error", APIKeyID: "key_ignored", + }) + if err != nil { + t.Fatal(err) + } + if path != "/admin/logs/stats" { + t.Fatalf("want GET /admin/logs/stats, got %q", path) + } + if got.Get("since") != "2026-08-08T09:55:00Z" || got.Get("model") != "gpt-5.1" || + got.Get("provider") != "openai" || got.Get("stage") != "on_error" || got.Has("api_key_id") { + t.Fatalf("bad query: %v", got) + } + if st.Summary.TotalEntries != 1200 || st.Summary.ErrorEntries != 13 || st.Summary.CostUSD != 1.2345 || + st.Summary.UnpricedRequests != 4 { + t.Fatalf("bad summary: %+v", st.Summary) + } + if st.LatencyMs == nil || st.LatencyMs.P95 != 980.5 || st.LatencyMs.Count != 1200 { + t.Fatalf("latency percentiles: %+v", st.LatencyMs) + } + // A null percentile block means "nothing measured" and must stay nil. + if st.TTFTMs != nil { + t.Fatalf("null ttft_ms must decode to nil, got %+v", st.TTFTMs) + } + if len(st.TopErrors) != 1 || st.TopErrors[0].Count != 9 { + t.Fatalf("top errors: %+v", st.TopErrors) + } + if string(st.ByProvider["openai"]) != `{"count":900}` || len(st.ByModel) != 1 { + t.Fatalf("breakdowns stay raw: %v", st.ByProvider) + } +} + +func TestParseSince(t *testing.T) { + now := time.Now() + got, err := ParseSince("15m") + if err != nil { + t.Fatal(err) + } + if d := now.Add(-15 * time.Minute).Sub(got); d > time.Second || d < -time.Second { + t.Fatalf("15m must mean 15 minutes ago, got %v (off by %v)", got, d) + } + // A signed duration means the same thing — nobody wants a future cursor. + // Bound the difference on both sides: an upper bound alone passes a + // timestamp two hours in the future, which is the bug being guarded. + got, err = ParseSince("-2h") + if err != nil { + t.Fatalf("-2h must parse: %v", err) + } + if d := now.Add(-2 * time.Hour).Sub(got); d > time.Second || d < -time.Second { + t.Fatalf("-2h must also mean two hours ago, got %v (off by %v)", got, d) + } + want := time.Date(2026, 8, 8, 10, 0, 0, 0, time.UTC) + if got, err = ParseSince("2026-08-08T10:00:00Z"); err != nil || !got.Equal(want) { + t.Fatalf("RFC3339 must parse: %v %v", got, err) + } + if _, err = ParseSince("yesterday"); err == nil { + t.Fatal("an unparseable value must be an error, not a silent zero time") + } + if _, err = ParseSince(""); err == nil { + t.Fatal("empty must be an error") + } +} + +// followStub serves pages keyed by the `since` parameter and records every +// since value it was asked for. +type followStub struct { + mu sync.Mutex + since []string + pages []string // body per request index + statuses []int // 0 means 200 +} + +func (s *followStub) handler(t *testing.T) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + s.mu.Lock() + i := len(s.since) + s.since = append(s.since, r.URL.Query().Get("since")) + body, status := "", 0 + if i < len(s.pages) { + body = s.pages[i] + } + if i < len(s.statuses) { + status = s.statuses[i] + } + s.mu.Unlock() + if status != 0 && status != 200 { + writeJSON(t, w, status, `{"error":{"message":"boom","type":"server_error"}}`) + return + } + writeJSON(t, w, 200, body) + } +} + +func (s *followStub) sinceAt(i int) string { + s.mu.Lock() + defer s.mu.Unlock() + if i >= len(s.since) { + return "" + } + return s.since[i] +} + +func logRow(trace, stage, created string) string { + return fmt.Sprintf(`{"trace_id":%q,"stage":%q,"model":"m","api_key_id":"","provider":"openai", + "prompt_tokens":0,"completion_tokens":0,"total_tokens":0,"error_message":"", + "created_at":%q,"duration_ms":null,"ttft_ms":null,"cost_usd":null}`, trace, stage, created) +} + +func logPage(rows ...string) string { + return fmt.Sprintf(`{"data":[%s],"summary":{"total_entries":%d,"returned_entries":%d}}`, + strings.Join(rows, ","), len(rows), len(rows)) +} + +func TestFollowerCursorAndDedupe(t *testing.T) { + a, b, cc := "2026-08-08T10:00:01Z", "2026-08-08T10:00:02Z", "2026-08-08T10:00:03Z" + stub := &followStub{pages: []string{ + // The gateway serves newest first; the follower must not. + logPage(logRow("B", "after_request", b), logRow("A", "after_request", a)), + // since >= B: the boundary row comes back, plus the new one. + logPage(logRow("C", "after_request", cc), logRow("B", "after_request", b)), + }} + srv := httptest.NewServer(stub.handler(t)) + defer srv.Close() + + f := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{}) + rows, err := f.Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 || rows[0].TraceID != "A" || rows[1].TraceID != "B" { + t.Fatalf("first poll must be ascending [A B], got %v", traceIDs(rows)) + } + if s := stub.sinceAt(0); s != "" { + t.Fatalf("first poll has no cursor yet, sent since=%q", s) + } + + rows, err = f.Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(rows) != 1 || rows[0].TraceID != "C" { + t.Fatalf("B must be deduped, want [C], got %v", traceIDs(rows)) + } + if s := stub.sinceAt(1); s != b { + t.Fatalf("cursor must advance to the newest row, sent since=%q want %q", s, b) + } +} + +func TestFollowerDrainsEveryPageBeforeAdvancingCursor(t *testing.T) { + created := []string{ + "2026-08-08T10:00:04Z", "2026-08-08T10:00:03Z", + "2026-08-08T10:00:02Z", "2026-08-08T10:00:01Z", + } + var mu sync.Mutex + var offsets []int + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) + limit, _ := strconv.Atoi(r.URL.Query().Get("limit")) + mu.Lock() + offsets = append(offsets, offset) + mu.Unlock() + end := min(offset+limit, len(created)) + rows := make([]string, 0, end-offset) + for i := offset; i < end; i++ { + rows = append(rows, logRow(fmt.Sprintf("T%d", i), "after_request", created[i])) + } + writeJSON(t, w, http.StatusOK, fmt.Sprintf( + `{"data":[%s],"summary":{"total_entries":%d,"returned_entries":%d}}`, + strings.Join(rows, ","), len(created), len(rows))) + })) + defer srv.Close() + + got, err := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{Limit: 2}).Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(got) != 4 { + t.Fatalf("all pages must be returned oldest first: %v", traceIDs(got)) + } + for i := 1; i < len(got); i++ { + if got[i].CreatedAt.Before(got[i-1].CreatedAt) { + t.Fatalf("all pages must be returned oldest first: %v", traceIDs(got)) + } + } + mu.Lock() + defer mu.Unlock() + if fmt.Sprint(offsets) != "[0 2]" { + t.Fatalf("page offsets = %v, want [0 2]", offsets) + } +} + +func TestFollowerTruncatedPollKeepsRowsAndAdvances(t *testing.T) { + base := time.Date(2026, 8, 8, 10, 10, 0, 0, time.UTC) + var mu sync.Mutex + var sinces []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + sinces = append(sinces, r.URL.Query().Get("since")) + mu.Unlock() + offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) + // Newest first, and a total the drain can never reach: the sustained + // burst that used to stall the tail forever. + row := logRow(fmt.Sprintf("T%d", offset), "after_request", + base.Add(-time.Duration(offset)*time.Second).Format(time.RFC3339)) + writeJSON(t, w, http.StatusOK, + `{"data":[`+row+`],"summary":{"total_entries":100000,"returned_entries":1}}`) + })) + defer srv.Close() + + f := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{Limit: 1}) + rows, err := f.Poll(context.Background()) + if !errors.Is(err, ErrFollowTruncated) { + t.Fatalf("a poll that hits the page bound must say so: %v", err) + } + if len(rows) != maxFollowPages { + t.Fatalf("rows already fetched must be kept, got %d want %d", len(rows), maxFollowPages) + } + if _, err := f.Poll(context.Background()); !errors.Is(err, ErrFollowTruncated) { + t.Fatalf("the second poll is still truncated: %v", err) + } + mu.Lock() + defer mu.Unlock() + // The advancing cursor is the whole fix: discarding it made every poll + // re-drain the same window, so the operator never saw a row. + if first, second := sinces[0], sinces[maxFollowPages]; first != "" || second != base.Format(time.RFC3339) { + t.Fatalf("cursor must advance past the rows returned: poll1 since=%q poll2 since=%q", first, second) + } +} + +func TestFollowerErrorKeepsCursor(t *testing.T) { + a, b, cc := "2026-08-08T10:00:01Z", "2026-08-08T10:00:02Z", "2026-08-08T10:00:03Z" + stub := &followStub{ + pages: []string{ + logPage(logRow("A", "after_request", a), logRow("B", "after_request", b)), + "", + logPage(logRow("C", "after_request", cc)), + }, + statuses: []int{200, http.StatusInternalServerError, 200}, + } + srv := httptest.NewServer(stub.handler(t)) + defer srv.Close() + + f := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{}) + if _, err := f.Poll(context.Background()); err != nil { + t.Fatal(err) + } + if _, err := f.Poll(context.Background()); err == nil { + t.Fatal("a 500 must be reported") + } + rows, err := f.Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(rows) != 1 || rows[0].TraceID != "C" { + t.Fatalf("want [C] after recovery, got %v", traceIDs(rows)) + } + // The cursor is what guarantees no row is skipped after a transient + // failure: it must be unchanged by the failed poll. + if s2, s3 := stub.sinceAt(1), stub.sinceAt(2); s2 != b || s3 != b { + t.Fatalf("cursor must survive the failure: poll2 since=%q poll3 since=%q want %q", s2, s3, b) + } +} + +func TestFollowerSameStageDifferentTraceNotDeduped(t *testing.T) { + ts := "2026-08-08T10:00:01Z" + stub := &followStub{pages: []string{ + logPage(logRow("A", "after_request", ts), logRow("A", "on_error", ts), logRow("B", "after_request", ts)), + }} + srv := httptest.NewServer(stub.handler(t)) + defer srv.Close() + + rows, err := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{}).Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + // Dedupe is trace+stage+time: one trace's two stages are two rows. + if len(rows) != 3 { + t.Fatalf("want 3 distinct rows, got %d: %v", len(rows), traceIDs(rows)) + } +} + +func TestFollowerDedupeRingStaysBounded(t *testing.T) { + base := time.Date(2026, 8, 8, 10, 0, 0, 0, time.UTC) + initial := make([]string, 0, followDedupeWindow) + for i := range followDedupeWindow { + initial = append(initial, logRow(fmt.Sprintf("t%d", i), "after_request", + base.Add(time.Duration(i)*time.Second).UTC().Format(time.RFC3339))) + } + const freshRows = 100 + next := make([]string, 0, freshRows+1) + next = append(next, initial[len(initial)-1]) // inclusive cursor boundary + for i := range freshRows { + next = append(next, logRow(fmt.Sprintf("new%d", i), "after_request", + base.Add(time.Duration(followDedupeWindow+i)*time.Second).UTC().Format(time.RFC3339))) + } + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + rows := initial + if r.URL.Query().Get("since") != "" { + rows = next + } + offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) + limit, _ := strconv.Atoi(r.URL.Query().Get("limit")) + end := min(offset+limit, len(rows)) + pageRows := rows[offset:end] + writeJSON(t, w, http.StatusOK, fmt.Sprintf( + `{"data":[%s],"summary":{"total_entries":%d,"returned_entries":%d}}`, + strings.Join(pageRows, ","), len(rows), len(pageRows))) + })) + defer srv.Close() + + f := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{Limit: 1000}) + got, err := f.Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(got) != followDedupeWindow { + t.Fatalf("first poll = %d rows, want %d", len(got), followDedupeWindow) + } + got, err = f.Poll(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(got) != 100 { + t.Fatalf("boundary row must dedupe while 100 new rows pass, got %d", len(got)) + } + // A long tail session must not grow a set of every row it ever saw. + if len(f.seen) > followDedupeWindow || len(f.order) > followDedupeWindow { + t.Fatalf("dedupe ring unbounded: seen=%d order=%d", len(f.seen), len(f.order)) + } +} + +func TestNewFollowerNormalizesNegativeLimit(t *testing.T) { + f := NewFollower(nil, LogsQuery{Limit: -1}) + if f.q.Limit != 100 { + t.Fatalf("negative limit must use the safe default, got %d", f.q.Limit) + } +} + +func TestFollowerPropagates501(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusNotImplemented, `{"error":{"message":"no log store","type":"server_error"}}`) + })) + defer srv.Close() + + _, err := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{}).Poll(context.Background()) + if !IsNotSupported(err) { + t.Fatalf("the tail must be able to degrade one screen on 501: %v", err) + } +} + +func traceIDs(rows []LogEntry) []string { + out := make([]string, 0, len(rows)) + for _, r := range rows { + out = append(out, r.TraceID+"/"+r.Stage) + } + return out +} diff --git a/internal/api/services.go b/internal/api/services.go new file mode 100644 index 0000000..a0ab1bb --- /dev/null +++ b/internal/api/services.go @@ -0,0 +1,135 @@ +package api + +import ( + "context" + "net/http" + "net/url" + "strconv" + "time" +) + +// Session is one dashboard session. There is no device or IP field on the +// wire — Subject is the credential's name. +type Session struct { + ID string `json:"id"` + CredentialID string `json:"credential_id"` + Subject string `json:"subject"` + Scopes []string `json:"scopes"` + CreatedAt time.Time `json:"created_at"` + LastSeenAt *time.Time `json:"last_seen_at,omitempty"` + ExpiresAt time.Time `json:"expires_at"` +} + +// AuditEntry is one row of the audit trail. +type AuditEntry struct { + OccurredAt time.Time `json:"occurred_at"` + Action string `json:"action"` + Actor string `json:"actor"` + ActorID string `json:"actor_id,omitempty"` + TargetID string `json:"target_id,omitempty"` + Outcome string `json:"outcome"` // ok|denied|error + Detail string `json:"detail,omitempty"` + SourceIP string `json:"source_ip,omitempty"` + TraceID string `json:"trace_id,omitempty"` +} + +// AuditQuery filters GET /admin/audit. Only non-zero fields are sent — +// Outcome in particular must be ok|denied|error or the gateway answers 400, +// so an empty one is omitted rather than sent blank. +type AuditQuery struct { + Action string + ActorID string + Outcome string + Since time.Time + Limit int + Offset int +} + +func (q AuditQuery) values() url.Values { + v := url.Values{} + for k, s := range map[string]string{"action": q.Action, "actor_id": q.ActorID, "outcome": q.Outcome} { + if s != "" { + v.Set(k, s) + } + } + if !q.Since.IsZero() { + v.Set("since", q.Since.UTC().Format(time.RFC3339)) + } + if q.Limit > 0 { + v.Set("limit", strconv.Itoa(q.Limit)) + } + if q.Offset > 0 { + v.Set("offset", strconv.Itoa(q.Offset)) + } + return v +} + +// AuditPage is one page of GET /admin/audit. +type AuditPage struct { + Data []AuditEntry `json:"data"` + Summary struct { + TotalEntries int `json:"total_entries"` + ReturnedEntries int `json:"returned_entries"` + } `json:"summary"` +} + +// PluginInfo is a plugin this gateway has configured. +type PluginInfo struct { + Name string `json:"name"` + Type string `json:"type"` + Enabled bool `json:"enabled"` +} + +// BuiltinPlugin is a plugin this gateway build ships. FailsOpen lives here +// only, which is why the plugins table merges the two listings by name. +type BuiltinPlugin struct { + Name string `json:"name"` + Type string `json:"type"` + Summary string `json:"summary"` + Settings []string `json:"settings"` + FailsOpen bool `json:"fails_open"` +} + +// Sessions lists active dashboard sessions, unwrapping the {"data":…} +// envelope. A gateway with sessions disabled answers 501, for which +// IsNotSupported reports true. +func (c *Client) Sessions(ctx context.Context) ([]Session, error) { + var out struct { + Data []Session `json:"data"` + } + if _, err := c.do(ctx, http.MethodGet, "/admin/sessions", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return out.Data, nil +} + +// Audit reads a page of the audit trail. +func (c *Client) Audit(ctx context.Context, q AuditQuery) (*AuditPage, error) { + var out AuditPage + if _, err := c.do(ctx, http.MethodGet, "/admin/audit", q.values(), nil, &out, doOpts{}); err != nil { + return nil, err + } + return &out, nil +} + +// Plugins lists the configured plugins. Like /admin/keys and /admin/providers, +// this one answers with a bare array. +func (c *Client) Plugins(ctx context.Context) ([]PluginInfo, error) { + var out []PluginInfo + if _, err := c.do(ctx, http.MethodGet, "/admin/plugins", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return out, nil +} + +// PluginCatalog lists the plugins this gateway build ships, unwrapping the +// {"data":…} envelope. +func (c *Client) PluginCatalog(ctx context.Context) ([]BuiltinPlugin, error) { + var out struct { + Data []BuiltinPlugin `json:"data"` + } + if _, err := c.do(ctx, http.MethodGet, "/admin/plugins/catalog", nil, nil, &out, doOpts{}); err != nil { + return nil, err + } + return out.Data, nil +} diff --git a/internal/api/services_test.go b/internal/api/services_test.go new file mode 100644 index 0000000..fae40d5 --- /dev/null +++ b/internal/api/services_test.go @@ -0,0 +1,190 @@ +package api + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "net/url" + "testing" + "time" +) + +// servicesStub serves the sessions/audit/plugins surface and records the last +// path and query it was asked for. +func servicesStub(t *testing.T, path *string, query *url.Values) *httptest.Server { + t.Helper() + record := func(r *http.Request) { + *path = r.URL.Path + q := r.URL.Query() + *query = q + } + mux := http.NewServeMux() + mux.HandleFunc("GET /admin/sessions", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `{"data":[ + {"id":"s1","credential_id":"k1","subject":"ci","scopes":["read_only"], + "created_at":"2026-08-08T09:00:00Z","last_seen_at":"2026-08-08T09:30:00Z", + "expires_at":"2026-08-09T09:00:00Z"}, + {"id":"s2","credential_id":"k2","subject":"ops","scopes":["admin"], + "created_at":"2026-08-08T08:00:00Z","expires_at":"2026-08-09T08:00:00Z"}]}`) + }) + mux.HandleFunc("GET /admin/audit", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `{"data":[ + {"occurred_at":"2026-08-08T09:00:00Z","action":"key.create","actor":"ops","actor_id":"k2", + "target_id":"k9","outcome":"ok","detail":"scopes=read_only","source_ip":"10.0.0.1","trace_id":"t1"}, + {"occurred_at":"2026-08-08T09:01:00Z","action":"session.create","actor":"unknown", + "outcome":"denied"}], + "summary":{"total_entries":2,"returned_entries":2}}`) + }) + // A BARE ARRAY, unlike /admin/plugins/catalog one path segment down. + mux.HandleFunc("GET /admin/plugins", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `[{"name":"request-logger","type":"logging","enabled":true}, + {"name":"word-filter","type":"guardrail","enabled":false}]`) + }) + mux.HandleFunc("GET /admin/plugins/catalog", func(w http.ResponseWriter, r *http.Request) { + record(r) + writeJSON(t, w, 200, `{"data":[ + {"name":"request-logger","type":"logging","summary":"Logs requests","settings":["persist"],"fails_open":true}, + {"name":"word-filter","type":"guardrail","summary":"Blocks words","settings":["blocked_words"],"fails_open":false}]}`) + }) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + return srv +} + +func TestSessionsUnwrapsDataEnvelope(t *testing.T) { + var path string + var query url.Values + srv := servicesStub(t, &path, &query) + + sessions, err := testClient(t, srv.URL, "fgw_ok").Sessions(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/admin/sessions" { + t.Fatalf("want GET /admin/sessions, got %q", path) + } + if len(sessions) != 2 { + t.Fatalf("want 2 sessions, got %d", len(sessions)) + } + s := sessions[0] + if s.ID != "s1" || s.CredentialID != "k1" || s.Subject != "ci" || len(s.Scopes) != 1 { + t.Fatalf("bad decode: %+v", s) + } + if s.LastSeenAt == nil || !s.LastSeenAt.Equal(time.Date(2026, 8, 8, 9, 30, 0, 0, time.UTC)) { + t.Fatalf("last_seen_at must decode: %+v", s.LastSeenAt) + } + if !s.ExpiresAt.Equal(time.Date(2026, 8, 9, 9, 0, 0, 0, time.UTC)) { + t.Fatalf("expires_at must decode: %+v", s.ExpiresAt) + } + // A session that has never been used has no last_seen_at at all. + if sessions[1].LastSeenAt != nil { + t.Fatalf("absent last_seen_at must stay nil: %+v", sessions[1]) + } +} + +func TestSessions501IsNotSupported(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusNotImplemented, + `{"error":{"message":"sessions are disabled","type":"server_error"}}`) + })) + defer srv.Close() + + _, err := testClient(t, srv.URL, "fgw_ok").Sessions(context.Background()) + if err == nil || !IsNotSupported(err) { + t.Fatalf("sessions disabled must degrade one screen, got %v", err) + } +} + +func TestAuditDecodesAndEncodesQuery(t *testing.T) { + var path string + var query url.Values + srv := servicesStub(t, &path, &query) + c := testClient(t, srv.URL, "fgw_ok") + + since := time.Date(2026, 8, 8, 0, 0, 0, 0, time.UTC) + page, err := c.Audit(context.Background(), AuditQuery{ + Action: "key.create", ActorID: "k2", Outcome: "ok", Since: since, Limit: 50, Offset: 10, + }) + if err != nil { + t.Fatal(err) + } + if path != "/admin/audit" { + t.Fatalf("want GET /admin/audit, got %q", path) + } + want := url.Values{ + "action": {"key.create"}, "actor_id": {"k2"}, "outcome": {"ok"}, + "since": {"2026-08-08T00:00:00Z"}, "limit": {"50"}, "offset": {"10"}, + } + if fmt.Sprint(query) != fmt.Sprint(want) { + t.Fatalf("query = %v, want %v", query, want) + } + if page.Summary.TotalEntries != 2 || len(page.Data) != 2 { + t.Fatalf("bad page: %+v", page) + } + e := page.Data[0] + if e.Action != "key.create" || e.Actor != "ops" || e.ActorID != "k2" || e.TargetID != "k9" || + e.Outcome != "ok" || e.Detail == "" || e.SourceIP != "10.0.0.1" || e.TraceID != "t1" { + t.Fatalf("bad decode: %+v", e) + } + if !e.OccurredAt.Equal(time.Date(2026, 8, 8, 9, 0, 0, 0, time.UTC)) { + t.Fatalf("occurred_at: %v", e.OccurredAt) + } + if page.Data[1].ActorID != "" || page.Data[1].Outcome != "denied" { + t.Fatalf("optional fields: %+v", page.Data[1]) + } + + // A zero query sends nothing: an empty outcome is a 400 server-side. + if _, err := c.Audit(context.Background(), AuditQuery{}); err != nil { + t.Fatal(err) + } + if len(query) != 0 { + t.Fatalf("zero query must send no parameters, got %v", query) + } +} + +func TestPluginsDecodesBareArray(t *testing.T) { + var path string + var query url.Values + srv := servicesStub(t, &path, &query) + + plugins, err := testClient(t, srv.URL, "fgw_ok").Plugins(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/admin/plugins" { + t.Fatalf("want GET /admin/plugins, got %q", path) + } + if len(plugins) != 2 || plugins[0].Name != "request-logger" || plugins[0].Type != "logging" || + !plugins[0].Enabled || plugins[1].Enabled { + t.Fatalf("bad decode: %+v", plugins) + } +} + +func TestPluginCatalogUnwrapsDataEnvelope(t *testing.T) { + var path string + var query url.Values + srv := servicesStub(t, &path, &query) + + catalog, err := testClient(t, srv.URL, "fgw_ok").PluginCatalog(context.Background()) + if err != nil { + t.Fatal(err) + } + if path != "/admin/plugins/catalog" { + t.Fatalf("want GET /admin/plugins/catalog, got %q", path) + } + if len(catalog) != 2 { + t.Fatalf("want 2 builtins, got %d", len(catalog)) + } + // fails_open lives only in the catalog — it is what the plugins table + // merges in by name. + if !catalog[0].FailsOpen || catalog[1].FailsOpen { + t.Fatalf("fails_open must decode: %+v", catalog) + } + if catalog[0].Summary == "" || len(catalog[0].Settings) != 1 { + t.Fatalf("bad decode: %+v", catalog[0]) + } +} diff --git a/internal/api/sse.go b/internal/api/sse.go new file mode 100644 index 0000000..fada71e --- /dev/null +++ b/internal/api/sse.go @@ -0,0 +1,379 @@ +package api + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "strings" + "time" +) + +// ChatMessage is one turn of a chat request. +type ChatMessage struct { + Role string `json:"role"` + Content string `json:"content"` +} + +// ChatRequest is the subset of POST /v1/chat/completions ferro sends. +// +// Stream is forced true by StreamChat: the CLI has no non-streaming path. The +// cost is that a streamed body carries no provider — that is resolved from the +// request log instead, by TraceAttribution. +type ChatRequest struct { + Model string `json:"model"` + Messages []ChatMessage `json:"messages"` + Stream bool `json:"stream"` +} + +// Usage is the token accounting the gateway sends in a chunk of its own before +// [DONE]. It arrives whether or not the client asked for it — the gateway +// strips usage only on an explicit stream_options.include_usage:false — so a +// stream that ends without one ended abnormally. +type Usage struct { + PromptTokens int `json:"prompt_tokens"` + CompletionTokens int `json:"completion_tokens"` + TotalTokens int `json:"total_tokens"` + ReasoningTokens int `json:"reasoning_tokens,omitempty"` + CacheReadTokens int `json:"cache_read_tokens,omitempty"` + CacheWriteTokens int `json:"cache_write_tokens,omitempty"` +} + +// MessageDelta is the incremental piece of one choice. +// +// ToolCalls is carried raw and unrendered until v0.2: decoding into a typed +// shape ferro does not display would make a tool-calling stream fail to parse +// for no benefit, and dropping the field would make it unrecoverable. +type MessageDelta struct { + Role string `json:"role,omitempty"` + Content string `json:"content,omitempty"` + ReasoningContent string `json:"reasoning_content,omitempty"` + ToolCalls json.RawMessage `json:"tool_calls,omitempty"` +} + +// StreamChoice is one candidate's delta within a chunk. FinishReason is a +// pointer because every chunk carries the field and only the last one carries +// a value. +type StreamChoice struct { + Index int `json:"index"` + Delta MessageDelta `json:"delta"` + FinishReason *string `json:"finish_reason"` +} + +// ChatChunk is one `data:` frame of a streamed completion. Choices may be +// empty — the usage chunk is exactly that shape — but the gateway never sends +// null for it. +type ChatChunk struct { + ID string `json:"id"` + Object string `json:"object"` + Created int64 `json:"created"` + Model string `json:"model"` + Choices []StreamChoice `json:"choices"` + Usage *Usage `json:"usage,omitempty"` +} + +// StreamEvent is one thing that happened on a stream: exactly one of the three +// fields is set. +// +// Err and Done are both terminal and mutually exclusive. A stream that fails +// mid-flight ends with an error frame and NO [DONE], so a reader that waits for +// Done after an Err waits forever; read until the channel closes instead. +type StreamEvent struct { + Chunk *ChatChunk // a decoded content/usage frame + Err *Error // mid-stream failure — the stream is over + Done bool // data: [DONE] +} + +// ChatStream is a live streamed completion. +// +// RequestID is the X-Request-ID response header, which equals the trace_id of +// the matching /admin/logs row. It is the only way to attribute a streamed +// request: no chunk names a provider. +// +// Cancel is always safe to call, safe to call more than once, and never blocks +// — including while the reader has stopped reading Events. Call it (defer it) +// even after a clean Done: it is what releases the reader goroutine and the +// connection. +type ChatStream struct { + RequestID string + Events <-chan StreamEvent + Cancel context.CancelFunc +} + +// Stream error codes. The first two are the gateway's own, sent inside an +// error frame; the third is ferro's, synthesized when the connection ends with +// neither a terminator nor an explanation. +const ( + CodeStreamError = "stream_error" // gateway: the upstream or the pipeline failed + CodeStreamTimeout = "stream_timeout" // gateway: the idle bound elapsed + CodeStreamIncomplete = "stream_incomplete" // client: connection ended without [DONE] + + // DefaultStreamIdleTimeout prevents a connected-but-silent upstream from + // leaving a CLI command or console turn waiting forever. + DefaultStreamIdleTimeout = 2 * time.Minute + + // maxStreamFrameBytes bounds one SSE frame, which is one line. It is a + // memory bound on a stream nothing else limits, so it stays where it is: + // raising it only moves the wall, and a frame this size is a broken or + // hostile upstream rather than an answer. + maxStreamFrameBytes = 1 << 20 + + // maxStreamBytes bounds all accepted JSON payloads in one response. A + // per-frame limit alone still allows an unending sequence of valid frames + // to exhaust the CLI or console. + maxStreamBytes = 4 << 20 +) + +type scanResult struct { + line string + err error + done bool +} + +// StreamChat opens a streamed chat completion. +// +// A non-2xx arriving before the stream starts is returned as an *Error and +// no ChatStream. Once streaming has begun every failure is delivered on the +// channel instead, because the HTTP status is already 200 by then. +// +// The caller owns the returned stream's lifetime: read Events until it closes, +// and call Cancel. +func (c *Client) StreamChat(ctx context.Context, req ChatRequest) (*ChatStream, error) { + req.Stream = true // a value copy: the caller's request is not mutated + body, err := json.Marshal(req) + if err != nil { + return nil, err + } + ctx, cancel := context.WithCancel(ctx) + // resolveURL is the same join c.do uses for every other endpoint, so a + // path-prefixed --gateway-url (e.g. https://gw.example.com/ferro) cannot + // resolve to a different URL here than it would through do. + reqURL := c.resolveURL("/v1/chat/completions").String() + httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, reqURL, bytes.NewReader(body)) + if err != nil { + cancel() + return nil, err + } + httpReq.Header.Set("Content-Type", "application/json") + httpReq.Header.Set("Accept", "text/event-stream") + httpReq.Header.Set("User-Agent", c.userAgent) + if c.apiKey != "" { + httpReq.Header.Set("Authorization", "Bearer "+c.apiKey) + } + + // A dedicated client: the shared one carries DefaultTimeout, which would + // cut every stream off after 15s. Lifetime is ctx's job here. The redirect + // refusal is not optional — a bearer token must not replay to whatever + // host a redirect names, on this surface as much as any other. + streamClient := &http.Client{ + Transport: c.hc.Transport, + CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }, + } + resp, err := streamClient.Do(httpReq) + if err != nil { + cancel() + return nil, err + } + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + defer func() { _ = resp.Body.Close() }() + defer cancel() + if resp.StatusCode < 400 { + return nil, &Error{ + Status: resp.StatusCode, + Message: "redirect refused", + RedirectTo: resp.Header.Get("Location"), + } + } + raw, _ := io.ReadAll(io.LimitReader(resp.Body, maxBody)) + return nil, decodeAPIError(resp.StatusCode, raw) + } + + events := make(chan StreamEvent) + st := &ChatStream{RequestID: resp.Header.Get("X-Request-ID"), Events: events, Cancel: cancel} + + go func() { + defer close(events) + defer cancel() + defer func() { _ = resp.Body.Close() }() + + lines := make(chan scanResult) + go scanStream(ctx, resp.Body, lines) + + var idle <-chan time.Time + var timer *time.Timer + if c.streamIdleTimeout > 0 { + timer = time.NewTimer(c.streamIdleTimeout) + idle = timer.C + defer timer.Stop() + } + resetIdle := func() { + if timer == nil { + return + } + if !timer.Stop() { + select { + case <-timer.C: + default: + } + } + timer.Reset(c.streamIdleTimeout) + } + + var streamBytes int + for { + select { + case <-ctx.Done(): + return + case <-idle: + sendEvent(ctx, events, StreamEvent{Err: &Error{ + Status: http.StatusGatewayTimeout, Type: CodeStreamError, Code: CodeStreamTimeout, + Message: "stream produced no events before the idle timeout", + }}) + cancel() + return + case result := <-lines: + if result.done { + if ctx.Err() != nil { + return + } + msg := "stream ended without a terminating frame" + switch { + case errors.Is(result.err, bufio.ErrTooLong): + // The stream really is incomplete, so the code is right, + // but "read failed: token too long" names a Go type and + // sends the reader looking at the network. Say what the + // gateway sent instead. + msg = fmt.Sprintf("a single stream frame exceeded the %d-byte limit; the answer is truncated", maxStreamFrameBytes) + case result.err != nil: + msg = "stream read failed: " + result.err.Error() + } + sendEvent(ctx, events, StreamEvent{Err: &Error{ + Status: http.StatusBadGateway, Type: CodeStreamError, Code: CodeStreamIncomplete, Message: msg, + }}) + return + } + line := result.line + if !strings.HasPrefix(line, "data:") { + continue // blank keep-alives, ": comments", and any field ferro does not read + } + // TrimSpace absorbs both the optional space after the colon and + // the \r of a CRLF stream. + payload := strings.TrimSpace(strings.TrimPrefix(line, "data:")) + + if payload == "[DONE]" { + resetIdle() + sendEvent(ctx, events, StreamEvent{Done: true}) + return + } + if e := decodeErrorFrame(payload); e != nil { + resetIdle() + // An error frame is the last frame: no [DONE] follows it, so + // this goroutine must not go back to waiting for one. + sendEvent(ctx, events, StreamEvent{Err: e}) + return + } + var chunk ChatChunk + if err := json.Unmarshal([]byte(payload), &chunk); err != nil { + continue // one malformed frame never kills a live stream + } + streamBytes += len(payload) + if streamBytes > maxStreamBytes { + sendEvent(ctx, events, StreamEvent{Err: &Error{ + Status: http.StatusBadGateway, Type: CodeStreamError, Code: CodeStreamIncomplete, + Message: fmt.Sprintf("aggregate stream payload exceeded the %d-byte limit; the answer is truncated", maxStreamBytes), + }}) + return + } + resetIdle() + if !sendEvent(ctx, events, StreamEvent{Chunk: &chunk}) { + return + } + } + } + }() + return st, nil +} + +func scanStream(ctx context.Context, r io.Reader, out chan<- scanResult) { + sc := bufio.NewScanner(r) + sc.Buffer(make([]byte, 0, 64*1024), maxStreamFrameBytes) + for sc.Scan() { + select { + case out <- scanResult{line: sc.Text()}: + case <-ctx.Done(): + return + } + } + select { + case out <- scanResult{err: sc.Err(), done: true}: + case <-ctx.Done(): + } +} + +// decodeErrorFrame reports whether payload is a mid-stream error frame, and +// decodes it. A content chunk carries no "error" key, so this cannot false-fire +// on one. +func decodeErrorFrame(payload string) *Error { + var probe struct { + Error *struct { + Message string `json:"message"` + Type string `json:"type"` + Code string `json:"code"` + } `json:"error"` + } + if json.Unmarshal([]byte(payload), &probe) != nil || probe.Error == nil { + return nil + } + // 502: the HTTP response was already 200 by the time this arrived, so the + // status is synthesized to say "the upstream failed mid-answer". + return &Error{ + Status: http.StatusBadGateway, + Message: probe.Error.Message, + Type: probe.Error.Type, + Code: probe.Error.Code, + } +} + +// sendEvent delivers ev unless ctx is cancelled first, and reports whether it +// was delivered. Every send goes through it: an unbuffered channel plus a +// reader that stopped reading is exactly the deadlock Cancel exists to break. +func sendEvent(ctx context.Context, ch chan<- StreamEvent, ev StreamEvent) bool { + select { + case ch <- ev: + return true + case <-ctx.Done(): + return false + } +} + +// TraceAttribution resolves which provider served a request and what it cost, +// by matching a response's X-Request-ID against /admin/logs trace_id. Streamed +// chunks carry no provider, so this is the only attribution path. +// +// It answers (nil, nil) rather than an error for every "cannot know yet" +// case — no trace id, no matching row (the log write lags the response), or a +// gateway with no log store (501). Attribution is a detail shown beside an +// answer that already arrived; failing the command over its absence would turn +// a cosmetic gap into a broken chat. +func (c *Client) TraceAttribution(ctx context.Context, traceID string, since time.Time) (*LogEntry, error) { + if traceID == "" { + return nil, nil + } + page, err := c.Logs(ctx, LogsQuery{Limit: 50, Since: since}) + if err != nil { + if IsNotSupported(err) { + return nil, nil + } + return nil, err + } + for _, e := range page.Data { + if e.TraceID == traceID { + return &e, nil + } + } + return nil, nil +} diff --git a/internal/api/sse_test.go b/internal/api/sse_test.go new file mode 100644 index 0000000..ef6d917 --- /dev/null +++ b/internal/api/sse_test.go @@ -0,0 +1,521 @@ +package api + +import ( + "context" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +// frame wraps one JSON payload in the gateway's framing: `data: \n\n`, +// no event name. +func frame(payload string) string { return "data: " + payload + "\n\n" } + +const doneFrame = "data: [DONE]\n\n" + +// writeSSE writes frames verbatim, flushing between them, so the client reads +// them as a stream rather than in one buffered shot. +func writeSSE(w http.ResponseWriter, requestID string, frames ...string) { + w.Header().Set("Content-Type", "text/event-stream") + w.Header().Set("X-Request-ID", requestID) + w.WriteHeader(http.StatusOK) + f, ok := w.(http.Flusher) + for _, fr := range frames { + // A failed frame write means the client hung up mid-stream, which the + // cancellation and early-close tests do on purpose. It is discarded + // rather than reported: failing the test here would make those cases + // flaky, and the client-side assertions already cover what was read. + _, _ = io.WriteString(w, fr) + if ok { + f.Flush() + } + } +} + +// drain reads until the channel closes, failing rather than hanging forever if +// it never does. +func drain(t *testing.T, st *ChatStream) []StreamEvent { + t.Helper() + var got []StreamEvent + deadline := time.After(5 * time.Second) + for { + select { + case ev, open := <-st.Events: + if !open { + return got + } + got = append(got, ev) + case <-deadline: + t.Fatal("stream never closed its Events channel") + } + } +} + +func content(events []StreamEvent) string { + var b strings.Builder + for _, ev := range events { + if ev.Chunk == nil { + continue + } + for _, ch := range ev.Chunk.Choices { + b.WriteString(ch.Delta.Content) + } + } + return b.String() +} + +func TestStreamChatHappyPath(t *testing.T) { + var gotBody, gotAccept, gotAuth string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + raw, _ := io.ReadAll(r.Body) + gotBody, gotAccept, gotAuth = string(raw), r.Header.Get("Accept"), r.Header.Get("Authorization") + writeSSE(w, "trace-abc", + frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}`), + frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[{"index":0,"delta":{"content":"Hello "},"finish_reason":null}]}`), + frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[{"index":0,"delta":{"content":"world"},"finish_reason":"stop"}]}`), + frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[],"usage":{"prompt_tokens":9,"completion_tokens":3,"total_tokens":12}}`), + doneFrame, + ) + })) + defer srv.Close() + + c, _ := New(srv.URL, "fgw_secret") + st, err := c.StreamChat(context.Background(), ChatRequest{ + Model: "m", + Messages: []ChatMessage{{Role: "user", Content: "hi"}}, + }) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + events := drain(t, st) + if len(events) != 5 { + t.Fatalf("want 4 chunks + Done, got %d events: %+v", len(events), events) + } + for i, ev := range events[:4] { + if ev.Chunk == nil || ev.Err != nil || ev.Done { + t.Fatalf("event %d must be a chunk, got %+v", i, ev) + } + } + if !events[4].Done || events[4].Chunk != nil || events[4].Err != nil { + t.Fatalf("last event must be Done, got %+v", events[4]) + } + if got := content(events); got != "Hello world" { + t.Fatalf("content = %q, want %q", got, "Hello world") + } + if fr := events[2].Chunk.Choices[0].FinishReason; fr == nil || *fr != "stop" { + t.Fatalf("finish_reason not decoded: %v", fr) + } + usage := events[3].Chunk.Usage + if usage == nil || usage.TotalTokens != 12 || usage.PromptTokens != 9 { + t.Fatalf("usage chunk not decoded: %+v", usage) + } + if len(events[3].Chunk.Choices) != 0 { + t.Fatalf("usage chunk carries an empty choices array, got %+v", events[3].Chunk.Choices) + } + if st.RequestID != "trace-abc" { + t.Fatalf("RequestID = %q, want the X-Request-ID header", st.RequestID) + } + // The request itself: stream is forced on, and the SSE surface is asked for. + if !strings.Contains(gotBody, `"stream":true`) { + t.Fatalf("StreamChat must force stream:true, body was %s", gotBody) + } + if gotAccept != "text/event-stream" || gotAuth != "Bearer fgw_secret" { + t.Fatalf("accept=%q auth=%q", gotAccept, gotAuth) + } +} + +func TestStreamChatDoneIgnoresFollowingBufferedFrames(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeSSE(w, "trace-done", doneFrame, + frame(`{"id":"late","choices":[{"index":0,"delta":{"content":"must be ignored"}}]}`)) + })) + defer srv.Close() + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + events := drain(t, st) + if len(events) != 1 || !events[0].Done { + t.Fatalf("[DONE] must terminate immediately: %+v", events) + } +} + +func TestStreamChatErrorFrameEndsStreamWithoutDone(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeSSE(w, "trace-err", + frame(`{"id":"c1","choices":[{"index":0,"delta":{"role":"assistant"}}]}`), + frame(`{"error":{"message":"boom","type":"stream_error","code":"stream_error"}}`), + // No [DONE]: that asymmetry is the gateway's real behavior. + ) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + events := drain(t, st) + var errs, dones int + for _, ev := range events { + if ev.Err != nil { + errs++ + } + if ev.Done { + dones++ + } + } + if errs != 1 || dones != 0 { + t.Fatalf("want exactly one Err and no Done, got %d/%d: %+v", errs, dones, events) + } + last := events[len(events)-1] + if last.Err.Code != CodeStreamError || last.Err.Message != "boom" || last.Err.Type != "stream_error" { + t.Fatalf("error frame not decoded: %+v", last.Err) + } + if !strings.Contains(last.Err.Error(), "boom") { + t.Fatalf("api.Error must read usefully: %q", last.Err.Error()) + } +} + +func TestStreamChatToleratesCRLFAndComments(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeSSE(w, "trace-crlf", + ": keep-alive\r\n\r\n", + "data: "+`{"id":"c1","choices":[{"index":0,"delta":{"content":"ok"}}]}`+"\r\n\r\n", + // The space after the colon is optional in the SSE grammar. The + // gateway always writes one; a proxy that re-frames the stream + // need not, and dropping the frame would lose content silently. + "data:"+`{"id":"c1","choices":[{"index":0,"delta":{"content":"!"}}]}`+"\r\n\r\n", + "\r\n", + "data: [DONE]\r\n\r\n", + ) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + events := drain(t, st) + if got := content(events); got != "ok!" { + t.Fatalf("content = %q, want %q (events %+v)", got, "ok!", events) + } + if !events[len(events)-1].Done { + t.Fatalf("a CRLF [DONE] must terminate the stream: %+v", events) + } +} + +func TestStreamChatSkipsMalformedFrame(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeSSE(w, "trace-junk", + frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"a"}}]}`), + frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":`), // truncated JSON + frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"b"}}]}`), + doneFrame, + ) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + events := drain(t, st) + if got := content(events); got != "ab" { + t.Fatalf("one bad frame must not kill the stream: content = %q, events %+v", got, events) + } + if !events[len(events)-1].Done { + t.Fatalf("stream must still reach Done: %+v", events) + } +} + +func TestStreamChatTruncatedStreamReportsError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + // A well-formed frame, then the connection ends: no [DONE], no error + // frame. A silently closed channel would render as a complete answer. + writeSSE(w, "trace-cut", frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"half"}}]}`)) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + events := drain(t, st) + last := events[len(events)-1] + if last.Err == nil || last.Err.Code != CodeStreamIncomplete { + t.Fatalf("a truncated stream must surface an Err, got %+v", events) + } +} + +func TestStreamChatOversizedFrameNamesItsOwnCause(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeSSE(w, "trace-big", frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"`+ + strings.Repeat("x", maxStreamFrameBytes)+`"}}]}`)) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + defer st.Cancel() + + last := drain(t, st) + e := last[len(last)-1].Err + if e == nil || e.Code != CodeStreamIncomplete { + t.Fatalf("an oversized frame still ends the stream incomplete: %+v", last) + } + // The stream is genuinely incomplete, so the code is right — but the + // message must name the frame size, not a scanner internal, or the reader + // goes looking at the network for a limit the client applied. + if !strings.Contains(e.Message, "exceeded") || strings.Contains(e.Message, "token too long") { + t.Fatalf("the message must name the frame limit, got %q", e.Message) + } +} + +func TestStreamChatSilentConnectionTimesOut(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + w.WriteHeader(http.StatusOK) + if f, ok := w.(http.Flusher); ok { + f.Flush() + } + <-r.Context().Done() + })) + defer srv.Close() + + c, err := New(srv.URL, "", WithStreamIdleTimeout(25*time.Millisecond)) + if err != nil { + t.Fatal(err) + } + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + events := drain(t, st) + if len(events) != 1 || events[0].Err == nil || events[0].Err.Code != CodeStreamTimeout { + t.Fatalf("silent connection must end with stream_timeout: %+v", events) + } +} + +func TestStreamChatMalformedFramesDoNotDefeatIdleTimeout(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + w.WriteHeader(http.StatusOK) + f, _ := w.(http.Flusher) + for { + if _, err := io.WriteString(w, "data: {not-json}\n\n"); err != nil { + return + } + if f != nil { + f.Flush() + } + select { + case <-r.Context().Done(): + return + case <-time.After(10 * time.Millisecond): + } + } + })) + defer srv.Close() + + c, err := New(srv.URL, "", WithStreamIdleTimeout(35*time.Millisecond)) + if err != nil { + t.Fatal(err) + } + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + events := drain(t, st) + if len(events) != 1 || events[0].Err == nil || events[0].Err.Code != CodeStreamTimeout { + t.Fatalf("malformed frames must not keep a broken stream alive: %+v", events) + } +} + +func TestStreamChatAggregatePayloadIsBounded(t *testing.T) { + payload := `{"id":"c1","choices":[{"index":0,"delta":{"content":"` + + strings.Repeat("x", 32<<10) + `"}}]}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + frames := make([]string, 0, maxStreamBytes/(32<<10)+2) + for range maxStreamBytes/(32<<10) + 1 { + frames = append(frames, frame(payload)) + } + writeSSE(w, "trace-aggregate", frames...) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + events := drain(t, st) + last := events[len(events)-1] + if last.Err == nil || last.Err.Code != CodeStreamIncomplete || + !strings.Contains(last.Err.Message, "aggregate") { + t.Fatalf("aggregate stream limit must terminate visibly: %+v", last) + } +} + +func TestStreamChatCancelMidStreamDoesNotDeadlock(t *testing.T) { + released := make(chan struct{}) + tick := frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"tick"}}]}`) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer close(released) + // Several frames, so the reader goroutine is blocked handing over a + // later one — an unbuffered channel with a reader that walked away — + // at the moment Cancel lands. + writeSSE(w, "trace-cancel", tick, tick, tick) + <-r.Context().Done() // never sends [DONE]: the client hangs up first + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + + select { + case ev := <-st.Events: + if ev.Chunk == nil { + t.Fatalf("want the first chunk, got %+v", ev) + } + case <-time.After(5 * time.Second): + t.Fatal("no first chunk") + } + + st.Cancel() + drain(t, st) // must close promptly, with no sender left blocked + st.Cancel() // idempotent: always safe to call again + <-released // the server saw the hang-up, so the connection is not leaked + + // This asserts that the channel closes, not that no goroutine leaked: leak + // detection under httptest means goroutine counting, which is flaky. Add it + // if a leak is ever suspected. +} + +func TestStreamChatPreStreamErrorReturnsAPIError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusUnauthorized, + `{"error":{"message":"bad key","type":"authentication_error","code":"unauthorized"}}`) + })) + defer srv.Close() + + c, _ := New(srv.URL, "fgw_bad") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if st != nil { + t.Fatal("a pre-stream failure must return no ChatStream") + } + var apiErr *Error + if !errors.As(err, &apiErr) || apiErr.Status != http.StatusUnauthorized || apiErr.Message != "bad key" { + t.Fatalf("want a decoded 401 envelope, got %v", err) + } +} + +func TestStreamChatURLMatchesDoResolutionForPathPrefixedBase(t *testing.T) { + // StreamChat builds its URL through the same c.resolveURL join c.do uses + // (see client.go), so a path-prefixed --gateway-url cannot land the + // request on a different path than every other endpoint — in particular + // it cannot produce a double slash on the streaming path. + var gotPath string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + writeSSE(w, "trace-prefix", doneFrame) + })) + defer srv.Close() + + for _, suffix := range []string{"/ferro/", "/ferro"} { + c, err := New(srv.URL+suffix, "") + if err != nil { + t.Fatalf("New: %v", err) + } + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("StreamChat: %v", err) + } + drain(t, st) + st.Cancel() + + want := "/ferro/v1/chat/completions" + if gotPath != want { + t.Fatalf("base %q: request path = %q, want %q (no double slash)", srv.URL+suffix, gotPath, want) + } + if strings.Contains(gotPath, "//") { + t.Fatalf("base %q: request path %q contains a double slash", srv.URL+suffix, gotPath) + } + } +} + +func TestTraceAttribution(t *testing.T) { + var calls int + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + calls++ + if r.URL.Path != "/admin/logs" { + t.Errorf("attribution must read /admin/logs, got %s", r.URL.Path) + } + writeJSON(t, w, http.StatusOK, `{"data":[ + {"trace_id":"other","provider":"openai","cost_usd":9.99}, + {"trace_id":"trace-abc","stage":"after_request","model":"m","provider":"anthropic","total_tokens":12,"cost_usd":0.0012} + ],"summary":{"total_entries":2,"returned_entries":2}}`) + })) + defer srv.Close() + c, _ := New(srv.URL, "fgw_k") + + row, err := c.TraceAttribution(context.Background(), "trace-abc", time.Time{}) + if err != nil { + t.Fatalf("TraceAttribution: %v", err) + } + if row == nil || row.Provider != "anthropic" || row.CostUSD == nil || *row.CostUSD != 0.0012 { + t.Fatalf("want the matching row, got %+v", row) + } + + row, err = c.TraceAttribution(context.Background(), "not-in-the-page", time.Time{}) + if row != nil || err != nil { + t.Fatalf("a missing row is (nil, nil) — log writes lag: got %+v, %v", row, err) + } + + before := calls + if row, err = c.TraceAttribution(context.Background(), "", time.Time{}); row != nil || err != nil || calls != before { + t.Fatalf("an empty trace id must answer (nil, nil) without a request: %+v %v calls=%d", row, err, calls-before) + } +} + +func TestTraceAttributionNoLogStoreIsNotAnError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusNotImplemented, + `{"error":{"message":"request logging is not configured","type":"server_error","code":"not_implemented"}}`) + })) + defer srv.Close() + + c, _ := New(srv.URL, "fgw_k") + row, err := c.TraceAttribution(context.Background(), "trace-abc", time.Now().Add(-time.Minute)) + if row != nil || err != nil { + t.Fatalf("a 501 log store must degrade to (nil, nil), got %+v, %v", row, err) + } +} diff --git a/internal/api/status.go b/internal/api/status.go new file mode 100644 index 0000000..f821309 --- /dev/null +++ b/internal/api/status.go @@ -0,0 +1,210 @@ +package api + +import ( + "context" + "errors" + "fmt" + "net/http" + "time" +) + +// The three values StatusReport.State takes. They are part of the frozen +// `ferro status --format json` contract, so consumers match on these strings +// rather than on a Go type. +const ( + StateConnected = "connected" + StateDegraded = "degraded" + StateUnreachable = "unreachable" +) + +// The values StatusReport.Auth takes: the two scopes a gateway credential can +// carry, and the marker for one the gateway refused. Part of the same frozen +// contract as the states above. +const ( + ScopeAdmin = "admin" + ScopeReadOnly = "read_only" + AuthUnauthorized = "unauthorized" +) + +// TargetSummary counts configured routing targets and how many are reachable. +type TargetSummary struct { + Total int `json:"total"` + Routable int `json:"routable"` +} + +// CircuitSummary counts providers whose breaker is not closed. +type CircuitSummary struct { + Open int `json:"open"` + HalfOpen int `json:"half_open"` +} + +// MCPSummary counts MCP tool servers and how many completed their handshake. +type MCPSummary struct { + Ready int `json:"ready"` + Total int `json:"total"` +} + +// StatusReport is the frozen `ferro status --format json` contract and the +// shape the TUI header renders. Adding a field is compatible; renaming or +// removing one is not. +type StatusReport struct { + State string `json:"state"` // connected|degraded|unreachable + URL string `json:"url"` + LatencyMs int64 `json:"latency_ms"` + // Providers and Models are nil when the gateway did not tell us, for the + // same reason Targets is: each is populated only from a call that can + // fail on its own. /health failing leaves a reachable, degraded gateway + // reporting no provider count, and /v1/models is skipped entirely without + // a credential or answered 404 by a build that does not serve it. A real + // zero and an unanswered question are different facts, and only a pointer + // can carry both. + Providers *int `json:"providers,omitempty"` + Models *int `json:"models,omitempty"` + // Targets is nil when the gateway did not tell us. /readyz answers a 503 + // with only {status, reason} — no targets array — so a zero count there + // would mean "none configured" when the truth is "yours are dead", which + // is the wrong answer during exactly the outage this command is run in. + // Absent is honest; 0 is a claim we cannot support. + Targets *TargetSummary `json:"targets,omitempty"` + Circuits CircuitSummary `json:"circuits"` + MCP *MCPSummary `json:"mcp,omitempty"` + Auth string `json:"auth,omitempty"` // admin|read_only|unauthorized|"" + Warnings []string `json:"warnings,omitempty"` +} + +// Status assembles the report both `ferro status` and the TUI header render. +// /health and /readyz are unauthenticated ground truth; admin and models +// enrich it best-effort. An auth problem degrades the report, it never fails +// it — only an unreachable gateway returns an error, and it returns a report +// alongside so callers can still say which URL was tried. +func (c *Client) Status(ctx context.Context) (*StatusReport, error) { + r := &StatusReport{State: StateUnreachable, URL: c.BaseURL()} + + start := time.Now() + health, healthStatus, err := c.Health(ctx) + r.LatencyMs = time.Since(start).Milliseconds() + if err != nil { + return r, err + } + r.State = StateConnected + applyHealth(r, health, healthStatus) + + readyStatus := 0 + ready, status, readyErr := c.Ready(ctx) + if readyErr == nil { + readyStatus = status + applyReady(r, ready, status) + } else { + r.Warnings = append(r.Warnings, "readiness unavailable: "+readyErr.Error()) + } + + if c.applyAuth(ctx, r) { + if models, err := c.Models(ctx); err == nil { + r.Models = Count(len(models)) + } else if !IsNotSupported(err) { + r.Warnings = append(r.Warnings, "models unavailable: "+err.Error()) + } + } + + unroutable := r.Targets != nil && r.Targets.Routable < r.Targets.Total + // A credential the gateway refused is a degraded gateway from where this + // operator sits: /health and /readyz are fine, and every authenticated API + // is still shut. Presenting no credential at all is not a fault — nothing + // was rejected, so that case reports unauthorized without degrading. + credentialRejected := r.Auth == AuthUnauthorized && c.apiKey != "" + if healthStatus == http.StatusServiceUnavailable || readyStatus == http.StatusServiceUnavailable || + readyErr != nil || r.Circuits.Open > 0 || r.Circuits.HalfOpen > 0 || unroutable || credentialRejected { + r.State = StateDegraded + } + return r, nil +} + +// Count records a count the gateway actually supplied. A nil *int in a +// StatusReport means the question went unanswered; Count(0) means the gateway +// answered zero. Callers building a report by hand — tests, fixtures — use it +// so that "answered zero" cannot be written accidentally as "never asked". +func Count(n int) *int { return &n } + +// applyHealth folds the /health body into the report: the provider count, the +// per-provider circuit counts with a warning naming each non-closed one, and a +// warning carrying the body's own status when /health answered 503. +func applyHealth(r *StatusReport, health *HealthReport, status int) { + r.Providers = Count(len(health.Providers)) + for _, p := range health.Providers { + switch p.Circuit { + case "open": + r.Circuits.Open++ + r.Warnings = append(r.Warnings, fmt.Sprintf("%s circuit open", p.Name)) + case "half_open": + r.Circuits.HalfOpen++ + r.Warnings = append(r.Warnings, fmt.Sprintf("%s circuit half-open", p.Name)) + } + } + if status == http.StatusServiceUnavailable { + r.Warnings = append(r.Warnings, "health: "+health.Status) + } +} + +// applyReady folds a successfully read /readyz body into the report. +// +// A not_ready body carries no targets array at all, so only count them when the +// gateway actually listed some. Leaving Targets nil renders as "—" rather than +// asserting a zero the server never reported; the same holds for MCP. +func applyReady(r *StatusReport, ready *ReadyReport, status int) { + if ready.Targets != nil { + t := &TargetSummary{Total: len(ready.Targets)} + for _, target := range ready.Targets { + if target.Routable { + t.Routable++ + } + } + r.Targets = t + } + if ready.MCPServers != nil { + m := &MCPSummary{Total: len(ready.MCPServers)} + for _, s := range ready.MCPServers { + if s.Ready { + m.Ready++ + } + } + r.MCP = m + } + if status == http.StatusServiceUnavailable && ready.Reason != "" { + r.Warnings = append(r.Warnings, "not ready: "+ready.Reason) + } +} + +// applyAuth probes /admin/health and records the scope the credential carries, +// preferring admin over read_only. It reports whether the caller authenticated +// at all, which is what decides whether the model count can be enriched. A +// 401/403 is recorded as unauthorized and degrades the report — an auth problem +// is never an error here. +// +// Every other failure — a 500, a timeout, an undecodable body — is recorded as +// a warning instead. Without one the probe's outcome is indistinguishable from +// a gateway that authenticated fine and serves no models. +func (c *Client) applyAuth(ctx context.Context, r *StatusReport) bool { + ah, err := c.AdminHealth(ctx) + if err != nil { + var ae *Error + if errors.As(err, &ae) && (ae.Status == http.StatusUnauthorized || ae.Status == http.StatusForbidden) { + r.Auth = AuthUnauthorized + if c.apiKey != "" { + r.Warnings = append(r.Warnings, "credential rejected: "+err.Error()) + } + return false + } + r.Warnings = append(r.Warnings, "admin health unavailable: "+err.Error()) + return false + } + for _, scope := range ah.Scopes { + if scope == ScopeAdmin { + r.Auth = scope + break + } + if scope == ScopeReadOnly && r.Auth == "" { + r.Auth = scope + } + } + return true +} diff --git a/internal/api/status_test.go b/internal/api/status_test.go new file mode 100644 index 0000000..77a21ec --- /dev/null +++ b/internal/api/status_test.go @@ -0,0 +1,347 @@ +package api + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +// cnt reads a supplied count, and answers -1 for one the gateway never gave — +// a value no real count can take, so "absent" can never satisfy an assertion +// about a number. +func cnt(n *int) int { + if n == nil { + return -1 + } + return *n +} + +func TestStatusConnectedWithAdmin(t *testing.T) { + srv := gatewayStub(t, true) + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + // A half-open circuit and an unroutable target both degrade the report. + if r.State != "degraded" || cnt(r.Providers) != 2 || cnt(r.Models) != 2 || r.Targets == nil || + r.Targets.Total != 2 || r.Targets.Routable != 1 || + r.Circuits.HalfOpen != 1 || r.Circuits.Open != 0 || + r.MCP == nil || r.MCP.Ready != 1 || r.MCP.Total != 2 || + r.Auth != "admin" || len(r.Warnings) == 0 { + t.Fatalf("bad report: %+v", r) + } + if r.URL != strings.TrimRight(srv.URL, "/") { + t.Fatalf("report must name the gateway: %q", r.URL) + } + if !strings.Contains(strings.Join(r.Warnings, ";"), "openai") { + t.Fatalf("the half-open provider must be named: %v", r.Warnings) + } + if r.LatencyMs < 0 { + t.Fatal("latency must be measured") + } +} + +func TestStatusUnauthorizedStillReports(t *testing.T) { + srv := gatewayStub(t, true) + // No key: /health and /readyz still answer; admin and models do not. + r, err := testClient(t, srv.URL, "").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + // Models is nil, not 0: without an accepted credential /v1/models is never + // asked, and reporting zero would state a fact the CLI does not have. + if r.Auth != "unauthorized" || r.Models != nil || cnt(r.Providers) != 2 { + t.Fatalf("unauth status must degrade gracefully: %+v", r) + } + if r.Targets == nil || r.Targets.Total != 2 || r.MCP == nil { + t.Fatalf("unauthenticated ground truth must still be read: %+v", r) + } +} + +func TestStatusUnreachable(t *testing.T) { + c := testClient(t, "http://127.0.0.1:1", "") + r, err := c.Status(context.Background()) + if err == nil || r == nil || r.State != "unreachable" { + t.Fatalf("want unreachable report + error, got %+v, %v", r, err) + } + if r.URL == "" { + t.Fatal("an unreachable report still names the URL it tried") + } +} + +func TestStatusDegradedOn503(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusServiceUnavailable, `{"status":"no_providers","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusServiceUnavailable, `{"status":"not_ready","reason":"no routable targets"}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"no_providers","providers":[],"components":[],"scopes":["read_only"]}`) + }) + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"object":"list","data":[]}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatalf("503 is a report, not a failure: %v", err) + } + joined := strings.Join(r.Warnings, ";") + if r.State != "degraded" || !strings.Contains(joined, "no_providers") || !strings.Contains(joined, "no routable targets") { + t.Fatalf("bad 503 report: %+v", r) + } + if r.Auth != "read_only" { + t.Fatalf("scope must be reported: %+v", r) + } +} + +func TestStatusConnectedWhenAllHealthy(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[{"name":"openai","status":"available","circuit":"closed","models":3}]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready","targets":[{"name":"openai-primary","routable":true}]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"healthy","providers":[],"components":[]}`) + }) + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"object":"list","data":[{"id":"gpt-5.1","object":"model","created":0,"owned_by":"openai"}]}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.State != "connected" || len(r.Warnings) != 0 || r.MCP != nil { + t.Fatalf("healthy gateway must report connected with no warnings: %+v", r) + } + // No scopes in the body: authenticated, but the scope is unknown — models + // are still enriched because the probe did not fail. + if r.Auth != "" || cnt(r.Models) != 1 { + t.Fatalf("scope-less admin health: %+v", r) + } +} + +func TestStatusDegradedWhenReadinessCannotBeRead(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{not-json`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusUnauthorized, `{"error":{"message":"nope"}}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.State != "degraded" || !strings.Contains(strings.Join(r.Warnings, ";"), "readiness") { + t.Fatalf("a failed readiness probe must degrade the report: %+v", r) + } +} + +func TestStatusPreservesReportedEmptyTargets(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready","targets":[]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusUnauthorized, `{"error":{"message":"nope"}}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.Targets == nil || r.Targets.Total != 0 { + t.Fatalf("a reported empty target list is known zero, not absent: %+v", r.Targets) + } +} + +func TestStatusMeasuresRealLatency(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + time.Sleep(25 * time.Millisecond) + writeJSON(t, w, 200, `{"status":"ok","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready"}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusUnauthorized, `{"error":{"message":"nope","type":"authentication_error"}}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.LatencyMs < 20 { + t.Fatalf("latency must be the measured /health RTT, got %dms", r.LatencyMs) + } +} + +// healthyExceptAdmin serves a gateway whose unauthenticated ground truth is +// perfect, so nothing but the admin probe can degrade the report. +func healthyExceptAdmin(t *testing.T, adminStatus int, adminBody string) *httptest.Server { + t.Helper() + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[{"name":"openai","status":"available","circuit":"closed","models":3}]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready","targets":[{"name":"openai-primary","routable":true}]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, adminStatus, adminBody) + }) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + return srv +} + +func TestStatusDegradesWhenCredentialIsRejected(t *testing.T) { + srv := healthyExceptAdmin(t, http.StatusUnauthorized, `{"error":{"message":"key expired"}}`) + + // A credential was presented and refused: healthy probes must not hide it. + r, err := testClient(t, srv.URL, "fgw_expired").Status(context.Background()) + if err != nil { + t.Fatalf("an auth failure degrades, it never fails: %v", err) + } + if r.State != StateDegraded || r.Auth != AuthUnauthorized { + t.Fatalf("a rejected credential must degrade: %+v", r) + } + if !strings.Contains(strings.Join(r.Warnings, ";"), "credential rejected") { + t.Fatalf("the report must say why it degraded: %v", r.Warnings) + } + + // No credential at all is not a fault — nothing was rejected. + r, err = testClient(t, srv.URL, "").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.State != StateConnected || r.Auth != AuthUnauthorized || len(r.Warnings) != 0 { + t.Fatalf("an unauthenticated probe must report connected: %+v", r) + } +} + +func TestStatusWarnsWhenAdminProbeFailsForANonAuthReason(t *testing.T) { + srv := healthyExceptAdmin(t, http.StatusInternalServerError, `{"error":{"message":"boom"}}`) + + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + // Without the warning a broken probe is indistinguishable from a gateway + // that authenticated fine and serves no models. + if !strings.Contains(strings.Join(r.Warnings, ";"), "admin health unavailable") { + t.Fatalf("a non-auth probe failure must be visible: %+v", r) + } + if r.Auth != "" { + t.Fatalf("a 500 says nothing about the credential: %+v", r) + } +} + +func TestStatusPreservesEmptyMCPAndSelectsKnownScope(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready","targets":[],"mcp_servers":[]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"healthy","providers":[],"components":[],"scopes":["custom","read_only","admin"]}`) + }) + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusInternalServerError, `{"error":{"message":"catalog failed"}}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.MCP == nil || r.MCP.Total != 0 || r.Auth != "admin" { + t.Fatalf("empty-present MCP and scope precedence were lost: %+v", r) + } + if !strings.Contains(strings.Join(r.Warnings, ";"), "models unavailable") { + t.Fatalf("model enrichment failure must be visible: %v", r.Warnings) + } +} + +// A gateway that answers zero and one that never answered are different facts. +// Before Providers/Models became pointers both rendered as a real 0, so a +// /health that failed on a still-reachable gateway reported "0 providers" — +// and the status table printed "0" for providers beside "-" for models under +// exactly the same condition. +func TestSuppliedZeroIsNotAbsent(t *testing.T) { + mux := http.NewServeMux() + // /health answers, and honestly reports no providers at all. + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ok","providers":[]}`) + }) + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"ready","targets":[]}`) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, 200, `{"status":"healthy","providers":[],"components":[],"scopes":["admin"]}`) + }) + // /v1/models is not served by this build at all — never answered. + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(t, w, http.StatusNotImplemented, `{"error":{"message":"not supported"}}`) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + r, err := testClient(t, srv.URL, "fgw_ok").Status(context.Background()) + if err != nil { + t.Fatal(err) + } + if r.Providers == nil || *r.Providers != 0 { + t.Fatalf("a reported empty provider list is a known zero, not absent: %v", cnt(r.Providers)) + } + if r.Models != nil { + t.Fatalf("an endpoint this build does not serve leaves the count absent, got %v", cnt(r.Models)) + } +} + +// The frozen --format json contract: an absent count is omitted entirely +// rather than serialized as 0, so a consumer can tell the two apart too. +func TestAbsentCountIsOmittedFromJSON(t *testing.T) { + zero := 0 + body, err := json.Marshal(&StatusReport{State: "degraded", Providers: &zero}) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(body), `"providers":0`) { + t.Fatalf("a supplied zero must serialize as 0: %s", body) + } + if strings.Contains(string(body), `"models"`) { + t.Fatalf("an absent count must be omitted, not sent as 0: %s", body) + } +} diff --git a/internal/api/types.go b/internal/api/types.go new file mode 100644 index 0000000..e05069f --- /dev/null +++ b/internal/api/types.go @@ -0,0 +1,88 @@ +package api + +// Wire shapes for the gateway's read endpoints. Every json tag here is the +// gateway's own struct tag, verbatim — the gateway is the schema, this file is +// only a mirror of it, so nothing is renamed for taste. + +// ProviderHealth is one row of the unauthenticated /health provider list. +type ProviderHealth struct { + Name string `json:"name"` + Status string `json:"status"` + Circuit string `json:"circuit"` // closed|open|half_open + Models int `json:"models"` +} + +// HealthReport is GET /health: 200 when serving, 503 when no provider is up. +type HealthReport struct { + Status string `json:"status"` // ok|no_providers + Providers []ProviderHealth `json:"providers"` +} + +// ReadyTarget is a configured routing target and whether a request can reach it. +type ReadyTarget struct { + Name string `json:"name"` + Routable bool `json:"routable"` +} + +// ReadyProvider is the circuit-only provider view served by /readyz. +type ReadyProvider struct { + Name string `json:"name"` + Circuit string `json:"circuit"` +} + +// MCPServer is one MCP tool server. LastError is served by /admin/health only: +// /readyz is unauthenticated and the reason can quote a URL or a token. +type MCPServer struct { + Name string `json:"name"` + Ready bool `json:"ready"` + Required bool `json:"required"` + LastError string `json:"last_error,omitempty"` +} + +// ReadyReport is GET /readyz: 200 ready, or 503 with Reason set. +type ReadyReport struct { + Status string `json:"status"` // ready|not_ready + Reason string `json:"reason,omitempty"` + Providers []ReadyProvider `json:"providers,omitempty"` + Targets []ReadyTarget `json:"targets,omitempty"` + MCPServers []MCPServer `json:"mcp_servers,omitempty"` +} + +// AdminProviderHealth is one row of the authenticated provider list, which +// carries a message a failing provider explains itself with. +type AdminProviderHealth struct { + Name string `json:"name"` + Status string `json:"status"` // healthy|degraded|disabled|unavailable|available + Models int `json:"models"` + Message string `json:"message,omitempty"` +} + +// AdminComponent is a subsystem (API, key store, log store, …) and its status. +type AdminComponent struct { + Name string `json:"name"` + Status string `json:"status"` +} + +// AdminHealth is GET /admin/health, which always answers 200 when the caller +// is authenticated — so it doubles as ferro's auth and scope probe. +type AdminHealth struct { + Status string `json:"status"` + Providers []AdminProviderHealth `json:"providers"` + Components []AdminComponent `json:"components"` + MCPServers []MCPServer `json:"mcp_servers,omitempty"` + Scopes []string `json:"scopes,omitempty"` +} + +// Model is one entry of the OpenAI-shaped GET /v1/models listing. +type Model struct { + ID string `json:"id"` + Object string `json:"object"` + Created int64 `json:"created"` + OwnedBy string `json:"owned_by"` + Mode string `json:"mode,omitempty"` + ContextWindow int `json:"context_window,omitempty"` + MaxOutputTokens int `json:"max_output_tokens,omitempty"` + Capabilities []string `json:"capabilities,omitempty"` + Status string `json:"status,omitempty"` + Deprecated bool `json:"deprecated,omitempty"` +} diff --git a/internal/command/chat.go b/internal/command/chat.go new file mode 100644 index 0000000..21ce690 --- /dev/null +++ b/internal/command/chat.go @@ -0,0 +1,285 @@ +package command + +import ( + "context" + "errors" + "fmt" + "io" + "os" + "strings" + "time" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +const ( + // maxPromptBytes prevents piped input from consuming memory without bound. + // Command-line arguments already have a much smaller OS-level limit. + maxPromptBytes = 1 << 20 + + // attributionRetryDelay is how long ferro waits before its single retry of + // the trace lookup. The request-log row is written after the stream ends, + // so the first lookup routinely races it and finds nothing. + attributionRetryDelay = 500 * time.Millisecond + + // attributionSkew widens the log window backwards past the moment the + // request started. created_at is stamped by the *gateway's* clock and the + // window is filtered against it, so without a margin a client running a + // second fast would never match its own row. + // It is a fixed margin, not clock synchronization — the row is then matched + // by exact trace id, so a wider window costs nothing but rows scanned. + // Matches internal/tui's attributionSlack. The TUI found empirically that a + // one-minute margin was not always enough, and two callers of the same endpoint + // disagreeing about clock tolerance is a bug waiting for a slow gateway. + attributionSkew = 2 * time.Minute +) + +// stdinIsTTY reports whether stdin is a terminal, which is how `ferro chat` +// with no arguments tells "the operator forgot the prompt" from "the prompt is +// being piped in". It is a variable so a test can state which of the two it is +// exercising; nothing else reassigns it. +var stdinIsTTY = isTerminalStdin + +func isTerminalStdin() bool { return isTTY(os.Stdin) } + +// chatResult is the frozen --format json contract. Provider and cost are +// omitted rather than zeroed when attribution found nothing: a consumer must be +// able to tell "served by nobody knows what" from "served by a provider named +// empty string", and $0.0000 is a real price some requests genuinely have. +type chatResult struct { + Model string `json:"model"` + Content string `json:"content"` + Usage *api.Usage `json:"usage"` + RequestID string `json:"request_id"` + Provider string `json:"provider,omitempty"` + CostUSD *float64 `json:"cost_usd,omitempty"` +} + +func newChatCmd() *cobra.Command { + var model, system string + cmd := &cobra.Command{ + Use: "chat [flags] ...", + Short: "Send one prompt through the gateway and stream the answer", + Long: "chat sends a single prompt to a model through the gateway and streams the\n" + + "answer to stdout as it arrives. The prompt is the arguments joined, or\n" + + "stdin when there are none and stdin is not a terminal.\n\n" + + "stdout carries the answer and nothing else — no ANSI, no markdown\n" + + "rendering — so `ferro chat ... > answer.txt` captures exactly what the\n" + + "model said. What served it, what it cost, and any failure go to stderr.\n" + + "A stream that fails or ends mid-answer exits 1: a truncated answer that\n" + + "exited 0 would be indistinguishable from a complete one.", + RunE: func(cmd *cobra.Command, args []string) error { + // Validated here rather than left to the gateway: an empty value + // satisfies cobra's required-flag check, which only asks whether the + // flag was set. + model = strings.TrimSpace(model) + if model == "" { + return errors.New("--model is required and must name a model this gateway serves (ferro models)") + } + prompt, err := readPrompt(cmd, args) + if err != nil { + return err + } + return runChat(cmd, model, system, prompt) + }, + } + f := cmd.Flags() + f.StringVar(&model, "model", "", "model to send the prompt to (required)") + f.StringVar(&system, "system", "", "system message sent ahead of the prompt") + _ = cmd.MarkFlagRequired("model") + return cmd +} + +// readPrompt takes the prompt from the arguments, or from stdin when there are +// none. Reading a terminal would block forever on input the operator does not +// know is wanted, so that case is an error naming both ways to supply one. +func readPrompt(cmd *cobra.Command, args []string) (string, error) { + if len(args) > 0 { + return strings.Join(args, " "), nil + } + if stdinIsTTY() { + return "", errors.New(`no prompt: pass one as arguments (ferro chat "explain X" --model M) or pipe it on stdin`) + } + b, err := io.ReadAll(io.LimitReader(cmd.InOrStdin(), maxPromptBytes+1)) + if err != nil { + return "", fmt.Errorf("read prompt from stdin: %w", err) + } + if len(b) > maxPromptBytes { + return "", fmt.Errorf("prompt exceeds the %d-byte stdin limit", maxPromptBytes) + } + prompt := strings.TrimSpace(string(b)) + if prompt == "" { + return "", errors.New("no prompt: stdin was empty") + } + return prompt, nil +} + +func runChat(cmd *cobra.Command, model, system, prompt string) error { + d := deps(cmd) + ctx := cmd.Context() + + msgs := make([]api.ChatMessage, 0, 2) + if system != "" { + msgs = append(msgs, api.ChatMessage{Role: "system", Content: system}) + } + msgs = append(msgs, api.ChatMessage{Role: "user", Content: prompt}) + + started := time.Now().Add(-attributionSkew) + st, err := d.Client.StreamChat(ctx, api.ChatRequest{Model: model, Messages: msgs}) + if err != nil { + return err + } + // Cancel releases the reader goroutine and the connection even after a + // clean end, and is safe to call twice. + defer st.Cancel() + + // Table format is the streaming, human-facing mode; json and yaml collect + // the whole answer and emit one document, so nothing but that document may + // touch stdout. + streaming := d.Printer.Format == FormatTable + + res := chatResult{Model: model, RequestID: st.RequestID} + var content strings.Builder + var wroteContent, endedWithNewline bool + var streamErr *api.Error + done := false + + for ev := range st.Events { + switch { + case ev.Err != nil: + streamErr = ev.Err + case ev.Done: + done = true + case ev.Chunk != nil: + // The gateway names the model that actually served the request; + // fall back to the requested one only when it does not. + if ev.Chunk.Model != "" { + res.Model = ev.Chunk.Model + } + if ev.Chunk.Usage != nil { + res.Usage = ev.Chunk.Usage + } + for _, ch := range ev.Chunk.Choices { + // reasoning_content and tool_calls are deliberately not + // printed — stdout is the answer, and anything else on it + // corrupts the one channel a pipeline reads. + if ch.Delta.Content == "" { + continue + } + if streaming { + // In production Out is os.Stdout, an *os.File: every write + // is a syscall, so deltas appear as they arrive with no + // flushing of ours to arrange. + _, _ = fmt.Fprint(d.Printer.Out, ch.Delta.Content) + wroteContent = true + endedWithNewline = strings.HasSuffix(ch.Delta.Content, "\n") + } else { + content.WriteString(ch.Delta.Content) + } + } + } + } + res.Content = content.String() + + if streaming && wroteContent && !endedWithNewline { + // Models rarely end on a newline; without this the shell prompt lands + // mid-answer. It is a terminator, not a rendering. + _, _ = fmt.Fprintln(d.Printer.Out) + } + + // Checked before the error paths: an interrupt can surface either as a + // silent close or as a truncation the reader noticed first, and both mean + // the same thing — the operator ended their own request. + if !done && ctx.Err() != nil { + d.Printer.Warn("interrupted — output is truncated") + if !streaming { + if err := d.printStructured(res); err != nil { + return err + } + return errors.New("chat interrupted — structured output is truncated") + } + return ctx.Err() + } + if streamErr != nil { + return streamFailure(streamErr) + } + if !done { + // Belt and braces: internal/api synthesizes stream_incomplete for this, + // so arriving here means even that frame could not be delivered. Same + // fact, same non-zero exit. + return streamFailure(&api.Error{Code: api.CodeStreamIncomplete}) + } + + if entry := attribute(ctx, d.Client, st.RequestID, started); entry != nil { + res.Provider = entry.Provider + res.CostUSD = entry.CostUSD + } + if !streaming { + return d.printStructured(res) + } + printChatMeta(d, res) + return nil +} + +// streamFailure turns a terminal stream code into the sentence an operator can +// act on. All three exit non-zero: the answer on stdout is incomplete in every +// one of them, and only the exit code can say so to a pipeline. +func streamFailure(e *api.Error) error { + switch e.Code { + case api.CodeStreamTimeout: + // The bound itself is the gateway's, configurable there and not + // reported on the wire, so naming a duration here would be a guess an + // operator reads during the incident it is wrong in. + return errors.New("stream idled out — the gateway closed it after its idle bound elapsed") + case api.CodeStreamIncomplete: + return errors.New("stream ended mid-answer — output is truncated") + default: + if e.Message == "" { + return fmt.Errorf("stream failed: %s", e.Error()) + } + return fmt.Errorf("stream failed: %s", e.Message) + } +} + +// attribute resolves which provider served the answer and what it cost. A +// streamed body names neither, so the only path is the request log — which is +// written after the stream ends, hence the one retry. +// +// Every failure answers nil: attribution is a detail printed beside an answer +// the operator already has, and failing the command over its absence would turn +// a cosmetic gap into a broken chat. +func attribute(ctx context.Context, c *api.Client, traceID string, since time.Time) *api.LogEntry { + for attempt := 0; attempt < 2; attempt++ { + if attempt > 0 { + select { + case <-ctx.Done(): + return nil + case <-time.After(attributionRetryDelay): + } + } + entry, err := c.TraceAttribution(ctx, traceID, since) + if err != nil || entry != nil { + return entry + } + } + return nil +} + +// printChatMeta writes the one narrative line a chat adds, to stderr. Each +// segment is omitted when the fact behind it is absent rather than rendered as +// a zero or an empty name — an invented provider is worse than a shorter line. +func printChatMeta(d *runtimeDeps, res chatResult) { + seg := []string{res.Model} + if res.Provider != "" { + seg = append(seg, res.Provider) + } + if res.Usage != nil { + seg = append(seg, fmt.Sprintf("%d in / %d out", res.Usage.PromptTokens, res.Usage.CompletionTokens)) + } + if res.CostUSD != nil { + seg = append(seg, fmtCost(res.CostUSD)) + } + _, _ = fmt.Fprintln(d.Printer.Err, strings.Join(seg, " "+d.Printer.glyph("·", "|")+" ")) +} diff --git a/internal/command/chat_test.go b/internal/command/chat_test.go new file mode 100644 index 0000000..d34a6fa --- /dev/null +++ b/internal/command/chat_test.go @@ -0,0 +1,411 @@ +package command + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "go.yaml.in/yaml/v3" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +// fullReply is what the fixture streams back, one delta per word. The command +// must reproduce it byte for byte: stdout is the answer, not a rendering of it. +const fullReply = "Ferro routed this through the fake gateway." + +// recorder captures what ferro put on the wire, so a test can assert both what +// was sent and — for the flag-validation case — that nothing was sent at all. +type recorder struct { + mu sync.Mutex + requests int + chatBody []byte +} + +func (r *recorder) record(path string, body []byte) { + r.mu.Lock() + defer r.mu.Unlock() + r.requests++ + if path == "/v1/chat/completions" { + r.chatBody = body + } +} + +func (r *recorder) count() int { + r.mu.Lock() + defer r.mu.Unlock() + return r.requests +} + +func (r *recorder) chat() []byte { + r.mu.Lock() + defer r.mu.Unlock() + return r.chatBody +} + +// recordingGateway is the fixture with a tap on it. The fixture stays the one +// definition of the wire contract; this only observes the traffic. +func recordingGateway(t *testing.T, s fixture.State) (*httptest.Server, *recorder) { + t.Helper() + rec := &recorder{} + inner := fixture.Handler(s) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, _ := io.ReadAll(r.Body) + r.Body = io.NopCloser(bytes.NewReader(body)) + rec.record(r.URL.Path, body) + inner.ServeHTTP(w, r) + })) + t.Cleanup(srv.Close) + return srv, rec +} + +// runChatWith runs one invocation with control over the three things a chat +// cares about that the shared `run` helper hides: stdin, the stdout writer, and +// the context that an interrupt cancels. +func runChatWith(ctx context.Context, t *testing.T, srv *httptest.Server, stdin io.Reader, stdout io.Writer, args ...string) (stderr string, err error) { + t.Helper() + t.Setenv("FERRO_API_KEY", "fgw_test") + root := NewRoot() + var errb bytes.Buffer + if stdin != nil { + root.SetIn(stdin) + } + root.SetOut(stdout) + root.SetErr(&errb) + root.SetArgs(append(args, "--gateway-url", srv.URL)) + // Executed on its own line: `return errb.String(), root.Execute…` would read + // the buffer before the command that fills it has run. + err = root.ExecuteContext(ctx) + return errb.String(), err +} + +func TestChatStreamsContentToStdoutVerbatim(t *testing.T) { + srv := gateway(t, fixture.Default()) + + stdout, _, err := run(t, srv, "chat", "hello", "there", "--model", "claude-sonnet-4-6") + if err != nil { + t.Fatalf("a complete stream must exit 0: %v", err) + } + if stdout != fullReply+"\n" { + t.Fatalf("stdout must carry the answer verbatim, got %q want %q", stdout, fullReply+"\n") + } + if strings.Contains(stdout, "\x1b") { + t.Fatalf("stdout must be free of ANSI — it is the pipeable channel: %q", stdout) + } +} + +// The answer belongs on stdout; everything ferro knows *about* the answer +// belongs on stderr, or `ferro chat ... > answer.txt` captures the narrative too. +func TestChatMetaLineGoesToStderrNotStdout(t *testing.T) { + srv := gateway(t, fixture.Default()) + + stdout, stderr, err := run(t, srv, "chat", "hi", "--model", "claude-sonnet-4-6") + if err != nil { + t.Fatal(err) + } + for _, want := range []string{"claude-sonnet-4-6", "anthropic", "24 in / 7 out", "$0.0031"} { + if !strings.Contains(stderr, want) { + t.Fatalf("meta line missing %q, stderr was %q", want, stderr) + } + } + if stdout != fullReply+"\n" { + t.Fatalf("meta leaked into stdout: %q", stdout) + } +} + +func TestChatJSONIsExactlyOneDocument(t *testing.T) { + srv := gateway(t, fixture.Default()) + + stdout, _, err := run(t, srv, "chat", "hi", "--model", "claude-sonnet-4-6", "--format", "json") + if err != nil { + t.Fatal(err) + } + doc := oneJSONDoc(t, stdout) + if doc["content"] != fullReply { + t.Fatalf("json content must be the whole answer: %v", doc["content"]) + } + for _, k := range []string{"model", "content", "usage", "request_id", "provider", "cost_usd"} { + if _, ok := doc[k]; !ok { + t.Fatalf("json document missing %q: %v", k, doc) + } + } + if strings.Contains(stdout, fullReply+"\n"+fullReply) { + t.Fatalf("json mode must not also stream prose: %q", stdout) + } +} + +// The model is not a detail the gateway can supply a default for, and a request +// missing it is a wasted round trip against a live gateway. +func TestChatWithoutModelFailsBeforeAnyRequest(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + + _, err := runChatWith(context.Background(), t, srv, nil, io.Discard, "chat", "hi") + if err == nil { + t.Fatal("a chat with no --model must fail") + } + if !strings.Contains(err.Error(), "model") { + t.Fatalf("the error must name the missing flag, got %v", err) + } + if n := rec.count(); n != 0 { + t.Fatalf("nothing may reach the gateway before --model is validated, saw %d requests", n) + } +} + +// An empty value passes cobra's required-flag check (the flag *was* set), so +// the guard has to be ferro's own. +func TestChatEmptyModelFailsBeforeAnyRequest(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + + _, err := runChatWith(context.Background(), t, srv, nil, io.Discard, "chat", "hi", "--model", " ") + if err == nil { + t.Fatal("a blank --model must fail") + } + if n := rec.count(); n != 0 { + t.Fatalf("a blank --model must not reach the gateway, saw %d requests", n) + } +} + +func TestChatSendsSystemAndUserMessages(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + + if _, err := runChatWith(context.Background(), t, srv, nil, io.Discard, + "chat", "how", "are", "you", "--model", "claude-sonnet-4-6", "--system", "be terse"); err != nil { + t.Fatal(err) + } + var sent struct { + Model string `json:"model"` + Stream bool `json:"stream"` + Messages []struct { + Role string `json:"role"` + Content string `json:"content"` + } `json:"messages"` + } + if err := json.Unmarshal(rec.chat(), &sent); err != nil { + t.Fatalf("chat body: %v (%s)", err, rec.chat()) + } + if sent.Model != "claude-sonnet-4-6" || !sent.Stream { + t.Fatalf("model/stream wrong: %+v", sent) + } + if len(sent.Messages) != 2 { + t.Fatalf("want system + user, got %+v", sent.Messages) + } + if sent.Messages[0].Role != "system" || sent.Messages[0].Content != "be terse" { + t.Fatalf("system message: %+v", sent.Messages[0]) + } + if sent.Messages[1].Role != "user" || sent.Messages[1].Content != "how are you" { + t.Fatalf("prompt must be the args joined: %+v", sent.Messages[1]) + } +} + +// A half-written answer that exits 0 is indistinguishable from a complete one +// to anything consuming this command — so a mid-stream failure is exit 1 with +// the reason on stderr. +func TestChatMidStreamErrorExitsNonZero(t *testing.T) { + s := fixture.Default() + s.ChatFails = true + srv := gateway(t, s) + + stdout, stderr, err := run(t, srv, "chat", "hi", "--model", "claude-sonnet-4-6") + if err == nil { + t.Fatal("a mid-stream error frame must exit non-zero") + } + if !strings.Contains(stderr, "upstream error from provider anthropic") { + t.Fatalf("stderr must carry the gateway's reason, got %q", stderr) + } + if !strings.Contains(stdout, "Ferro routed") { + t.Fatalf("the part that did arrive still belongs on stdout: %q", stdout) + } +} + +// A gateway with no request-log store cannot attribute anything. That is a +// missing detail beside an answer that arrived, not a failed chat. +func TestChatWithoutLogStoreSucceedsAndOmitsProvider(t *testing.T) { + s := fixture.Default() + s.NoLogStore = true + srv := gateway(t, s) + + stdout, stderr, err := run(t, srv, "chat", "hi", "--model", "claude-sonnet-4-6") + if err != nil { + t.Fatalf("absent attribution must not fail the chat: %v", err) + } + if stdout != fullReply+"\n" { + t.Fatalf("the answer must still arrive: %q", stdout) + } + if !strings.Contains(stderr, "24 in / 7 out") { + t.Fatalf("usage comes from the stream, not the log: %q", stderr) + } + if strings.Contains(stderr, "anthropic") || strings.Contains(stderr, "$") { + t.Fatalf("an unattributed answer must not name a provider or a cost: %q", stderr) + } +} + +// The other two terminal codes cannot be produced by the fixture — one is the +// gateway's idle bound elapsing, the other a dropped connection — so their +// wording is asserted here. All three are errors, which is what makes them +// exit non-zero. +func TestStreamFailureWording(t *testing.T) { + cases := []struct { + name string + err api.Error + want string + }{ + {"timeout", api.Error{Code: api.CodeStreamTimeout}, "stream idled out — the gateway closed it after its idle bound elapsed"}, + {"incomplete", api.Error{Code: api.CodeStreamIncomplete}, "stream ended mid-answer — output is truncated"}, + {"error", api.Error{Code: api.CodeStreamError, Message: "upstream exploded"}, "stream failed: upstream exploded"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + got := streamFailure(&tc.err) + if got == nil { + t.Fatal("every terminal stream code must be an error, or a truncated answer exits 0") + } + if got.Error() != tc.want { + t.Fatalf("got %q want %q", got, tc.want) + } + }) + } +} + +// cancelingWriter cancels as soon as the first byte of the answer lands, so +// "the operator pressed ctrl-c mid-stream" is a deterministic event rather than +// a race against a sleep. +type cancelingWriter struct { + mu sync.Mutex + buf strings.Builder + cancel context.CancelFunc +} + +func (w *cancelingWriter) Write(p []byte) (int, error) { + w.mu.Lock() + defer w.mu.Unlock() + n, err := w.buf.Write(p) + if w.cancel != nil { + w.cancel() + w.cancel = nil + } + return n, err +} + +func (w *cancelingWriter) String() string { + w.mu.Lock() + defer w.mu.Unlock() + return w.buf.String() +} + +// A partial answer must never exit zero: shell consumers have no other way to +// distinguish it from a complete response. +func TestChatInterruptedFailsAndSaysSo(t *testing.T) { + s := fixture.Default() + s.ChatDelay = 40 * time.Millisecond + srv := gateway(t, s) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + out := &cancelingWriter{cancel: cancel} + + stderr, err := runChatWith(ctx, t, srv, nil, out, "chat", "hi", "--model", "claude-sonnet-4-6") + if !errors.Is(err, context.Canceled) { + t.Fatalf("an interrupted chat must return cancellation, got: %v", err) + } + if !strings.Contains(stderr, "interrupted") { + t.Fatalf("an interrupted chat must say the output is truncated: %q", stderr) + } + if got := out.String(); got == "" || strings.Contains(got, "gateway.") { + t.Fatalf("want the partial answer, got %q", got) + } +} + +func TestChatStructuredInterruptPrintsPartialDocumentAndFails(t *testing.T) { + for _, format := range []string{"json", "yaml"} { + t.Run(format, func(t *testing.T) { + s := fixture.Default() + s.ChatDelay = 40 * time.Millisecond + srv := gateway(t, s) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + timer := time.AfterFunc(150*time.Millisecond, cancel) + defer timer.Stop() + var out bytes.Buffer + stderr, err := runChatWith(ctx, t, srv, nil, &out, + "chat", "hi", "--model", "claude-sonnet-4-6", "--format", format) + if err == nil || !strings.Contains(err.Error(), "structured output is truncated") { + t.Fatalf("structured interruption must exit non-zero: %v", err) + } + if !strings.Contains(stderr, "interrupted") { + t.Fatalf("interruption warning missing: %q", stderr) + } + var doc map[string]any + if format == "json" { + if err := json.Unmarshal(out.Bytes(), &doc); err != nil { + t.Fatalf("partial JSON must remain one valid document: %v (%q)", err, out.String()) + } + } else if err := yaml.Unmarshal(out.Bytes(), &doc); err != nil { + t.Fatalf("partial YAML must remain one valid document: %v (%q)", err, out.String()) + } + if _, ok := doc["content"]; !ok { + t.Fatalf("partial document lost its content field: %v", doc) + } + }) + } +} + +func TestChatReadsPromptFromStdinWhenNotATTY(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + stdinIsTTY = func() bool { return false } + t.Cleanup(func() { stdinIsTTY = isTerminalStdin }) + + if _, err := runChatWith(context.Background(), t, srv, strings.NewReader("summarize this\n"), io.Discard, + "chat", "--model", "claude-sonnet-4-6"); err != nil { + t.Fatal(err) + } + var sent struct { + Messages []struct{ Content string } `json:"messages"` + } + if err := json.Unmarshal(rec.chat(), &sent); err != nil { + t.Fatal(err) + } + if len(sent.Messages) != 1 || sent.Messages[0].Content != "summarize this" { + t.Fatalf("prompt must come from stdin: %+v", sent.Messages) + } +} + +func TestChatRejectsOversizedStdinPrompt(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + stdinIsTTY = func() bool { return false } + t.Cleanup(func() { stdinIsTTY = isTerminalStdin }) + + _, err := runChatWith(context.Background(), t, srv, + strings.NewReader(strings.Repeat("x", maxPromptBytes+1)), io.Discard, + "chat", "--model", "claude-sonnet-4-6") + if err == nil || !strings.Contains(err.Error(), "prompt exceeds") { + t.Fatalf("oversized stdin must fail clearly, got %v", err) + } + if n := rec.count(); n != 0 { + t.Fatalf("oversized stdin must not reach the gateway, saw %d requests", n) + } +} + +// With no args and a terminal on stdin there is no prompt and nothing to wait +// for: say so rather than block forever on a read that will never return. +func TestChatWithNoPromptAndATTYFailsWithGuidance(t *testing.T) { + srv, rec := recordingGateway(t, fixture.Default()) + stdinIsTTY = func() bool { return true } + t.Cleanup(func() { stdinIsTTY = isTerminalStdin }) + + _, err := runChatWith(context.Background(), t, srv, nil, io.Discard, "chat", "--model", "claude-sonnet-4-6") + if err == nil || !strings.Contains(err.Error(), "prompt") { + t.Fatalf("want a prompt-shaped error, got %v", err) + } + if n := rec.count(); n != 0 { + t.Fatalf("a promptless chat must not reach the gateway, saw %d requests", n) + } +} diff --git a/internal/command/keys.go b/internal/command/keys.go new file mode 100644 index 0000000..0965db4 --- /dev/null +++ b/internal/command/keys.go @@ -0,0 +1,198 @@ +package command + +import ( + "errors" + "fmt" + "strings" + "time" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +func newKeysCmd() *cobra.Command { + keys := &cobra.Command{ + Use: "keys", + Short: "Manage gateway API keys", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { return cmd.Help() }, + } + keys.AddCommand(newKeysListCmd(), newKeysGetCmd(), newKeysCreateCmd(), + newKeysRotateCmd(), newKeysRevokeCmd()) + return keys +} + +func newKeysListCmd() *cobra.Command { + return &cobra.Command{ + Use: verbList, + Short: "List API keys with their derived state", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + rows, err := d.Client.Keys(cmd.Context()) + if err != nil { + return err + } + if d.Printer.Format != FormatTable { + return d.printStructured(rows) + } + cells := make([][]string, 0, len(rows)) + for _, k := range rows { + cells = append(cells, []string{ + // ID leads because rotate and revoke take one, and the + // listing is the only place to find it. + k.ID, + k.Name, + // Already masked on the wire; ferro never unmasks. + k.Key, + strings.Join(k.Scopes, ","), + table.FmtTimePtr(k.ExpiresAt), + table.FmtTimePtr(k.LastUsedAt), + fmt.Sprintf("%d", k.UsageCount), + api.KeyState(k), + }) + } + d.Printer.Table([]string{"ID", colName, "KEY", colScopes, colExpires, "LAST USED", "USES", colState}, cells) + return nil + }, + } +} + +func newKeysGetCmd() *cobra.Command { + return &cobra.Command{ + Use: "get ", + Short: "Show one key", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + d := deps(cmd) + k, err := d.Client.Key(cmd.Context(), args[0]) + if err != nil { + // A gateway build without GET /admin/keys/{id} still serves the + // row in the list, so fall back rather than fail. + if !api.IsNotSupported(err) { + return err + } + if k, err = findKey(cmd, args[0]); err != nil { + return err + } + } + return d.printStructured(k) + }, + } +} + +// findKey resolves one key out of the full listing. +func findKey(cmd *cobra.Command, id string) (*api.Key, error) { + rows, err := deps(cmd).Client.Keys(cmd.Context()) + if err != nil { + return nil, err + } + for i := range rows { + if rows[i].ID == id { + return &rows[i], nil + } + } + return nil, fmt.Errorf("no key with id %q on this gateway", id) +} + +func newKeysCreateCmd() *cobra.Command { + create := &cobra.Command{ + Use: "create", + Short: "Create an API key (the secret is shown exactly once)", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + name, _ := cmd.Flags().GetString("name") + scope, _ := cmd.Flags().GetString("scope") + expiresIn, _ := cmd.Flags().GetDuration("expires-in") + + req, err := keyCreateRequest(name, scope, expiresIn) + if err != nil { + return err + } + k, err := d.Client.CreateKey(cmd.Context(), req) + if err != nil { + return err + } + return printSecretOnce(d, k, "secret shown once — the gateway stores only a hash") + }, + } + create.Flags().String("name", "", "key name (required)") + create.Flags().String("scope", api.ScopeReadOnly, + api.ScopeAdmin+"|"+api.ScopeReadOnly+" (always sent explicitly)") + create.Flags().Duration("expires-in", 720*time.Hour, "lifetime from now; 0 for no expiry") + return create +} + +// keyCreateRequest validates client-side so a bad flag costs no request. +func keyCreateRequest(name, scope string, expiresIn time.Duration) (api.KeyCreateRequest, error) { + // These messages lead with a word rather than a flag: the styled error + // renderer capitalises the first character, which mangles "--name". + if name == "" { + return api.KeyCreateRequest{}, errors.New( + "a key name is required, so pass --name (a log row names the key, and an unnamed one is unattributable once it is revoked)") + } + // The two scope names come from internal/api, which derives the same + // vocabulary from the wire; a second copy here could drift from it. + if scope != api.ScopeAdmin && scope != api.ScopeReadOnly { + return api.KeyCreateRequest{}, fmt.Errorf( + "scope %q is not valid: --scope must be %s|%s — ferro always sends one explicitly rather than relying on the gateway's default", + scope, api.ScopeAdmin, api.ScopeReadOnly) + } + if expiresIn < 0 { + return api.KeyCreateRequest{}, errors.New("expiry must be 0 for no expiry or a positive duration") + } + req := api.KeyCreateRequest{Name: name, Scopes: []string{scope}} + if expiresIn > 0 { + t := time.Now().Add(expiresIn).UTC() + req.ExpiresAt = &t + } + return req, nil +} + +func newKeysRotateCmd() *cobra.Command { + return &cobra.Command{ + Use: "rotate ", + Short: "Rotate a key (the previous secret dies immediately)", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + d := deps(cmd) + k, err := d.Client.RotateKey(cmd.Context(), args[0]) + if err != nil { + return err + } + return printSecretOnce(d, k, + "previous secret stopped authenticating; the new one is shown once") + }, + } +} + +// printSecretOnce is the one deliberate credential display: the secret goes to +// stdout so it can be piped into a secret store, and every word about it goes +// to stderr so the pipe stays clean. +func printSecretOnce(d *runtimeDeps, k *api.Key, warning string) error { + d.Printer.Warn("%s", warning) + if d.Printer.Format != FormatTable { + return d.printStructured(k) + } + _, err := fmt.Fprintln(d.Printer.Out, k.Key) + return err +} + +func newKeysRevokeCmd() *cobra.Command { + return &cobra.Command{ + Use: "revoke ", + Short: "Revoke a key (immediate and irreversible)", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + d := deps(cmd) + if err := d.Client.RevokeKey(cmd.Context(), args[0]); err != nil { + return err + } + d.Printer.OK("revoked %s", args[0]) + return nil + }, + } +} diff --git a/internal/command/keys_test.go b/internal/command/keys_test.go new file mode 100644 index 0000000..b7712b1 --- /dev/null +++ b/internal/command/keys_test.go @@ -0,0 +1,182 @@ +package command + +import ( + "strings" + "testing" + "time" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +func TestKeysListDerivesStateAndNeverPrintsASecret(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "keys", "list") + if err != nil { + t.Fatal(err) + } + // ID is here and not in the plan's column set on purpose: rotate and revoke + // take an id, and a table listing that omits it cannot start that workflow. + for _, col := range []string{"ID", "NAME", "KEY", "SCOPES", "EXPIRES", "LAST USED", "USES", "STATE"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + // The gateway serves no state field; all three states are derived from + // revoked_at / active, and the seeded store carries one of each. + for _, state := range []string{"active", "revoked", "expired"} { + if !strings.Contains(stdout, state) { + t.Fatalf("derived STATE %q missing: %q", state, stdout) + } + } + // The wire masks reads as head8...tail4; anything longer would mean the + // listing had grown a full secret. + for _, line := range strings.Split(stdout, "\n") { + for _, f := range strings.Fields(line) { + if strings.HasPrefix(f, "fgw_") && !strings.Contains(f, "...") { + t.Fatalf("list printed an unmasked credential: %q", f) + } + } + } +} + +func TestKeysListJSONIsOneDocument(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "keys", "list", "--format", "json") + if err != nil { + t.Fatal(err) + } + var rows []map[string]any + if err := decodeOne(stdout, &rows); err != nil { + t.Fatalf("stdout must be one JSON document: %v (%q)", err, stdout) + } + if len(rows) == 0 { + t.Fatalf("expected the seeded keys: %q", stdout) + } +} + +func TestKeysCreateSecretOnStdoutWarningOnStderr(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, stderr, err := run(t, srv, "keys", "create", "--name", "ci", "--scope", "read_only", "--expires-in", "720h") + if err != nil { + t.Fatal(err) + } + secret := strings.TrimSpace(stdout) + if !strings.HasPrefix(secret, "fgw_") || strings.Contains(secret, "...") { + t.Fatalf("the full secret must go to stdout so it can be piped, got %q", stdout) + } + if !strings.Contains(stderr, "shown once") { + t.Fatalf("the shown-once warning belongs on stderr, got %q", stderr) + } + if strings.Contains(stdout, "shown once") { + t.Fatalf("narrative leaked into the pipeable channel: %q", stdout) + } +} + +func TestKeysCreateRejectsBadScopeBeforeAnyRequest(t *testing.T) { + _, _, err := execute(t, "keys", "create", "--name", "x", "--scope", "root", + "--gateway-url", "http://127.0.0.1:1") + if err == nil || !strings.Contains(err.Error(), "admin|read_only") { + t.Fatalf("scope must be validated client-side, naming the valid values: %v", err) + } + if !strings.Contains(err.Error(), "always sends one explicitly") { + t.Fatalf("the error must explain why ferro always sends a scope: %v", err) + } + // The gateway defaults a scope-less create to read_only, so the message + // must not claim the opposite — it said "granted admin server-side" while + // defaultScopes was minting least privilege. + if strings.Contains(err.Error(), "server-side") { + t.Fatalf("the message must not restate the old backwards claim: %v", err) + } +} + +func TestKeysCreateRequiresName(t *testing.T) { + _, _, err := execute(t, "keys", "create", "--gateway-url", "http://127.0.0.1:1") + if err == nil || !strings.Contains(err.Error(), "--name") { + t.Fatalf("a nameless key is unattributable later: %v", err) + } +} + +func TestKeysCreateRejectsNegativeExpiry(t *testing.T) { + _, err := keyCreateRequest("ci", "read_only", -time.Hour) + if err == nil || !strings.Contains(err.Error(), "positive duration") { + t.Fatalf("negative expiry must not become a non-expiring key: %v", err) + } +} + +func TestKeysRotateShowsNewSecretOnce(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, stderr, err := run(t, srv, "keys", "rotate", "key_02") + if err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(strings.TrimSpace(stdout), "fgw_") { + t.Fatalf("rotate must print the new secret to stdout: %q", stdout) + } + if !strings.Contains(stderr, "shown once") || !strings.Contains(stderr, "stopped authenticating") { + t.Fatalf("stderr must say the old secret is dead and the new one is shown once: %q", stderr) + } +} + +func TestKeysRevokeConfirmsOnStderrAndPrintsNothingToStdout(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, stderr, err := run(t, srv, "keys", "revoke", "key_01") + if err != nil { + t.Fatal(err) + } + if strings.TrimSpace(stdout) != "" { + t.Fatalf("revoke has no payload; stdout must stay empty: %q", stdout) + } + if !strings.Contains(stderr, "key_01") { + t.Fatalf("the confirmation belongs on stderr: %q", stderr) + } +} + +func TestKeysGetResolvesOneKey(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "keys", "get", "key_01") + if err != nil { + t.Fatal(err) + } + var got map[string]any + if err := decodeOne(stdout, &got); err != nil { + t.Fatalf("keys get renders a structured document: %v (%q)", err, stdout) + } + if got["id"] != "key_01" { + t.Fatalf("wrong key: %v", got) + } +} + +func TestKeysGetUnknownIDFails(t *testing.T) { + srv := gateway(t, fixture.Default()) + if _, _, err := run(t, srv, "keys", "get", "key_nope"); err == nil { + t.Fatal("an unknown key id must be an error, not an empty success") + } +} + +// The operator-facing symptom of the KeyState bug: a key whose expiry has +// passed is served active:true with revoked_at:null, and STATE showed +// "active" — the one answer that matters on a surface read to decide whether +// a credential still works. +func TestKeysListReportsAnExpiredKeyAsExpired(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "keys", "list") + if err != nil { + t.Fatal(err) + } + var row string + for _, l := range strings.Split(stdout, "\n") { + if strings.Contains(l, "demo-temp") { + row = l + } + } + if row == "" { + t.Fatalf("expected the seeded expired key: %q", stdout) + } + if !strings.Contains(row, api.KeyStateExpired) { + t.Fatalf("a key past its expiry must report %q, got %q", api.KeyStateExpired, row) + } + if strings.Contains(row, api.KeyStateRevoked) { + t.Fatalf("an expired key was never revoked: %q", row) + } +} diff --git a/internal/command/logs.go b/internal/command/logs.go new file mode 100644 index 0000000..0998e18 --- /dev/null +++ b/internal/command/logs.go @@ -0,0 +1,330 @@ +package command + +import ( + "errors" + "fmt" + "slices" + "strings" + "time" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +const ( + // tailInterval is the poll cadence of `logs tail`; tailMaxInterval caps the + // ×2 backoff a failing gateway earns. + tailInterval = 2 * time.Second + tailMaxInterval = 30 * time.Second + + // metricCostUSD is the one spelling of the cost total: `logs stats` prints + // it as a row name and the JSON form of the same report carries it as a + // field, so a script greps one name whichever --format it asked for. + metricCostUSD = "cost_usd" + + // tailLookback is the window the first poll covers when no --since was + // given. It is a cursor, not a report: enough history that a row written + // while the command was starting is not missed, little enough that a bare + // tail does not replay the gateway's whole default window as though it had + // just happened. + tailLookback = 2 * time.Minute +) + +func newLogsCmd() *cobra.Command { + logs := &cobra.Command{ + Use: "logs", + Short: "Read the gateway request log", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { return cmd.Help() }, + } + logs.AddCommand(newLogsListCmd(), newLogsStatsCmd(), newLogsTailCmd()) + return logs +} + +// addLogFilterFlags installs the filter set `list` and `tail` share, so a flag +// cannot mean one thing in one verb and another in the next. +func addLogFilterFlags(cmd *cobra.Command) { + f := cmd.Flags() + f.String("since", "", "duration (15m, 2h) or an RFC3339 timestamp") + f.String("model", "", "only rows for this model") + f.String("provider", "", "only rows served by this provider") + f.String("stage", "", "pipeline stage; 'all' for every stage (default: terminal stages only)") + f.String("api-key-id", "", "only rows for this credential id ('none' for credential-less rows)") +} + +func addLogStatsFilterFlags(cmd *cobra.Command) { + f := cmd.Flags() + f.String("since", "", "duration (15m, 2h) or an RFC3339 timestamp") + f.String("model", "", "only rows for this model") + f.String("provider", "", "only rows served by this provider") + f.String("stage", "", "only rows for this pipeline stage") +} + +func logsQueryFromFlags(cmd *cobra.Command) (api.LogsQuery, error) { + f := cmd.Flags() + q := api.LogsQuery{} + q.Model, _ = f.GetString("model") + q.Provider, _ = f.GetString("provider") + q.Stage, _ = f.GetString("stage") + q.APIKeyID, _ = f.GetString("api-key-id") + + if since, _ := f.GetString("since"); since != "" { + t, err := api.ParseSince(since) + if err != nil { + return q, err + } + q.Since = t + } + // list-only paging flags; absent on tail, where they make no sense. + if f.Lookup("limit") != nil { + q.Limit, _ = f.GetInt("limit") + } + if f.Lookup("offset") != nil { + q.Offset, _ = f.GetInt("offset") + } + return q, nil +} + +// noStore turns a 501 into the sentence an operator can act on. The raw error +// stays wrapped for anyone who needs the status code. +func noStore(err error) error { + if api.IsNotSupported(err) { + return fmt.Errorf("this gateway has no request-log store configured, so there are no request logs to read (set REQUEST_LOG_STORE_BACKEND and REQUEST_LOG_STORE_DSN): %w", err) + } + return err +} + +func newLogsListCmd() *cobra.Command { + list := &cobra.Command{ + Use: verbList, + Short: "List request-log rows", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + q, err := logsQueryFromFlags(cmd) + if err != nil { + return err + } + page, err := d.Client.Logs(cmd.Context(), q) + if err != nil { + return noStore(err) + } + if d.Printer.Format != FormatTable { + return d.printStructured(page) + } + rows := make([][]string, 0, len(page.Data)) + for _, e := range page.Data { + rows = append(rows, []string{ + table.FmtTime(e.CreatedAt), e.TraceID, table.OrDash(e.Provider), table.OrDash(e.Model), + e.Stage, fmtMillis(e.DurationMs), fmtCost(e.CostUSD), + fmt.Sprintf("%d", e.TotalTokens), + }) + } + d.Printer.Table([]string{colTime, "TRACE", colProvider, "MODEL", "STAGE", "MS", "COST", "TOKENS"}, rows) + return nil + }, + } + addLogFilterFlags(list) + list.Flags().Int("limit", 50, "rows to return (gateway caps at 200)") + list.Flags().Int("offset", 0, "rows to skip") + return list +} + +func newLogsStatsCmd() *cobra.Command { + stats := &cobra.Command{ + Use: "stats", + Short: "Aggregate request-log statistics (totals, errors, latency percentiles)", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + q, err := logsQueryFromFlags(cmd) + if err != nil { + return err + } + s, err := d.Client.LogStats(cmd.Context(), q) + if err != nil { + return noStore(err) + } + if d.Printer.Format != FormatTable { + return d.printStructured(s) + } + sum := s.Summary + rows := slices.Concat( + [][]string{ + {"requests", fmt.Sprintf("%d", sum.TotalEntries)}, + {"errors", fmt.Sprintf("%d", sum.ErrorEntries)}, + {"error_rate", fmtRate(sum.ErrorEntries, sum.TotalEntries)}, + {"tokens", fmt.Sprintf("%d", sum.TotalTokens)}, + {"prompt_tokens", fmt.Sprintf("%d", sum.PromptTokens)}, + {"completion_tokens", fmt.Sprintf("%d", sum.CompletionTokens)}, + {metricCostUSD, fmt.Sprintf("%.4f", sum.CostUSD)}, + {"unpriced_requests", fmt.Sprintf("%d", sum.UnpricedRequests)}, + }, + percentileRows("latency", s.LatencyMs), + percentileRows("ttft", s.TTFTMs), + ) + d.Printer.Table([]string{"METRIC", "VALUE"}, rows) + return nil + }, + } + addLogStatsFilterFlags(stats) + return stats +} + +// percentileRows renders one distribution. A nil block means nothing was +// measured, which is a "-" and not a zero-latency gateway. +func percentileRows(prefix string, p *api.Percentiles) [][]string { + // The unmeasured table, which is also the answer when p is nil. + rows := [][]string{ + {prefix + "_p50_ms", "-"}, + {prefix + "_p95_ms", "-"}, + {prefix + "_p99_ms", "-"}, + {prefix + "_max_ms", "-"}, + } + if p == nil { + return rows + } + for i, v := range []float64{p.P50, p.P95, p.P99, p.Max} { + rows[i][1] = fmt.Sprintf("%.1f", v) + } + return rows +} + +func newLogsTailCmd() *cobra.Command { + tail := &cobra.Command{ + Use: "tail", + Short: "Follow the request log (one plain line per new row)", + Long: "tail polls the request log every 2s and prints each new row as a line.\n" + + "A failing poll backs off ×2 to 30s and keeps the last cursor, so no row\n" + + "is skipped. Interrupting a tail is a clean exit, not a failure.", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + q, err := logsQueryFromFlags(cmd) + if err != nil { + return err + } + if q.Since.IsZero() { + q.Since = time.Now().Add(-tailLookback) + } + f := api.NewFollower(d.Client, q) + delay := tailInterval + for { + rows, err := f.Poll(cmd.Context()) + // A truncated poll is progress, not a failure: its rows are + // complete and its cursor moved past them, so they are printed, + // the cadence stays, and only the older end it could not reach + // is reported — on stderr, where every loss is stated. + truncated := errors.Is(err, api.ErrFollowTruncated) + switch { + case err == nil || truncated: + delay = tailInterval + if truncated { + d.Printer.Warn("%v", err) + } + for _, e := range rows { + _, _ = fmt.Fprintln(d.Printer.Out, formatLogLine(e)) + } + case cmd.Context().Err() != nil: + // The failing poll is the interrupt itself, not a fault. + return nil + case api.IsNotSupported(err): + // A feature that is absent will not appear by retrying. + return noStore(err) + default: + // Backed off before it is reported: the warning names the + // wait the operator is about to sit through, not the one + // that has already elapsed. + delay = backoff(delay) + d.Printer.Warn("poll failed (%v) — retrying in %s", err, delay) + } + select { + case <-cmd.Context().Done(): + return nil // an interrupted tail is a clean exit + case <-time.After(delay): + } + } + }, + } + addLogFilterFlags(tail) + return tail +} + +func backoff(d time.Duration) time.Duration { + return min(d*2, tailMaxInterval) +} + +// formatLogLine is the tail's one-row-per-line rendering. Fields are +// space-separated and normalized to one physical line, so `awk` still works; +// the free-form error message remains last. Every fixed-width field goes +// through oneField, not only the error message: a Provider, Model or Stage +// the gateway sent with an embedded space or newline would otherwise widen +// into an extra column, and a newline in any field would break the +// one-physical-line contract `awk` depends on. +func formatLogLine(e api.LogEntry) string { + fields := []string{ + oneField(table.FmtTime(e.CreatedAt)), + oneField(e.TraceID), + oneField(table.OrDash(e.Provider)), + oneField(table.OrDash(e.Model)), + oneField(e.Stage), + oneField(fmtMillis(e.DurationMs)), + oneField(fmtCost(e.CostUSD)), + fmt.Sprintf("%d", e.TotalTokens), + } + line := strings.Join(fields, " ") + if e.ErrorMessage != "" { + line += " " + oneLine(e.ErrorMessage) + } + return line +} + +// oneField collapses s to a single whitespace-free token, joining any +// embedded words with "_" rather than a space, so the value can never widen +// into more than the one column it occupies in formatLogLine's fixed-width +// prefix. A value that normalizes to nothing (empty, or all whitespace) +// becomes "-": an empty column still occupies a position in the joined +// string but disappears under an `awk`-style whitespace split, silently +// shifting every column after it. +func oneField(s string) string { + f := strings.Fields(s) + if len(f) == 0 { + return "-" + } + return strings.Join(f, "_") +} + +// oneLine collapses s's internal whitespace runs to single spaces. Used only +// for the trailing, free-form error message, which may keep its internal +// spaces because it is always the last thing on the row -- past every column +// a script indexes into by position -- and only a literal newline or tab +// inside it can break the one-line contract. +func oneLine(s string) string { + return strings.Join(strings.Fields(s), " ") +} + +// fmtMillis and fmtCost keep the nullable-measurement rule in one place: the +// gateway sends null for "not measured", and a rendered 0 would claim a real +// instantaneous or free request. +func fmtMillis(v *float64) string { + if v == nil { + return "-" + } + return fmt.Sprintf("%.1f", *v) +} + +func fmtCost(v *float64) string { + if v == nil { + return "-" + } + return fmt.Sprintf("$%.4f", *v) +} + +func fmtRate(part, total int) string { + if total == 0 { + return "-" + } + return fmt.Sprintf("%.2f%%", 100*float64(part)/float64(total)) +} diff --git a/internal/command/logs_test.go b/internal/command/logs_test.go new file mode 100644 index 0000000..dfc2dda --- /dev/null +++ b/internal/command/logs_test.go @@ -0,0 +1,326 @@ +package command + +import ( + "bytes" + "context" + "fmt" + "net/http" + "net/http/httptest" + "net/url" + "strconv" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +// executeCtx is execute() with a caller-owned context, which is what a tail +// needs: cancelling it is how SIGINT reaches the poll loop. +func executeCtx(ctx context.Context, args ...string) (stdout, stderr string, err error) { + root := NewRoot() + var out, errb bytes.Buffer + root.SetOut(&out) + root.SetErr(&errb) + root.SetArgs(args) + err = root.ExecuteContext(ctx) + return out.String(), errb.String(), err +} + +func TestLogsListRendersDashForNullMeasurements(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "logs", "list") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"TIME", "TRACE", "PROVIDER", "MODEL", "STAGE", "MS", "COST", "TOKENS"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + // The seeded gpt-4o-mini row has null duration_ms, ttft_ms and cost_usd. + // Rendering those as 0 would claim a free, instantaneous request. + var row string + for _, l := range strings.Split(stdout, "\n") { + if strings.Contains(l, "gpt-4o-mini") { + row = l + } + } + if row == "" { + t.Fatalf("expected the seeded gpt-4o-mini row: %q", stdout) + } + // TIME TRACE PROVIDER MODEL STAGE MS COST TOKENS — MS and COST are the two + // nullable ones on this row, and both must be a dash rather than a zero + // that would claim a free, instantaneous request. + fields := strings.Fields(row) + if len(fields) != 8 { + t.Fatalf("want 8 whitespace-free columns, got %d in %q", len(fields), row) + } + if fields[5] != "-" || fields[6] != "-" { + t.Fatalf("null duration_ms/cost_usd must render as -, got ms=%q cost=%q", fields[5], fields[6]) + } + if fields[7] != "856" { + t.Fatalf("a measured token count must survive: %q", row) + } +} + +func TestLogsListSendsSinceAndFilters(t *testing.T) { + var got atomic.Pointer[url.Values] + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + q := r.URL.Query() + got.Store(&q) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"data":[],"summary":{"total_entries":0,"returned_entries":0}}`)) + })) + defer srv.Close() + + if _, _, err := execute(t, "logs", "list", "--since", "15m", "--provider", "anthropic", + "--stage", "all", "--limit", "7", "--gateway-url", srv.URL); err != nil { + t.Fatal(err) + } + q := got.Load() + if q == nil { + t.Fatal("no request reached the gateway") + } + since := q.Get("since") + if since == "" { + t.Fatalf("--since must reach the wire: %v", *q) + } + ts, err := time.Parse(time.RFC3339, since) + if err != nil { + t.Fatalf("since must be RFC3339, got %q", since) + } + if d := time.Since(ts); d < 14*time.Minute || d > 16*time.Minute { + t.Fatalf("15m must mean 15 minutes ago, got %s", d) + } + if q.Get("provider") != "anthropic" || q.Get("stage") != "all" || q.Get("limit") != "7" { + t.Fatalf("filters lost on the way to the wire: %v", *q) + } +} + +func TestLogsListRejectsBadSince(t *testing.T) { + _, _, err := execute(t, "logs", "list", "--since", "yesterday", "--gateway-url", "http://127.0.0.1:1") + if err == nil || !strings.Contains(err.Error(), "since") { + t.Fatalf("an unparseable --since must be reported before any request: %v", err) + } +} + +func TestLogsStatsRendersPercentiles(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "logs", "stats") + if err != nil { + t.Fatal(err) + } + // Read the rendered rows rather than matching literal totals. The fixture + // aggregates its own seeded rows now, so a hardcoded "1240" pinned this + // test to that data and failed the moment the fixture started answering + // honestly — which is a change to the fixture, not to this renderer. + got := map[string]string{} + for _, line := range strings.Split(stdout, "\n") { + if f := strings.Fields(line); len(f) == 2 { + got[f[0]] = f[1] + } + } + for _, want := range []string{ + "requests", "error_rate", "cost_usd", + "latency_p50_ms", "latency_p95_ms", "latency_p99_ms", "ttft_p50_ms", + } { + if got[want] == "" { + t.Fatalf("stats must render %q:\n%s", want, stdout) + } + } + // Percentiles are non-decreasing by construction, so this holds for any + // data — and it fails if the renderer ever transposes or mislabels the + // columns, which matching one value in isolation cannot detect. + p50, p95, p99 := statNum(t, got, "latency_p50_ms"), statNum(t, got, "latency_p95_ms"), statNum(t, got, "latency_p99_ms") + if p50 > p95 || p95 > p99 { + t.Fatalf("latency percentiles must be non-decreasing, got %v/%v/%v:\n%s", p50, p95, p99, stdout) + } +} + +func statNum(t *testing.T, rows map[string]string, name string) float64 { + t.Helper() + v, err := strconv.ParseFloat(strings.TrimSuffix(rows[name], "%"), 64) + if err != nil { + t.Fatalf("%s must render as a number, got %q", name, rows[name]) + } + return v +} + +func TestLogsStatsExposesOnlySupportedFilters(t *testing.T) { + srv := gateway(t, fixture.Default()) + if _, _, err := run(t, srv, "logs", "stats", "--stage", "on_error"); err != nil { + t.Fatalf("stage is supported by the stats endpoint: %v", err) + } + if _, _, err := run(t, srv, "logs", "stats", "--api-key-id", "key_01"); err == nil { + t.Fatal("stats must not advertise the list-only api-key-id filter") + } +} + +func TestFormatLogLineKeepsErrorsOnOneLine(t *testing.T) { + line := formatLogLine(api.LogEntry{Stage: "on_error", ErrorMessage: "first\nsecond\tthird"}) + if strings.ContainsAny(line, "\n\r\t") || !strings.HasSuffix(line, "first second third") { + t.Fatalf("tail rows must remain one line: %q", line) + } +} + +// A Provider, Model or Stage carrying a space or newline must not widen into +// an extra column or break the one-physical-line contract: every fixed-width +// field is normalized, not only ErrorMessage. +func TestFormatLogLineNormalizesEveryField(t *testing.T) { + line := formatLogLine(api.LogEntry{ + TraceID: "trace 1", + Provider: "open\nai rogue", + Model: "gpt 4\to", + Stage: "custom\nstage", + }) + if strings.ContainsAny(line, "\n\r\t") { + t.Fatalf("a field carrying whitespace must not break the one-line contract: %q", line) + } + fields := strings.Fields(line) + if len(fields) != 8 { + t.Fatalf("want 8 whitespace-delimited columns even with dirty fields, got %d in %q", len(fields), line) + } + if fields[1] != "trace_1" { + t.Fatalf("trace id's embedded space must not split into a second column: %q", line) + } + if fields[2] != "open_ai_rogue" || fields[3] != "gpt_4_o" || fields[4] != "custom_stage" { + t.Fatalf("provider/model/stage must stay one column each: %q", line) + } +} + +// A gateway with no log store answers 501. That is a feature that is absent, +// not a crash: the message names the missing store instead of the status code. +func TestLogsDegradeWithAHintWhenNoStore(t *testing.T) { + s := fixture.Default() + s.NoLogStore = true + srv := gateway(t, s) + + for _, verb := range []string{"list", "stats", "tail"} { + _, _, err := run(t, srv, "logs", verb) + if err == nil { + t.Fatalf("logs %s must fail when the store is absent", verb) + } + if !strings.Contains(err.Error(), "request-log store") { + t.Fatalf("logs %s must name the missing store, got %v", verb, err) + } + } +} + +func TestLogsTailPrintsRowsAndExitsCleanlyOnCancel(t *testing.T) { + srv := gateway(t, fixture.Default()) + t.Setenv("FERRO_API_KEY", "fgw_test") + ctx, cancel := context.WithTimeout(t.Context(), 300*time.Millisecond) + defer cancel() + + stdout, _, err := executeCtx(ctx, "logs", "tail", "--since", "1h", + "--gateway-url", srv.URL) + if err != nil { + t.Fatalf("a tail the operator interrupted is not a failure: %v", err) + } + if !strings.Contains(stdout, "anthropic") { + t.Fatalf("tail must print each new row as a line: %q", stdout) + } + if strings.Contains(stdout, "TRACE") { + t.Fatalf("tail emits lines, not a re-drawn table header: %q", stdout) + } +} + +func TestLogsTailBacksOffAndKeepsGoingOnFailure(t *testing.T) { + var calls atomic.Int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + calls.Add(1) + w.WriteHeader(http.StatusInternalServerError) + _, _ = w.Write([]byte(`{"error":{"message":"boom","type":"server_error","code":"server_error"}}`)) + })) + defer srv.Close() + + ctx, cancel := context.WithTimeout(t.Context(), 200*time.Millisecond) + defer cancel() + + stdout, stderr, err := executeCtx(ctx, "logs", "tail", + "--gateway-url", srv.URL) + if err != nil { + t.Fatalf("a poll failure is a warning, not an exit: %v", err) + } + if calls.Load() == 0 { + t.Fatal("the tail never polled") + } + if !strings.Contains(stderr, "retrying") { + t.Fatalf("the failure and the retry delay belong on stderr: %q", stderr) + } + if strings.TrimSpace(stdout) != "" { + t.Fatalf("a failed poll must not write to the machine channel: %q", stdout) + } +} + +// A poll that hits the follower's page bound keeps the rows it fetched and +// moves its cursor past them, so it is progress: the rows belong on stdout, the +// gap belongs on stderr, and the cadence must not back off as it does for a +// poll that failed and fetched nothing. +func TestLogsTailReportsTruncationWithoutBackingOff(t *testing.T) { + // The follower asks for 100 rows a page and stops paging early on a short + // one, so a full page is what keeps it going. The rows carry only an id: + // this is about the page bound, not about rendering. + rows := make([]string, 0, 100) + for i := range 100 { + rows = append(rows, fmt.Sprintf(`{"trace_id":"trace-%03d"}`, i)) + } + // A full page every time, against a total the follower can never reach: + // every poll exhausts its page bound with rows still outstanding. + body := []byte(`{"data":[` + strings.Join(rows, ",") + + `],"summary":{"total_entries":1000000,"returned_entries":100}}`) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write(body) + })) + defer srv.Close() + + // Long enough for one whole poll — 32 pages of it — then the interrupt. + ctx, cancel := context.WithTimeout(t.Context(), time.Second) + defer cancel() + + stdout, stderr, err := executeCtx(ctx, "logs", "tail", "--gateway-url", srv.URL) + if err != nil { + t.Fatalf("a truncated poll is not a failed command: %v", err) + } + if !strings.Contains(stdout, "trace-000") { + t.Fatalf("the rows a truncated poll did fetch must still reach stdout: %q (stderr %q)", stdout, stderr) + } + if !strings.Contains(stderr, "skipped") { + t.Fatalf("the skipped older rows must be stated on stderr: %q", stderr) + } + if strings.Contains(stderr, "retrying") { + t.Fatalf("a truncated poll made progress and must not back off: %q", stderr) + } +} + +func TestBackoffDoublesToCap(t *testing.T) { + d := tailInterval + for range 10 { + d = backoff(d) + } + if d != tailMaxInterval { + t.Fatalf("backoff must double to a %s cap, got %s", tailMaxInterval, d) + } +} + +// The flag set is shared by list and tail, so it is worth one direct test. +func TestLogsQueryFromFlagsPassesNoneSentinel(t *testing.T) { + cmd := &cobra.Command{} + addLogFilterFlags(cmd) + if err := cmd.ParseFlags([]string{"--api-key-id", "none"}); err != nil { + t.Fatal(err) + } + q, err := logsQueryFromFlags(cmd) + if err != nil { + t.Fatal(err) + } + if q.APIKeyID != "none" { + t.Fatalf("the gateway's none sentinel must pass through untouched, got %q", q.APIKeyID) + } +} diff --git a/internal/command/models.go b/internal/command/models.go new file mode 100644 index 0000000..60f1cf3 --- /dev/null +++ b/internal/command/models.go @@ -0,0 +1,40 @@ +package command + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/table" +) + +func newModelsCmd() *cobra.Command { + return &cobra.Command{ + Use: "models", + Short: "List the models this gateway routes", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + models, err := d.Client.Models(cmd.Context()) + if err != nil { + return err + } + if d.Printer.Format != FormatTable { + return d.printStructured(models) + } + rows := make([][]string, 0, len(models)) + for _, m := range models { + rows = append(rows, []string{ + m.ID, + table.OrDash(m.OwnedBy), + table.OrDash(m.Mode), + table.PositiveOrDash(m.ContextWindow), + fmt.Sprintf("%d", len(m.Capabilities)), + table.OrDash(m.Status), + }) + } + d.Printer.Table([]string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", colStatus}, rows) + return nil + }, + } +} diff --git a/internal/command/output.go b/internal/command/output.go new file mode 100644 index 0000000..8f1c8c7 --- /dev/null +++ b/internal/command/output.go @@ -0,0 +1,197 @@ +package command + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "os" + + "go.yaml.in/yaml/v3" + "golang.org/x/term" + + "github.com/ferro-labs/gateway-cli/internal/table" +) + +// Format is the --format value. Report commands may refuse some of these +// rather than invent an unstable encoding of prose. +type Format string + +// The three output formats. Table is for reading, JSON and YAML for piping. +const ( + FormatTable Format = "table" + FormatJSON Format = "json" + FormatYAML Format = "yaml" +) + +// Printer enforces ferro's output discipline: stdout carries machine-readable +// payloads and nothing else, while human narrative, warnings, and errors go to +// stderr. That split is what makes `ferro status --format json | jq` safe. +type Printer struct { + Out, Err io.Writer + Format Format + Color bool + ASCII bool +} + +// isTTY reports whether f is attached to a terminal. It is the package's one +// answer to that question: the stdout/stderr split, the colour decision, and +// chat's piped-prompt detection all ask it here rather than each spelling out +// the same descriptor dance. A var, not a func, so a test can swap it in to +// simulate one stream being a terminal and another not being one -- real +// *os.File values do not let a test fake that any other way. +// +// The int conversion is imposed by the two standard APIs on either side of it — +// os.File.Fd returns a uintptr, golang.org/x/term.IsTerminal takes an int, and +// x/term offers no *os.File-shaped alternative. A descriptor never approaches +// the range where that conversion could lose information. +var isTTY = func(f *os.File) bool { return term.IsTerminal(int(f.Fd())) } + +// NoColor reports whether ANSI must be suppressed for writes to f. Any one of +// these is enough: the NO_COLOR convention, a dumb terminal, or f not being a +// TTY (a pipe or file must never receive escape codes). +// +// The decision is taken per stream rather than globally off stdout: a +// Printer's narrative (OK/Warn/Fail) always writes to p.Err, so with +// `ferro status 2> run.log` -- stdout still a terminal, stderr redirected to +// a file -- colour must be decided from stderr, or the escape codes land in +// run.log even though nothing asked for them there. Callers that draw on +// stdout (the full-screen console) still pass os.Stdout. +func NoColor(f *os.File) bool { + if _, set := os.LookupEnv("NO_COLOR"); set { + return true + } + if os.Getenv("TERM") == "dumb" { + return true + } + return !isTTY(f) +} + +const ( + ansiGreen = "\x1b[32m" + ansiYellow = "\x1b[33m" + ansiRed = "\x1b[31m" + ansiReset = "\x1b[0m" +) + +func (p *Printer) glyph(unicode, ascii string) string { + if p.ASCII { + return ascii + } + return unicode +} + +// note writes one narrative line to stderr. The glyph carries the state on its +// own so meaning survives NO_COLOR, a pipe, and colour-blind readers; colour +// is only ever an enhancement. +func (p *Printer) note(color, glyph, format string, a ...any) { + msg := fmt.Sprintf(format, a...) + if p.Color { + _, _ = fmt.Fprintf(p.Err, "%s%s%s %s\n", color, glyph, ansiReset, msg) + return + } + _, _ = fmt.Fprintf(p.Err, "%s %s\n", glyph, msg) +} + +// OK reports success on stderr, so it never contaminates a piped payload. +func (p *Printer) OK(format string, a ...any) { + p.note(ansiGreen, p.glyph("✓", "[OK]"), format, a...) +} + +// Warn reports a non-fatal condition on stderr. +func (p *Printer) Warn(format string, a ...any) { + p.note(ansiYellow, p.glyph("!", "[!]"), format, a...) +} + +// Fail reports a failure on stderr. The caller still decides the exit code. +func (p *Printer) Fail(format string, a ...any) { + p.note(ansiRed, p.glyph("✗", "[X]"), format, a...) +} + +// The shared column-header vocabulary. A fact keeps one word wherever it is +// printed — TIME is always when it happened, NAME the object's own name, STATE +// the condition ferro derived, STATUS the one the gateway reported — so a +// reader who has learnt one table can read the next, and a script locating a +// column by name finds it under that name everywhere. +const ( + colTime = "TIME" + colName = "NAME" + colState = "STATE" + colStatus = "STATUS" + colScopes = "SCOPES" + colExpires = "EXPIRES" + colProvider = "PROVIDER" + colModels = "MODELS" + colURL = "URL" +) + +// Table writes a plain, alignment-padded table to stdout. No ANSI, no box +// drawing: this output is as likely to be piped into awk as read by a human. +// The layout itself lives in internal/table, shared with the console's own +// rendering of the same verb — see internal/tui/home.go's tableRows. +func (p *Printer) Table(headers []string, rows [][]string) { + table.Write(p.Out, headers, rows) +} + +// JSON writes v to stdout as one indented document. +func (p *Printer) JSON(v any) error { + enc := json.NewEncoder(p.Out) + enc.SetIndent("", " ") + return enc.Encode(v) +} + +// YAML renders v using the same key names the JSON output uses. +// +// Every wire type in internal/api carries `json:` tags and no `yaml:` tags, +// and yaml.v3 does not read json tags — it lowercases the Go field name +// instead, so total_entries would print as totalentries and cost_usd as +// costusd. Round-tripping through JSON makes one set of tags serve both +// formats, which also means a new field cannot be correct in JSON and wrong +// in YAML. +func (p *Printer) YAML(v any) error { + b, err := json.Marshal(v) + if err != nil { + return err + } + // UseNumber keeps integers exact; without it every number decodes as + // float64 and a trace timestamp renders as 1.786193769e+09. + dec := json.NewDecoder(bytes.NewReader(b)) + dec.UseNumber() + var doc any + if err := dec.Decode(&doc); err != nil { + return err + } + out, err := yaml.Marshal(nativeNumbers(doc)) + if err != nil { + return err + } + _, err = p.Out.Write(out) + return err +} + +// nativeNumbers hands the json.Number values UseNumber preserved to yaml as +// plain scalars. Left as json.Number they are a string type and YAML would +// quote them: total_entries: "1500". +func nativeNumbers(v any) any { + switch t := v.(type) { + case map[string]any: + for k, val := range t { + t[k] = nativeNumbers(val) + } + return t + case []any: + for i, val := range t { + t[i] = nativeNumbers(val) + } + return t + case json.Number: + // The gateway's own digits, unquoted, with nothing re-parsed in + // between. Converting to int64 or float64 first would round anything + // past 2^53 that is not an int64 — and the by_provider / by_model + // breakdowns reach here as raw gateway JSON, so what fits is the + // gateway's to decide rather than this package's to assume. + return &yaml.Node{Kind: yaml.ScalarNode, Value: t.String()} + default: + return v + } +} diff --git a/internal/command/output_test.go b/internal/command/output_test.go new file mode 100644 index 0000000..e69d46b --- /dev/null +++ b/internal/command/output_test.go @@ -0,0 +1,218 @@ +package command + +import ( + "bytes" + "encoding/json" + "os" + "strings" + "testing" +) + +func newTestPrinter(format Format) (*Printer, *bytes.Buffer, *bytes.Buffer) { + var out, errb bytes.Buffer + return &Printer{Out: &out, Err: &errb, Format: format}, &out, &errb +} + +func TestTableRendersHeaderUnderlineAndRows(t *testing.T) { + p, out, _ := newTestPrinter(FormatTable) + p.Table([]string{"STATE", "URL"}, [][]string{{"connected", "http://localhost:8080"}}) + + lines := strings.Split(strings.TrimRight(out.String(), "\n"), "\n") + if len(lines) != 3 { + t.Fatalf("want header + underline + 1 row, got %d lines:\n%s", len(lines), out.String()) + } + if !strings.HasPrefix(lines[0], "STATE") { + t.Fatalf("header line: %q", lines[0]) + } + if !strings.HasPrefix(lines[1], "-----") { + t.Fatalf("underline must be dashes matching header width, got %q", lines[1]) + } + if !strings.Contains(lines[2], "connected") { + t.Fatalf("row line: %q", lines[2]) + } +} + +// stdout is the machine channel: `ferro status --format json | jq` must see a +// JSON document and nothing else, no matter how much narrative was produced. +func TestJSONPurityNarrativeGoesToStderr(t *testing.T) { + p, out, errb := newTestPrinter(FormatJSON) + p.OK("connected in 23ms") + p.Warn("anthropic circuit half-open") + p.Fail("something failed") + if err := p.JSON(map[string]any{"state": "degraded", "latency_ms": 23}); err != nil { + t.Fatal(err) + } + + var doc map[string]any + if err := json.Unmarshal(out.Bytes(), &doc); err != nil { + t.Fatalf("stdout must be exactly one JSON document, got %q: %v", out.String(), err) + } + if doc["state"] != "degraded" { + t.Fatalf("payload lost: %v", doc) + } + for _, want := range []string{"connected in 23ms", "half-open", "something failed"} { + if !strings.Contains(errb.String(), want) { + t.Fatalf("narrative %q must reach stderr, got %q", want, errb.String()) + } + } +} + +func TestYAMLGoesToStdout(t *testing.T) { + p, out, _ := newTestPrinter(FormatYAML) + if err := p.YAML(map[string]string{"state": "connected"}); err != nil { + t.Fatal(err) + } + if !strings.Contains(out.String(), "state: connected") { + t.Fatalf("yaml output: %q", out.String()) + } +} + +// Color must never be the only carrier of meaning, and it must be absent +// entirely when the printer is not in color mode. +func TestNoColorEmitsNoANSI(t *testing.T) { + p, _, errb := newTestPrinter(FormatTable) + p.Color = false + p.OK("all good") + p.Fail("all bad") + if strings.Contains(errb.String(), "\x1b[") { + t.Fatalf("ANSI leaked with Color=false: %q", errb.String()) + } + // The glyph still distinguishes the two, so meaning survives without color. + if !strings.Contains(errb.String(), "✓") || !strings.Contains(errb.String(), "✗") { + t.Fatalf("glyphs must carry state when color cannot: %q", errb.String()) + } +} + +func TestColorEmitsANSIWhenEnabled(t *testing.T) { + p, _, errb := newTestPrinter(FormatTable) + p.Color = true + p.OK("all good") + if !strings.Contains(errb.String(), "\x1b[") { + t.Fatalf("want ANSI with Color=true, got %q", errb.String()) + } +} + +func TestASCIIGlyphVocabulary(t *testing.T) { + p, _, errb := newTestPrinter(FormatTable) + p.ASCII = true + p.OK("ok") + p.Warn("warn") + p.Fail("fail") + got := errb.String() + for _, want := range []string{"[OK]", "[!]", "[X]"} { + if !strings.Contains(got, want) { + t.Fatalf("ascii mode must use %s, got %q", want, got) + } + } + if strings.ContainsAny(got, "✓✗") { + t.Fatalf("ascii mode leaked unicode glyphs: %q", got) + } +} + +// The api wire types carry json tags and no yaml tags. yaml.v3 does not read +// json tags, so a naive Marshal renders total_entries as totalentries — the +// same field, named differently depending on --format. +func TestYAMLUsesJSONFieldNames(t *testing.T) { + p, out, _ := newTestPrinter(FormatYAML) + payload := struct { + TotalEntries int `json:"total_entries"` + CostUSD float64 `json:"cost_usd"` + CreatedUnix int64 `json:"created_unix"` + TraceID string `json:"trace_id"` + }{TotalEntries: 1500, CostUSD: 0.0031, CreatedUnix: 1786193769, TraceID: "tr_abc"} + + if err := p.YAML(payload); err != nil { + t.Fatal(err) + } + got := out.String() + for _, want := range []string{"total_entries: 1500", "cost_usd: 0.0031", "trace_id: tr_abc"} { + if !strings.Contains(got, want) { + t.Fatalf("want %q in:\n%s", want, got) + } + } + // Large integers must stay integers: neither quoted (json.Number leaking + // through as a string) nor rendered in scientific notation (float64). + if !strings.Contains(got, "created_unix: 1786193769") { + t.Fatalf("integer precision lost:\n%s", got) + } + for _, bad := range []string{"totalentries", "costusd", `"1500"`, "e+09"} { + if strings.Contains(got, bad) { + t.Fatalf("unexpected %q in:\n%s", bad, got) + } + } +} + +// The by_provider / by_model breakdowns reach the printer as raw gateway JSON, +// so their numbers are not bounded by any Go type this package declares. A +// number is rendered with the digits it arrived with; re-parsing it as int64 or +// float64 first would round anything that does not fit and print the result as +// though the gateway had sent it. +func TestYAMLPreservesDigitsBeyondInt64(t *testing.T) { + p, out, _ := newTestPrinter(FormatYAML) + payload := map[string]json.RawMessage{ + "by_provider": json.RawMessage(`{"requests":18446744073709551615,"cost_usd":0.0031}`), + } + if err := p.YAML(payload); err != nil { + t.Fatal(err) + } + got := out.String() + if !strings.Contains(got, "requests: 18446744073709551615") { + t.Fatalf("a number past int64 must survive intact, not be rounded:\n%s", got) + } + if !strings.Contains(got, "cost_usd: 0.0031") || strings.Contains(got, `"0.0031"`) { + t.Fatalf("ordinary numbers must stay unquoted YAML numbers:\n%s", got) + } +} + +// NoColor takes the stream it is deciding for as a parameter: it must never +// answer for os.Stderr by inspecting os.Stdout, which is the bug that let +// `ferro status 2> run.log` leak ANSI into the redirected file while stdout +// stayed a terminal. +func TestNoColorHonoursNOCOLOREnvRegardlessOfStream(t *testing.T) { + t.Setenv("NO_COLOR", "1") + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer func() { _ = r.Close() }() + defer func() { _ = w.Close() }() + // The stream must read as a terminal for this to test anything: NoColor + // checks NO_COLOR before !isTTY, so against a bare pipe it returns true on + // the TTY check alone and the assertion holds even if NO_COLOR were + // ignored outright. + orig := isTTY + isTTY = func(*os.File) bool { return true } + t.Cleanup(func() { isTTY = orig }) + if !NoColor(w) { + t.Fatal("NO_COLOR must suppress colour on any stream, TTY or not") + } +} + +func TestNoColorRejectsNonTTYStream(t *testing.T) { + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + defer func() { _ = r.Close() }() + defer func() { _ = w.Close() }() + // A pipe is never a terminal, independent of NO_COLOR/TERM. + if !NoColor(w) { + t.Fatal("a non-TTY stream must suppress colour") + } +} + +func TestYAMLKeepsNestedNumbersNative(t *testing.T) { + p, out, _ := newTestPrinter(FormatYAML) + payload := map[string]any{ + "summary": map[string]any{"count": int64(9007199254740991)}, + "series": []any{map[string]any{"value": 12.5}}, + } + if err := p.YAML(payload); err != nil { + t.Fatal(err) + } + got := out.String() + if !strings.Contains(got, "count: 9007199254740991") || !strings.Contains(got, "value: 12.5") || + strings.Contains(got, `"9007199254740991"`) { + t.Fatalf("nested numbers lost their native YAML types:\n%s", got) + } +} diff --git a/internal/command/providers.go b/internal/command/providers.go new file mode 100644 index 0000000..8b9c69c --- /dev/null +++ b/internal/command/providers.go @@ -0,0 +1,103 @@ +package command + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +// providerRow is the merged view: no single endpoint serves all five columns. +// /health is unauthenticated and carries the circuit; /admin/health needs a +// credential and carries the status, the model count and the failure message. +type providerRow struct { + Name string `json:"name"` + Status string `json:"status"` + Circuit string `json:"circuit"` + Models int `json:"models"` + Message string `json:"message,omitempty"` +} + +func mergeProviders(h *api.HealthReport, ah *api.AdminHealth) []providerRow { + circuits := map[string]string{} + for _, p := range h.Providers { + circuits[p.Name] = p.Circuit + } + if ah == nil { + // Unauthenticated is a smaller answer, not an error. + rows := make([]providerRow, 0, len(h.Providers)) + for _, p := range h.Providers { + rows = append(rows, providerRow{ + Name: p.Name, Status: p.Status, Circuit: p.Circuit, + Models: p.Models, + }) + } + return rows + } + rows := make([]providerRow, 0, max(len(ah.Providers), len(h.Providers))) + seen := make(map[string]struct{}, len(ah.Providers)) + for _, p := range ah.Providers { + seen[p.Name] = struct{}{} + rows = append(rows, providerRow{ + Name: p.Name, Status: p.Status, Circuit: circuits[p.Name], + Models: p.Models, Message: p.Message, + }) + } + for _, p := range h.Providers { + if _, ok := seen[p.Name]; ok { + continue + } + rows = append(rows, providerRow{ + Name: p.Name, Status: p.Status, Circuit: p.Circuit, Models: p.Models, + }) + } + return rows +} + +func newProvidersCmd() *cobra.Command { + return &cobra.Command{ + Use: "providers", + Short: "Provider health, circuit state and model counts", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + health, _, err := d.Client.Health(cmd.Context()) + if err != nil { + return err + } + // Best effort: an unusable credential costs the status and message + // columns, not the command. + admin, adminErr := d.Client.AdminHealth(cmd.Context()) + if adminErr != nil { + admin = nil + // Only a refused credential is reported as one; a timeout or a + // gateway error says so instead, so the reader is not sent to + // check a credential that was never the problem. + why := "admin health unavailable" + if api.IsUnauthorized(adminErr) { + why = "no admin credential accepted" + } + d.Printer.Warn("%s — status and message come from /health only (%v)", why, adminErr) + } + + rows := mergeProviders(health, admin) + if d.Printer.Format != FormatTable { + return d.printStructured(rows) + } + cells := make([][]string, 0, len(rows)) + for _, r := range rows { + // Every cell that can be absent renders "-": an empty one would + // collapse the column for anything splitting this table on + // whitespace, and read as a status rather than as its absence. + cells = append(cells, []string{ + r.Name, table.OrDash(r.Status), table.OrDash(r.Circuit), + fmt.Sprintf("%d", r.Models), table.OrDash(r.Message), + }) + } + d.Printer.Table([]string{colProvider, colStatus, "CIRCUIT", colModels, "MESSAGE"}, cells) + return nil + }, + } +} diff --git a/internal/command/root.go b/internal/command/root.go new file mode 100644 index 0000000..636b9a1 --- /dev/null +++ b/internal/command/root.go @@ -0,0 +1,207 @@ +// Package command holds ferro's scriptable Cobra surface. It owns the +// stdout/stderr split, output formats, and exit codes; it holds no terminal +// screen state. Bare `ferro` hands off to internal/tui. +package command + +import ( + "context" + "errors" + "fmt" + "os" + "strings" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/config" + "github.com/ferro-labs/gateway-cli/internal/tui" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" + "github.com/ferro-labs/gateway-cli/internal/version" +) + +type depsKey struct{} + +// verbList is the one spelling of the listing verb. Every noun that can be +// listed spells it this way, so an operator who has typed `keys list` can guess +// `logs list` rather than discover it is `logs ls`. +const verbList = "list" + +// runtimeDeps is what every verb needs and none of them should assemble for +// itself: the resolved connection, an output printer honouring the global +// flags, and a client pointed at that connection. +type runtimeDeps struct { + Resolved config.Resolved + Printer *Printer + Client *api.Client +} + +// deps returns the runtime wiring built by PersistentPreRunE. It is nil only +// for commands that opt out of setup (version), which never call it. +func deps(cmd *cobra.Command) *runtimeDeps { + d, _ := cmd.Context().Value(depsKey{}).(*runtimeDeps) + return d +} + +// printStructured renders a value for --format json|yaml. Table-formatted +// commands that have no sensible column layout fall back to JSON rather than +// inventing one. +func (d *runtimeDeps) printStructured(v any) error { + if d.Printer.Format == FormatYAML { + return d.Printer.YAML(v) + } + return d.Printer.JSON(v) +} + +// rootFlags are the persistent flags every subcommand inherits. They are +// resolved against environment variables and profiles in PersistentPreRunE. +type rootFlags struct { + configPath string + gatewayURL string + profile string + format string + ascii bool + insecureHTTP bool +} + +// NewRoot builds the command tree. Tests construct it directly so they can +// swap stdout/stderr; main() wraps it in fang for styled help and errors. +func NewRoot() *cobra.Command { + f := &rootFlags{} + root := &cobra.Command{ + Use: "ferro", + Short: "Operator console for the Ferro Labs AI Gateway", + Long: "ferro manages a running Ferro Labs AI Gateway over its HTTP admin API.\n" + + "With no arguments it opens a full-screen operations console; with a verb\n" + + "it runs a scriptable command whose output belongs to your pipeline.", + // Errors go to stderr on their own; the usage wall on every failure + // buries the one line that says what went wrong. + SilenceUsage: true, + RunE: func(cmd *cobra.Command, _ []string) error { + // The full-screen console needs a terminal. On a pipe or a file, + // drawing it would spray escape codes into somebody's stdout, so + // refuse and point at the scriptable surface instead. + if !stdinIsTTY() || !stdoutIsTTY() { + return errors.New("ferro's full-screen console needs terminal input and output; " + + "run `ferro --help` for the scriptable commands") + } + d := deps(cmd) + // tui takes the command tree rather than importing this package: + // root.go calls tui.Run, so the reverse import would be a cycle. + // Passing cmd.Root() keeps the console's verb vocabulary derived + // from the real cobra tree, so the two cannot drift. It always draws + // on stdout, so its colour decision is stdout's TTY state -- unlike + // the Printer's below, which follows stderr, the stream it writes to. + return tui.Run(d.Client, d.Resolved, + theme.Mode{Color: !NoColor(os.Stdout), ASCII: f.ascii}, cmd.Root()) + }, + PersistentPreRunE: func(cmd *cobra.Command, _ []string) error { + // version must work offline, with no config and no credential. + if cmd.Name() == "version" || cmd.Name() == "help" || isCompletion(cmd) { + return nil + } + + // --config outranks FERRO_CONFIG, which outranks the OS default -- + // the same precedence --gateway-url takes over FERRO_URL below. + path := config.DefaultPath() + if v := os.Getenv(config.EnvConfigPath); v != "" { + path = v + } + if f.configPath != "" { + path = f.configPath + } + file, err := config.Load(path) + if err != nil { + return err + } + resolved, err := config.Resolve(file, f.gatewayURL, f.profile, os.Getenv) + if err != nil { + return err + } + + format := Format(f.format) + switch format { + case FormatTable, FormatJSON, FormatYAML: + default: + return fmt.Errorf("unknown --format %q (want table, json, or yaml)", f.format) + } + + clientOpts := []api.Option{api.WithUserAgent("ferro-cli/" + version.Version)} + if f.insecureHTTP { + clientOpts = append(clientOpts, api.WithInsecureHTTP()) + } + client, err := api.New(resolved.URL, resolved.APIKey, clientOpts...) + if err != nil { + return err + } + + d := &runtimeDeps{ + Resolved: resolved, + Printer: &Printer{ + Out: cmd.OutOrStdout(), + Err: cmd.ErrOrStderr(), + Format: format, + // note() (OK/Warn/Fail) always writes to Err, so the colour + // decision follows stderr's own TTY state, not stdout's -- + // `ferro status 2> run.log` must not leak ANSI into the file. + Color: !NoColor(os.Stderr), + ASCII: f.ascii, + }, + Client: client, + } + cmd.SetContext(context.WithValue(cmd.Context(), depsKey{}, d)) + return nil + }, + } + + pf := root.PersistentFlags() + pf.StringVar(&f.configPath, "config", "", "path to the ferro config file (env "+config.EnvConfigPath+")") + pf.StringVar(&f.gatewayURL, "gateway-url", "", "gateway base URL (env FERRO_URL)") + pf.StringVar(&f.profile, "profile", "", "connection profile from the ferro config file") + pf.StringVar(&f.format, "format", "table", "output format: table|json|yaml") + pf.BoolVar(&f.ascii, "ascii", false, "ASCII-only glyphs ([OK] [X] [!] [-])") + pf.BoolVar(&f.insecureHTTP, "insecure-http", false, "allow plaintext HTTP to a non-loopback gateway") + + root.AddCommand( + newVersionCmd(), + newStatusCmd(), + newKeysCmd(), + newLogsCmd(), + newModelsCmd(), + newProvidersCmd(), + newServicesCmd(), + newMCPCmd(), + newPluginsCmd(), + newSessionsCmd(), + newAuditCmd(), + newChatCmd(), + ) + return root +} + +var stdoutIsTTY = func() bool { return isTTY(os.Stdout) } + +// completionVerb is the name cobra gives the generated shell-completion +// command. The hidden helpers a shell actually runs on every Tab +// (__complete, __completeNoDesc) share cobra's own ShellCompRequestCmd as +// their prefix. None of them may load config or resolve a credential. +const completionVerb = "completion" + +func isCompletion(cmd *cobra.Command) bool { + for ; cmd != nil; cmd = cmd.Parent() { + if cmd.Name() == completionVerb || strings.HasPrefix(cmd.Name(), cobra.ShellCompRequestCmd) { + return true + } + } + return false +} + +func newVersionCmd() *cobra.Command { + return &cobra.Command{ + Use: "version", + Short: "Print ferro version, commit, and build date", + RunE: func(cmd *cobra.Command, _ []string) error { + _, _ = fmt.Fprintf(cmd.OutOrStdout(), "ferro %s\n", version.String()) + return nil + }, + } +} diff --git a/internal/command/root_test.go b/internal/command/root_test.go new file mode 100644 index 0000000..5c786a2 --- /dev/null +++ b/internal/command/root_test.go @@ -0,0 +1,217 @@ +package command + +import ( + "bytes" + "io" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/spf13/cobra" +) + +func execute(t *testing.T, args ...string) (stdout, stderr string, err error) { + t.Helper() + root := NewRoot() + var out, errb bytes.Buffer + root.SetOut(&out) + root.SetErr(&errb) + root.SetArgs(args) + err = root.Execute() + return out.String(), errb.String(), err +} + +func TestVersionCommand(t *testing.T) { + stdout, _, err := execute(t, "version") + if err != nil { + t.Fatalf("version: %v", err) + } + if !strings.Contains(stdout, "ferro") || !strings.Contains(stdout, "dev") { + t.Fatalf("want binary name + version on stdout, got %q", stdout) + } +} + +func TestUnknownCommandFails(t *testing.T) { + _, _, err := execute(t, "definitely-not-a-verb") + if err == nil { + t.Fatal("unknown command must error (exit 1)") + } +} + +func TestBareCommandRequiresTerminalInput(t *testing.T) { + oldStdin, oldStdout := stdinIsTTY, stdoutIsTTY + stdinIsTTY = func() bool { return false } + stdoutIsTTY = func() bool { return true } + t.Cleanup(func() { stdinIsTTY, stdoutIsTTY = oldStdin, oldStdout }) + _, _, err := execute(t) + if err == nil || !strings.Contains(err.Error(), "input and output") { + t.Fatalf("bare ferro with redirected stdin must refuse the TUI: %v", err) + } +} + +func TestRootDoesNotAcceptAPIKeyInArguments(t *testing.T) { + if flag := NewRoot().PersistentFlags().Lookup("api-key"); flag != nil { + t.Fatal("bearer credentials must not be accepted through process arguments") + } +} + +func TestCompletionSkipsMalformedConfig(t *testing.T) { + dir := t.TempDir() + t.Setenv("XDG_CONFIG_HOME", dir) + if err := os.MkdirAll(filepath.Join(dir, "ferro"), 0o700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "ferro", "config.yaml"), []byte(": bad: [\n"), 0o600); err != nil { + t.Fatal(err) + } + root := NewRoot() + root.AddCommand(&cobra.Command{Use: "completion", Run: func(*cobra.Command, []string) {}}) + root.SetArgs([]string{"completion"}) + if err := root.Execute(); err != nil { + t.Fatalf("static completion must not parse connection config: %v", err) + } +} + +// The version command must work with no gateway and no credentials, so it +// cannot be gated behind the connection setup every other verb needs. +func TestVersionNeedsNoGateway(t *testing.T) { + t.Setenv("FERRO_URL", "http://127.0.0.1:1") + if _, _, err := execute(t, "version"); err != nil { + t.Fatalf("version must not touch the network: %v", err) + } +} + +// version opts out of connection setup entirely: it must work with no config +// file, no credential, and no reachable gateway. +func TestVersionSkipsConnectionSetup(t *testing.T) { + t.Setenv("FERRO_URL", "http://127.0.0.1:1") + if _, _, err := execute(t, "version", "--format", "xml"); err != nil { + t.Fatalf("version must bypass flag validation and client setup: %v", err) + } +} + +// Connection setup runs for every verb except version. Probed with a stub +// command so this stays a test of the wiring rather than of whichever verb +// happens to exist. +func withProbe(t *testing.T, args ...string) (*runtimeDeps, error) { + t.Helper() + root := NewRoot() + var got *runtimeDeps + root.AddCommand(&cobra.Command{ + Use: "probe", + RunE: func(cmd *cobra.Command, _ []string) error { + got = deps(cmd) + return nil + }, + }) + root.SetOut(io.Discard) + root.SetErr(io.Discard) + root.SetArgs(append([]string{"probe"}, args...)) + // Execute first, then read got. Go orders function calls in a return + // statement left to right, but it does not order a variable read against + // a call beside it — and got is assigned inside this one, by RunE. As + // `return got, root.Execute()` the read may legally happen first, handing + // every caller a nil deps and passing anyway. + err := root.Execute() + return got, err +} + +func TestBadFormatRejectedWithGuidance(t *testing.T) { + _, err := withProbe(t, "--format", "xml") + if err == nil || !strings.Contains(err.Error(), "table") { + t.Fatalf("bad --format must name the valid values, got %v", err) + } +} + +func TestDepsBuiltFromFlagsAndEnv(t *testing.T) { + t.Setenv("FERRO_API_KEY", "fgw_from_env") + d, err := withProbe(t, "--gateway-url", "http://gw.example:9000", "--insecure-http") + if err != nil { + t.Fatal(err) + } + if d == nil { + t.Fatal("every non-version verb must receive runtime deps") + } + if d.Resolved.URL != "http://gw.example:9000" { + t.Fatalf("flag must win for URL, got %q", d.Resolved.URL) + } + if d.Resolved.KeySource != "env:FERRO_API_KEY" { + t.Fatalf("key source: %q", d.Resolved.KeySource) + } + if d.Client == nil || d.Printer == nil { + t.Fatal("deps must carry a client and a printer") + } +} + +func writeConfigFile(t *testing.T, dir, name, profile, url string) string { + t.Helper() + path := filepath.Join(dir, name) + body := "current_profile: " + profile + "\nprofiles:\n - name: " + profile + "\n url: " + url + "\n" + if err := os.WriteFile(path, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + return path +} + +// --config names a config file DefaultPath would never find, so PersistentPreRunE +// must resolve the connection from it rather than from the OS default location. +func TestConfigFlagOverridesDefaultPath(t *testing.T) { + path := writeConfigFile(t, t.TempDir(), "custom.yaml", "from-flag", "https://from-flag:1") + d, err := withProbe(t, "--config", path) + if err != nil { + t.Fatal(err) + } + if d.Resolved.URL != "https://from-flag:1" { + t.Fatalf("--config must load the named file, got %+v", d.Resolved) + } +} + +// FERRO_CONFIG is the env-var override the config package's own doc comment +// promises; without wiring it in, no flag or env var could ever change the +// path config.Load reads, no matter what the comment said. +func TestFerroConfigEnvOverridesDefaultPath(t *testing.T) { + path := writeConfigFile(t, t.TempDir(), "env.yaml", "from-env", "https://from-env:2") + t.Setenv("FERRO_CONFIG", path) + d, err := withProbe(t) + if err != nil { + t.Fatal(err) + } + if d.Resolved.URL != "https://from-env:2" { + t.Fatalf("FERRO_CONFIG must override the default path, got %+v", d.Resolved) + } +} + +func TestConfigFlagBeatsFerroConfigEnv(t *testing.T) { + dir := t.TempDir() + envPath := writeConfigFile(t, dir, "env.yaml", "from-env", "https://from-env:1") + flagPath := writeConfigFile(t, dir, "flag.yaml", "from-flag", "https://from-flag:2") + t.Setenv("FERRO_CONFIG", envPath) + d, err := withProbe(t, "--config", flagPath) + if err != nil { + t.Fatal(err) + } + if d.Resolved.URL != "https://from-flag:2" { + t.Fatalf("--config must win over FERRO_CONFIG, got %+v", d.Resolved) + } +} + +// Regression for the Printer's colour decision being taken from stdout while +// its narrative (OK/Warn/Fail) is always written to stderr: with a terminal +// stdout and a redirected stderr -- `ferro status 2> run.log` -- the old +// stdout-only check would turn colour on and leak ANSI escapes into the file. +// The decision must follow the stream the Printer actually writes to. +func TestPrinterColorFollowsStderrNotStdout(t *testing.T) { + oldIsTTY := isTTY + // stdout is a terminal; stderr is not -- the shape `2> run.log` takes. + isTTY = func(f *os.File) bool { return f == os.Stdout } + t.Cleanup(func() { isTTY = oldIsTTY }) + + d, err := withProbe(t) + if err != nil { + t.Fatal(err) + } + if d.Printer.Color { + t.Fatal("colour must follow stderr's terminal state, not stdout's") + } +} diff --git a/internal/command/services.go b/internal/command/services.go new file mode 100644 index 0000000..b36f6b9 --- /dev/null +++ b/internal/command/services.go @@ -0,0 +1,305 @@ +package command + +import ( + "fmt" + "slices" + "strings" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +// auditOutcomes is the gateway's whole vocabulary for ?outcome=. Anything else +// is a 400 there, so it is refused here before a request is spent. +var auditOutcomes = []string{"ok", "denied", "error"} + +// The four services `ferro services` summarises, one row each. Each is named +// once so the row a reachable service produces and the row its absence produces +// cannot end up calling the same service two different things. +const ( + svcMCP = "MCP servers" + svcPlugins = "Plugins" + svcSessions = "Sessions" + svcAudit = "Audit" +) + +// stateUnsupported is the state a service row carries when this gateway does +// not serve that feature at all — a 501 rather than a count of zero, which +// would claim the feature is present and empty. +const stateUnsupported = "unsupported" + +type serviceSummary struct { + Name string `json:"name"` + State string `json:"state"` +} + +func newServicesCmd() *cobra.Command { + return &cobra.Command{ + Use: "services", + Short: "MCP, plugin, session, and audit service summary", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + rows := make([]serviceSummary, 0, 4) + + servers, err := mcpServers(cmd) + switch { + case api.IsNotSupported(err): + rows = append(rows, serviceSummary{Name: svcMCP, State: stateUnsupported}) + case err != nil: + return err + default: + ready := 0 + for _, s := range servers { + if s.Ready { + ready++ + } + } + rows = append(rows, serviceSummary{ + Name: svcMCP, + State: fmt.Sprintf("%d/%d ready", ready, len(servers)), + }) + } + + plugins, err := d.Client.Plugins(cmd.Context()) + switch { + case api.IsNotSupported(err): + rows = append(rows, serviceSummary{Name: svcPlugins, State: stateUnsupported}) + case err != nil: + return err + default: + active := 0 + for _, p := range plugins { + if p.Enabled { + active++ + } + } + rows = append(rows, serviceSummary{Name: svcPlugins, State: fmt.Sprintf("%d active", active)}) + } + + sessions, err := d.Client.Sessions(cmd.Context()) + switch { + case api.IsNotSupported(err): + rows = append(rows, serviceSummary{Name: svcSessions, State: stateUnsupported}) + case err != nil: + return err + default: + rows = append(rows, serviceSummary{Name: svcSessions, State: fmt.Sprintf("%d operators", len(sessions))}) + } + + audit, err := d.Client.Audit(cmd.Context(), api.AuditQuery{Limit: 1}) + switch { + case api.IsNotSupported(err): + rows = append(rows, serviceSummary{Name: svcAudit, State: stateUnsupported}) + case err != nil: + return err + default: + rows = append(rows, serviceSummary{Name: svcAudit, State: fmt.Sprintf("%d events", audit.Summary.TotalEntries)}) + } + + if d.Printer.Format != FormatTable { + return d.printStructured(rows) + } + cells := make([][]string, 0, len(rows)) + for _, row := range rows { + cells = append(cells, []string{row.Name, row.State}) + } + d.Printer.Table([]string{"SERVICE", colState}, cells) + return nil + }, + } +} + +func newMCPCmd() *cobra.Command { + return &cobra.Command{ + Use: "mcp", + Short: "MCP tool servers and their readiness", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + // /admin/health is the richer source: it alone carries last_error, + // which /readyz withholds because it is unauthenticated and the + // reason can quote a server URL or a token. + servers, err := mcpServers(cmd) + if err != nil { + return err + } + if d.Printer.Format != FormatTable { + return d.printStructured(servers) + } + if len(servers) == 0 { + d.Printer.Warn("this gateway has no MCP servers configured") + } + rows := make([][]string, 0, len(servers)) + for _, s := range servers { + rows = append(rows, []string{s.Name, table.BoolYN(s.Ready), table.BoolYN(s.Required), table.OrDash(s.LastError)}) + } + d.Printer.Table([]string{colName, "READY", "REQUIRED", "LAST ERROR"}, rows) + return nil + }, + } +} + +func mcpServers(cmd *cobra.Command) ([]api.MCPServer, error) { + d := deps(cmd) + ah, err := d.Client.AdminHealth(cmd.Context()) + if err == nil { + return ah.MCPServers, nil + } + d.Printer.Warn("admin health unavailable (%v) — falling back to /readyz, which withholds last_error", err) + ready, _, err := d.Client.Ready(cmd.Context()) + if err != nil { + return nil, err + } + return ready.MCPServers, nil +} + +// pluginRow merges the two listings: /admin/plugins says what this gateway has +// configured, /admin/plugins/catalog says what this build ships — and only the +// catalog knows whether a plugin fails open. +type pluginRow struct { + Name string `json:"name"` + Type string `json:"type"` + Enabled bool `json:"enabled"` + Fails string `json:"fails"` + Summary string `json:"summary,omitempty"` +} + +func mergePlugins(configured []api.PluginInfo, catalog []api.BuiltinPlugin) []pluginRow { + shipped := table.NewPluginCatalog(catalog) + rows := make([]pluginRow, 0, len(configured)) + for _, p := range configured { + policy := shipped.For(p.Name) + rows = append(rows, pluginRow{ + Name: p.Name, Type: p.Type, Enabled: p.Enabled, + Fails: policy.Fails, Summary: policy.Summary, + }) + } + return rows +} + +func newPluginsCmd() *cobra.Command { + return &cobra.Command{ + Use: "plugins", + Short: "Configured plugins, merged with this build's catalog", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + configured, err := d.Client.Plugins(cmd.Context()) + if err != nil { + return err + } + catalog, err := d.Client.PluginCatalog(cmd.Context()) + if err != nil { + // A build without the catalog route still lists what it runs; + // it just cannot say what fails open. + if !api.IsNotSupported(err) { + return err + } + d.Printer.Warn("this gateway serves no plugin catalog — fail-open policy and summaries are unavailable") + catalog = nil + } + rows := mergePlugins(configured, catalog) + if d.Printer.Format != FormatTable { + return d.printStructured(rows) + } + cells := make([][]string, 0, len(rows)) + for _, r := range rows { + cells = append(cells, []string{r.Name, r.Type, table.BoolYN(r.Enabled), r.Fails, table.OrDash(r.Summary)}) + } + d.Printer.Table([]string{colName, "TYPE", "ENABLED", "FAILS", "SUMMARY"}, cells) + return nil + }, + } +} + +func newSessionsCmd() *cobra.Command { + return &cobra.Command{ + Use: "sessions", + Short: "Active dashboard sessions", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + sessions, err := d.Client.Sessions(cmd.Context()) + if err != nil { + if api.IsNotSupported(err) { + return fmt.Errorf("dashboard sessions are not enabled on this gateway, so there are none to list: %w", err) + } + return err + } + if d.Printer.Format != FormatTable { + return d.printStructured(sessions) + } + rows := make([][]string, 0, len(sessions)) + for _, s := range sessions { + rows = append(rows, []string{ + s.Subject, strings.Join(s.Scopes, ","), + table.FmtTime(s.CreatedAt), table.FmtTimePtr(s.LastSeenAt), table.FmtTime(s.ExpiresAt), + }) + } + d.Printer.Table([]string{"SUBJECT", colScopes, "CREATED", "LAST SEEN", colExpires}, rows) + return nil + }, + } +} + +func newAuditCmd() *cobra.Command { + audit := &cobra.Command{ + Use: "audit", + Short: "Read the credential and configuration audit trail", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + q, err := auditQueryFromFlags(cmd) + if err != nil { + return err + } + page, err := d.Client.Audit(cmd.Context(), q) + if err != nil { + return err + } + if d.Printer.Format != FormatTable { + return d.printStructured(page) + } + rows := make([][]string, 0, len(page.Data)) + for _, e := range page.Data { + rows = append(rows, []string{ + table.FmtTime(e.OccurredAt), e.Action, table.OrDash(e.Actor), e.Outcome, table.OrDash(e.TargetID), + }) + } + d.Printer.Table([]string{colTime, "ACTION", "ACTOR", "OUTCOME", "TARGET"}, rows) + return nil + }, + } + f := audit.Flags() + f.String("action", "", "only this action (key.create, session.create, …)") + f.String("actor", "", "only this actor's credential id") + f.String("outcome", "", "ok|denied|error") + f.String("since", "", "duration (15m, 2h) or an RFC3339 timestamp") + f.Int("limit", 50, "rows to return (gateway caps at 200)") + return audit +} + +func auditQueryFromFlags(cmd *cobra.Command) (api.AuditQuery, error) { + f := cmd.Flags() + q := api.AuditQuery{} + q.Action, _ = f.GetString("action") + q.ActorID, _ = f.GetString("actor") + q.Outcome, _ = f.GetString("outcome") + q.Limit, _ = f.GetInt("limit") + + if q.Outcome != "" && !slices.Contains(auditOutcomes, q.Outcome) { + return q, fmt.Errorf("outcome %q is not valid: --outcome must be one of %s, and the gateway answers 400 to anything else", + q.Outcome, strings.Join(auditOutcomes, ", ")) + } + if since, _ := f.GetString("since"); since != "" { + t, err := api.ParseSince(since) + if err != nil { + return q, err + } + q.Since = t + } + return q, nil +} diff --git a/internal/command/services_test.go b/internal/command/services_test.go new file mode 100644 index 0000000..78d4704 --- /dev/null +++ b/internal/command/services_test.go @@ -0,0 +1,365 @@ +package command + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +func TestModelsTable(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "models") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", "STATUS"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + if !strings.Contains(stdout, "claude-sonnet-4-6") || !strings.Contains(stdout, "anthropic") { + t.Fatalf("model rows missing: %q", stdout) + } +} + +func TestModelsJSONIsOneDocument(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "models", "--format", "json") + if err != nil { + t.Fatal(err) + } + var rows []map[string]any + if err := decodeOne(stdout, &rows); err != nil { + t.Fatalf("stdout must be one JSON document: %v (%q)", err, stdout) + } + if len(rows) == 0 { + t.Fatalf("expected models: %q", stdout) + } +} + +func TestProvidersMergesCircuitFromHealth(t *testing.T) { + s := fixture.Default() + s.Degraded = true + srv := gateway(t, s) + + stdout, _, err := run(t, srv, "providers") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"PROVIDER", "STATUS", "CIRCUIT", "MODELS", "MESSAGE"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + // Circuit comes from /health, status/models/message from /admin/health: + // neither endpoint alone can fill this table. + if !strings.Contains(stdout, "half_open") { + t.Fatalf("circuit must come from /health: %q", stdout) + } + if !strings.Contains(stdout, "circuit half_open after") { + t.Fatalf("message must come from /admin/health: %q", stdout) + } +} + +// Unauthenticated is a smaller answer, not an error: /health alone still names +// every provider and its circuit. +func TestMergeProvidersFallsBackToHealthAlone(t *testing.T) { + h := &api.HealthReport{Providers: []api.ProviderHealth{ + {Name: "anthropic", Status: "available", Circuit: "open", Models: 412}, + }} + rows := mergeProviders(h, nil) + if len(rows) != 1 || rows[0].Circuit != "open" || rows[0].Models != 412 { + t.Fatalf("health-only fallback lost data: %+v", rows) + } + if rows[0].Message != "" { + t.Fatalf("there is no message without /admin/health: %+v", rows) + } +} + +func TestMergeProvidersKeepsHealthOnlyRowsAndNumericCounts(t *testing.T) { + h := &api.HealthReport{Providers: []api.ProviderHealth{ + {Name: "openai", Status: "available", Circuit: "closed", Models: 10}, + {Name: "fallback", Status: "available", Circuit: "open", Models: 2}, + }} + ah := &api.AdminHealth{Providers: []api.AdminProviderHealth{{Name: "openai", Status: "healthy", Models: 10}}} + rows := mergeProviders(h, ah) + if len(rows) != 2 || rows[1].Name != "fallback" || rows[1].Models != 2 { + t.Fatalf("admin health omissions must not hide /health providers: %+v", rows) + } + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "providers", "--format", "json") + if err != nil { + t.Fatal(err) + } + var doc []map[string]any + if err := decodeOne(stdout, &doc); err != nil { + t.Fatal(err) + } + if len(doc) == 0 { + t.Fatal("expected provider rows") + } + if _, ok := doc[0]["models"].(float64); !ok { + t.Fatalf("models must be a JSON number, got %T (%v)", doc[0]["models"], doc[0]["models"]) + } +} + +func TestPluginsMergeShowsFailsOpenFromCatalog(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "plugins") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"NAME", "TYPE", "ENABLED", "FAILS", "SUMMARY"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + // fails_open lives only in the catalog, so its presence proves the merge. + if !strings.Contains(stdout, "open") || !strings.Contains(stdout, "closed") { + t.Fatalf("FAILS column must be merged from the catalog: %q", stdout) + } + if !strings.Contains(stdout, "Records one row per request stage") { + t.Fatalf("SUMMARY must be merged from the catalog: %q", stdout) + } +} + +// A plugin the build does not ship (registered out of tree) still lists, with +// the catalog-only columns blank rather than guessed. +func TestMergePluginsKeepsUncatalogedPlugins(t *testing.T) { + rows := mergePlugins( + []api.PluginInfo{{Name: "vendor-thing", Type: "guardrail", Enabled: true}}, + []api.BuiltinPlugin{{Name: "budget", Type: "guardrail", FailsOpen: false}}, + ) + if len(rows) != 1 || rows[0].Name != "vendor-thing" { + t.Fatalf("configured plugins drive the listing: %+v", rows) + } + if rows[0].Fails != "-" || rows[0].Summary != "" { + t.Fatalf("unknown fail policy must not be guessed: %+v", rows) + } +} + +func TestMCPTable(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "mcp") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"NAME", "READY", "REQUIRED", "LAST ERROR"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + if !strings.Contains(stdout, "filesystem") { + t.Fatalf("mcp rows missing: %q", stdout) + } +} + +func TestServicesAggregateIsReachable(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "services") + if err != nil { + t.Fatal(err) + } + for _, service := range []string{"MCP servers", "Plugins", "Sessions", "Audit"} { + if !strings.Contains(stdout, service) { + t.Fatalf("services output missing %q: %s", service, stdout) + } + } +} + +func TestServicesMarksUnsupportedComponentWithoutDroppingOthers(t *testing.T) { + s := fixture.Default() + s.NoSessions = true + srv := gateway(t, s) + stdout, _, err := run(t, srv, "services", "--format", "json") + if err != nil { + t.Fatal(err) + } + var rows []serviceSummary + if err := decodeOne(stdout, &rows); err != nil { + t.Fatalf("stdout must be one JSON document: %v (%q)", err, stdout) + } + if len(rows) != 4 { + t.Fatalf("one unsupported component must not hide the others: %+v", rows) + } + for _, row := range rows { + if row.Name == "Sessions" && row.State != "unsupported" { + t.Fatalf("unsupported sessions must not be reported as a healthy zero: %+v", rows) + } + } +} + +// /admin/health carries last_error but needs a credential; /readyz carries the +// same servers unauthenticated. A bad key degrades to the smaller answer. +func TestMCPFallsBackToReadyzWithoutCredential(t *testing.T) { + srv := gateway(t, fixture.Default()) + t.Setenv("FERRO_API_KEY", "fgw_wrong") + stdout, stderr, err := execute(t, "mcp", "--gateway-url", srv.URL) + if err != nil { + t.Fatalf("an unauthorized caller still gets the readyz view: %v", err) + } + if !strings.Contains(stdout, "filesystem") { + t.Fatalf("fallback lost the rows: %q", stdout) + } + if !strings.Contains(stderr, "readyz") { + t.Fatalf("the degraded source must be stated on stderr: %q", stderr) + } +} + +func TestSessionsTable(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "sessions") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"SUBJECT", "SCOPES", "CREATED", "LAST SEEN", "EXPIRES"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + if !strings.Contains(stdout, "ops-laptop") { + t.Fatalf("session rows missing: %q", stdout) + } + // ci-pipeline has never been seen. Only its LAST SEEN cell may be a dash: + // a "-" anywhere in the table would also be satisfied by a zero-time + // 0001-01-01 in that cell, or by every cell collapsing to a dash. + var row string + for _, l := range strings.Split(stdout, "\n") { + if strings.Contains(l, "ci-pipeline") { + row = l + } + } + if row == "" { + t.Fatalf("expected the seeded ci-pipeline session row: %q", stdout) + } + // SUBJECT SCOPES CREATED LAST-SEEN EXPIRES — every cell is whitespace-free, + // so the table still splits into fields for anything piping it. + fields := strings.Fields(row) + if len(fields) != 5 { + t.Fatalf("want 5 whitespace-free columns, got %d in %q", len(fields), row) + } + if fields[3] != "-" { + t.Fatalf("a null last_seen_at must render as -, got %q in %q", fields[3], row) + } + if fields[2] == "-" || fields[4] == "-" { + t.Fatalf("created_at and expires_at are set on this session and must render as dates: %q", row) + } +} + +func TestSessionsDisabledDegradesWithAHint(t *testing.T) { + s := fixture.Default() + s.NoSessions = true + srv := gateway(t, s) + + _, _, err := run(t, srv, "sessions") + if err == nil || !strings.Contains(err.Error(), "sessions") { + t.Fatalf("a 501 must be reported as a disabled feature: %v", err) + } + if strings.Contains(err.Error(), "501") && !strings.Contains(err.Error(), "not enabled") { + t.Fatalf("the hint must lead, not the status code: %v", err) + } +} + +func TestAuditTableAndFilters(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "audit", "--outcome", "ok", "--limit", "10") + if err != nil { + t.Fatal(err) + } + for _, col := range []string{"TIME", "ACTION", "ACTOR", "OUTCOME", "TARGET"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + if !strings.Contains(stdout, "key.create") { + t.Fatalf("audit rows missing: %q", stdout) + } +} + +// The gateway answers 400 for an outcome outside its vocabulary. Refusing it +// here spends no request and gives the same vocabulary back. +func TestAuditRejectsBadOutcomeClientSide(t *testing.T) { + _, _, err := execute(t, "audit", "--outcome", "bogus", "--gateway-url", "http://127.0.0.1:1") + if err == nil || !strings.Contains(err.Error(), "denied") { + t.Fatalf("--outcome must be validated client-side against ok|denied|error: %v", err) + } +} + +// A dash is a rendering of absence, not a value the gateway sent. Every field +// of providerRow must therefore stay literal in --format json, and be dashed +// only where the table is drawn. circuit briefly broke that rule on its own, +// so one document carried "-" for an absent circuit beside an empty string +// for an absent status — two conventions in one object. +func TestProvidersJSONKeepsAbsenceLiteral(t *testing.T) { + h := &api.HealthReport{Providers: []api.ProviderHealth{ + {Name: "anthropic", Status: "available", Models: 412}, // no circuit reported + }} + rows := mergeProviders(h, nil) + if len(rows) != 1 { + t.Fatalf("want one row, got %d", len(rows)) + } + if rows[0].Circuit != "" { + t.Fatalf("an absent circuit stays empty in the structured row, got %q", rows[0].Circuit) + } + + body, err := json.Marshal(rows[0]) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(body), `"-"`) { + t.Fatalf("no field may serialize a table dash: %s", body) + } + if !strings.Contains(string(body), `"circuit":""`) { + t.Fatalf("circuit must serialize as the empty string it is: %s", body) + } +} + +// "No admin credential accepted" is a specific claim. A gateway that times out +// or 500s on /admin/health costs the same two columns, but says so — telling +// the operator to check a credential that was never the problem is a wrong +// answer, and the one they would act on first. +func TestProvidersNamesWhyAdminHealthWasUnavailable(t *testing.T) { + for _, tc := range []struct { + name string + status int + body string + want string + absent string + }{ + {"refused credential", http.StatusUnauthorized, `{"error":{"message":"nope"}}`, + "no admin credential accepted", "admin health unavailable"}, + {"broken gateway", http.StatusInternalServerError, `{"error":{"message":"boom"}}`, + "admin health unavailable", "no admin credential accepted"}, + } { + t.Run(tc.name, func(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"status":"ok","providers":[{"name":"openai","status":"available","circuit":"closed","models":3}]}`)) + }) + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(tc.status) + _, _ = w.Write([]byte(tc.body)) + }) + srv := httptest.NewServer(mux) + defer srv.Close() + + _, stderr, err := run(t, srv, "providers") + if err != nil { + t.Fatalf("an unusable admin probe costs columns, not the command: %v", err) + } + if !strings.Contains(stderr, tc.want) { + t.Fatalf("want %q in the warning, got %q", tc.want, stderr) + } + if strings.Contains(stderr, tc.absent) { + t.Fatalf("must not claim %q for a %d, got %q", tc.absent, tc.status, stderr) + } + }) + } +} diff --git a/internal/command/status.go b/internal/command/status.go new file mode 100644 index 0000000..0cb9c18 --- /dev/null +++ b/internal/command/status.go @@ -0,0 +1,64 @@ +package command + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/table" +) + +func newStatusCmd() *cobra.Command { + return &cobra.Command{ + Use: "status", + Short: "Health of a running gateway (exit 1 only when unreachable)", + Long: "status prints one row describing the gateway this profile points at.\n\n" + + "The exit code is the contract: 1 means the gateway could not be reached\n" + + "at all, so `ferro status || alert` pages on an outage and stays quiet for\n" + + "a degraded-but-serving gateway, which exits 0 with its state printed.", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + d := deps(cmd) + // Status returns a report even when it fails, naming the URL and the + // state it reached — printing it is what makes state:"unreachable" + // visible to a `--format json` consumer instead of an empty stdout. + report, statusErr := d.Client.Status(cmd.Context()) + + if d.Printer.Format != FormatTable { + if err := d.printStructured(report); err != nil { + return err + } + } else { + mcp := "-" + if report.MCP != nil { + mcp = fmt.Sprintf("%d/%d", report.MCP.Ready, report.MCP.Total) + } + // A not_ready gateway reports no targets array at all. Rendering + // "0/0" there would read as "none configured" when the truth is + // "yours are dead" — the warnings below carry the real reason. + targets := "-" + if report.Targets != nil { + targets = fmt.Sprintf("%d/%d", report.Targets.Routable, report.Targets.Total) + } + d.Printer.Table( + []string{colState, colURL, "LATENCY", "TARGETS", "PROVIDERS", colModels, "MCP", "AUTH"}, + [][]string{{ + report.State, + report.URL, + fmt.Sprintf("%dms", report.LatencyMs), + targets, + table.CountOrDash(report.Providers), + table.CountOrDash(report.Models), + mcp, + table.OrDash(report.Auth), + }}, + ) + } + for _, w := range report.Warnings { + d.Printer.Warn("%s", w) + } + // Degraded stays exit 0; only an unreachable gateway is exit 1. + return statusErr + }, + } +} diff --git a/internal/command/status_test.go b/internal/command/status_test.go new file mode 100644 index 0000000..5eb7e13 --- /dev/null +++ b/internal/command/status_test.go @@ -0,0 +1,137 @@ +package command + +import ( + "encoding/json" + "errors" + "io" + "net/http/httptest" + "strings" + "testing" + + "github.com/ferro-labs/gateway-cli/internal/fixture" +) + +// gateway starts the one in-repo definition of the wire contract. Every command +// test talks to it instead of a hand-rolled stub, so a fixture that drifts from +// the gateway fails these tests rather than quietly blessing the drift. +func gateway(t *testing.T, s fixture.State) *httptest.Server { + t.Helper() + srv := httptest.NewServer(fixture.Handler(s)) + t.Cleanup(srv.Close) + return srv +} + +// run executes a verb against srv with the fixture's credential. +func run(t *testing.T, srv *httptest.Server, args ...string) (stdout, stderr string, err error) { + t.Helper() + t.Setenv("FERRO_API_KEY", "fgw_test") + return execute(t, append(args, "--gateway-url", srv.URL)...) +} + +// decodeOne decodes stdout into v and fails if a second document follows: the +// stdout-is-the-machine-channel rule means exactly one payload, never a payload +// with narrative wrapped around it. +func decodeOne(stdout string, v any) error { + dec := json.NewDecoder(strings.NewReader(stdout)) + if err := dec.Decode(v); err != nil { + return err + } + var extra any + if err := dec.Decode(&extra); !errors.Is(err, io.EOF) { + if err != nil { + return err + } + return errMoreThanOneDoc + } + return nil +} + +var errMoreThanOneDoc = errors.New("stdout carried more than one JSON document") + +// oneJSONDoc asserts stdout is exactly one JSON document — the whole point of +// keeping narrative on stderr. +func oneJSONDoc(t *testing.T, stdout string) map[string]any { + t.Helper() + var doc map[string]any + if err := decodeOne(stdout, &doc); err != nil { + t.Fatalf("stdout must be one JSON document, got %q: %v", stdout, err) + } + return doc +} + +func TestStatusTableExitAndColumns(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "status") + if err != nil { + t.Fatalf("healthy status must exit 0: %v", err) + } + for _, col := range []string{"STATE", "URL", "LATENCY", "TARGETS", "PROVIDERS", "MODELS", "MCP", "AUTH"} { + if !strings.Contains(stdout, col) { + t.Fatalf("missing column %s in %q", col, stdout) + } + } + if !strings.Contains(stdout, "connected") { + t.Fatalf("healthy gateway must report connected: %q", stdout) + } +} + +func TestStatusJSONIsPureAndStable(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "status", "--format", "json") + if err != nil { + t.Fatal(err) + } + doc := oneJSONDoc(t, stdout) + for _, k := range []string{"state", "url", "latency_ms", "targets", "circuits"} { + if _, ok := doc[k]; !ok { + t.Fatalf("frozen status contract missing %q: %v", k, doc) + } + } +} + +// Degraded is not a failure: `ferro status || alert` must mean "unreachable", +// so a half-open circuit still exits 0 with the degraded state on stdout. +func TestStatusDegradedExits0AndWarnsOnStderr(t *testing.T) { + s := fixture.Default() + s.Degraded = true + srv := gateway(t, s) + + stdout, stderr, err := run(t, srv, "status") + if err != nil { + t.Fatalf("degraded must still exit 0: %v", err) + } + if !strings.Contains(stdout, "degraded") { + t.Fatalf("degraded state must be printed: %q", stdout) + } + if !strings.Contains(stderr, "half-open") { + t.Fatalf("warnings belong on stderr, got %q", stderr) + } + if strings.Contains(stdout, "half-open") { + t.Fatalf("narrative leaked into stdout: %q", stdout) + } +} + +func TestStatusUnreachableExits1ButStillReportsState(t *testing.T) { + stdout, _, err := execute(t, "status", "--gateway-url", "http://127.0.0.1:1", "--format", "json") + if err == nil { + t.Fatal("unreachable must exit 1") + } + doc := oneJSONDoc(t, stdout) + if doc["state"] != "unreachable" { + t.Fatalf("the report must still name the state that was reached: %v", doc) + } +} + +// A gateway reachable without a usable credential is still reachable: the +// report degrades to what /health and /readyz say rather than failing. +func TestStatusWithoutCredentialDegradesNotFails(t *testing.T) { + srv := gateway(t, fixture.Default()) + t.Setenv("FERRO_API_KEY", "fgw_wrong") + stdout, _, err := execute(t, "status", "--gateway-url", srv.URL) + if err != nil { + t.Fatalf("a bad credential must not make status exit 1: %v", err) + } + if !strings.Contains(stdout, "unauthorized") { + t.Fatalf("auth column must report unauthorized: %q", stdout) + } +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 0000000..8b5f248 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,150 @@ +// Package config resolves where ferro connects and with which credential. +// Precedence — path: --config > FERRO_CONFIG > DefaultPath() +// +// URL: --gateway-url > FERRO_URL > profile.url > http://localhost:8080 +// key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY > "" +// +// ferro stores no gateway data; this file holds connection profiles only. +package config + +import ( + "fmt" + "os" + "path/filepath" + "sort" + "strings" + + "go.yaml.in/yaml/v3" +) + +// DefaultURL is where ferro looks when nothing else says otherwise. +const DefaultURL = "http://localhost:8080" + +// The environment variables Resolve reads, and the KeySource label it reports +// for each source. Building the labels from the variable names is what keeps +// the two spellings from drifting: a doctor screen naming a variable nothing +// reads is worse than no label at all. +const ( + envURL = "FERRO_URL" + envFerroKey = "FERRO_API_KEY" + envMasterKey = "MASTER_KEY" + + keySourceFerroEnv = "env:" + envFerroKey + keySourceMasterEnv = "env:" + envMasterKey + keySourceProfile = "profile:" +) + +// Profile is one named connection. It holds no credential: api_key_env names +// an environment variable, so the config file never carries a secret. +type Profile struct { + Name string `yaml:"name"` + URL string `yaml:"url"` + APIKeyEnv string `yaml:"api_key_env,omitempty"` +} + +// File is the on-disk ferro config: connection profiles and nothing else. +type File struct { + CurrentProfile string `yaml:"current_profile,omitempty"` + Profiles []Profile `yaml:"profiles,omitempty"` +} + +// Resolved is what the rest of ferro consumes. KeySource is for doctor-style +// display ("env:FERRO_API_KEY", "profile:PROD_KEY", "env:MASTER_KEY"). +type Resolved struct { + ProfileName string + URL string + APIKey string + KeySource string +} + +// EnvConfigPath is the environment variable that overrides DefaultPath. +// --config on the CLI outranks it in turn (see the precedence note above). A +// config path names a filesystem location, never a credential, so unlike +// FERRO_API_KEY it carries nothing that must not appear in a shell history. +const EnvConfigPath = "FERRO_CONFIG" + +// DefaultPath is the config location, empty when the OS reports no config dir. +func DefaultPath() string { + dir, err := os.UserConfigDir() + if err != nil { + return "" + } + return filepath.Join(dir, "ferro", "config.yaml") +} + +// Load reads the config file. A missing file is not an error -- ferro works +// with flags and environment alone. +func Load(path string) (File, error) { + var f File + if path == "" { + return f, nil + } + // Normalise before use so the file that is read and the file a parse error + // names are spelled the same way, whatever lexical noise (`a/../b`, a + // trailing slash) the flag or FERRO_CONFIG carried. + clean := filepath.Clean(path) + b, err := os.ReadFile(clean) + if os.IsNotExist(err) { + return f, nil + } + if err != nil { + return f, err + } + if err := yaml.Unmarshal(b, &f); err != nil { + return f, fmt.Errorf("parse %s: %w", clean, err) + } + return f, nil +} + +// Resolve applies the precedence documented on this package to produce the +// connection ferro will use. +func Resolve(f File, flagURL, flagProfile string, getenv func(string) string) (Resolved, error) { + r := Resolved{URL: DefaultURL} + + name := flagProfile + if name == "" { + name = f.CurrentProfile + } + var prof *Profile + if name != "" { + for i := range f.Profiles { + if f.Profiles[i].Name == name { + prof = &f.Profiles[i] + break + } + } + if prof == nil { + names := make([]string, 0, len(f.Profiles)) + for _, p := range f.Profiles { + names = append(names, p.Name) + } + sort.Strings(names) + if len(names) == 0 { + return r, fmt.Errorf("unknown profile %q (no profiles are defined)", name) + } + return r, fmt.Errorf("unknown profile %q (valid: %s)", name, strings.Join(names, ", ")) + } + } + if prof != nil { + r.ProfileName = prof.Name + if prof.URL != "" { + r.URL = prof.URL + } + } + if v := getenv(envURL); v != "" { + r.URL = v + } + if flagURL != "" { + r.URL = flagURL + } + + switch { + case getenv(envFerroKey) != "": + r.APIKey, r.KeySource = getenv(envFerroKey), keySourceFerroEnv + case prof != nil && prof.APIKeyEnv != "" && getenv(prof.APIKeyEnv) != "": + r.APIKey, r.KeySource = getenv(prof.APIKeyEnv), keySourceProfile+prof.APIKeyEnv + case getenv(envMasterKey) != "": + r.APIKey, r.KeySource = getenv(envMasterKey), keySourceMasterEnv + } + return r, nil +} diff --git a/internal/config/config_test.go b/internal/config/config_test.go new file mode 100644 index 0000000..32669ac --- /dev/null +++ b/internal/config/config_test.go @@ -0,0 +1,97 @@ +package config + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func env(m map[string]string) func(string) string { + return func(k string) string { return m[k] } +} + +func TestResolvePrecedence(t *testing.T) { + file := File{ + CurrentProfile: "prod", + Profiles: []Profile{ + {Name: "prod", URL: "https://gw.example.com", APIKeyEnv: "PROD_KEY"}, + {Name: "local", URL: "http://localhost:9999"}, + }, + } + cases := []struct { + name string + flagURL string + flagProfile string + envv map[string]string + wantURL, wantKey string + wantSource string + }{ + {name: "URL flag and key environment beat profile", flagURL: "http://flag:1", + envv: map[string]string{"FERRO_URL": "http://env:1", "FERRO_API_KEY": "fgw_env"}, + wantURL: "http://flag:1", wantKey: "fgw_env", wantSource: "env:FERRO_API_KEY"}, + {name: "env beats profile", + envv: map[string]string{"FERRO_URL": "http://env:1", "FERRO_API_KEY": "fgw_env", "PROD_KEY": "fgw_prod"}, + wantURL: "http://env:1", wantKey: "fgw_env", wantSource: "env:FERRO_API_KEY"}, + {name: "profile url + key env deref", + envv: map[string]string{"PROD_KEY": "fgw_prod"}, + wantURL: "https://gw.example.com", wantKey: "fgw_prod", wantSource: "profile:PROD_KEY"}, + {name: "MASTER_KEY is the last key fallback", + flagProfile: "local", envv: map[string]string{"MASTER_KEY": "fgw_master"}, + wantURL: "http://localhost:9999", wantKey: "fgw_master", wantSource: "env:MASTER_KEY"}, + {name: "defaults", flagProfile: "none-selected", envv: map[string]string{}, + flagURL: "", wantURL: "http://localhost:8080", wantKey: "", wantSource: ""}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + f := file + if tc.flagProfile == "none-selected" { + f = File{} // no profiles at all + tc.flagProfile = "" + } + r, err := Resolve(f, tc.flagURL, tc.flagProfile, env(tc.envv)) + if err != nil { + t.Fatal(err) + } + if r.URL != tc.wantURL || r.APIKey != tc.wantKey || r.KeySource != tc.wantSource { + t.Fatalf("got url=%q key=%q src=%q", r.URL, r.APIKey, r.KeySource) + } + }) + } +} + +func TestResolveUnknownProfileErrors(t *testing.T) { + _, err := Resolve(File{Profiles: []Profile{{Name: "a"}}}, "", "nope", env(nil)) + if err == nil { + t.Fatal("unknown --profile must error and list valid names") + } +} + +func TestResolveStaleCurrentProfileErrors(t *testing.T) { + _, err := Resolve(File{CurrentProfile: "removed", Profiles: []Profile{{Name: "prod"}}}, "", "", env(nil)) + if err == nil || !strings.Contains(err.Error(), `unknown profile "removed"`) { + t.Fatalf("a stale current_profile must not silently connect to localhost: %v", err) + } + _, err = Resolve(File{CurrentProfile: "removed"}, "", "", env(nil)) + if err == nil || !strings.Contains(err.Error(), "no profiles are defined") { + t.Fatalf("an empty profile list needs a clear error: %v", err) + } +} + +func TestLoadMissingFileIsZero(t *testing.T) { + f, err := Load("/definitely/not/here.yaml") + if err != nil || len(f.Profiles) != 0 { + t.Fatalf("missing file must be zero value, got %+v, %v", f, err) + } +} + +func TestLoadMalformedYAMLNamesTheFile(t *testing.T) { + path := filepath.Join(t.TempDir(), "config.yaml") + if err := os.WriteFile(path, []byte("profiles: [\n"), 0o600); err != nil { + t.Fatal(err) + } + _, err := Load(path) + if err == nil || !strings.Contains(err.Error(), path) { + t.Fatalf("malformed YAML must fail and name its file: %v", err) + } +} diff --git a/internal/fixture/handler.go b/internal/fixture/handler.go new file mode 100644 index 0000000..d6fb7dd --- /dev/null +++ b/internal/fixture/handler.go @@ -0,0 +1,908 @@ +package fixture + +import ( + "crypto/rand" + "encoding/hex" + "encoding/json" + "math" + "net/http" + "net/url" + "sort" + "strconv" + "strings" + "sync" + "time" +) + +// Handler serves the whole v0.1.0 surface for the world State describes. The +// key store is stateful for the handler's lifetime: create/rotate/revoke/delete +// mutate it and later GETs reflect the change. +func Handler(s State) http.Handler { + if s.AcceptKey == "" { + s.AcceptKey = defaultKey + } + ks := newKeyStore() + tr := newTracer() + mux := http.NewServeMux() + registerHealth(mux, s) + registerKeys(mux, ks) + registerChat(mux, s, tr) + registerLogs(mux, s, tr) + registerAdmin(mux, s) + registerModels(mux) + + // Anything unrouted answers in the documented envelope rather than the + // mux's plain-text 404, so the CLI's decoder is exercised even here. + mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + writeErr(w, http.StatusNotFound, kindNotFound, "no route for "+r.Method+" "+r.URL.Path) + }) + + return withRequestID(withAuth(s, mux)) +} + +// registerHealth wires the liveness and readiness surface. /livez, /health and +// /readyz are unauthenticated on the real router and so are they here; +// /admin/health is the bearer-guarded probe that also reports component state. +func registerHealth(mux *http.ServeMux, s State) { + mux.HandleFunc("GET /livez", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, map[string]any{fieldStatus: statusOK}) + }) + + mux.HandleFunc("GET /health", func(w http.ResponseWriter, _ *http.Request) { + // Verified against a live gateway: no_providers <=> providers is EMPTY, + // and 503 <=> no_providers. Nothing else makes /health non-200 — a + // half-open circuit with two live providers still answers 200 "ok". + // + // Degraded and provider-less are therefore independent axes, and an + // earlier version of this handler conflated them: it served 503 + // "no_providers" alongside two populated providers, so ferro reported + // "providers=2" next to the warning "health: no_providers" — a pairing + // live traffic can never show. Degraded now means what it means on the + // real server: a 200 whose circuit is half-open. + if s.NoProviders { + writeJSON(w, http.StatusServiceUnavailable, map[string]any{ + fieldStatus: statusNoProviders, + fieldProviders: []map[string]any{}, + }) + return + } + writeJSON(w, http.StatusOK, map[string]any{ + fieldStatus: statusOK, + fieldProviders: []map[string]any{ + {fieldName: providerAnthropic, fieldStatus: statusAvailable, fieldCircuit: circuitOf(s), fieldModels: 412}, + {fieldName: providerOpenAI, fieldStatus: statusAvailable, fieldCircuit: circuitClosed, fieldModels: 1104}, + }, + }) + }) + + mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, _ *http.Request) { + // Every not-ready path on the real server goes through one writer that + // emits ONLY {status, reason} — no providers, no targets, no + // mcp_servers. Serving the arrays on a 503 taught callers to read + // counts that will not be there, which is how ferro status came to + // report "0/0 targets" for a gateway whose targets were merely dead. + if s.NoProviders { + writeJSON(w, http.StatusServiceUnavailable, map[string]any{ + fieldStatus: statusNotReady, + "reason": "no routable targets", + }) + return + } + // A gateway with some routable targets is still ready — only "none + // routable" is 503 — so the degraded world reports 200 with one target + // marked unroutable. + out := map[string]any{ + fieldStatus: statusReady, + fieldProviders: []map[string]any{ + {fieldName: providerAnthropic, fieldCircuit: circuitOf(s)}, + {fieldName: providerOpenAI, fieldCircuit: circuitClosed}, + }, + "targets": []map[string]any{ + {fieldName: providerAnthropic, "routable": !s.Degraded}, + {fieldName: providerOpenAI, "routable": true}, + }, + } + if !s.NoMCP { + out["mcp_servers"] = []map[string]any{ + {fieldName: "filesystem", fieldReady: true, "required": false}, + } + } + writeJSON(w, http.StatusOK, out) + }) + + mux.HandleFunc("GET /admin/health", func(w http.ResponseWriter, _ *http.Request) { + anthropic := map[string]any{fieldName: providerAnthropic, fieldStatus: statusAvailable, fieldModels: 412} + status := statusHealthy + if s.NoProviders { + status = statusNoProviders // the default state of a credential-free gateway + } + if s.Degraded { + status = statusDegraded + anthropic[fieldMessage] = "circuit half_open after 3 consecutive failures" + } + // Component names and vocabulary verified against a live gateway: + // Title Case with spaces (not snake_case), status healthy/disabled/ + // unavailable (not "ok"), and five entries -- API and Audit log were + // both missing here. A missing log store reports "disabled", not an + // absent row. + logStore := statusHealthy + if s.NoLogStore { + logStore = statusDisabled + } + components := []map[string]any{ + {fieldName: "API", fieldStatus: statusHealthy}, + {fieldName: "Key store", fieldStatus: statusHealthy}, + {fieldName: "Config store", fieldStatus: statusHealthy}, + {fieldName: "Request logs", fieldStatus: logStore}, + {fieldName: "Audit log", fieldStatus: statusHealthy}, + } + out := map[string]any{ + // Always 200: this is the auth/scope probe. + fieldStatus: status, + fieldProviders: []map[string]any{ + anthropic, + {fieldName: providerOpenAI, fieldStatus: statusAvailable, fieldModels: 1104}, + }, + "components": components, + fieldScopes: []string{scopeAdmin}, + } + if !s.NoMCP { + out["mcp_servers"] = []map[string]any{ + {fieldName: "filesystem", fieldReady: true, "required": false}, + } + } + writeJSON(w, http.StatusOK, out) + }) + +} + +// registerLogs wires the request-log surface. Both routes answer 501 when no +// store is configured, which is how the CLI feature-detects it. +func registerLogs(mux *http.ServeMux, s State, tr *tracer) { + mux.HandleFunc("GET /admin/logs", func(w http.ResponseWriter, r *http.Request) { + if s.NoLogStore { + writeErr(w, http.StatusNotImplemented, kindServer, "no request log store configured") + return + } + q := r.URL.Query() + since, ok := parseSince(w, q) + if !ok { + return + } + rows := filterLogs(logRows(tr), q, since) + total := len(rows) + rows, ok = page(w, rows, q) + if !ok { + return + } + writeJSON(w, http.StatusOK, map[string]any{ + fieldData: rows, + fieldSummary: map[string]any{ + fieldTotalEntries: total, + "returned_entries": len(rows), + }, + "filters": map[string]any{ + fieldLimit: q.Get(fieldLimit), + fieldOffset: q.Get(fieldOffset), + fieldSince: q.Get(fieldSince), + fieldModel: q.Get(fieldModel), + fieldProvider: q.Get(fieldProvider), + fieldStage: q.Get(fieldStage), + fieldAPIKeyID: q.Get(fieldAPIKeyID), + }, + }) + }) + + // GET /admin/logs/stats aggregates the same seeded rows /admin/logs lists, + // filtered the way the real handler's Stats query filters them + // (internal/admin/handlers/logs.go's logsStats + requestlog.SQLWriter.Stats): + // stage, model and provider are exact-match-or-absent and since keeps rows + // at or after the cursor. There is deliberately no default-to-terminal- + // stages narrowing here (unlike /admin/logs) and no api_key_id filter — the + // real endpoint applies neither, and internal/api.LogStats never sends one. + // An earlier version of this handler ignored every parameter and served one + // fixed aggregate regardless of the query, so a CLI bug that dropped a + // filter before it reached the wire was invisible against this fixture. + mux.HandleFunc("GET /admin/logs/stats", func(w http.ResponseWriter, r *http.Request) { + if s.NoLogStore { + writeErr(w, http.StatusNotImplemented, kindServer, "no request log store configured") + return + } + q := r.URL.Query() + since, ok := parseSince(w, q) + if !ok { + return + } + writeJSON(w, http.StatusOK, logStatsResponse(filterStats(logRows(tr), q, since))) + }) + +} + +// registerAdmin wires the remaining admin control-plane reads: sessions, the +// audit trail, the plugin surfaces and the provider inventory. +func registerAdmin(mux *http.ServeMux, s State) { + mux.HandleFunc("GET /admin/sessions", func(w http.ResponseWriter, _ *http.Request) { + if s.NoSessions { + writeErr(w, http.StatusNotImplemented, kindServer, "dashboard sessions are disabled") + return + } + now := time.Now().UTC() + writeJSON(w, http.StatusOK, map[string]any{ + fieldData: []map[string]any{ + { + "id": "sess_01", "credential_id": keyIDOps, "subject": actorOps, + fieldScopes: []string{scopeAdmin}, "created_at": ts(now.Add(-3 * time.Hour)), + "last_seen_at": ts(now.Add(-4 * time.Minute)), "expires_at": ts(now.Add(21 * time.Hour)), + }, + { + "id": "sess_02", "credential_id": keyIDCI, "subject": "ci-pipeline", + fieldScopes: []string{scopeReadOnly}, "created_at": ts(now.Add(-40 * time.Minute)), + "last_seen_at": nil, "expires_at": ts(now.Add(23 * time.Hour)), + }, + }, + }) + }) + + mux.HandleFunc("GET /admin/audit", func(w http.ResponseWriter, r *http.Request) { + q := r.URL.Query() + if out := q.Get(fieldOutcome); out != "" && + out != outcomeOK && out != outcomeDenied && out != outcomeError { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, + // Worded exactly as internal/admin/handlers/audit_read.go does. + "invalid outcome: must be one of ok, denied, error") + return + } + // Shared with /admin/logs and /admin/logs/stats: the real handler's + // since is the same parseSince on every route that accepts it + // (internal/admin/handlers/queryparams.go), so all three reject a + // malformed value with the identical 400 message. + since, ok := parseSince(w, q) + if !ok { + return + } + rows := filterAudit(auditRows(), q, since) + total := len(rows) + rows, ok = page(w, rows, q) + if !ok { + return + } + writeJSON(w, http.StatusOK, map[string]any{ + fieldData: rows, + fieldSummary: map[string]any{ + fieldTotalEntries: total, + "returned_entries": len(rows), + }, + }) + }) + + mux.HandleFunc("GET /admin/plugins", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, []map[string]any{ // bare array + {fieldName: "request-logger", fieldType: typeLogging, fieldEnabled: true}, + {fieldName: "budget", fieldType: typeGuardrail, fieldEnabled: true}, + {fieldName: "rate-limit", fieldType: typeRateLimit, fieldEnabled: true}, + {fieldName: "word-filter", fieldType: typeGuardrail, fieldEnabled: false}, + }) + }) + + mux.HandleFunc("GET /admin/plugins/catalog", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, map[string]any{ + fieldData: []map[string]any{ + { + fieldName: "request-logger", fieldType: typeLogging, + fieldSummary: "Records one row per request stage", + fieldSettings: []string{"persist", "log_bodies"}, fieldFailsOpen: true, + }, + { + fieldName: "budget", fieldType: typeGuardrail, + fieldSummary: "Refuses requests once a spend ceiling is reached", + fieldSettings: []string{"limit_usd", "window", "store_id"}, fieldFailsOpen: false, + }, + { + fieldName: "rate-limit", fieldType: typeRateLimit, + fieldSummary: "Per-credential request rate ceiling", + fieldSettings: []string{"requests_per_second", "burst"}, fieldFailsOpen: false, + }, + { + fieldName: "word-filter", fieldType: typeGuardrail, + fieldSummary: "Rejects prompts containing blocked words", + fieldSettings: []string{"blocked_words"}, fieldFailsOpen: false, + }, + }, + }) + }) + + mux.HandleFunc("GET /admin/providers", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, []map[string]any{ // bare array + {fieldName: providerAnthropic, fieldModels: modelsOwnedBy(providerAnthropic)}, + {fieldName: providerOpenAI, fieldModels: modelsOwnedBy(providerOpenAI)}, + }) + }) +} + +// registerModels wires the /v1 discovery surface; the /v1 chat surface is +// registerChat's (stream.go). +func registerModels(mux *http.ServeMux) { + mux.HandleFunc("GET /v1/models", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, map[string]any{ + fieldObject: "list", + fieldData: modelCatalog(), + }) + }) +} + +// withAuth enforces the bearer on /admin/ AND /v1/, matching the real router. +// +// /health, /livez and /readyz are unauthenticated there and so are they here. +// Everything else is not: the gateway puts /v1/* behind the same middleware as +// /admin/* (only ALLOW_UNAUTHENTICATED_PROXY, a dev-only switch, lifts it). A +// fake that let /v1/models and /v1/chat/completions through unauthenticated +// would let the CLI's model discovery and playground be built without sending +// a credential, and the omission would surface as a 401 on first contact with +// a real gateway — precisely the drift this package must not introduce. +func withAuth(s State, next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + guarded := strings.HasPrefix(r.URL.Path, "/admin/") || + strings.HasPrefix(r.URL.Path, "/v1/") + if s.RequireAuth && guarded && + r.Header.Get("Authorization") != "Bearer "+s.AcceptKey { + writeErr(w, http.StatusUnauthorized, kindAuthentication, + "missing or invalid bearer token") + return + } + next.ServeHTTP(w, r) + }) +} + +// withRequestID stamps X-Request-ID on every response, as the gateway does. It +// is the id a log row carries as trace_id. +func withRequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Request-ID", newTraceID()) + next.ServeHTTP(w, r) + }) +} + +// tracer remembers the last chat stream so /admin/logs can answer with a row +// whose trace_id equals that stream's X-Request-ID. +type tracer struct { + mu sync.RWMutex + id string + model string +} + +func newTracer() *tracer { + return &tracer{id: newTraceID(), model: modelSonnet} +} + +func (t *tracer) set(id, model string) { + t.mu.Lock() + defer t.mu.Unlock() + t.id, t.model = id, model +} + +func (t *tracer) last() (id, model string) { + t.mu.RLock() + defer t.mu.RUnlock() + return t.id, t.model +} + +// logRow is a /admin/logs entry, tags exactly as the gateway serves them. +// duration_ms, ttft_ms and cost_usd are nullable — the CLI renders "-" for a +// null, never 0 — and there is deliberately no cache/cached flag. +type logRow struct { + TraceID string `json:"trace_id"` + Stage string `json:"stage"` + Model string `json:"model"` + APIKeyID string `json:"api_key_id"` + Provider string `json:"provider"` + PromptTokens int `json:"prompt_tokens"` + CompletionTokens int `json:"completion_tokens"` + TotalTokens int `json:"total_tokens"` + ErrorMessage string `json:"error_message"` + CreatedAt string `json:"created_at"` + DurationMS *float64 `json:"duration_ms"` + TTFTMS *float64 `json:"ttft_ms"` + CostUSD *float64 `json:"cost_usd"` +} + +// logRows is the seeded request log, newest first. The first row attributes the +// most recent chat stream — same trace_id as its X-Request-ID — which is what +// lets the playground resolve provider and cost against the fake. +// +// The rows are in descending created_at order because that is the only order a +// real log is read in, and the tail's since-cursor advances on it: a seed that +// put an older row last-but-one would validate paging and cursor behavior +// against an order the gateway cannot produce. +func logRows(tr *tracer) []logRow { + id, model := tr.last() + now := time.Now().UTC() + return []logRow{ + { + TraceID: id, Stage: stageAfterRequest, Model: model, APIKeyID: keyIDOps, + Provider: providerAnthropic, PromptTokens: 24, CompletionTokens: 7, TotalTokens: 31, + CreatedAt: ts(now.Add(-2 * time.Second)), + DurationMS: fp(1284.5), TTFTMS: fp(312), CostUSD: fp(0.0031), + }, + { + // Non-terminal stage: visible only with stage=all, so the default + // terminal-stage filter is observably doing something. It is the + // row above's own earlier stage — same request, one second before + // it completed — so it sorts here rather than at the end. + TraceID: id, Stage: stageBeforeRequest, Model: model, APIKeyID: keyIDOps, + Provider: providerAnthropic, CreatedAt: ts(now.Add(-3 * time.Second)), + }, + { + // Nullable measurements: the CLI must render "-", never 0. + TraceID: "8f2c1d4ab9e34f7c9a0d5e6b71c28d3f", Stage: stageAfterRequest, + Model: modelGPT4oMini, APIKeyID: keyIDCI, Provider: providerOpenAI, + PromptTokens: 812, CompletionTokens: 44, TotalTokens: 856, + CreatedAt: ts(now.Add(-51 * time.Second)), + }, + { + TraceID: "b31a77c0e5d24a1e8c93f0a6d2471be5", Stage: stageOnError, + Model: modelOpus, APIKeyID: keyIDOps, Provider: providerAnthropic, + ErrorMessage: "upstream_unavailable: circuit open", + CreatedAt: ts(now.Add(-4 * time.Minute)), + DurationMS: fp(30001.2), + }, + { + // Credential-less request: api_key_id is empty (?api_key_id=none). + TraceID: "c07e5f9138b64d2fa1c6e7092b4d8a11", Stage: stageAfterRequest, + Model: modelGPT4o, Provider: providerOpenAI, + PromptTokens: 128, CompletionTokens: 512, TotalTokens: 640, + CreatedAt: ts(now.Add(-9 * time.Minute)), + DurationMS: fp(4102), TTFTMS: fp(180), CostUSD: fp(0.0184), + }, + } +} + +// parseSince reads the optional since query parameter as RFC3339, writing the +// real handler's exact 400 (internal/admin/handlers/queryparams.go's +// parseSince) on anything that fails to parse and reporting ok=false so the +// caller returns. Reading it through url.Values.Get keeps a present-but-empty +// value read as absent — the same present-but-empty rule page applies to +// limit and offset — so `?since=` is not a second, silent way to ask for +// "unfiltered". Shared by /admin/logs, /admin/logs/stats and /admin/audit, +// the three routes that accept it. +func parseSince(w http.ResponseWriter, q url.Values) (time.Time, bool) { + raw := q.Get(fieldSince) + if raw == "" { + return time.Time{}, true + } + t, err := time.Parse(time.RFC3339, raw) + if err != nil { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "invalid since: must be RFC3339 format") + return time.Time{}, false + } + return t, true +} + +// filterLogs applies the exact-match filters the endpoint documents. A fake +// that ignored them would answer rows the query excluded — a lie downstream +// tests would then enshrine. since is pre-parsed by parseSince rather than +// reparsed here, so a malformed value 400s before any row is ever filtered. +func filterLogs(rows []logRow, q map[string][]string, since time.Time) []logRow { + get := func(k string) string { + if v := q[k]; len(v) > 0 { + return v[0] + } + return "" + } + stage, model, provider, keyID := get(fieldStage), get(fieldModel), get(fieldProvider), get(fieldAPIKeyID) + + // `since` is what a live tail advances on: Follower re-sends its cursor + // every poll and expects to be given only what is newer. Echoing the + // parameter without applying it made every poll return the whole page, so + // the tail depended entirely on client-side dedupe to look correct. + out := make([]logRow, 0, len(rows)) + for _, row := range rows { + switch { + case stage == "" && row.Stage != stageAfterRequest && row.Stage != stageOnError: + continue // default filter: terminal stages only, one row per request + case stage != "" && stage != "all" && row.Stage != stage: + continue + case model != "" && row.Model != model: + continue + case provider != "" && row.Provider != provider: + continue + case keyID == "none" && row.APIKeyID != "": + continue + case keyID != "" && keyID != "none" && row.APIKeyID != keyID: + continue + case !since.IsZero() && olderThan(row.CreatedAt, since): + continue + } + out = append(out, row) + } + return out +} + +// filterStats applies the filters GET /admin/logs/stats actually documents: +// stage, model and provider match exactly or are absent; since keeps rows at +// or after the cursor. There is no default-to-terminal-stages narrowing (the +// real query's WHERE clause never adds one — internal/requestlog/store.go's +// SQLWriter.Stats) and no api_key_id filter (the real handler never reads +// one), so this is deliberately not filterLogs with a parameter dropped. +func filterStats(rows []logRow, q map[string][]string, since time.Time) []logRow { + get := func(k string) string { + if v := q[k]; len(v) > 0 { + return v[0] + } + return "" + } + stage, model, provider := get(fieldStage), get(fieldModel), get(fieldProvider) + + out := make([]logRow, 0, len(rows)) + for _, row := range rows { + switch { + case stage != "" && row.Stage != stage: + continue + case model != "" && row.Model != model: + continue + case provider != "" && row.Provider != provider: + continue + case !since.IsZero() && olderThan(row.CreatedAt, since): + continue + } + out = append(out, row) + } + return out +} + +// dimensionStat is one group's contribution to by_stage/by_provider/by_model — +// the same five fields the real handler's encodeDimension serves per group +// (internal/admin/handlers/logs.go) — accumulated here from the filtered rows +// instead of the store's SQL aggregation. +type dimensionStat struct { + Count int + Errors int + Tokens int + CostUSD float64 + Unpriced int +} + +func (d *dimensionStat) add(row logRow) { + d.Count++ + d.Tokens += row.TotalTokens + if row.ErrorMessage != "" { + d.Errors++ + } + if row.CostUSD != nil { + d.CostUSD += *row.CostUSD + } else { + d.Unpriced++ + } +} + +func encodeDimensions(groups map[string]*dimensionStat) map[string]any { + out := make(map[string]any, len(groups)) + for name, stat := range groups { + out[name] = map[string]any{ + fieldCount: stat.Count, "errors": stat.Errors, "tokens": stat.Tokens, + "cost_usd": stat.CostUSD, "unpriced": stat.Unpriced, + } + } + return out +} + +// logStatsResponse aggregates exactly the rows filterStats left in, the way +// the real handler's Stats does: an empty result answers zeroed counts and +// null percentiles rather than 200-with-yesterday's-numbers, so a filter that +// matches nothing reads differently from one that was silently dropped. +func logStatsResponse(rows []logRow) map[string]any { + byStage := map[string]*dimensionStat{} + byProvider := map[string]*dimensionStat{} + byModel := map[string]*dimensionStat{} + errorCounts := map[string]int{} + errorEntries, totalTokens, promptTokens, completionTokens, unpriced := 0, 0, 0, 0, 0 + cost := 0.0 + var latencies, ttfts []float64 + + group := func(m map[string]*dimensionStat, key string, row logRow) { + if m[key] == nil { + m[key] = &dimensionStat{} + } + m[key].add(row) + } + + for _, row := range rows { + if row.ErrorMessage != "" { + errorEntries++ + errorCounts[row.ErrorMessage]++ + } + totalTokens += row.TotalTokens + promptTokens += row.PromptTokens + completionTokens += row.CompletionTokens + if row.CostUSD != nil { + cost += *row.CostUSD + } else { + unpriced++ + } + group(byStage, row.Stage, row) + group(byProvider, row.Provider, row) + group(byModel, row.Model, row) + if row.DurationMS != nil { + latencies = append(latencies, *row.DurationMS) + } + if row.TTFTMS != nil { + ttfts = append(ttfts, *row.TTFTMS) + } + } + + return map[string]any{ + fieldSummary: map[string]any{ + fieldTotalEntries: len(rows), + "error_entries": errorEntries, + "total_tokens": totalTokens, + "prompt_tokens": promptTokens, + "completion_tokens": completionTokens, + "cost_usd": cost, + "unpriced_requests": unpriced, + }, + "latency_ms": percentilesOf(latencies), + "ttft_ms": percentilesOf(ttfts), + "by_stage": encodeDimensions(byStage), + "by_provider": encodeDimensions(byProvider), + "by_model": encodeDimensions(byModel), + "top_errors": topErrors(errorCounts), + // The API defines series's inner shape (internal/admin/handlers/logs.go's + // encodeSeries), but no CLI surface reads it (internal/api.LogStats + // intentionally decodes no series field), so the fixture keeps the + // cheaper empty object rather than modeling bucket math nothing consumes. + "series": map[string]any{}, + } +} + +// topErrors mirrors the real handler's encodeErrorGroups shape +// ({message, count}), ranked highest count first with message as the +// tiebreaker so JSON array order — unlike a map's — is deterministic. +func topErrors(counts map[string]int) []map[string]any { + type group struct { + message string + count int + } + groups := make([]group, 0, len(counts)) + for msg, n := range counts { + groups = append(groups, group{msg, n}) + } + sort.Slice(groups, func(i, j int) bool { + if groups[i].count != groups[j].count { + return groups[i].count > groups[j].count + } + return groups[i].message < groups[j].message + }) + out := make([]map[string]any, 0, len(groups)) + for _, g := range groups { + out = append(out, map[string]any{fieldMessage: g.message, fieldCount: g.count}) + } + return out +} + +// percentilesOf mirrors the real handler's encodePercentiles: nil when +// nothing was measured — never a zero-filled block, which would read as a +// real, implausibly fast measurement — otherwise nearest-rank p50/p95/p99 +// plus max/mean/count. +func percentilesOf(vals []float64) any { + if len(vals) == 0 { + return nil + } + sorted := append([]float64(nil), vals...) + sort.Float64s(sorted) + rank := func(p float64) float64 { + idx := int(math.Ceil(p/100*float64(len(sorted)))) - 1 + if idx < 0 { + idx = 0 + } + return sorted[idx] + } + sum := 0.0 + for _, v := range sorted { + sum += v + } + return map[string]any{ + "p50": rank(50), "p95": rank(95), "p99": rank(99), + "max": sorted[len(sorted)-1], "mean": sum / float64(len(sorted)), fieldCount: len(sorted), + } +} + +// page applies offset then limit (limit is capped at 200, as documented). +// Shared by /admin/logs and /admin/audit, whose rows differ only in type. +// +// A limit that fails strconv.Atoi or is <= 0 writes the same 400 the real +// handler's parseLimit returns (internal/admin/handlers/queryparams.go) and +// reports ok=false, so the caller must return without serving its normal 200 +// body. +// +// Both bounds mirror internal/admin/handlers/queryparams.go exactly, including +// the case that is easy to get wrong: the parameter PRESENT BUT EMPTY. +// parseLimit and parseOffset both read through url.Values.Get and return their +// default on "", so `?limit=` is the same request as no limit at all — the +// convention the gateway applies to model, provider, stage and api_key_id too. +// Reading it through the same Get is what keeps that from drifting; matching on +// len(q[key]) instead would 400 a request the real gateway serves, and the +// resulting "bug" would look like it lived in the CLI. +func page[T any](w http.ResponseWriter, rows []T, q url.Values) ([]T, bool) { + limit := 100 + if raw := q.Get(fieldLimit); raw != "" { + n, err := strconv.Atoi(raw) + if err != nil || n <= 0 { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "invalid limit: must be a positive integer") + return nil, false + } + limit = n + } + limit = min(limit, 200) + + offset := 0 + if raw := q.Get(fieldOffset); raw != "" { + n, err := strconv.Atoi(raw) + if err != nil || n < 0 { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "invalid offset: must be a non-negative integer") + return nil, false + } + offset = n + } + offset = min(offset, len(rows)) + + rows = rows[offset:] + if limit < len(rows) { + rows = rows[:limit] + } + return rows, true +} + +func auditRows() []map[string]any { + now := time.Now().UTC() + return []map[string]any{ + { + fieldOccurredAt: ts(now.Add(-3 * time.Minute)), fieldAction: "key.create", + fieldActor: actorOps, fieldActorID: keyIDOps, "target_id": "key_05", + fieldOutcome: outcomeOK, fieldDetail: "scopes=read_only", fieldSourceIP: sourceIPLocal, + "trace_id": "3a1f7c02d94b41e6b0f5a8c7d2e91b64", + }, + { + fieldOccurredAt: ts(now.Add(-2 * time.Hour)), fieldAction: "session.create", + fieldActor: "unknown", fieldOutcome: outcomeDenied, fieldDetail: "invalid credential", + fieldSourceIP: "10.0.4.19", + }, + { + fieldOccurredAt: ts(now.AddDate(0, 0, -12)), fieldAction: "key.revoke", + fieldActor: actorOps, fieldActorID: keyIDOps, "target_id": "key_03", + fieldOutcome: outcomeOK, fieldSourceIP: sourceIPLocal, + }, + { + fieldOccurredAt: ts(now.AddDate(0, 0, -20)), fieldAction: "logs.purge", + fieldActor: actorOps, fieldActorID: keyIDOps, fieldOutcome: outcomeError, + fieldDetail: "log store unavailable", fieldSourceIP: sourceIPLocal, + }, + } +} + +func filterAudit(rows []map[string]any, q map[string][]string, since time.Time) []map[string]any { + get := func(k string) string { + if v := q[k]; len(v) > 0 { + return v[0] + } + return "" + } + out := make([]map[string]any, 0, len(rows)) + for _, row := range rows { + occurred, _ := time.Parse(time.RFC3339Nano, stringValue(row[fieldOccurredAt])) + if action := get("action"); action != "" && stringValue(row["action"]) != action { + continue + } + if actorID := get(fieldActorID); actorID != "" && stringValue(row[fieldActorID]) != actorID { + continue + } + if outcome := get(fieldOutcome); outcome != "" && stringValue(row[fieldOutcome]) != outcome { + continue + } + if !since.IsZero() && occurred.Before(since) { + continue + } + out = append(out, row) + } + return out +} + +func stringValue(v any) string { + s, _ := v.(string) + return s +} + +// modelCatalog is the /v1/models payload; /admin/providers serves the same rows +// grouped by owner. +func modelCatalog() []map[string]any { + return []map[string]any{ + { + "id": modelSonnet, fieldObject: objectModel, fieldCreated: 1748736000, + fieldOwnedBy: providerAnthropic, fieldMode: modalityChat, fieldContextWindow: 200000, + fieldMaxOutputTokens: 64000, fieldStatus: statusStable, fieldDeprecated: false, + fieldCapabilities: []string{modalityChat, capabilityStreaming, capabilityTools, capabilityVision}, + }, + { + "id": modelOpus, fieldObject: objectModel, fieldCreated: 1751328000, + fieldOwnedBy: providerAnthropic, fieldMode: modalityChat, fieldContextWindow: 200000, + fieldMaxOutputTokens: 32000, fieldStatus: statusStable, fieldDeprecated: false, + fieldCapabilities: []string{modalityChat, capabilityStreaming, capabilityTools, capabilityVision}, + }, + { + "id": modelGPT4o, fieldObject: objectModel, fieldCreated: 1715558400, + fieldOwnedBy: providerOpenAI, fieldMode: modalityChat, fieldContextWindow: 128000, + fieldMaxOutputTokens: 16384, fieldStatus: statusStable, fieldDeprecated: false, + fieldCapabilities: []string{modalityChat, capabilityStreaming, capabilityTools, capabilityVision}, + }, + { + "id": modelGPT4oMini, fieldObject: objectModel, fieldCreated: 1721260800, + fieldOwnedBy: providerOpenAI, fieldMode: modalityChat, fieldContextWindow: 128000, + fieldMaxOutputTokens: 16384, fieldStatus: statusStable, fieldDeprecated: false, + fieldCapabilities: []string{modalityChat, capabilityStreaming, capabilityTools}, + }, + { + "id": modelEmbedding3Small, fieldObject: objectModel, fieldCreated: 1705363200, + fieldOwnedBy: providerOpenAI, fieldMode: modalityEmbedding, fieldContextWindow: 8191, + fieldStatus: statusStable, fieldDeprecated: false, + fieldCapabilities: []string{modalityEmbedding}, + }, + } +} + +func modelsOwnedBy(owner string) []map[string]any { + out := []map[string]any{} + for _, m := range modelCatalog() { + if m[fieldOwnedBy] == owner { + out = append(out, m) + } + } + return out +} + +func circuitOf(s State) string { + if s.Degraded { + return circuitHalfOpen + } + return circuitClosed +} + +func writeJSON(w http.ResponseWriter, code int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(code) + _ = json.NewEncoder(w).Encode(v) +} + +// writeErr emits the gateway's error envelope, so the CLI's decodeAPIError is +// exercised by the fixture rather than mocked around. +func writeErr(w http.ResponseWriter, code int, kind, msg string) { + writeJSON(w, code, map[string]any{ + fieldError: map[string]any{fieldMessage: msg, fieldType: kind, "code": kind}, + }) +} + +// ts renders a wire timestamp: RFC3339, UTC. +func ts(t time.Time) string { return t.UTC().Format(time.RFC3339) } + +func sp(s string) *string { return &s } +func fp(f float64) *float64 { return &f } + +// newTraceID mints a 32-hex id shaped like the gateway's (its X-Request-ID is +// the OTel trace id). +func newTraceID() string { + var b [16]byte + _, _ = rand.Read(b[:]) + return hex.EncodeToString(b[:]) +} + +// randToken mints a random base32 token for a key secret. +func randToken() string { return rand.Text() } + +// olderThan reports whether an RFC3339 created_at precedes the cursor. A row +// whose timestamp will not parse is kept: dropping rows on a formatting +// problem would make a tail silently lossy, which is worse than showing one +// row twice. +func olderThan(createdAt string, since time.Time) bool { + t, err := time.Parse(time.RFC3339, createdAt) + if err != nil { + return false + } + return t.Before(since) +} diff --git a/internal/fixture/handler_test.go b/internal/fixture/handler_test.go new file mode 100644 index 0000000..65e8a95 --- /dev/null +++ b/internal/fixture/handler_test.go @@ -0,0 +1,619 @@ +package fixture + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +// reply is everything that outlives a finished request. do reads the body to +// completion and closes it, so there is no *http.Response worth handing back — +// only a spent connection a caller could forget to release. +type reply struct { + status int + header http.Header + body []byte +} + +// do runs one request against a fresh server wrapping h. Every test goes +// through it, so the request context, the body read and the close are done in +// one place rather than re-hand-rolled per test. +func do(t *testing.T, h http.Handler, method, path, bearer, body string) reply { + t.Helper() + srv := httptest.NewServer(h) + t.Cleanup(srv.Close) + var payload io.Reader + if body != "" { + payload = strings.NewReader(body) + } + req, err := http.NewRequestWithContext(t.Context(), method, srv.URL+path, payload) + if err != nil { + t.Fatal(err) + } + if bearer != "" { + req.Header.Set("Authorization", "Bearer "+bearer) + } + resp, err := srv.Client().Do(req) + if err != nil { + t.Fatal(err) + } + defer func() { + if err := resp.Body.Close(); err != nil { + t.Errorf("close response body: %v", err) + } + }() + out, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + return reply{status: resp.StatusCode, header: resp.Header, body: out} +} + +// get is do for the read surface, which is most of it. +func get(t *testing.T, h http.Handler, method, path, bearer string) reply { + t.Helper() + return do(t, h, method, path, bearer, "") +} + +func TestHealthShapeMatchesContract(t *testing.T) { + res := get(t, Handler(Default()), "GET", "/health", "") + if res.status != 200 { + t.Fatalf("healthy /health must be 200, got %d", res.status) + } + var out struct { + Status string `json:"status"` + Providers []struct { + Name string `json:"name"` + Circuit string `json:"circuit"` + Models int `json:"models"` + } `json:"providers"` + } + if err := json.Unmarshal(res.body, &out); err != nil { + t.Fatal(err) + } + if out.Status != "ok" || len(out.Providers) == 0 || out.Providers[0].Models == 0 { + t.Fatalf("fixture drifted from the documented /health shape: %s", res.body) + } +} + +// Degraded and provider-less are independent axes on the real gateway, and an +// earlier version of this fixture conflated them into one 503. Verified live: +// a half-open circuit with live providers still answers 200 "ok"; only an +// empty provider set makes /health non-200. +func TestDegradedIsA200WithAHalfOpenCircuit(t *testing.T) { + res := get(t, Handler(State{Degraded: true}), "GET", "/health", "") + if res.status != 200 { + t.Fatalf("a circuit does not make /health non-200, got %d", res.status) + } + if !strings.Contains(string(res.body), "half_open") || + !strings.Contains(string(res.body), `"status":"ok"`) { + t.Fatalf("degraded must report ok with a half-open circuit: %s", res.body) + } +} + +func TestNoProvidersIs503WithAnEmptyProviderSet(t *testing.T) { + res := get(t, Handler(State{NoProviders: true}), "GET", "/health", "") + if res.status != 503 { + t.Fatalf("an empty provider set is the one 503 /health has, got %d", res.status) + } + if !strings.Contains(string(res.body), `"no_providers"`) || + !strings.Contains(string(res.body), `"providers":[]`) { + t.Fatalf("no_providers must come with an EMPTY providers array: %s", res.body) + } +} + +// The not-ready body carries only status and reason. Serving the arrays here +// taught ferro status to read target counts that are not there, and report +// "0/0 targets" for a gateway whose targets were merely dead. +func TestNotReadyCarriesOnlyStatusAndReason(t *testing.T) { + res := get(t, Handler(State{NoProviders: true}), "GET", "/readyz", "") + if res.status != 503 { + t.Fatalf("want 503, got %d", res.status) + } + // Assert on decoded KEYS, not substrings: the reason text is literally + // "no routable targets", which contains the very word being banned. + var doc map[string]any + if err := json.Unmarshal(res.body, &doc); err != nil { + t.Fatalf("decode: %v (%s)", err, res.body) + } + // doc["reason"] is nil when the key is absent, and nil != "", so comparing + // against the empty string alone cannot fail. Assert presence and a + // non-empty string instead. + reason, ok := doc["reason"].(string) + if doc["status"] != "not_ready" || !ok || reason == "" { + t.Fatalf("want status and a non-empty reason: %s", res.body) + } + for _, absent := range []string{"targets", "providers", "mcp_servers"} { + if _, present := doc[absent]; present { + t.Fatalf("a not_ready body must not carry %q: %s", absent, res.body) + } + } +} + +func TestAdminRoutesRequireBearer(t *testing.T) { + h := Handler(Default()) + res := get(t, h, "GET", "/admin/keys", "") + if res.status != 401 || !strings.Contains(string(res.body), "authentication_error") { + t.Fatalf("want the documented 401 envelope, got %d %s", res.status, res.body) + } + if res = get(t, h, "GET", "/admin/keys", "fgw_test"); res.status != 200 { + t.Fatalf("valid bearer must be accepted, got %d", res.status) + } +} + +func TestFeatureAbsenceIs501(t *testing.T) { + res := get(t, Handler(State{NoLogStore: true}), "GET", "/admin/logs", "") + if res.status != 501 { + t.Fatalf("absent log store must 501 so the CLI can feature-detect, got %d", res.status) + } +} + +func TestKeysAreStatefulAcrossRequests(t *testing.T) { + h := Handler(Default()) // one handler, two requests: the store must persist + res := do(t, h, "POST", "/admin/keys", "fgw_test", + `{"name":"itest","scopes":["read_only"]}`) + if res.status != 201 { + t.Fatalf("create must be 201: %d %s", res.status, res.body) + } + var created struct { + ID string `json:"id"` + Key string `json:"key"` + } + if err := json.Unmarshal(res.body, &created); err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(created.Key, "fgw_") || len(created.Key) < 20 { + t.Fatalf("create must return the full secret once, got %q", created.Key) + } + list := get(t, h, "GET", "/admin/keys", "fgw_test") + if !strings.Contains(string(list.body), "itest") { + t.Fatal("created key must appear in the list — the fake is stateful by design") + } + if strings.Contains(string(list.body), created.Key) { + t.Fatal("list must mask the secret, like the real gateway does") + } +} + +// GET/rotate/revoke/delete had no unit coverage: only cli/itest exercised +// them, and only against a live gateway, skipping entirely when +// FERRO_ITEST_KEY is unset — so a regression in keyStore.rotate/revoke/remove +// could pass CI. This covers the mutating half of the key surface the way +// TestKeysAreStatefulAcrossRequests covers create/list. +func TestKeyLifecycleMutatesTheStore(t *testing.T) { + h := Handler(Default()) + + rotated := do(t, h, http.MethodPost, "/admin/keys/key_01/rotate", "fgw_test", "") + if rotated.status != http.StatusOK { + t.Fatalf("rotate must be 200: %d %s", rotated.status, rotated.body) + } + var row struct { + Key string `json:"key"` + RotatedAt *string `json:"rotated_at"` + } + if err := json.Unmarshal(rotated.body, &row); err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(row.Key, "fgw_") || row.RotatedAt == nil { + t.Fatalf("rotate must serve the new secret once and stamp rotated_at: %s", rotated.body) + } + if listed := get(t, h, http.MethodGet, "/admin/keys/key_01", "fgw_test"); strings.Contains(string(listed.body), row.Key) { + t.Fatal("a later read must mask the rotated secret") + } + + if res := do(t, h, http.MethodPost, "/admin/keys/key_02/revoke", "fgw_test", ""); res.status != http.StatusOK { + t.Fatalf("revoke must be 200: %d %s", res.status, res.body) + } + if res := do(t, h, http.MethodDelete, "/admin/keys/key_02", "fgw_test", ""); res.status != http.StatusNoContent { + t.Fatalf("delete must be 204: %d %s", res.status, res.body) + } + res := get(t, h, http.MethodGet, "/admin/keys/key_02", "fgw_test") + if res.status != http.StatusNotFound || !strings.Contains(string(res.body), "not_found_error") { + t.Fatalf("a deleted key must 404 in the documented envelope: %d %s", res.status, res.body) + } +} + +// The real gateway defaults an unspecified scope list to read_only, in the key +// store both its backends share. A fake that stored the empty list instead +// would hand every fixture-backed test a scopeless key the gateway never mints. +func TestCreateWithoutScopesDefaultsToReadOnly(t *testing.T) { + for _, body := range []string{ + `{"name":"absent"}`, + `{"name":"null","scopes":null}`, + `{"name":"empty","scopes":[]}`, + } { + res := do(t, Handler(Default()), "POST", "/admin/keys", "fgw_test", body) + if res.status != 201 { + t.Fatalf("create must be 201: %d %s", res.status, res.body) + } + var created struct { + Scopes []string `json:"scopes"` + } + if err := json.Unmarshal(res.body, &created); err != nil { + t.Fatal(err) + } + if len(created.Scopes) != 1 || created.Scopes[0] != "read_only" { + t.Fatalf("%s must mint a read-only key, got %v", body, created.Scopes) + } + } +} + +// A real log is read newest first, and the tail's since-cursor advances on that +// order. A seeded row out of order would validate paging against an order the +// gateway cannot produce. +func TestSeededLogIsNewestFirst(t *testing.T) { + res := get(t, Handler(Default()), "GET", "/admin/logs?stage=all", "fgw_test") + var page struct { + Data []struct { + Stage string `json:"stage"` + CreatedAt string `json:"created_at"` + } `json:"data"` + } + if err := json.Unmarshal(res.body, &page); err != nil { + t.Fatal(err) + } + if len(page.Data) < 2 { + t.Fatalf("stage=all must expose every seeded row: %s", res.body) + } + previous := time.Now().UTC().Add(time.Hour) + for _, row := range page.Data { + at, err := time.Parse(time.RFC3339, row.CreatedAt) + if err != nil { + t.Fatalf("created_at must be RFC3339: %v", err) + } + if at.After(previous) { + t.Fatalf("row %q at %s breaks descending created_at order: %s", + row.Stage, row.CreatedAt, res.body) + } + previous = at + } +} + +func TestChatStreamFraming(t *testing.T) { + res := do(t, Handler(Default()), "POST", "/v1/chat/completions", "fgw_test", + `{"model":"claude-sonnet-4-6","messages":[{"role":"user","content":"hi"}],"stream":true}`) + if ct := res.header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") { + t.Fatalf("want SSE content type, got %q", ct) + } + if res.header.Get("X-Request-ID") == "" { + t.Fatal("X-Request-ID is how the CLI attributes a stream — it must be set") + } + got := string(res.body) + if !strings.Contains(got, "data: ") || !strings.Contains(got, `"usage"`) || + !strings.Contains(got, "data: [DONE]") { + t.Fatalf("stream must be data-framed, carry a usage chunk, and end with [DONE]:\n%s", got) + } +} + +func TestChatErrorFrameHasNoDone(t *testing.T) { + // The real gateway ends an errored stream WITHOUT [DONE]; a fake that sends + // one anyway would hide the CLI bug this behavior exists to catch. + // + // The WHOLE stream is read, not its first frame: "there is no [DONE]" is a + // claim about the end of the stream, and a partial read can only fail to + // find one that was in fact sent. + res := do(t, Handler(State{ChatFails: true}), "POST", "/v1/chat/completions", "", + `{"model":"m","messages":[],"stream":true}`) + got := string(res.body) + if !strings.Contains(got, "stream_error") || strings.Contains(got, "[DONE]") { + t.Fatalf("errored stream must carry stream_error and no [DONE]:\n%s", got) + } +} + +// The real gateway puts /v1/* behind the same bearer check as /admin/*. If the +// fake did not, the CLI's model discovery and playground could be built without +// sending a credential and would 401 on first contact with a real gateway. +func TestV1RoutesRequireBearerToo(t *testing.T) { + h := Handler(Default()) + // Each route is probed with the METHOD the CLI reaches it by. A handler + // that authenticated GET /v1/chat/completions but not the POST the + // playground sends would pass a GET-only loop and 401 in production. + for _, tc := range []struct{ method, path, body string }{ + {http.MethodGet, "/v1/models", ""}, + {http.MethodPost, "/v1/chat/completions", `{"model":"m","messages":[],"stream":true}`}, + } { + res := do(t, h, tc.method, tc.path, "", tc.body) + if res.status != 401 { + t.Fatalf("%s %s without a bearer must be 401, got %d", tc.method, tc.path, res.status) + } + if !strings.Contains(string(res.body), "authentication_error") { + t.Fatalf("%s %s must use the documented error envelope: %s", tc.method, tc.path, res.body) + } + } + if res := get(t, h, "GET", "/v1/models", "fgw_test"); res.status != 200 { + t.Fatalf("valid bearer must be accepted on /v1/models, got %d", res.status) + } +} + +// ...while the liveness surface stays open, as it is on the real router. +func TestHealthSurfaceStaysUnauthenticated(t *testing.T) { + h := Handler(Default()) + for _, path := range []string{"/health", "/readyz"} { + if res := get(t, h, "GET", path, ""); res.status == 401 { + t.Fatalf("%s must not require a credential", path) + } + } + res := get(t, h, "GET", "/livez", "") + if res.status != http.StatusOK || strings.TrimSpace(string(res.body)) != `{"status":"ok"}` { + t.Fatalf("/livez must be an open 200 status payload, got %d %s", res.status, res.body) + } +} + +func TestChatRequiresStreaming(t *testing.T) { + h := Handler(Default()) + for _, body := range []string{ + `{"model":"m"}`, + `{"model":"m","stream":false}`, + `{"model":"m","stream":true}{"stream":true}`, + `{"stream":false,"stream":true}`, + } { + res := do(t, h, http.MethodPost, "/v1/chat/completions", "fgw_test", body) + if res.status != http.StatusBadRequest { + t.Fatalf("non-streaming request must be rejected, got %d", res.status) + } + } +} + +func TestAuditFiltersAndPagesRows(t *testing.T) { + h := Handler(Default()) + res := get(t, h, "GET", "/admin/audit?outcome=ok&limit=1&offset=1", "fgw_test") + if res.status != http.StatusOK { + t.Fatalf("audit query failed: %d %s", res.status, res.body) + } + var page struct { + Data []map[string]any `json:"data"` + Summary struct { + TotalEntries int `json:"total_entries"` + } `json:"summary"` + } + if err := json.Unmarshal(res.body, &page); err != nil { + t.Fatal(err) + } + if page.Summary.TotalEntries != 2 || len(page.Data) != 1 || + page.Data[0]["outcome"] != "ok" || page.Data[0]["action"] != "key.revoke" { + t.Fatalf("filters must apply before paging: %s", res.body) + } +} + +func TestAuditRejectsInvalidSince(t *testing.T) { + res := get(t, Handler(Default()), "GET", "/admin/audit?since=not-a-time", "fgw_test") + if res.status != http.StatusBadRequest || + !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { + t.Fatalf("invalid since must use the invalid-request envelope: %d %s", res.status, res.body) + } +} + +// The real gateway's parseLimit 400s a limit that is <= 0 or not an integer +// (internal/admin/handlers/queryparams.go); an earlier version of this fixture +// silently fell back to its default and served an empty page instead. Both +// endpoints share the page[T] helper, so one table covers both. +func TestNonPositiveLimitIs400OnLogsAndAudit(t *testing.T) { + for _, path := range []string{ + "/admin/logs?limit=0", + "/admin/logs?limit=-1", + "/admin/logs?limit=abc", + "/admin/audit?limit=0", + "/admin/audit?limit=-1", + "/admin/audit?limit=abc", + } { + res := get(t, Handler(Default()), "GET", path, "fgw_test") + if res.status != http.StatusBadRequest || + !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { + t.Fatalf("%s: want the documented 400 envelope for a non-positive limit, got %d %s", path, res.status, res.body) + } + } +} + +// parseOffset rejects the same two shapes parseLimit does, one bound over. +func TestNegativeOffsetIs400OnLogsAndAudit(t *testing.T) { + for _, path := range []string{ + "/admin/logs?offset=-1", + "/admin/logs?offset=abc", + "/admin/audit?offset=-1", + "/admin/audit?offset=abc", + } { + res := get(t, Handler(Default()), "GET", path, "fgw_test") + if res.status != http.StatusBadRequest || + !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { + t.Fatalf("%s: want the documented 400 envelope for a bad offset, got %d %s", path, res.status, res.body) + } + } +} + +// A present-but-empty bound is the one shape that must NOT 400: parseLimit and +// parseOffset both read through url.Values.Get and return their default on "", +// so `?limit=` is the same request as no limit at all. A fixture that rejected +// it would send someone hunting a CLI bug that does not exist. +func TestEmptyBoundIsReadAsAbsentNotRejected(t *testing.T) { + for _, path := range []string{ + "/admin/logs?limit=", + "/admin/logs?offset=", + "/admin/logs?limit=&offset=", + "/admin/audit?limit=", + "/admin/audit?offset=", + } { + res := get(t, Handler(Default()), "GET", path, "fgw_test") + if res.status != http.StatusOK { + t.Fatalf("%s: an empty bound means absent, want 200, got %d %s", path, res.status, res.body) + } + } +} + +// The real stats endpoint 400s a malformed since exactly as /admin/logs and +// /admin/audit do (internal/admin/handlers/queryparams.go's parseSince is +// shared by all three) — this fixture used to accept anything on +// /admin/logs/stats because it never looked at the query at all. +func TestMalformedSinceIs400OnLogsAndStats(t *testing.T) { + for _, path := range []string{ + "/admin/logs?since=not-a-time", + "/admin/logs/stats?since=not-a-time", + } { + res := get(t, Handler(Default()), "GET", path, "fgw_test") + if res.status != http.StatusBadRequest || + !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { + t.Fatalf("%s: want the documented 400 envelope for a malformed since, got %d %s", path, res.status, res.body) + } + } +} + +type statsSummary struct { + Summary struct { + TotalEntries int `json:"total_entries"` + } `json:"summary"` + ByProvider map[string]json.RawMessage `json:"by_provider"` +} + +func decodeStats(t *testing.T, path string) statsSummary { + t.Helper() + res := get(t, Handler(Default()), "GET", path, "fgw_test") + if res.status != http.StatusOK { + t.Fatalf("%s: want 200, got %d %s", path, res.status, res.body) + } + var out statsSummary + if err := json.Unmarshal(res.body, &out); err != nil { + t.Fatalf("%s: %v", path, err) + } + return out +} + +// Before this fix /admin/logs/stats served the same fixed aggregate no matter +// what the query asked for, so a CLI regression that dropped a filter before +// it reached the wire was invisible against this fixture. Each of these +// narrows a five-row seed a different way, and the unfiltered count (5) proves +// the baseline itself is real data, not a coincidence of one filter. +func TestStatsFiltersNarrowTheAggregate(t *testing.T) { + base := decodeStats(t, "/admin/logs/stats") + if base.Summary.TotalEntries != 5 { + t.Fatalf("unfiltered stats: want all 5 seeded rows, got %d", base.Summary.TotalEntries) + } + if _, ok := base.ByProvider["anthropic"]; !ok { + t.Fatalf("unfiltered by_provider must include anthropic: %+v", base.ByProvider) + } + if _, ok := base.ByProvider["openai"]; !ok { + t.Fatalf("unfiltered by_provider must include openai: %+v", base.ByProvider) + } + + for _, tc := range []struct { + path string + want int + }{ + {"/admin/logs/stats?provider=openai", 2}, + {"/admin/logs/stats?stage=before_request", 1}, + {"/admin/logs/stats?model=does-not-exist", 0}, + } { + got := decodeStats(t, tc.path) + if got.Summary.TotalEntries != tc.want { + t.Fatalf("%s: want %d entries, got %d (a fixture that dropped this filter would still report %d)", + tc.path, tc.want, got.Summary.TotalEntries, base.Summary.TotalEntries) + } + } + + // provider=openai must also drop anthropic out of the by_provider + // breakdown, not just shrink the total. + openaiOnly := decodeStats(t, "/admin/logs/stats?provider=openai") + if _, ok := openaiOnly.ByProvider["anthropic"]; ok { + t.Fatalf("provider=openai must drop anthropic from by_provider: %+v", openaiOnly.ByProvider) + } +} + +// A present-but-empty filter value means absent, the same rule the other +// admin list routes apply (TestEmptyBoundIsReadAsAbsentNotRejected): it must +// not 400, and — because /admin/logs/stats used to ignore every parameter — +// it must not silently narrow the aggregate either. +func TestStatsEmptyFilterValueIsAbsentNotRejected(t *testing.T) { + for _, path := range []string{ + "/admin/logs/stats?model=", + "/admin/logs/stats?provider=", + "/admin/logs/stats?stage=", + "/admin/logs/stats?since=", + } { + got := decodeStats(t, path) + if got.Summary.TotalEntries != 5 { + t.Fatalf("%s: an empty value means absent, want all 5 seeded rows, got %d", path, got.Summary.TotalEntries) + } + } +} + +// since keeps only rows at or after the cursor (internal/requestlog/store.go's +// SQLWriter.Stats: "created_at >= ?"), so a cursor five minutes back must drop +// exactly the row seeded nine minutes back and keep the other four. +func TestStatsSinceKeepsOnlyRowsAtOrAfterTheCursor(t *testing.T) { + since := time.Now().Add(-5 * time.Minute).UTC().Format(time.RFC3339) + got := decodeStats(t, "/admin/logs/stats?since="+since) + if got.Summary.TotalEntries != 4 { + t.Fatalf("since=-5m must drop the row seeded 9 minutes ago, want 4 entries, got %d", got.Summary.TotalEntries) + } +} + +// model.ValidateScopes refuses anything outside the closed set with a 400, so +// the fixture must too — a fake that accepts "readonly" lets a CLI that sends +// the wrong spelling pass every test here and fail against a real gateway. +func TestCreateRejectsAnUnknownScope(t *testing.T) { + h := Handler(Default()) + res := do(t, h, http.MethodPost, "/admin/keys", "fgw_test", + `{"name":"typo","scopes":["readonly"]}`) + if res.status != http.StatusBadRequest { + t.Fatalf("an unknown scope must be 400, got %d %s", res.status, res.body) + } + for _, want := range []string{`unknown scope \"readonly\"`, "admin, read_only", "invalid_request_error"} { + if !strings.Contains(string(res.body), want) { + t.Fatalf("want %s in the gateway's own wording: %s", want, res.body) + } + } + // The refusal must not have created anything. + if list := get(t, h, http.MethodGet, "/admin/keys", "fgw_test"); strings.Contains(string(list.body), "typo") { + t.Fatalf("a refused create must not reach the store: %s", list.body) + } +} + +// Both members of the closed set are accepted, so the guard above cannot pass +// by rejecting everything. +func TestCreateAcceptsBothValidScopes(t *testing.T) { + h := Handler(Default()) + for _, scope := range []string{scopeAdmin, scopeReadOnly} { + res := do(t, h, http.MethodPost, "/admin/keys", "fgw_test", + `{"name":"ok-`+scope+`","scopes":["`+scope+`"]}`) + if res.status != http.StatusCreated { + t.Fatalf("%s must be accepted, got %d %s", scope, res.status, res.body) + } + } +} + +// An expired key is served the way the gateway serves one: active:true, +// revoked_at:null, expires_at in the past. Seeding active:false here was +// fixture-only fiction that hid a real CLI bug. +func TestExpiredKeyKeepsActiveTrueOnTheWire(t *testing.T) { + res := get(t, Handler(Default()), http.MethodGet, "/admin/keys", "fgw_test") + var rows []struct { + Name string `json:"name"` + RevokedAt *string `json:"revoked_at"` + ExpiresAt *string `json:"expires_at"` + Active bool `json:"active"` + } + if err := json.Unmarshal(res.body, &rows); err != nil { + t.Fatal(err) + } + var found bool + for _, r := range rows { + if r.Name != "demo-temp" { + continue + } + found = true + if !r.Active || r.RevokedAt != nil || r.ExpiresAt == nil { + t.Fatalf("an expired key stays active:true with revoked_at:null and an expires_at: %+v", r) + } + expiry, err := time.Parse(time.RFC3339, *r.ExpiresAt) + if err != nil { + t.Fatal(err) + } + if !time.Now().After(expiry) { + t.Fatalf("the seeded expiry must already have passed, got %s", *r.ExpiresAt) + } + } + if !found { + t.Fatal("the expired fixture key must be seeded") + } +} diff --git a/internal/fixture/keys.go b/internal/fixture/keys.go new file mode 100644 index 0000000..1700ade --- /dev/null +++ b/internal/fixture/keys.go @@ -0,0 +1,284 @@ +package fixture + +import ( + "encoding/json" + "fmt" + "net/http" + "strings" + "sync" + "time" +) + +// keyRow is the /admin/keys row, tags exactly as the gateway serves them. +// There is deliberately no "state" and no "revoked" field: the CLI derives +// revoked/expired/active from revoked_at, active and expires_at. +type keyRow struct { + ID string `json:"id"` + Key string `json:"key"` // masked head8...tail4 on reads + Name string `json:"name"` + Scopes []string `json:"scopes"` + CreatedAt string `json:"created_at"` + RevokedAt *string `json:"revoked_at"` + ExpiresAt *string `json:"expires_at"` + RotatedAt *string `json:"rotated_at"` + LastUsedAt *string `json:"last_used_at"` + UsageCount int `json:"usage_count"` + Active bool `json:"active"` +} + +// keyStore is the stateful half of the fake: create/rotate/revoke/delete mutate +// it and later GETs reflect the change, so the TUI key wizard can be exercised +// end to end. One lock guards the whole store — a fake serves one operator, so +// a mutex and a slice are enough. +type keyStore struct { + mu sync.RWMutex + rows []keyRow + secrets map[string]string // key id -> full secret, never serialized on reads + n int +} + +func newKeyStore() *keyStore { + now := time.Now().UTC() + ks := &keyStore{secrets: map[string]string{}} + // Four seeded rows covering every state the CLI derives: active, active + // with an expiry, revoked, and expired. + ks.seed(actorOps, []string{scopeAdmin}, now.AddDate(0, -3, 0), func(r *keyRow) { + r.LastUsedAt = sp(ts(now.Add(-4 * time.Minute))) + r.UsageCount = 18422 + }) + ks.seed("ci-pipeline", []string{scopeReadOnly}, now.AddDate(0, -1, 0), func(r *keyRow) { + r.ExpiresAt = sp(ts(now.AddDate(0, 2, 0))) + r.LastUsedAt = sp(ts(now.Add(-51 * time.Minute))) + r.UsageCount = 3907 + }) + ks.seed("laptop-old", []string{scopeAdmin}, now.AddDate(-1, 0, 0), func(r *keyRow) { + r.RevokedAt = sp(ts(now.AddDate(0, 0, -12))) + r.LastUsedAt = sp(ts(now.AddDate(0, 0, -12))) + r.UsageCount = 240 + r.Active = false + }) + // An expired key keeps active:true and revoked_at:null. The gateway clears + // active only in Revoke (memory store keys.go, and the SQL store's own + // UPDATE), so nothing flips it when a deadline passes — model.KeyIsUsable + // checks expires_at separately for exactly that reason. Seeding this row + // as active:false was fixture-only fiction, and it hid a real bug: the CLI + // derived "expired" from !active, which a real expired key never sets, so + // `ferro keys list` called it active. + ks.seed("demo-temp", []string{scopeReadOnly}, now.AddDate(0, 0, -40), func(r *keyRow) { + r.ExpiresAt = sp(ts(now.AddDate(0, 0, -6))) + r.UsageCount = 12 + }) + return ks +} + +// seed appends one row; opt tweaks it into the state being seeded. +func (ks *keyStore) seed(name string, scopes []string, created time.Time, opt func(*keyRow)) { + id, secret := ks.nextID(), newSecret() + row := keyRow{ + ID: id, + Key: mask(secret), + Name: name, + Scopes: scopes, + CreatedAt: ts(created), + Active: true, + } + if opt != nil { + opt(&row) + } + ks.rows = append(ks.rows, row) + ks.secrets[id] = secret +} + +// nextID mints a readable, stable-looking id. Callers hold the lock (or are +// constructing the store). +func (ks *keyStore) nextID() string { + ks.n++ + return fmt.Sprintf("key_%02d", ks.n) +} + +// newSecret mints a master-key-shaped credential: `fgw_` + random token. +func newSecret() string { return "fgw_" + strings.ToLower(randToken()) } + +func (ks *keyStore) list() []keyRow { + ks.mu.RLock() + defer ks.mu.RUnlock() + out := make([]keyRow, len(ks.rows)) + copy(out, ks.rows) + return out +} + +// unknownScope reports the first scope outside the gateway's closed set, and +// ok=false with it. An empty list is valid — the store defaults it — so this +// rejects only a scope that was actually asked for and cannot be granted. +func unknownScope(scopes []string) (string, bool) { + for _, s := range scopes { + if s != scopeAdmin && s != scopeReadOnly { + return s, false + } + } + return "", true +} + +// defaultScopes gives an unspecified scope list the gateway's own default. The +// real server applies it in the key store rather than the handler — both +// backends call one defaultScopes on the way into Create — so an absent, null +// and empty `scopes` all mint a least-privilege read-only key. Storing the +// empty list instead would have handed every fixture-backed test a scopeless +// key the real gateway never issues. +func defaultScopes(scopes []string) []string { + if len(scopes) == 0 { + return []string{scopeReadOnly} + } + return scopes +} + +// create returns the stored (masked) row and the full secret, which the caller +// serves exactly once. +func (ks *keyStore) create(name string, scopes []string, expiresAt *string) (keyRow, string) { + ks.mu.Lock() + defer ks.mu.Unlock() + id, secret := ks.nextID(), newSecret() + row := keyRow{ + ID: id, + Key: mask(secret), + Name: name, + Scopes: defaultScopes(scopes), + CreatedAt: ts(time.Now().UTC()), + ExpiresAt: expiresAt, + Active: true, + } + ks.rows = append(ks.rows, row) + ks.secrets[id] = secret + return row, secret +} + +// rotate replaces the secret in place, returning the row and the new secret. +func (ks *keyStore) rotate(id string) (keyRow, string, bool) { + ks.mu.Lock() + defer ks.mu.Unlock() + i := ks.indexOf(id) + if i < 0 { + return keyRow{}, "", false + } + secret := newSecret() + ks.rows[i].Key = mask(secret) + ks.rows[i].RotatedAt = sp(ts(time.Now().UTC())) + ks.secrets[id] = secret + return ks.rows[i], secret, true +} + +func (ks *keyStore) revoke(id string) bool { + ks.mu.Lock() + defer ks.mu.Unlock() + i := ks.indexOf(id) + if i < 0 { + return false + } + ks.rows[i].RevokedAt = sp(ts(time.Now().UTC())) + ks.rows[i].Active = false + return true +} + +func (ks *keyStore) remove(id string) bool { + ks.mu.Lock() + defer ks.mu.Unlock() + i := ks.indexOf(id) + if i < 0 { + return false + } + ks.rows = append(ks.rows[:i], ks.rows[i+1:]...) + delete(ks.secrets, id) + return true +} + +// indexOf is called with the lock held. +func (ks *keyStore) indexOf(id string) int { + for i := range ks.rows { + if ks.rows[i].ID == id { + return i + } + } + return -1 +} + +// mask is the gateway's read masking: first 8 characters, "...", last 4. +func mask(secret string) string { + if len(secret) < 12 { + return "..." + } + return secret[:8] + "..." + secret[len(secret)-4:] +} + +// registerKeys wires the /admin/keys surface onto the mux. +func registerKeys(mux *http.ServeMux, ks *keyStore) { + mux.HandleFunc("GET /admin/keys", func(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, ks.list()) // bare array, no envelope + }) + + // The real gateway serves this (internal/admin/handlers/server.go); leaving + // it out made `ferro keys get` 404 against the fake while working against a + // live gateway — a fixture gap that reads as a CLI bug. + mux.HandleFunc("GET /admin/keys/{id}", func(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + for _, row := range ks.list() { + if row.ID == id { + writeJSON(w, http.StatusOK, row) // masked, like every read + return + } + } + writeErr(w, http.StatusNotFound, kindNotFound, "api key not found") + }) + + mux.HandleFunc("POST /admin/keys", func(w http.ResponseWriter, r *http.Request) { + var in struct { + Name string `json:"name"` + Scopes []string `json:"scopes"` + ExpiresAt *string `json:"expires_at"` + } + if err := json.NewDecoder(r.Body).Decode(&in); err != nil { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "malformed request body") + return + } + if in.Name == "" { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "name is required") + return + } + if bad, ok := unknownScope(in.Scopes); !ok { + // model.ValidateScopes, worded and ordered exactly as it words it. + writeErr(w, http.StatusBadRequest, kindInvalidRequest, + fmt.Sprintf("unknown scope %q: valid scopes are %s, %s", bad, scopeAdmin, scopeReadOnly)) + return + } + // No nil-to-empty normalisation here: the store defaults an unspecified + // list, so a created row always carries at least one scope. + row, secret := ks.create(in.Name, in.Scopes, in.ExpiresAt) + row.Key = secret // the full secret, served exactly once + writeJSON(w, http.StatusCreated, row) + }) + + mux.HandleFunc("POST /admin/keys/{id}/rotate", func(w http.ResponseWriter, r *http.Request) { + row, secret, ok := ks.rotate(r.PathValue("id")) + if !ok { + writeErr(w, http.StatusNotFound, kindNotFound, msgKeyNotFound) + return + } + row.Key = secret // the new secret, served exactly once + writeJSON(w, http.StatusOK, row) + }) + + mux.HandleFunc("POST /admin/keys/{id}/revoke", func(w http.ResponseWriter, r *http.Request) { + if !ks.revoke(r.PathValue("id")) { + writeErr(w, http.StatusNotFound, kindNotFound, msgKeyNotFound) + return + } + writeJSON(w, http.StatusOK, map[string]any{fieldStatus: statusRevoked}) + }) + + mux.HandleFunc("DELETE /admin/keys/{id}", func(w http.ResponseWriter, r *http.Request) { + if !ks.remove(r.PathValue("id")) { + writeErr(w, http.StatusNotFound, kindNotFound, msgKeyNotFound) + return + } + w.WriteHeader(http.StatusNoContent) // 204, empty body + }) +} diff --git a/internal/fixture/state.go b/internal/fixture/state.go new file mode 100644 index 0000000..4d7e48b --- /dev/null +++ b/internal/fixture/state.go @@ -0,0 +1,37 @@ +// Package fixture serves stable gateway response shapes for the CLI and TUI. +// The shapes mirror supported HTTP responses and deliberately omit +// fields whose contract is unknown. +package fixture + +import "time" + +// defaultKey is the credential Default() accepts. Master keys are `fgw_`-prefixed. +const defaultKey = "fgw_test" + +// State picks which world the fake serves, so one handler covers the happy +// path, the degraded path, and the feature-absent path that drives the CLI's +// 404/501 degradation. Zero value = healthy and unauthenticated. +type State struct { + RequireAuth bool // admin routes 401 without a Bearer token + AcceptKey string // the credential RequireAuth accepts (default "fgw_test") + // Degraded is a HEALTHY gateway in trouble: /health stays 200 "ok" with a + // half-open circuit, and /readyz reports one target unroutable. Verified + // against a live gateway — a circuit does not make /health non-200. + Degraded bool + // NoProviders is the separate axis: no credential is configured, so + // /health is 503 "no_providers" with an EMPTY providers array. This is the + // default state of a credential-free gateway, and it is the one thing that + // makes /health non-200. + NoProviders bool + NoLogStore bool // /admin/logs and /admin/logs/stats return 501 + NoSessions bool // /admin/sessions returns 501 + NoMCP bool // omit mcp_servers from /readyz and /admin/health + ChatFails bool // emit a mid-stream error frame instead of [DONE] + ChatDelay time.Duration // per-chunk delay; 0 in tests, ~60ms for a visible demo +} + +// Default is the world most tests want: healthy, authenticated, every feature +// present. +func Default() State { + return State{RequireAuth: true, AcceptKey: defaultKey} +} diff --git a/internal/fixture/stream.go b/internal/fixture/stream.go new file mode 100644 index 0000000..76c94f7 --- /dev/null +++ b/internal/fixture/stream.go @@ -0,0 +1,163 @@ +package fixture + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "time" +) + +// registerChat wires the streaming chat surface. +// +// Only streaming requests are supported because the CLI contract defines the +// SSE response and the playground always streams. +func registerChat(mux *http.ServeMux, s State, tr *tracer) { + mux.HandleFunc("POST /v1/chat/completions", func(w http.ResponseWriter, r *http.Request) { + in, err := decodeChatRequest(r.Body) + if err != nil { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "malformed request body") + return + } + if in.Stream == nil || !*in.Stream { + writeErr(w, http.StatusBadRequest, kindInvalidRequest, "stream must be true") + return + } + if in.Model == "" { + in.Model = modelSonnet + } + // The X-Request-ID the middleware minted is the log row's trace_id. + // Recording it here is what closes the attribution loop the playground + // depends on: /admin/logs answers with a row carrying this exact id. + trace := w.Header().Get("X-Request-ID") + tr.set(trace, in.Model) + streamChat(w, s, in.Model, trace) + }) +} + +type chatInput struct { + Model string + Stream *bool +} + +func decodeChatRequest(r io.Reader) (chatInput, error) { + dec := json.NewDecoder(r) + tok, err := dec.Token() + if err != nil || tok != json.Delim('{') { + return chatInput{}, fmt.Errorf("chat request must be an object") + } + var in chatInput + sawStream := false + for dec.More() { + tok, err = dec.Token() + if err != nil { + return chatInput{}, err + } + key, ok := tok.(string) + if !ok { + return chatInput{}, fmt.Errorf("chat request member must be a string") + } + switch key { + case fieldModel: + err = dec.Decode(&in.Model) + case "stream": + if sawStream { + return chatInput{}, fmt.Errorf("duplicate stream member") + } + sawStream = true + err = dec.Decode(&in.Stream) + default: + err = dec.Decode(&json.RawMessage{}) + } + if err != nil { + return chatInput{}, err + } + } + if _, err = dec.Token(); err != nil { + return chatInput{}, err + } + if err = dec.Decode(&struct{}{}); err != io.EOF { + return chatInput{}, fmt.Errorf("chat request must contain one JSON value") + } + return in, nil +} + +// streamedText is the reply the fake types out, one delta per element. +var streamedText = []string{"Ferro ", "routed ", "this ", "through ", "the ", "fake ", "gateway."} + +// streamChat writes the documented SSE framing: `data: \n\n` lines only, +// no `event:` names, terminated by `data: [DONE]` — except on an errored +// stream, which ends with an error frame and NO [DONE]. That asymmetry is real +// gateway behavior; a fake that smoothed it over would hide the CLI bug it +// exists to catch. +func streamChat(w http.ResponseWriter, s State, model, id string) { + h := w.Header() + h.Set("Content-Type", "text/event-stream") + h.Set("Cache-Control", "no-cache") + h.Set("Connection", "keep-alive") + w.WriteHeader(http.StatusOK) + + flusher, canFlush := w.(http.Flusher) + // Flush per frame only when a delay is configured (the demo path, where a + // human watches text arrive). With ChatDelay == 0 the whole stream is + // written in one shot, so a test that does a single Read observes complete + // framing instead of racing the flusher. + live := s.ChatDelay > 0 + created := time.Now().Unix() + + frame := func(v any) { + b, _ := json.Marshal(v) + _, _ = fmt.Fprintf(w, "data: %s\n\n", b) + if live && canFlush { + flusher.Flush() + time.Sleep(s.ChatDelay) + } + } + chunk := func(choices []map[string]any) map[string]any { + return map[string]any{ + "id": id, + fieldObject: "chat.completion.chunk", + fieldCreated: created, + fieldModel: model, + "choices": choices, + } + } + delta := func(d map[string]any) []map[string]any { + return []map[string]any{{"index": 0, "delta": d}} + } + + frame(chunk(delta(map[string]any{"role": "assistant"}))) + + for i, word := range streamedText { + if s.ChatFails && i == 2 { + // Mid-stream failure: error frame, then the stream just ends. + frame(map[string]any{fieldError: map[string]any{ + fieldMessage: "upstream error from provider anthropic", + fieldType: "stream_error", + "code": "stream_error", + }}) + if canFlush { + flusher.Flush() + } + return + } + frame(chunk(delta(map[string]any{"content": word}))) + } + + frame(chunk([]map[string]any{{"index": 0, "delta": map[string]any{}, "finish_reason": "stop"}})) + + // The usage chunk always arrives (the gateway strips it only on an explicit + // include_usage:false); choices is [], never null. + usage := chunk([]map[string]any{}) + usage["usage"] = map[string]any{ + "prompt_tokens": 24, + "completion_tokens": len(streamedText), + "total_tokens": 24 + len(streamedText), + } + frame(usage) + + _, _ = fmt.Fprint(w, "data: [DONE]\n\n") + if canFlush { + flusher.Flush() + } +} diff --git a/internal/fixture/wire.go b/internal/fixture/wire.go new file mode 100644 index 0000000..00a7f11 --- /dev/null +++ b/internal/fixture/wire.go @@ -0,0 +1,148 @@ +package fixture + +// The gateway's wire vocabulary, in one place. +// +// This package is the in-repo definition of the gateway's HTTP contract, and +// the same field names recur across handlers that were written months apart — +// `status` alone appears in the health surface, the key surface, the plugin +// catalog and the model catalog. Spelled inline, one of them can drift from +// the rest and still compile, and the fixture then teaches every downstream +// test the wrong name for a field. +// +// The rule the file follows: a spelling written in three or more places gets a +// constant. A spelling below that gets one only when it completes a set already +// named here — the other provider, the other plugin type, the other stage — so +// no vocabulary ends up half constant and half literal. Everything a single +// handler writes once stays inline, where the wire shape reads as the wire. + +// JSON field names served on the wire. /admin/logs and /admin/audit name their +// query parameters after the fields they filter on, deliberately, so the +// filters share these constants with the rows they select. +const ( + fieldAction = "action" + fieldActor = "actor" + fieldActorID = "actor_id" + fieldAPIKeyID = "api_key_id" + fieldCapabilities = "capabilities" + fieldCircuit = "circuit" + fieldContextWindow = "context_window" + fieldCount = "count" + fieldCreated = "created" + fieldData = "data" + fieldDeprecated = "deprecated" + fieldDetail = "detail" + fieldEnabled = "enabled" + fieldError = "error" + fieldFailsOpen = "fails_open" + fieldLimit = "limit" + fieldMaxOutputTokens = "max_output_tokens" + fieldMessage = "message" + fieldMode = "mode" + fieldModel = "model" + fieldModels = "models" + fieldName = "name" + fieldObject = "object" + fieldOccurredAt = "occurred_at" + fieldOffset = "offset" + fieldOutcome = "outcome" + fieldOwnedBy = "owned_by" + fieldProvider = "provider" + fieldProviders = "providers" + fieldReady = "ready" + fieldScopes = "scopes" + fieldSettings = "settings" + fieldSince = "since" + fieldSourceIP = "source_ip" + fieldStage = "stage" + fieldStatus = "status" + fieldSummary = "summary" + fieldTotalEntries = "total_entries" + fieldType = "type" +) + +// The error envelope's `type`/`code` vocabulary, as writeErr serves it. +const ( + kindAuthentication = "authentication_error" + kindInvalidRequest = "invalid_request_error" + kindNotFound = "not_found_error" + kindServer = "server_error" +) + +// msgKeyNotFound is the one message three key routes share. +const msgKeyNotFound = "key not found" + +// Provider and model identity, repeated across /health, /readyz, /admin/health, +// /admin/providers, /admin/logs and /v1/models. +const ( + providerAnthropic = "anthropic" + providerOpenAI = "openai" + + modelSonnet = "claude-sonnet-4-6" + modelOpus = "claude-opus-4-6" + modelGPT4o = "gpt-4o" + modelGPT4oMini = "gpt-4o-mini" + modelEmbedding3Small = "text-embedding-3-small" + + // objectModel is the OpenAI object type a /v1/models row reports. It shares + // a spelling with fieldModel and means something else: one is the name of a + // field, the other is a value that field never carries. + objectModel = "model" +) + +// The closed vocabularies the gateway serves: key scopes, plugin stages, plugin +// types, the health words the CLI branches on, and the audit outcomes +// /admin/audit validates its query against. statusOK and outcomeOK share a +// spelling and nothing else — a health status and an audit outcome are separate +// sets that happen to have both settled on "ok". +const ( + scopeAdmin = "admin" + scopeReadOnly = "read_only" + + stageBeforeRequest = "before_request" + stageAfterRequest = "after_request" + stageOnError = "on_error" + + typeGuardrail = "guardrail" + typeLogging = "logging" + typeRateLimit = "ratelimit" + + // Every value the fixture ever serves under `status` is named here, so a + // reader can see the whole vocabulary the CLI branches on in one place and + // a new one cannot be added inline without joining it. + statusOK = "ok" + statusHealthy = "healthy" + statusDegraded = "degraded" + statusDisabled = "disabled" + statusAvailable = "available" + statusStable = "stable" + statusReady = "ready" + statusNotReady = "not_ready" + statusNoProviders = "no_providers" + statusRevoked = "revoked" + + circuitClosed = "closed" + circuitHalfOpen = "half_open" + + outcomeOK = "ok" + outcomeDenied = "denied" + outcomeError = "error" + + // modalityChat and modalityEmbedding are each both a model's mode and one + // of its capabilities — the same word for the same thing, so each is one + // constant rather than two. + modalityChat = "chat" + modalityEmbedding = "embedding" + capabilityStreaming = "streaming" + capabilityTools = "tools" + capabilityVision = "vision" +) + +// Seed identity: the ids and address the seeded rows cross-reference, so a key +// row, a session, an audit entry and a log row agree on which credential and +// which host they are talking about. +const ( + keyIDOps = "key_01" + keyIDCI = "key_02" + actorOps = "ops-laptop" + sourceIPLocal = "127.0.0.1" +) diff --git a/internal/table/format.go b/internal/table/format.go new file mode 100644 index 0000000..00deef2 --- /dev/null +++ b/internal/table/format.go @@ -0,0 +1,65 @@ +package table + +import ( + "fmt" + "time" +) + +// OrDash renders an empty string as "-". Every table cell that can be absent +// uses this rather than printing "": an empty cell collapses a column for +// anything splitting the table on whitespace, and reads as a blank status +// rather than as its absence. +func OrDash(s string) string { + if s == "" { + return "-" + } + return s +} + +// CountOrDash renders a count the gateway never supplied as "-", and one it +// supplied as the number it gave — a real zero included. Taking *int rather +// than int is what keeps the two apart: the gateway never asked and the +// gateway answered zero must not print the same cell. +func CountOrDash(n *int) string { + if n == nil { + return "-" + } + return fmt.Sprintf("%d", *n) +} + +// PositiveOrDash renders a measurement whose zero is not a real value — a +// model's context window, which no model publishes as 0 — so unlike +// CountOrDash a plain int is honest here: the two readings CountOrDash keeps +// apart genuinely coincide for this kind of value. +func PositiveOrDash(n int) string { + if n <= 0 { + return "-" + } + return fmt.Sprintf("%d", n) +} + +// BoolYN renders a bool as the table's yes/no vocabulary. +func BoolYN(b bool) string { + if b { + return "yes" + } + return "no" +} + +// FmtTime renders a wire timestamp in local time. RFC3339 keeps every table +// cell whitespace-free, so a piped table still splits into fields. +func FmtTime(t time.Time) string { + if t.IsZero() { + return "-" + } + return t.Local().Format(time.RFC3339) +} + +// FmtTimePtr renders an optional timestamp: "-" when the gateway did not +// supply one. +func FmtTimePtr(t *time.Time) string { + if t == nil { + return "-" + } + return FmtTime(*t) +} diff --git a/internal/table/plugins.go b/internal/table/plugins.go new file mode 100644 index 0000000..18a6adb --- /dev/null +++ b/internal/table/plugins.go @@ -0,0 +1,53 @@ +package table + +import "github.com/ferro-labs/gateway-cli/internal/api" + +// A plugin's fail policy is vocabulary the operator reads, so it is spelled +// once. "open" and "closed" answer what happens to a request when the plugin +// itself breaks: a logging or metrics plugin fails open and the request +// proceeds, while a guardrail, auth or rate limiter fails closed and the +// request does not. +const ( + FailsOpen = "open" + FailsClosed = "closed" +) + +// PluginPolicy is what this build's catalog says about one configured plugin. +// Fails is "-" when the catalog does not name the plugin at all — an unknown +// policy, which is a different claim from "closed". +type PluginPolicy struct { + Summary string + Fails string +} + +// PluginCatalog answers what a build ships, indexed by plugin name. +type PluginCatalog map[string]PluginPolicy + +// NewPluginCatalog indexes GET /admin/plugins/catalog. +// +// Only the catalog knows whether a plugin fails open, so both the scriptable +// table and the console must derive the FAILS cell from it. They each used to +// carry their own copy of this lookup and their own open/closed constants, +// which let one report a policy the other did not — for the same plugin, on +// the same gateway, in the same release. +func NewPluginCatalog(builtins []api.BuiltinPlugin) PluginCatalog { + c := make(PluginCatalog, len(builtins)) + for _, b := range builtins { + fails := FailsClosed + if b.FailsOpen { + fails = FailsOpen + } + c[b.Name] = PluginPolicy{Summary: b.Summary, Fails: fails} + } + return c +} + +// For resolves a configured plugin against the catalog. A plugin the build +// does not ship — registered out of tree — reports an unknown policy rather +// than being assumed to fail closed. +func (c PluginCatalog) For(name string) PluginPolicy { + if p, ok := c[name]; ok { + return p + } + return PluginPolicy{Fails: "-"} +} diff --git a/internal/table/table.go b/internal/table/table.go new file mode 100644 index 0000000..0f2acb8 --- /dev/null +++ b/internal/table/table.go @@ -0,0 +1,52 @@ +// Package table lays out headers and rows as an aligned, tab-padded table and +// renders the handful of "-"-for-missing-value cells that both cli/internal/tui +// and cli/internal/command print. It exists to break an import cycle: +// internal/command hands bare `ferro` off to internal/tui (see +// command/root.go's REPL wiring), so internal/tui can never import +// internal/command back — yet a verb read in the console and the same verb +// read through a pipe must render identically. This package imports neither +// of those two, and both call it instead of keeping their own copy. +package table + +import ( + "bytes" + "fmt" + "io" + "strings" + "text/tabwriter" +) + +// Write renders headers and rows as a plain, alignment-padded table to w: a +// header line, a dashed rule the width of each heading, then one line per +// row. No ANSI, no box drawing — this is the layout `ferro ` pipes to +// stdout, as likely to be read by awk as by a person. +func Write(w io.Writer, headers []string, rows [][]string) { + tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0) + _, _ = fmt.Fprintln(tw, strings.Join(headers, "\t")) + + dashes := make([]string, len(headers)) + for i, h := range headers { + dashes[i] = strings.Repeat("-", len(h)) + } + _, _ = fmt.Fprintln(tw, strings.Join(dashes, "\t")) + + for _, r := range rows { + _, _ = fmt.Fprintln(tw, strings.Join(r, "\t")) + } + _ = tw.Flush() +} + +// Rows renders headers and rows through the identical layout Write uses, but +// returns one string per output line — header, dashed rule, then one per data +// row — with trailing padding trimmed. It exists for a caller with no +// io.Writer of its own to hand tabwriter: the console transcript, which wraps +// each line as its own row and dims the header and its rule. +func Rows(headers []string, rows [][]string) []string { + var buf bytes.Buffer + Write(&buf, headers, rows) + lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n") + for i, l := range lines { + lines[i] = strings.TrimRight(l, " ") + } + return lines +} diff --git a/internal/table/table_test.go b/internal/table/table_test.go new file mode 100644 index 0000000..57fdfe7 --- /dev/null +++ b/internal/table/table_test.go @@ -0,0 +1,137 @@ +package table + +import ( + "bytes" + "strings" + "testing" + "time" +) + +func TestWriteRendersHeaderRuleAndRows(t *testing.T) { + var buf bytes.Buffer + Write(&buf, []string{"NAME", "STATE"}, [][]string{{"openai", "closed"}}) + + lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n") + if len(lines) != 3 { + t.Fatalf("want header + rule + 1 row, got %d lines:\n%s", len(lines), buf.String()) + } + if !strings.HasPrefix(lines[0], "NAME") { + t.Fatalf("header line: %q", lines[0]) + } + if !strings.HasPrefix(lines[1], "----") { + t.Fatalf("rule must be dashes matching header width, got %q", lines[1]) + } + if !strings.Contains(lines[2], "openai") { + t.Fatalf("row line: %q", lines[2]) + } +} + +// Rows must be Write's output split into lines, not a second layout — that is +// the whole point of routing both callers through one implementation. +func TestRowsMatchesWrite(t *testing.T) { + headers := []string{"NAME", "READY"} + cells := [][]string{{"filesystem", "yes"}, {"a-much-longer-server-name", "no"}} + + var buf bytes.Buffer + Write(&buf, headers, cells) + want := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n") + for i := range want { + want[i] = strings.TrimRight(want[i], " ") + } + + got := Rows(headers, cells) + if strings.Join(got, "\n") != strings.Join(want, "\n") { + t.Fatalf("Rows drifted from Write:\ngot: %q\nwant: %q", got, want) + } +} + +func TestOrDash(t *testing.T) { + for _, tc := range []struct{ in, want string }{ + {"", "-"}, + {"anthropic", "anthropic"}, + } { + if got := OrDash(tc.in); got != tc.want { + t.Errorf("OrDash(%q) = %q, want %q", tc.in, got, tc.want) + } + } +} + +func TestCountOrDashDistinguishesNilFromZero(t *testing.T) { + zero := 0 + five := 5 + for _, tc := range []struct { + name string + in *int + want string + }{ + {"nil means never asked", nil, "-"}, + {"zero is a real answer", &zero, "0"}, + {"a positive count", &five, "5"}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := CountOrDash(tc.in); got != tc.want { + t.Errorf("CountOrDash(%v) = %q, want %q", tc.in, got, tc.want) + } + }) + } +} + +func TestPositiveOrDashTreatsZeroAsAbsent(t *testing.T) { + for _, tc := range []struct { + name string + in int + want string + }{ + {"zero is not a real context window", 0, "-"}, + {"negative is not a real context window", -1, "-"}, + {"a real context window", 200000, "200000"}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := PositiveOrDash(tc.in); got != tc.want { + t.Errorf("PositiveOrDash(%d) = %q, want %q", tc.in, got, tc.want) + } + }) + } +} + +func TestBoolYN(t *testing.T) { + if BoolYN(true) != "yes" || BoolYN(false) != "no" { + t.Fatalf("BoolYN(true)=%q BoolYN(false)=%q", BoolYN(true), BoolYN(false)) + } +} + +func TestFmtTimeRendersLocalRFC3339(t *testing.T) { + if got := FmtTime(time.Time{}); got != "-" { + t.Fatalf("zero time must render as \"-\", got %q", got) + } + utc, err := time.Parse(time.RFC3339, "2026-08-08T09:00:00Z") + if err != nil { + t.Fatal(err) + } + // Pin the zone and assert a literal. Computing the expectation as + // utc.Local().Format(...) restates the implementation, and on a UTC + // machine — which CI is — it collapses to the same string however + // FmtTime handles zones, so the conversion would go untested precisely + // where it runs. FixedZone rather than LoadLocation because the test + // matrix includes Windows, where the tz database may not be present. + orig := time.Local + time.Local = time.FixedZone("IST", 5*60*60+30*60) + t.Cleanup(func() { time.Local = orig }) + + if got, want := FmtTime(utc), "2026-08-08T14:30:00+05:30"; got != want { + t.Fatalf("FmtTime must render in local time: got %q, want %q", got, want) + } +} + +func TestFmtTimePtr(t *testing.T) { + if got := FmtTimePtr(nil); got != "-" { + t.Fatalf("nil pointer must render as \"-\", got %q", got) + } + utc, err := time.Parse(time.RFC3339, "2026-08-08T09:00:00Z") + if err != nil { + t.Fatal(err) + } + if got, want := FmtTimePtr(&utc), FmtTime(utc); got != want { + t.Fatalf("FmtTimePtr(&t) = %q, want %q", got, want) + } +} diff --git a/internal/tui/app.go b/internal/tui/app.go new file mode 100644 index 0000000..a63a01f --- /dev/null +++ b/internal/tui/app.go @@ -0,0 +1,859 @@ +// Package tui is ferro's full-screen operations console. +// +// One root model (App) owns navigation, polling and layout; each screen is a +// plain struct with pure update/view funcs, so only this file touches the +// Bubble Tea interface and a v2 API surprise is contained to one adapter. +// +// Two rules make the whole package testable and honest: +// +// - Update delegates to the unexported update, which mutates the App and +// returns a command. Tests call it directly — no terminal, no program loop. +// - Nothing here performs I/O from a view func. Every request lives in a +// tea.Cmd in msgs.go and comes back as a typed message. +// +// Measurements are in terminal cells (lipgloss.Width), never bytes: a frame +// padded with len() breaks the first time a CJK model name or a styled glyph +// arrives. +package tui + +import ( + "fmt" + "strconv" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + "github.com/charmbracelet/x/ansi" + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/config" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" + "github.com/ferro-labs/gateway-cli/internal/version" +) + +// Screen is the pane the main frame is currently showing. +type Screen int + +// The screens the console can show. Each owns a pane; the shell owns the +// header, rail, composer, and polling. +const ( + ScreenHome Screen = iota + ScreenLogs + ScreenKeys + ScreenPlayground +) + +// Responsive breakpoints and the fixed rail geometry. +// Never render a border that cannot close within the measured width. +const ( + wideMin = 110 // mark + left rail + panels + mediumMin = 80 // compact brand + STATUS frame + railWidth = 34 + railGap = 2 + + // minSplitWidth is the narrowest main frame that can carry the + // TARGETS│TRAFFIC split header with both titles and a closing rule. + minSplitWidth = 30 + + // providerRows caps the rail's provider list; the remainder collapses + // into a "+N more" line rather than pushing SERVICES off screen. + providerRows = 6 + + // unknownCount marks a rail counter this gateway does not serve (404/501) + // or would not answer without a credential. It renders as a dash, never 0. + unknownCount = -1 + + // emDash is the one honest answer for a value that does not exist on the + // wire. There is no gateway version over HTTP, so the header prints this. + emDash = "—" +) + +// The connection states the header reads. The first two are the gateway's own +// words, matched against what /health reported; the third is ours, for a +// gateway that reported nothing at all. +const ( + stateConnected = "connected" + stateDegraded = "degraded" + stateUnreachable = "unreachable" +) + +// The provider states that count as working. Anything else earns the warning +// glyph, so a status this console has never heard of is shown as a concern +// rather than silently as health. +const ( + statusHealthy = "healthy" + statusAvailable = "available" +) + +// RailData is the left rail's four sources, already reduced to what it draws. +// A count of unknownCount means "not served", which is not the same as zero. +type RailData struct { + Providers []api.AdminProviderHealth // nil when unauthorized + MCPReady, MCPTotal int + PluginsActive int + Sessions int + AuditToday int + AuthError bool +} + +// App is the root model. Every field the screens read lives here; the polling +// bookkeeping below the line stays unexported. +type App struct { + Client *api.Client + Profile config.Resolved + Theme theme.Theme + + Width, Height int + Screen Screen + + // Composer is the console's only navigation surface; Transcript is what + // the home screen shows. Both are values: the App owns them outright. + Composer Composer + Transcript Transcript + + // The three screens below Home. Each is a value the App owns outright and + // each carries its own generation counter, so a message from a screen the + // operator has left is dropped rather than applied — the same contract + // pollGen gives the shell's own polls. + Logs logsScreen + Keys keysScreen + Play playScreen + + // Modal is the console's one overlay. It renders in place of the pane and + // takes every key while it is open, which is what makes a typed + // confirmation a confirmation rather than a race with the command line. + Modal *Modal + + // Status is the last GOOD report. A failed poll sets StatusErr and leaves + // this alone, so one dropped refresh never blanks the header — it ages it. + Status *api.StatusReport + StatusErr error + StatusAt time.Time + + Traffic *api.LogStats // nil → the TRAFFIC panel renders "—" + TrafficErr error + + Rail RailData + RailErr error + + // pollGen is bumped when the connection changes; a message carrying an + // older generation is dropped, so a slow in-flight response cannot + // overwrite state fetched against the newer profile. + pollGen int + + statusEvery, trafficEvery time.Duration +} + +var _ tea.Model = (*App)(nil) + +func newApp(client *api.Client, profile config.Resolved, mode theme.Mode) *App { + return &App{ + Client: client, + Profile: profile, + Theme: theme.New(mode), + // Replaced by the first WindowSizeMsg; a sane default keeps the very + // first frame from drawing at 0 cells. + Width: 100, + Height: 30, + Screen: ScreenHome, + Rail: RailData{PluginsActive: unknownCount, Sessions: unknownCount, AuditToday: unknownCount}, + Composer: newComposer(Verbs(nil)), + statusEvery: statusPoll, + trafficEvery: trafficPoll, + } +} + +// Run starts the console. The caller has already established that stdout is a +// terminal — a bare `ferro` on a pipe must never draw this. +// +// root is the caller's own cobra tree, and the composer's vocabulary is walked +// out of it: the console completes exactly what the CLI can run. It is passed +// in rather than built here because internal/command is what hands bare `ferro` +// to this function, so importing it back would be a cycle. +func Run(client *api.Client, profile config.Resolved, mode theme.Mode, root *cobra.Command) error { + a := newApp(client, profile, mode) + a.Composer = newComposer(Verbs(root)) + _, err := tea.NewProgram(a).Run() + return err +} + +// Init starts the polling loops. Part of tea.Model. +func (a *App) Init() tea.Cmd { + return tea.Batch( + fetchStatus(a.Client, a.pollGen), + fetchRail(a.Client, a.pollGen, a.Rail), + fetchTraffic(a.Client, a.pollGen), + tickStatus(a.statusEvery), + tickTraffic(a.trafficEvery), + ) +} + +// Update delegates to update, which mutates a and returns a command. Tests +// drive that directly, with no terminal. Part of tea.Model. +func (a *App) Update(msg tea.Msg) (tea.Model, tea.Cmd) { return a, a.update(msg) } + +// View is the only adapter that knows about tea.View. Everything else — every +// screen, every test — deals in strings. +func (a *App) View() tea.View { + v := tea.NewView(a.render()) + v.AltScreen = true + return v +} + +func (a *App) update(msg tea.Msg) tea.Cmd { + switch m := msg.(type) { + case tea.WindowSizeMsg: + a.Width, a.Height = m.Width, m.Height + // The playground lays its markdown out ahead of the view, so it is the + // one screen that has to be told the pane changed size. + a.Play.resize(a.paneWidth()) + return nil + + case tea.KeyPressMsg: + key := m.String() + if key == keyCtrlC { + a.Play.leave() + a.Logs.leave() + a.Keys.leave() + return tea.Quit + } + if a.Modal != nil { + // An open modal owns the keyboard outright. A confirmation whose + // keys also reach the command line is not a confirmation. + return a.Modal.handle(key, a) + } + prev := a.Screen + if a.screenKey(key) { + return nil + } + // The composer owns every other key, esc included: in reverse search + // esc abandons the search, and only outside it does esc mean "back". + return a.left(prev, a.Composer.handle(key, a)) + + case runCmdMsg: + prev := a.Screen + return a.left(prev, a.route(m.raw)) + + case keysListMsg, modalResultMsg: + return a.Keys.update(a, msg) + + case logsBatchMsg, logsNamesMsg, tickLogsMsg: + return a.Logs.update(a, msg) + + case playModelsMsg, chatOpenMsg, chatDeltaMsg, chatUsageMsg, chatEndMsg, chatMetaMsg, flushTickMsg: + return a.Play.update(a, msg) + + case verbRowsMsg: + a.Transcript.Push(m.rows...) + if m.err != nil { + // The gateway's own words, not a paraphrase: an api.Error already + // says what failed and often what to do about it. + a.Transcript.Push(TranscriptRow{Glyph: kindBad, Text: m.err.Error()}) + } + a.Transcript.Push(TranscriptRow{ + Text: fmt.Sprintf("Completed in %dms", m.took.Milliseconds()), + Dim: true, + }) + return nil + + case statusMsg: + if m.gen != a.pollGen { + return nil + } + if m.err != nil { + a.StatusErr = m.err + a.statusEvery = backoff(a.statusEvery) + // api.Status returns a report alongside its error so the caller can + // still name the URL it tried. Adopt it only when nothing better is + // held — a good report is never replaced by a failure's. + if a.Status == nil && m.report != nil { + a.Status, a.StatusAt = m.report, time.Now() + } + return nil + } + a.Status, a.StatusErr, a.StatusAt = m.report, nil, time.Now() + a.statusEvery = statusPoll + return nil + + case trafficMsg: + if m.gen != a.pollGen { + return nil + } + if m.err != nil { + a.TrafficErr = m.err + a.trafficEvery = backoff(a.trafficEvery) + return nil + } + a.Traffic, a.TrafficErr = m.stats, nil + a.trafficEvery = trafficPoll + return nil + + case railMsg: + if m.gen != a.pollGen { + return nil + } + a.Rail, a.RailErr = m.data, m.err + return nil + + case tickStatusMsg: + return tea.Batch(fetchStatus(a.Client, a.pollGen), fetchRail(a.Client, a.pollGen, a.Rail), tickStatus(a.statusEvery)) + + case tickTrafficMsg: + return tea.Batch(fetchTraffic(a.Client, a.pollGen), tickTraffic(a.trafficEvery)) + } + return nil +} + +// backoff doubles a poll interval, capped, so an unreachable gateway is probed +// less often the longer it stays down. A success resets it at the call site. +func backoff(d time.Duration) time.Duration { + if d *= 2; d > maxPoll { + return maxPoll + } + return d +} + +// ---------------------------------------------------------------- rendering + +// render composes the whole screen. It is a pure function of App state: no +// network, no clock beyond the stale-age readout. +func (a *App) render() string { + wide := a.Width >= wideMin + medium := !wide && a.Width >= mediumMin + + var header string + if wide && a.Screen == ScreenHome { + header = a.viewBrandBlock() + } else { + header = a.compactBrand() + } + + mainW := a.Width + if wide { + mainW = a.Width - railWidth - railGap + } + + // Line budget: header + blank + body + composer + hints(1). The composer + // is measured rather than assumed: it grows by two lines when it has + // suggestions to show, and the pane must give those lines up so the header + // does not scroll off the top of the screen. + composer := a.composerView() + fixed := lipgloss.Height(header) + 2 + lipgloss.Height(composer) + overhead := 2 // a plain frame's top and bottom borders + if wide || medium { + overhead = 7 // top + 3 stat rows + divider + pane title + bottom + } + if medium { + fixed += 6 // the STATUS frame and its trailing newline + } + rows := max(a.Height-fixed-overhead, 1) + + main := a.mainFrame(mainW, wide || medium, rows) + + var b strings.Builder + b.WriteString(header) + b.WriteString("\n\n") + switch { + case wide: + rail := lipgloss.JoinVertical(lipgloss.Left, + a.Theme.Frame("CONNECTED PROVIDERS", a.viewProviders(), railWidth), + a.Theme.Frame("SERVICES", a.viewServices(), railWidth)) + b.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, rail, strings.Repeat(" ", railGap), main)) + case medium: + b.WriteString(a.Theme.Frame("STATUS", a.viewCompactStatus(), a.Width)) + b.WriteString("\n") + b.WriteString(main) + default: + b.WriteString(main) + } + b.WriteString("\n") + b.WriteString(composer) + b.WriteString("\n") + b.WriteString(a.viewHints()) + return b.String() +} + +// viewBrandBlock is the wide home header: the split-F mark beside the text +// stack. Every value in it is real — see stateLine and originLine. +func (a *App) viewBrandBlock() string { + stackW := max(a.Width-lipgloss.Width(theme.Mark(a.Theme))-3, 10) + stack := strings.Join(clampLines([]string{ + a.brand() + " " + a.Theme.Dim.Render(version.Version), + a.Theme.Border.Render(a.rule(10)), + a.Theme.Text.Render("AI Gateway"), + a.stateLine(), + a.Theme.Dim.Render(a.originLine()), + }, stackW), "\n") + return lipgloss.JoinHorizontal(lipgloss.Top, theme.Mark(a.Theme), " ", stack) +} + +// compactBrand is the one-line header every other width and screen gets: the +// artwork collapses before any operational data does. +func (a *App) compactBrand() string { + line := a.brand() + " " + a.Theme.Dim.Render(version.Version) + " " + a.stateLine() + return ansi.Truncate(line, a.Width, "") +} + +// brand is the wordmark. Bold is still an ANSI escape, so it is gated on the +// same Color switch NO_COLOR and a non-TTY stdout turn off. +func (a *App) brand() string { + return a.Theme.Bright.Bold(a.Theme.Mode.Color).Render("Ferro Labs") +} + +// stateLine is the connection readout: glyph and colour from the report's own +// state, then profile, URL and the client-measured round trip. When the last +// poll failed the line keeps its data and gains a staleness age. +func (a *App) stateLine() string { + g := a.Theme.Mode.Glyphs() + glyph, label, style := g.None, "connecting", a.Theme.Dim + if a.Status != nil { + switch a.Status.State { + case stateConnected: + glyph, label, style = g.Dot, stateConnected, a.Theme.OK + case stateDegraded: + glyph, label, style = g.Warn, stateDegraded, a.Theme.Warn + default: + glyph, label, style = g.Bad, a.Status.State, a.Theme.Bad + } + } else if a.StatusErr != nil { + glyph, label, style = g.Bad, stateUnreachable, a.Theme.Bad + } + + parts := []string{} + if a.Profile.ProfileName != "" { + parts = append(parts, a.Profile.ProfileName) + } + parts = append(parts, a.url()) + if a.Status != nil && a.Status.LatencyMs > 0 { + parts = append(parts, fmt.Sprintf("%dms", a.Status.LatencyMs)) + } + if a.StatusErr != nil && !a.StatusAt.IsZero() { + parts = append(parts, fmt.Sprintf("stale %ds", int(time.Since(a.StatusAt).Seconds()))) + } else if a.StatusErr != nil { + parts = append(parts, "stale") + } + return style.Render(glyph+" "+label) + a.Theme.Dim.Render(" · "+strings.Join(parts, " · ")) +} + +// originLine is the counts row. The gateway serves no version over HTTP, so +// that segment is a dash — never a guess. +func (a *App) originLine() string { + parts := []string{"gateway " + a.dash()} + if a.Status != nil { + // A gateway that did not report targets gets a dash. /readyz answers a + // 503 carrying only {status, reason}, and "0 targets" there would read + // as "none configured" during exactly the outage this header is read in. + if t := a.Status.Targets; t != nil { + parts = append(parts, fmt.Sprintf("%d targets", t.Total)) + } else { + parts = append(parts, a.dash()+" targets") + } + if n := a.Status.Models; n != nil { + parts = append(parts, comma(*n)+" models") + } + } + return strings.Join(parts, " · ") +} + +func (a *App) url() string { + if a.Status != nil && a.Status.URL != "" { + return a.Status.URL + } + return a.Profile.URL +} + +// ------------------------------------------------------------------- panels + +// mainFrame draws the console's main frame. With panels it carries the split +// header layout that theme.Frame cannot express: +// +// ┌─ TARGETS ──────────┬─ TRAFFIC ──────────┐ +// │ Healthy 7 │ RPS 159.0 │ +// ├────────────────────┴────────────────────┤ +// │ COMMAND OUTPUT │ +// └─────────────────────────────────────────┘ +// +// This is the one frame drawn outside the theme; everything else goes through +// it. Below minSplitWidth the split cannot close, so the pane falls back to a +// plain titled frame. +func (a *App) mainFrame(w int, panels bool, rows int) string { + if !panels || w < minSplitWidth { + return a.Theme.Frame(a.paneTitle(), a.paneView(w-4, rows), w) + } + b := a.boxChars() + bd := a.Theme.Border + lw := (w - 3) / 2 + rw := w - 3 - lw + + out := make([]string, 0, rows+7) + out = append(out, bd.Render(b.tl+b.h)+" "+a.Theme.Dim.Render("TARGETS")+" "+ + bd.Render(strings.Repeat(b.h, lw-10)+b.tj+b.h)+" "+a.Theme.Dim.Render("TRAFFIC")+" "+ + bd.Render(strings.Repeat(b.h, rw-10)+b.tr)) + + targets, traffic := a.viewTargets(), a.viewTraffic() + edge := bd.Render(b.v) + for i := range 3 { + out = append(out, edge+" "+padRight(targets[i], lw-2)+" "+edge+" "+padRight(traffic[i], rw-2)+" "+edge) + } + out = append(out, bd.Render(b.lj+strings.Repeat(b.h, lw)+b.bj+strings.Repeat(b.h, rw)+b.rj)) + + body := append([]string{a.Theme.Bright.Render(a.paneTitle())}, strings.Split(a.paneView(w-4, rows), "\n")...) + for _, line := range body { + out = append(out, edge+" "+padRight(line, w-4)+" "+edge) + } + out = append(out, bd.Render(b.bl+strings.Repeat(b.h, w-2)+b.br)) + return strings.Join(out, "\n") +} + +// viewTargets is the TARGETS panel: routable targets, and the two circuit +// states that explain the difference. No report → dashes, never zeros. +func (a *App) viewTargets() [3]string { + if a.Status == nil { + d := a.dash() + return [3]string{ + padRight("Healthy", 14) + d, + padRight("Degraded", 14) + d, + padRight("Open circuit", 14) + d, + } + } + warn := func(n int, style lipgloss.Style) string { + if n > 0 { + return style.Render(strconv.Itoa(n)) + } + return strconv.Itoa(n) + } + // Circuits are reported by /health, which answers even when /readyz is a + // bare 503 — so they stay real while the target counts go absent. + healthy := a.Theme.Dim.Render(a.dash()) + if t := a.Status.Targets; t != nil { + healthy = a.Theme.OK.Render(strconv.Itoa(t.Routable)) + } + return [3]string{ + padRight("Healthy", 14) + healthy, + padRight("Degraded", 14) + warn(a.Status.Circuits.HalfOpen, a.Theme.Warn), + padRight("Open circuit", 14) + warn(a.Status.Circuits.Open, a.Theme.Bad), + } +} + +// viewTraffic derives the panel from one /admin/logs/stats window. Every +// unknown renders as a dash: a gateway with no log store answers 501, which is +// an absence of data, not a zero and not an error state. +func (a *App) viewTraffic() [3]string { + rps, p95, errRate := a.dash(), a.dash(), a.dash() + if t := a.Traffic; t != nil { + rps = fmt.Sprintf("%.1f", float64(t.Summary.TotalEntries)/trafficWindow.Seconds()) + if t.LatencyMs != nil { + p95 = fmt.Sprintf("%.0fms", t.LatencyMs.P95) + } + if t.Summary.TotalEntries > 0 { + errRate = fmt.Sprintf("%.2f%%", 100*float64(t.Summary.ErrorEntries)/float64(t.Summary.TotalEntries)) + } + } + // 7 cells, not 5: a p95 of 1284ms truncated to "1284m" does not read as a + // clipped number, it reads as minutes. + return [3]string{ + padRight("RPS", 14) + padLeft(rps, 7), + padRight("P95", 14) + padLeft(p95, 7), + padRight("Errors", 14) + padLeft(errRate, 7), + } +} + +// --------------------------------------------------------------------- rail + +// viewProviders is the CONNECTED PROVIDERS frame body. There is no per-provider +// latency on the wire, so the right column is the model count the gateway +// actually reports. +func (a *App) viewProviders() string { + inner := railWidth - 4 + g := a.Theme.Mode.Glyphs() + if a.Rail.AuthError { + return a.Theme.Dim.Render(padRight("auth required "+a.dash()+" set FERRO_API_KEY", inner)) + } + if len(a.Rail.Providers) == 0 { + return a.Theme.Dim.Render(padRight("no providers reported", inner)) + } + shown := min(len(a.Rail.Providers), providerRows) + lines := make([]string, 0, shown+1) + for _, p := range a.Rail.Providers[:shown] { + glyph := a.Theme.OK.Render(g.Dot) + if p.Status != statusHealthy && p.Status != statusAvailable { + glyph = a.Theme.Warn.Render(g.Warn) + } + lines = append(lines, gapPad(inner, glyph+" "+p.Name, a.Theme.Dim.Render(comma(p.Models)+" models"))) + } + if rest := len(a.Rail.Providers) - shown; rest > 0 { + lines = append(lines, a.Theme.Dim.Render(fmt.Sprintf("+%d more", rest))) + } + return strings.Join(lines, "\n") +} + +// viewServices is the SERVICES frame body: the four readiness counters the +// mock keeps permanently on screen. +func (a *App) viewServices() string { + mcp := a.dash() + style := a.Theme.Text + if a.Rail.MCPTotal > 0 { + mcp = fmt.Sprintf("%d/%d ready", a.Rail.MCPReady, a.Rail.MCPTotal) + if a.Rail.MCPReady < a.Rail.MCPTotal { + style = a.Theme.Warn + } else { + style = a.Theme.OK + } + } + // Label column 16 + the longest value ("N events today") is exactly the + // rail's 30 inner cells; widening it truncates the audit row. + return strings.Join([]string{ + padRight("MCP servers", 16) + style.Render(mcp), + padRight("Plugins", 16) + a.count(a.Rail.PluginsActive, "active", a.Theme.OK), + padRight("Sessions", 16) + a.count(a.Rail.Sessions, "operators", a.Theme.Text), + padRight("Audit", 16) + a.count(a.Rail.AuditToday, "events today", a.Theme.Dim), + }, "\n") +} + +// count renders a rail counter, or a dash when the gateway does not serve it. +func (a *App) count(n int, unit string, style lipgloss.Style) string { + if n == unknownCount { + return a.Theme.Dim.Render(a.dash()) + } + return style.Render(fmt.Sprintf("%d %s", n, unit)) +} + +// viewCompactStatus is the medium-width collapse of the rail plus the header +// details the one-line brand cannot carry. +func (a *App) viewCompactStatus() string { + // "gateway " is the header's phrasing; here the row label already + // says Gateway, so the dash stands alone rather than repeating the word. + gateway, targets, providers := a.dash(), a.dash(), a.dash() + if a.Status != nil { + if a.Status.LatencyMs > 0 { + gateway += fmt.Sprintf(" · %dms", a.Status.LatencyMs) + } + routable := a.dash() + "/" + a.dash() + if t := a.Status.Targets; t != nil { + routable = fmt.Sprintf("%d/%d", t.Routable, t.Total) + } + targets = fmt.Sprintf("%s routable · %d degraded · %d open", + routable, a.Status.Circuits.HalfOpen, a.Status.Circuits.Open) + // A count the gateway supplied is shown as given, zero included; one it + // never supplied leaves the dash these start as. + if n := a.Status.Providers; n != nil { + providers = strconv.Itoa(*n) + } + if n := a.Status.Models; n != nil { + providers += " · " + comma(*n) + " models" + } + } + services := fmt.Sprintf("MCP %s · plugins %s · sessions %s · audit %s", + a.mcpRatio(), plainCount(a.Rail.PluginsActive, a.dash()), + plainCount(a.Rail.Sessions, a.dash()), plainCount(a.Rail.AuditToday, a.dash())) + if a.Rail.AuthError { + services = "auth required " + a.dash() + " set FERRO_API_KEY" + } + inner := a.Width - 4 + return strings.Join(clampLines([]string{ + padRight("Gateway", 12) + a.Theme.Dim.Render(gateway), + padRight("Targets", 12) + a.Theme.Text.Render(targets), + padRight("Providers", 12) + a.Theme.Text.Render(providers), + padRight("Services", 12) + a.Theme.Dim.Render(services), + }, inner), "\n") +} + +func (a *App) mcpRatio() string { + if a.Rail.MCPTotal == 0 { + return a.dash() + } + return fmt.Sprintf("%d/%d", a.Rail.MCPReady, a.Rail.MCPTotal) +} + +func plainCount(n int, dash string) string { + if n == unknownCount { + return dash + } + return strconv.Itoa(n) +} + +// --------------------------------------------------------- pane + composer + +func (a *App) paneTitle() string { + switch a.Screen { + case ScreenLogs: + return "LOGS" + case ScreenKeys: + return "KEYS" + case ScreenPlayground: + return "PLAYGROUND" + default: + return "COMMAND OUTPUT" + } +} + +// paneView dispatches to the current screen's body. Every branch returns +// exactly rows lines, at most w cells wide, so the composer stays anchored to +// the bottom of the screen whatever is on show above it. +// +// A modal renders IN PLACE of the pane rather than over it. There is nothing +// to dim behind an overlay in a terminal, and the pane's exact-line contract is +// the one thing an overlay would have to break. +func (a *App) paneView(w, rows int) string { + if a.Modal != nil { + return a.Modal.view(a, w, rows) + } + switch a.Screen { + case ScreenLogs: + return a.Logs.view(a, w, rows) + case ScreenKeys: + return a.Keys.view(a, w, rows) + case ScreenPlayground: + return a.Play.view(a, w, rows) + default: + return a.homeView(w, rows) + } +} + +// paneWidth is the width paneView will next be called with, derived exactly as +// render() derives it. A screen that lays content out ahead of the view — the +// playground wraps markdown when a delta batch flushes, not per frame — needs +// the number outside a view func. +func (a *App) paneWidth() int { + w := a.Width + if w >= wideMin { + w -= railWidth + railGap + } + return max(w-4, 1) +} + +// screenKey offers a key to the pane before the composer sees it and reports +// whether the pane took it. +// +// The pane is only offered a key while the command line is EMPTY. The composer +// is the console's only navigation surface, so typing `keys` from the logs +// screen has to outrank moving a cursor — which is also why the selection keys +// are ↑/↓ and not j/k: `k` is the first letter of a verb, and a screen that +// swallowed it would make that verb untypeable from this pane. +func (a *App) screenKey(key string) bool { + if a.Composer.searchMode || a.Composer.Input != "" { + return false + } + switch a.Screen { + case ScreenLogs: + return a.Logs.handleKey(key) + case ScreenKeys: + return a.Keys.handleKey(key) + } + return false +} + +// left cancels the screen the shell has just moved off. Every path that can +// change a.Screen funnels through here — the router, and the composer's own +// esc — so a tail keeps ticking and a stream keeps streaming for exactly as +// long as its pane is on show, and not one message longer. +func (a *App) left(prev Screen, cmd tea.Cmd) tea.Cmd { + if a.Screen == prev { + return cmd + } + switch prev { + case ScreenLogs: + a.Logs.leave() + case ScreenKeys: + a.Keys.leave() + case ScreenPlayground: + a.Play.leave() + } + return cmd +} + +func (a *App) composerView() string { return a.Composer.view(a) } + +func (a *App) viewHints() string { + left, right := "↵ run tab complete ↑ history ctrl+r search", "? help ctrl+c quit" + if a.Theme.Mode.ASCII { + left = "enter run tab complete up history ctrl+r search" + } + return gapPad(a.Width, " "+a.Theme.Dim.Render(left), a.Theme.Dim.Render(right)) +} + +// ------------------------------------------------------------------ helpers + +// boxChars mirrors the theme's border vocabulary with the two junctions the +// split header needs; theme.Frame draws no junctions, so it exports none. +type boxChars struct{ tl, tr, bl, br, h, v, tj, bj, lj, rj string } + +func (a *App) boxChars() boxChars { + if a.Theme.Mode.ASCII { + return boxChars{"+", "+", "+", "+", "-", "|", "+", "+", "+", "+"} + } + return boxChars{"┌", "┐", "└", "┘", "─", "│", "┬", "┴", "├", "┤"} +} + +func (a *App) dash() string { + if a.Theme.Mode.ASCII { + return "-" + } + return emDash +} + +func (a *App) rule(n int) string { + if a.Theme.Mode.ASCII { + return strings.Repeat("-", n) + } + return strings.Repeat("─", n) +} + +// padRight pads or truncates to exactly w cells. ANSI-aware in both directions: +// measuring ignores escape sequences and truncation keeps them intact. +func padRight(s string, w int) string { + if w <= 0 { + return "" + } + s = ansi.Truncate(s, w, "") + if p := w - lipgloss.Width(s); p > 0 { + s += strings.Repeat(" ", p) + } + return s +} + +func padLeft(s string, w int) string { + if w <= 0 { + return "" + } + s = ansi.Truncate(s, w, "") + if p := w - lipgloss.Width(s); p > 0 { + s = strings.Repeat(" ", p) + s + } + return s +} + +// gapPad lays left and right out at the two ends of exactly w cells, giving up +// the left side first when they cannot both fit. +func gapPad(w int, left, right string) string { + if w <= 0 { + return "" + } + right = ansi.Truncate(right, w, "") + rw := lipgloss.Width(right) + left = ansi.Truncate(left, max(w-rw-1, 0), "") + return left + strings.Repeat(" ", max(w-lipgloss.Width(left)-rw, 0)) + right +} + +func clampLines(lines []string, w int) []string { + out := make([]string, len(lines)) + for i, l := range lines { + out[i] = ansi.Truncate(l, w, "") + } + return out +} + +// comma groups thousands. 2500 models reads as a quantity; 2500 reads as an id. +func comma(n int) string { + s := strconv.Itoa(n) + sign := "" + if strings.HasPrefix(s, "-") { + sign, s = "-", s[1:] + } + for i := len(s) - 3; i > 0; i -= 3 { + s = s[:i] + "," + s[i:] + } + return sign + s +} diff --git a/internal/tui/app_test.go b/internal/tui/app_test.go new file mode 100644 index 0000000..ca43622 --- /dev/null +++ b/internal/tui/app_test.go @@ -0,0 +1,528 @@ +package tui + +import ( + "errors" + "io" + "net/http" + "net/http/httptest" + "regexp" + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/config" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// testApp builds a fully-populated shell with no client: every test here is +// pure MVU — no terminal, no program loop, no network. +func testApp(w, h int) *App { + a := newApp(nil, config.Resolved{ProfileName: "local", URL: "http://localhost:8080"}, theme.Mode{}) + a.Width, a.Height = w, h + a.Status = &api.StatusReport{ + State: "connected", + URL: "http://localhost:8080", + LatencyMs: 23, + Providers: api.Count(8), + Models: api.Count(2500), + Targets: &api.TargetSummary{Total: 8, Routable: 7}, + Circuits: api.CircuitSummary{Open: 0, HalfOpen: 1}, + MCP: &api.MCPSummary{Ready: 3, Total: 4}, + Auth: "admin", + } + a.StatusAt = time.Now() + a.Traffic = testStats(47700, 200, 916) + a.Rail = RailData{ + Providers: []api.AdminProviderHealth{ + {Name: "openai", Status: "healthy", Models: 1104}, + {Name: "anthropic", Status: "healthy", Models: 412}, + {Name: "gemini", Status: "healthy", Models: 96}, + {Name: "groq", Status: "healthy", Models: 40}, + {Name: "mistral", Status: "healthy", Models: 32}, + {Name: "cohere", Status: "healthy", Models: 18}, + {Name: "deepseek", Status: "healthy", Models: 9}, + {Name: "xai", Status: "healthy", Models: 6}, + }, + MCPReady: 3, MCPTotal: 4, + PluginsActive: 6, Sessions: 2, AuditToday: 4, + } + return a +} + +func testStats(total, errs int, p95 float64) *api.LogStats { + s := &api.LogStats{} + s.Summary.TotalEntries = total + s.Summary.ErrorEntries = errs + s.LatencyMs = &api.Percentiles{P50: 210, P95: p95, P99: 1800, Count: total} + return s +} + +func TestBreakpointComposition(t *testing.T) { + a := testApp(126, 40) + view := a.render() + for _, s := range []string{"CONNECTED PROVIDERS", "SERVICES", "TARGETS", "TRAFFIC", "COMMAND"} { + if !strings.Contains(view, s) { + t.Fatalf("wide view missing %q:\n%s", s, view) + } + } + + a.Width = 96 + if v := a.render(); strings.Contains(v, "CONNECTED PROVIDERS") || !strings.Contains(v, "STATUS") { + t.Fatalf("medium must collapse rail into STATUS frame:\n%s", v) + } + + a.Width = 72 + if v := a.render(); strings.Contains(v, "STATUS") || !strings.Contains(v, "COMMAND") { + t.Fatalf("narrow is pane + composer only:\n%s", v) + } +} + +// TestEveryViewLineFitsWidth is the box-drawing guard: a single line wider than +// the terminal wraps and destroys every frame below it. +func TestEveryViewLineFitsWidth(t *testing.T) { + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + for _, w := range []int{72, 96, 126} { + a := testApp(w, 40) + a.Theme = theme.New(mode) + for i, line := range strings.Split(a.render(), "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } +} + +// The same guard, with each screen and a modal on show: the box drawing has to +// survive what the panes put inside it, not just an empty transcript. +func TestEveryViewLineFitsWidthOnEveryScreen(t *testing.T) { + now := time.Now() + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + for _, w := range []int{72, 96, 126} { + a := composerApp() + a.Theme, a.Width = theme.New(mode), w + + a.route("logs --since 15m --model claude-sonnet-4-6") + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{ + logRow("tr_00000001", now), logRow("tr_00000002", now.Add(time.Second)), + }}) + a.Logs.sel, a.Logs.detail = 0, true + + a.update(keysListMsg{gen: a.Keys.gen, keys: []api.Key{ + {ID: "key_01", Key: "fgw_abcd…wxyz", Name: "ops-laptop", Scopes: []string{"admin"}, Active: true}, + }}) + a.Keys.sel, a.Keys.detail = 0, true + + a.route("playground") + a.Play.submit(a, "a prompt long enough to wrap at every width under test") + a.update(chatDeltaMsg{gen: a.Play.gen, text: strings.Repeat("streamed words ", 12)}) + a.update(flushTickMsg{gen: a.Play.gen}) + a.update(chatEndMsg{gen: a.Play.gen, done: true}) + a.update(chatMetaMsg{gen: a.Play.gen, row: &api.LogEntry{Provider: "anthropic", CostUSD: f64(0.0031)}}) + + for _, screen := range []Screen{ScreenHome, ScreenLogs, ScreenKeys, ScreenPlayground} { + a.Screen = screen + for _, modal := range []*Modal{nil, { + Title: "Rotate ops-laptop?", + Body: "Blast radius: every client holding the current secret fails immediately\nuntil it is redeployed with the new one.", + Rows: []ModalKV{{K: "id", V: "key_01"}, {K: "last used", V: "3 minutes ago · 41,000 requests", Warn: true}}, + Input: true, + Placeholder: `type "ops-laptop" to confirm`, + Confirm: "ops-laptop", + OKLabel: "rotate", + Danger: true, + }} { + a.Modal = modal + for i, line := range strings.Split(a.render(), "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d screen=%v modal=%t line %d overflows: %d cells %q", + mode, w, screen, modal != nil, i, lw, line) + } + } + } + } + } + } +} + +func TestNarrowUnderMinimumStillRenders(t *testing.T) { + a := testApp(20, 12) + for i, line := range strings.Split(a.render(), "\n") { + if lw := lipgloss.Width(line); lw > 20 { + t.Fatalf("line %d overflows at w=20: %d cells %q", i, lw, line) + } + } +} + +func TestFailedPollKeepsLastGoodStatus(t *testing.T) { + a := testApp(126, 40) + a.Status, a.StatusErr = nil, nil + + good := &api.StatusReport{State: "connected", Providers: api.Count(3)} + a.update(statusMsg{gen: 0, report: good}) + a.update(statusMsg{gen: 0, err: errors.New("boom")}) + + if a.Status != good || a.StatusErr == nil { + t.Fatalf("stale data must persist with its age; errors annotate, never erase (status=%v err=%v)", a.Status, a.StatusErr) + } + if !strings.Contains(a.render(), "stale") { + t.Fatal("a stale header must say so") + } +} + +func TestStalePollGenerationDropped(t *testing.T) { + a := testApp(126, 40) + a.Status = nil + a.pollGen = 1 + a.update(statusMsg{gen: 0, report: &api.StatusReport{State: "connected"}}) + if a.Status != nil { + t.Fatal("results from a previous generation must be dropped") + } + a.update(trafficMsg{gen: 0, stats: testStats(10, 0, 5)}) + a.update(railMsg{gen: 0, data: RailData{PluginsActive: 99}}) + if a.Traffic == nil || a.Traffic.Summary.TotalEntries == 10 { + t.Fatal("stale trafficMsg must be dropped too") + } + if a.Rail.PluginsActive == 99 { + t.Fatal("stale railMsg must be dropped too") + } +} + +// There is no gateway version over HTTP. The header must say so, not guess. +func TestHeaderNeverInventsAGatewayVersion(t *testing.T) { + v := testApp(126, 40).render() + if !strings.Contains(v, "gateway "+emDash) { + t.Fatalf("header must render `gateway %s`:\n%s", emDash, v) + } + if m := regexp.MustCompile(`gateway v?\d`).FindString(v); m != "" { + t.Fatalf("header fabricated a gateway version: %q", m) + } +} + +func TestNilTrafficRendersDash(t *testing.T) { + a := testApp(126, 40) + a.Traffic = nil + v := a.render() + for _, label := range []string{"RPS", "P95", "Errors"} { + row := findRow(v, label) + if !strings.Contains(row, emDash) { + t.Fatalf("unknown %s must render %s, got %q", label, emDash, row) + } + for _, bad := range []string{"0.0", "NaN", "0ms", "0.00%"} { + if strings.Contains(row, bad) { + t.Fatalf("unknown %s must not render %q: %q", label, bad, row) + } + } + } + + // A measured window with no requests still has no percentiles. + a.Traffic = &api.LogStats{} + v = a.render() + if !strings.Contains(findRow(v, "P95"), emDash) { + t.Fatalf("nil LatencyMs must render %s: %q", emDash, findRow(v, "P95")) + } + if strings.Contains(findRow(v, "Errors"), "NaN") { + t.Fatalf("0/0 errors must not divide: %q", findRow(v, "Errors")) + } +} + +// A gateway that answers /readyz with a bare 503 reports no targets at all. +// Rendering that as 0 would say "none are configured" during exactly the +// outage the header is read in — and dereferencing it would take the console +// down instead. +func TestAbsentTargetsRenderDashNotZero(t *testing.T) { + for _, w := range []int{72, 96, 126} { + a := testApp(w, 40) + a.Status.State, a.Status.Targets = "unreachable", nil + v := a.render() + for _, bad := range []string{"0 targets", "0/0"} { + if strings.Contains(v, bad) { + t.Fatalf("w=%d: unreported targets must never render %q:\n%s", w, bad, v) + } + } + if w < mediumMin { + continue // narrow drops both the counts header and the panels + } + if row := findRow(v, "Healthy"); !strings.Contains(row, a.dash()) { + t.Fatalf("w=%d: unreported targets must render a dash: %q", w, row) + } + } + + // The wide header is the one place the total is spelled out in words. + a := testApp(126, 40) + a.Status.Targets = nil + if v := a.render(); !strings.Contains(v, a.dash()+" targets") { + t.Fatalf("the counts row must say %s targets, not invent one:\n%s", a.dash(), v) + } +} + +func TestCompactStatusDoesNotInventZeroMeasurements(t *testing.T) { + a := testApp(96, 30) + a.Status = &api.StatusReport{State: "connected", URL: "http://localhost:8080"} + view := a.viewCompactStatus() + gatewayRow := findRow(view, "Gateway") + providersRow := findRow(view, "Providers") + if !strings.Contains(gatewayRow, a.dash()) || strings.Contains(gatewayRow, "0ms") || + !strings.Contains(providersRow, a.dash()) || strings.Contains(providersRow, "0") { + t.Fatalf("unreported latency and provider counts must render as dashes:\n%s", view) + } +} + +func TestTrafficDerivedFromLogStats(t *testing.T) { + v := testApp(126, 40).render() + for label, want := range map[string]string{ + "RPS": "159.0", // 47700 entries / 300s + "P95": "916ms", + "Errors": "0.42%", // 200 / 47700 + } { + if row := findRow(v, label); !strings.Contains(row, want) { + t.Fatalf("%s row must contain %q, got %q", label, want, row) + } + } +} + +func TestHeaderRendersRealStatusOnly(t *testing.T) { + v := testApp(126, 40).render() + for _, want := range []string{ + "Ferro Labs", + "AI Gateway", + "connected", + "local", + "http://localhost:8080", + "23ms", + "8 targets", + "2,500 models", + } { + if !strings.Contains(v, want) { + t.Fatalf("header missing %q:\n%s", want, v) + } + } +} + +func TestUnreachableStateGetsBadGlyph(t *testing.T) { + a := testApp(126, 40) + a.Status = &api.StatusReport{State: "unreachable", URL: "http://localhost:8080"} + g := a.Theme.Mode.Glyphs() + if v := a.render(); !strings.Contains(v, g.Bad+" unreachable") { + t.Fatalf("unreachable must carry the bad glyph:\n%s", v) + } + a.Status.State = "degraded" + if v := a.render(); !strings.Contains(v, g.Warn+" degraded") { + t.Fatalf("degraded must carry the warn glyph:\n%s", v) + } +} + +func TestRailReportsMissingCredential(t *testing.T) { + a := testApp(126, 40) + a.Rail = RailData{AuthError: true, PluginsActive: -1, Sessions: -1, AuditToday: -1} + v := a.render() + if !strings.Contains(v, "auth required") { + t.Fatalf("unauthorized rail must say so:\n%s", v) + } + if !strings.Contains(findRow(v, "Plugins"), emDash) { + t.Fatalf("unknown service counts render %s: %q", emDash, findRow(v, "Plugins")) + } +} + +func TestWindowSizeAndQuitKeys(t *testing.T) { + a := testApp(80, 24) + a.update(tea.WindowSizeMsg{Width: 126, Height: 40}) + if a.Width != 126 || a.Height != 40 { + t.Fatalf("resize ignored: %dx%d", a.Width, a.Height) + } + if cmd := a.update(tea.KeyPressMsg{Mod: tea.ModCtrl, Code: 'c'}); cmd == nil { + t.Fatal("ctrl+c must return a quit command") + } + a.Screen = ScreenLogs + a.update(tea.KeyPressMsg{Code: tea.KeyEscape}) + if a.Screen != ScreenHome { + t.Fatal("esc must return to home") + } +} + +func TestPollBackoffDoublesAndResets(t *testing.T) { + a := testApp(126, 40) + a.update(statusMsg{err: errors.New("boom")}) + a.update(statusMsg{err: errors.New("boom")}) + if a.statusEvery != 4*statusPoll { + t.Fatalf("two failures must back off to %v, got %v", 4*statusPoll, a.statusEvery) + } + for range 10 { + a.update(statusMsg{err: errors.New("boom")}) + } + if a.statusEvery != maxPoll { + t.Fatalf("backoff must cap at %v, got %v", maxPoll, a.statusEvery) + } + a.update(statusMsg{report: &api.StatusReport{State: "connected"}}) + if a.statusEvery != statusPoll { + t.Fatalf("a good poll must reset the cadence, got %v", a.statusEvery) + } +} + +func TestCommaGrouping(t *testing.T) { + for in, want := range map[int]string{0: "0", 12: "12", 999: "999", 1000: "1,000", 2500: "2,500", 1234567: "1,234,567"} { + if got := comma(in); got != want { + t.Fatalf("comma(%d) = %q, want %q", in, got, want) + } + } +} + +// findRow returns the first rendered line mentioning label, for asserting on +// one panel row without pinning the whole layout. +func findRow(view, label string) string { + for _, line := range strings.Split(view, "\n") { + if strings.Contains(line, label) { + return line + } + } + return "" +} + +// railStub answers the four sources fetchRail polls. Any handler left nil +// answers 500, so a test only wires the endpoints its scenario cares about. +func railStub(health, plugins, sessions, audit http.HandlerFunc) *httptest.Server { + mux := http.NewServeMux() + fail := func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusInternalServerError) } + for path, h := range map[string]http.HandlerFunc{ + "/admin/health": health, "/admin/plugins": plugins, + "/admin/sessions": sessions, "/admin/audit": audit, + } { + if h == nil { + h = fail + } + mux.HandleFunc(path, h) + } + return httptest.NewServer(mux) +} + +// A gateway poll fans out to four independent sources, and one of them can +// fail while the other three answer fine. fetchRail must not let that one +// failure blank the whole rail: a source that errors THIS round keeps prev's +// last good value for it, while a source that succeeds still refreshes. +func TestFetchRailKeepsLastGoodDataWhenOneSourceFails(t *testing.T) { + srv := railStub(nil, // /admin/health fails — left unwired, answers 500 + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `[{"name":"rate-limit","type":"ratelimit","enabled":true}]`) + }, + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"data":[{"id":"s1"}]}`) + }, + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"data":[],"summary":{"total_entries":3,"returned_entries":0}}`) + }) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "k") + if err != nil { + t.Fatalf("client: %v", err) + } + + prev := RailData{ + Providers: []api.AdminProviderHealth{{Name: "anthropic", Status: "healthy", Models: 412}}, + MCPReady: 2, MCPTotal: 2, + } + msg, ok := fetchRail(c, 0, prev)().(railMsg) + if !ok { + t.Fatal("fetchRail must answer a railMsg") + } + + if msg.err == nil { + t.Fatal("the failing source must still be reported") + } + if len(msg.data.Providers) != 1 || msg.data.Providers[0].Name != "anthropic" { + t.Fatalf("a failed health poll must keep the last known providers, got %+v", msg.data.Providers) + } + if msg.data.MCPTotal != 2 || msg.data.MCPReady != 2 { + t.Fatalf("a failed health poll must keep the last known MCP counts, got %d/%d ready", msg.data.MCPReady, msg.data.MCPTotal) + } + if msg.data.PluginsActive != 1 { + t.Fatalf("a source that succeeded this round must still refresh, got plugins=%d", msg.data.PluginsActive) + } + if msg.data.Sessions != 1 { + t.Fatalf("a source that succeeded this round must still refresh, got sessions=%d", msg.data.Sessions) + } + if msg.data.AuditToday != 3 { + t.Fatalf("a source that succeeded this round must still refresh, got audit=%d", msg.data.AuditToday) + } +} + +// AuthError is a verdict about the round just polled, not a sticky flag: a +// credential fixed after a 401 must clear it, or the rail would keep telling +// the operator to re-authenticate after they already have. +func TestFetchRailClearsAuthErrorOnceTheCredentialWorks(t *testing.T) { + answer := func(body string) http.HandlerFunc { + return func(w http.ResponseWriter, _ *http.Request) { _, _ = io.WriteString(w, body) } + } + srv := railStub( + answer(`{"status":"ok","providers":[]}`), + answer(`[]`), + answer(`{"data":[]}`), + answer(`{"data":[],"summary":{"total_entries":0,"returned_entries":0}}`), + ) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "k") + if err != nil { + t.Fatalf("client: %v", err) + } + + msg, ok := fetchRail(c, 0, RailData{AuthError: true})().(railMsg) + if !ok { + t.Fatal("fetchRail must answer a railMsg") + } + if msg.data.AuthError { + t.Fatal("a since-fixed credential must clear AuthError, not carry it forward forever") + } +} + +// Every counter fetchRail derives by walking a list must be recomputed from +// the round it is walking, not added to the round before it. d starts as prev +// so a failed source keeps its last good value — which turns any bare ++ into +// a running total. Feeding a poll's own answer back in as prev is the only +// shape that catches it: one poll in isolation always looks right. +func TestFetchRailCountersDoNotAccumulateAcrossPolls(t *testing.T) { + srv := railStub( + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"status":"healthy","providers":[{"name":"openai","status":"healthy","models":7}],`+ + `"mcp_servers":[{"name":"fs","ready":true},{"name":"search","ready":false}]}`) + }, + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `[{"name":"rate-limit","type":"ratelimit","enabled":true}]`) + }, + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"data":[{"id":"s1"}]}`) + }, + func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"data":[],"summary":{"total_entries":3,"returned_entries":0}}`) + }) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "k") + if err != nil { + t.Fatalf("client: %v", err) + } + + first, ok := fetchRail(c, 0, RailData{})().(railMsg) + if !ok { + t.Fatal("fetchRail must answer a railMsg") + } + if first.data.MCPTotal != 2 || first.data.MCPReady != 1 { + t.Fatalf("first poll must count the served list: total=%d ready=%d", + first.data.MCPTotal, first.data.MCPReady) + } + + // The gateway has not changed, so neither may the counts. + second, ok := fetchRail(c, 0, first.data)().(railMsg) + if !ok { + t.Fatal("fetchRail must answer a railMsg") + } + if second.data.MCPTotal != 2 || second.data.MCPReady != 1 { + t.Fatalf("an unchanged gateway must report unchanged counts, got total=%d ready=%d", + second.data.MCPTotal, second.data.MCPReady) + } + if second.data.PluginsActive != first.data.PluginsActive { + t.Fatalf("plugin count drifted across polls: %d then %d", + first.data.PluginsActive, second.data.PluginsActive) + } +} diff --git a/internal/tui/composer.go b/internal/tui/composer.go new file mode 100644 index 0000000..e4001b3 --- /dev/null +++ b/internal/tui/composer.go @@ -0,0 +1,389 @@ +package tui + +import ( + "strings" + "unicode" + "unicode/utf8" + + tea "charm.land/bubbletea/v2" + "github.com/spf13/cobra" +) + +// The composer is the console's only navigation surface: there is no menu and +// no key-per-screen. Everything an operator can do here is a verb they could +// also have typed at a shell, which is why the vocabulary is walked out of the +// real cobra tree rather than listed a second time in this file. + +const ( + // historyMax is the recall depth. A ring, not a log: the composer is a + // navigation aid, and a shell already keeps the durable history. + historyMax = 30 + + // suggestMax caps the suggestion row at what fits on one line without + // pushing the pane around. + suggestMax = 6 + + // cobraCompletion is the shell-completion command cobra generates. The + // console skips it for the same reason it skips help: it cannot install a + // script into the shell that launched it. + cobraCompletion = "completion" +) + +// The console's keyboard vocabulary, spelled exactly as tea.KeyPressMsg.String() +// spells it. The composer, the modal and every screen's handleKey are keyed on +// these strings rather than on tea key types — that is what makes them testable +// — so a mistyped literal is a binding that silently never fires and no test +// that drives the same typo can see it. Naming them once turns that into a +// compile error. The test suites deliberately keep typing the raw strings: they +// are the independent check that these values are what the terminal sends. +const ( + keyEnter = "enter" + keyEsc = "esc" + keyUp = "up" + keyDown = "down" + keyLeft = "left" + keyRight = "right" + keyTab = "tab" + keySpace = "space" + keyBackspace = "backspace" + keyCtrlC = "ctrl+c" + keyCtrlR = "ctrl+r" + keyCtrlU = "ctrl+u" +) + +// tuiVerbs exist only in the console — there is no `ferro clear` to script. +var tuiVerbs = []string{verbPlayground, verbModel, verbClear, verbHelp} + +// Composer is the command line: input, completion, bounded history, and +// reverse search. It holds no styles; every rendering decision reads the App's +// theme at draw time, so a mode switch needs no rebuild. +type Composer struct { + Input string + History []string // newest first + + verbs []string + + // histIdx is -1 for the live input, which live holds while a walk is in + // progress. Losing a half-typed line to an accidental ↑ is the one thing + // history recall must never do. + histIdx int + live string + + searchMode bool + searchTerm string +} + +func newComposer(verbs []string) Composer { + return Composer{verbs: verbs, histIdx: -1} +} + +// Verbs is the console's vocabulary: every path in the cobra tree, plus the +// three verbs that exist only here, plus a slash alias per top-level verb. +// +// It takes the root rather than building one so internal/tui imports no CLI +// package: internal/command is what hands bare `ferro` to Run, and an import +// back the other way would be a cycle. +func Verbs(root *cobra.Command) []string { + verbs := []string{} + var walk func(prefix string, cmd *cobra.Command) + walk = func(prefix string, cmd *cobra.Command) { + for _, sub := range cmd.Commands() { + name := sub.Name() + // help and completion are shell plumbing, not operations: the + // console prints its own verb tree and cannot install a completion + // script into the shell that launched it. + if name == verbHelp || name == cobraCompletion || sub.Hidden { + continue + } + path := strings.TrimSpace(prefix + " " + name) + verbs = append(verbs, path) + walk(path, sub) + } + } + if root != nil { + walk("", root) + } + verbs = append(verbs, tuiVerbs...) + + // Slash aliases are top-level only: /keys is an action, "/keys create" is + // not a spelling anyone types. + aliases := make([]string, 0, len(verbs)) + for _, v := range verbs { + if !strings.Contains(v, " ") { + aliases = append(aliases, "/"+v) + } + } + return append(verbs, aliases...) +} + +// handle is keyed on the key's string form, which is what makes the composer +// testable: constructing tea.KeyPressMsg values is awkward and the mapping from +// one to the other is untested glue either way. +func (c *Composer) handle(key string, a *App) tea.Cmd { + if c.searchMode { + return c.handleSearch(key) + } + switch key { + case keyEnter: + return c.submit(a) + case keyTab: + if m := c.match(); m != "" { + c.Input = m + } + return nil + case keyUp: + c.walk(1) + return nil + case keyDown: + c.walk(-1) + return nil + case keyCtrlR: + c.searchMode, c.searchTerm = true, "" + return nil + case keyEsc: + a.Screen = ScreenHome + return nil + case keyBackspace: + c.Input = trimLastRune(c.Input) + return nil + case keyCtrlU: + c.Input = "" + return nil + case keySpace: + c.Input += " " + return nil + case "?": + // Only on an empty line: mid-line it is a character, and `logs ?` must + // not silently become the help screen. + if strings.TrimSpace(c.Input) == "" { + return emit(runCmdMsg{raw: verbHelp}) + } + } + if r, ok := printable(key); ok { + c.Input += string(r) + } + return nil +} + +func (c *Composer) handleSearch(key string) tea.Cmd { + switch key { + case keyEnter: + if m := c.searchMatch(); m != "" { + c.Input = m + } + c.searchMode, c.searchTerm = false, "" + return nil + case keyEsc, keyCtrlC: + // Abandoning a search leaves the line exactly as it was found. + c.searchMode, c.searchTerm = false, "" + return nil + case keyBackspace: + c.searchTerm = trimLastRune(c.searchTerm) + return nil + case keySpace: + c.searchTerm += " " + return nil + } + if r, ok := printable(key); ok { + c.searchTerm += string(r) + } + return nil +} + +// submit runs the line. A blank line is a no-op rather than an error: pressing +// enter on an empty composer is how people check that the console is alive. +func (c *Composer) submit(a *App) tea.Cmd { + input := strings.TrimSpace(c.Input) + // EVERY leading slash goes, not one. The sanitisation below reads the head + // of raw to decide what may be retained, so a line that keeps a slash on its + // head names no verb, matches nothing, and is recorded whole — which for + // //chat is the prompt, in full, in history and reverse search. + raw := strings.TrimLeft(input, "/") + if raw == "" { + return nil + } + // Prompts can contain credentials or customer data. Keep command recall, but + // never retain prompt content in history or reverse search. + record := a.Screen != ScreenPlayground + if a.Screen == ScreenPlayground && strings.HasPrefix(input, "/") { + fields := strings.Fields(raw) + record = len(fields) > 0 && knownVerb(c.verbs, strings.ToLower(fields[0])) + } + if record { + history := raw + fields := strings.Fields(raw) + if len(fields) > 1 { + verb := strings.ToLower(fields[0]) + if verb == verbChat || verb == verbPlayground { + history = verb + } + } + c.record(history) + } + c.Input, c.histIdx, c.live = "", -1, "" + return emit(runCmdMsg{raw: raw}) +} + +// record pushes onto the ring, newest first. Consecutive duplicates collapse: +// running `status` four times while watching a rollout should not cost four +// entries of recall. +func (c *Composer) record(raw string) { + if len(c.History) > 0 && c.History[0] == raw { + return + } + next := make([]string, 0, min(len(c.History)+1, historyMax)) + next = append(next, raw) + next = append(next, c.History...) + if len(next) > historyMax { + next = next[:historyMax] + } + c.History = next +} + +// walk moves d steps toward older history (+1) or back toward the live input +// (-1), stopping at both ends rather than wrapping. +func (c *Composer) walk(d int) { + i := c.histIdx + d + if i < -1 || i >= len(c.History) { + return + } + if c.histIdx == -1 { + c.live = c.Input + } + c.histIdx = i + if i == -1 { + c.Input = c.live + return + } + c.Input = c.History[i] +} + +// query is the completion prefix: trimmed, and with the slash alias folded +// away so /log and log complete identically. +func (c *Composer) query() string { + return strings.TrimPrefix(strings.TrimSpace(c.Input), "/") +} + +// match is the verb tab completes to, and the one the ghost hint names. +func (c *Composer) match() string { + q := c.query() + if q == "" { + return "" + } + for _, v := range c.verbs { + if v != q && strings.HasPrefix(v, q) { + return v + } + } + return "" +} + +// ghost is the first matching verb, or "" when the line already names one. +func (c *Composer) ghost() string { return c.match() } + +func (c *Composer) suggestions() []string { + q := c.query() + if q == "" { + return nil + } + out := make([]string, 0, suggestMax) + for _, v := range c.verbs { + if v == q || !strings.HasPrefix(v, q) { + continue + } + out = append(out, v) + if len(out) == suggestMax { + break + } + } + return out +} + +func (c *Composer) searchMatch() string { + if c.searchTerm == "" { + return "" + } + for _, h := range c.History { + if strings.Contains(h, c.searchTerm) { + return h + } + } + return "" +} + +// view draws the framed command line. Its height is 3 lines, or 5 when there +// are suggestions to show; render() measures it rather than assuming, so the +// pane above gives up the two lines instead of the header scrolling away. +func (c *Composer) view(a *App) string { + inner := a.Width - 4 + g := a.Theme.Mode.Glyphs() + prompt := a.Theme.Accent.Bold(a.Theme.Mode.Color).Render(g.Prompt) + + var left, right string + switch { + case c.searchMode: + left = prompt + " " + a.Theme.Dim.Render("search:") + " " + + a.Theme.Bright.Render(c.searchTerm) + c.cursor(a) + if m := c.searchMatch(); m != "" { + right = a.Theme.Dim.Render(a.arrow() + " " + m) + } else if c.searchTerm != "" { + right = a.Theme.Dim.Render("no match") + } + case c.Input == "": + left = prompt + " " + c.cursor(a) + + a.Theme.Dim.Render(" Type a command, / for actions, or ? for help") + default: + left = prompt + " " + a.Theme.Bright.Render(c.Input) + c.cursor(a) + if m := c.ghost(); m != "" { + right = a.Theme.Faint.Render("tab " + a.arrow() + " " + m) + } + } + + lines := []string{gapPad(inner, left, right)} + if s := c.suggestions(); len(s) > 0 { + lines = append(lines, + a.Theme.Hairline.Render(a.rule(max(inner, 0))), + a.Theme.Dim.Render(padRight(strings.Join(s, " "), inner))) + } + return a.Theme.Frame("COMMAND", strings.Join(lines, "\n"), a.Width) +} + +// cursor is drawn rather than left to the terminal: the console renders one +// frame at a time and a hardware cursor would sit wherever the last write did. +func (c *Composer) cursor(a *App) string { + if a.Theme.Mode.ASCII { + return a.Theme.Accent.Render("_") + } + return a.Theme.Accent.Render("▌") +} + +// ------------------------------------------------------------------ helpers + +func emit(msg tea.Msg) tea.Cmd { return func() tea.Msg { return msg } } + +// arrow is the "leads to" glyph the ghost hint and search preview use. +func (a *App) arrow() string { + if a.Theme.Mode.ASCII { + return "->" + } + return "→" +} + +// printable reports whether a key string is a single printable rune — the +// only keys the composer types into the line. Named keys ("enter", "ctrl+r") +// are multi-rune and fall through. +func printable(key string) (rune, bool) { + r, size := utf8.DecodeRuneInString(key) + if size != len(key) || r == utf8.RuneError || !unicode.IsPrint(r) { + return 0, false + } + return r, true +} + +func trimLastRune(s string) string { + if s == "" { + return "" + } + _, size := utf8.DecodeLastRuneInString(s) + return s[:len(s)-size] +} diff --git a/internal/tui/composer_test.go b/internal/tui/composer_test.go new file mode 100644 index 0000000..289beef --- /dev/null +++ b/internal/tui/composer_test.go @@ -0,0 +1,352 @@ +package tui + +import ( + "slices" + "strings" + "testing" + + "charm.land/lipgloss/v2" + "github.com/spf13/cobra" + + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// fakeRoot mirrors the shape of the real cobra tree — a couple of leaf verbs, a +// parent with children, and the two commands the walk must skip. The real tree +// is asserted against in verbs_cobra_test.go, which lives in the external test +// package so internal/tui never imports internal/command. +func fakeRoot() *cobra.Command { + root := &cobra.Command{Use: "ferro"} + keys := &cobra.Command{Use: "keys"} + keys.AddCommand(&cobra.Command{Use: "create"}, &cobra.Command{Use: "rotate"}, &cobra.Command{Use: "revoke"}) + logs := &cobra.Command{Use: "logs"} + logs.AddCommand(&cobra.Command{Use: "tail"}, &cobra.Command{Use: "stats"}) + root.AddCommand( + &cobra.Command{Use: "status"}, + &cobra.Command{Use: "providers"}, + keys, logs, + &cobra.Command{Use: "completion"}, + &cobra.Command{Use: "help"}, + ) + return root +} + +// composerApp is an App whose composer speaks the fake tree's vocabulary. +func composerApp() *App { + a := testApp(126, 40) + a.Composer = newComposer(Verbs(fakeRoot())) + return a +} + +// run drives one key and returns the message its command produced, or nil. +func run(t *testing.T, a *App, key string) any { + t.Helper() + cmd := a.Composer.handle(key, a) + if cmd == nil { + return nil + } + return cmd() +} + +func typeIn(a *App, s string) { + for _, r := range s { + key := string(r) + if r == ' ' { + key = "space" + } + a.Composer.handle(key, a) + } +} + +func TestComposerEnterEmitsAndRecords(t *testing.T) { + a := composerApp() + typeIn(a, "status") + + msg, ok := run(t, a, "enter").(runCmdMsg) + if !ok || msg.raw != "status" { + t.Fatalf("enter must emit runCmdMsg{status}, got %#v", msg) + } + if a.Composer.Input != "" { + t.Fatalf("enter must clear the input, got %q", a.Composer.Input) + } + if len(a.Composer.History) != 1 || a.Composer.History[0] != "status" { + t.Fatalf("enter must record history, got %v", a.Composer.History) + } +} + +func TestComposerDoesNotRetainPlaygroundPrompts(t *testing.T) { + a := composerApp() + a.Screen = ScreenPlayground + typeIn(a, "SENTINEL_SECRET_DO_NOT_STORE") + + msg, ok := run(t, a, "enter").(runCmdMsg) + if !ok || msg.raw != "SENTINEL_SECRET_DO_NOT_STORE" { + t.Fatalf("the prompt must still be submitted, got %#v", msg) + } + if len(a.Composer.History) != 0 { + t.Fatalf("playground prompts must not enter command history: %v", a.Composer.History) + } +} + +func TestComposerDoesNotRetainUnknownSlashPrompts(t *testing.T) { + a := composerApp() + a.Screen = ScreenPlayground + a.Composer.Input = "/customer-secret please analyze" + msg, ok := run(t, a, "enter").(runCmdMsg) + if !ok || msg.raw != "customer-secret please analyze" { + t.Fatalf("unknown slash input remains a prompt: %#v", msg) + } + if len(a.Composer.History) != 0 { + t.Fatalf("unknown slash prompts can carry private data and must not be retained: %v", a.Composer.History) + } + + a.Composer.Input = "/model gpt-4o" + run(t, a, "enter") + if len(a.Composer.History) != 1 || a.Composer.History[0] != "model gpt-4o" { + t.Fatalf("known slash actions should remain recallable: %v", a.Composer.History) + } +} + +func TestComposerSanitizesInlineChatHistory(t *testing.T) { + for _, input := range []string{ + "chat SENTINEL_SECRET_DO_NOT_STORE", + "CHAT SENTINEL_SECRET_DO_NOT_STORE", + "PLAYGROUND SENTINEL_SECRET_DO_NOT_STORE", + "//chat SENTINEL_SECRET_DO_NOT_STORE", + } { + t.Run(input, func(t *testing.T) { + a := composerApp() + a.Composer.Input = input + run(t, a, "enter") + if got := a.Composer.History; len(got) != 1 || + (got[0] != "chat" && got[0] != "playground") { + t.Fatalf("history may retain the verb but not its prompt: %v", got) + } + if strings.Contains(strings.Join(a.Composer.History, " "), "SENTINEL") { + t.Fatalf("history retained prompt content: %v", a.Composer.History) + } + }) + } +} + +func TestComposerEmptyEnterIsNoop(t *testing.T) { + a := composerApp() + typeIn(a, " ") + if cmd := a.Composer.handle("enter", a); cmd != nil { + t.Fatal("a blank line must not run anything") + } + if len(a.Composer.History) != 0 { + t.Fatalf("a blank line must not enter history, got %v", a.Composer.History) + } +} + +func TestComposerTabCompletesPrefix(t *testing.T) { + a := composerApp() + typeIn(a, "sta") + run(t, a, "tab") + if a.Composer.Input != "status" { + t.Fatalf("tab must complete to the first matching verb, got %q", a.Composer.Input) + } + + // A prefix nothing matches leaves the line exactly as typed. + a.Composer.Input = "zzz" + run(t, a, "tab") + if a.Composer.Input != "zzz" { + t.Fatalf("tab with no match must not rewrite the line, got %q", a.Composer.Input) + } +} + +func TestComposerHistoryWalk(t *testing.T) { + a := composerApp() + typeIn(a, "status") + run(t, a, "enter") + typeIn(a, "providers") + run(t, a, "enter") + + // The live input must survive a walk into history and come back intact. + typeIn(a, "half typed") + + run(t, a, "up") + if a.Composer.Input != "providers" { + t.Fatalf("first up must recall the newest command, got %q", a.Composer.Input) + } + run(t, a, "up") + if a.Composer.Input != "status" { + t.Fatalf("second up must recall the older command, got %q", a.Composer.Input) + } + run(t, a, "up") + if a.Composer.Input != "status" { + t.Fatalf("up past the oldest entry must stay put, got %q", a.Composer.Input) + } + run(t, a, "down") + if a.Composer.Input != "providers" { + t.Fatalf("down must walk back toward the live input, got %q", a.Composer.Input) + } + run(t, a, "down") + if a.Composer.Input != "half typed" { + t.Fatalf("down off the end must restore the live input, got %q", a.Composer.Input) + } +} + +func TestComposerHistoryBounded(t *testing.T) { + a := composerApp() + for i := range 35 { + a.Composer.Input = string(rune('a'+i%26)) + strings.Repeat("x", i) + run(t, a, "enter") + } + if len(a.Composer.History) != historyMax { + t.Fatalf("history must be bounded at %d, got %d", historyMax, len(a.Composer.History)) + } + if a.Composer.History[0] != "i"+strings.Repeat("x", 34) { + t.Fatalf("history must be newest first, got %q", a.Composer.History[0]) + } +} + +func TestComposerHistoryDedupesConsecutive(t *testing.T) { + a := composerApp() + for range 3 { + a.Composer.Input = "status" + run(t, a, "enter") + } + a.Composer.Input = "providers" + run(t, a, "enter") + a.Composer.Input = "status" + run(t, a, "enter") + + if got := a.Composer.History; len(got) != 3 { + t.Fatalf("consecutive duplicates must collapse, got %v", got) + } +} + +func TestComposerReverseSearch(t *testing.T) { + a := composerApp() + typeIn(a, "status") + run(t, a, "enter") + typeIn(a, "providers") + run(t, a, "enter") + + run(t, a, "ctrl+r") + if !a.Composer.searchMode { + t.Fatal("ctrl+r must enter reverse search") + } + typeIn(a, "sta") + if got := a.Composer.searchMatch(); got != "status" { + t.Fatalf("search must match history, got %q", got) + } + if v := a.Composer.view(a); !strings.Contains(v, "status") { + t.Fatalf("search mode must show the match:\n%s", v) + } + run(t, a, "enter") + if a.Composer.searchMode || a.Composer.Input != "status" { + t.Fatalf("enter must accept the match and leave search (mode=%v input=%q)", a.Composer.searchMode, a.Composer.Input) + } + + // Esc abandons the search without touching the line. + a.Composer.Input = "kept" + run(t, a, "ctrl+r") + typeIn(a, "pro") + run(t, a, "esc") + if a.Composer.searchMode || a.Composer.Input != "kept" { + t.Fatalf("esc must abandon search intact (mode=%v input=%q)", a.Composer.searchMode, a.Composer.Input) + } +} + +func TestComposerSlashAlias(t *testing.T) { + a := composerApp() + typeIn(a, "/logs") + msg, ok := run(t, a, "enter").(runCmdMsg) + if !ok || msg.raw != "logs" { + t.Fatalf("a leading / must be stripped, got %#v", msg) + } +} + +func TestComposerQuestionMarkOnEmptyInputAsksForHelp(t *testing.T) { + a := composerApp() + msg, ok := run(t, a, "?").(runCmdMsg) + if !ok || msg.raw != "help" { + t.Fatalf("? on an empty line must run help, got %#v", msg) + } + if a.Composer.Input != "" { + t.Fatalf("? must not be typed into the line, got %q", a.Composer.Input) + } + + // With a line in progress it is just a character. + typeIn(a, "logs ?") + if a.Composer.Input != "logs ?" { + t.Fatalf("? mid-line is a character, got %q", a.Composer.Input) + } +} + +func TestComposerBackspaceAndEscape(t *testing.T) { + a := composerApp() + typeIn(a, "abc") + run(t, a, "backspace") + if a.Composer.Input != "ab" { + t.Fatalf("backspace must delete one rune, got %q", a.Composer.Input) + } + a.Screen = ScreenLogs + run(t, a, "esc") + if a.Screen != ScreenHome { + t.Fatal("esc outside search must return to home") + } +} + +func TestComposerGhostAndSuggestions(t *testing.T) { + a := composerApp() + typeIn(a, "k") + if got := a.Composer.ghost(); got != "keys" { + t.Fatalf("ghost must name the first matching verb, got %q", got) + } + if s := a.Composer.suggestions(); len(s) == 0 || !slices.Contains(s, "keys create") { + t.Fatalf("suggestions must include the subcommands, got %v", s) + } + if s := a.Composer.suggestions(); len(s) > suggestMax { + t.Fatalf("suggestions are capped at %d, got %d", suggestMax, len(s)) + } + v := a.Composer.view(a) + if !strings.Contains(v, "tab") || !strings.Contains(v, "keys") { + t.Fatalf("the composer must render the ghost hint:\n%s", v) + } + + a.Composer.Input = "" + if a.Composer.ghost() != "" || len(a.Composer.suggestions()) != 0 { + t.Fatal("an empty line offers no ghost and no suggestions") + } +} + +func TestVerbsWalksTheTree(t *testing.T) { + v := Verbs(fakeRoot()) + for _, want := range []string{"status", "keys", "keys create", "logs tail", "playground", "clear", "help", "/providers"} { + if !slices.Contains(v, want) { + t.Fatalf("Verbs must contain %q, got %v", want, v) + } + } + for _, unwanted := range []string{"completion", "/keys create"} { + if slices.Contains(v, unwanted) { + t.Fatalf("Verbs must not contain %q, got %v", unwanted, v) + } + } + // A nil tree still yields the TUI-only vocabulary rather than panicking. + if got := Verbs(nil); !slices.Contains(got, "clear") { + t.Fatalf("Verbs(nil) must still carry the TUI verbs, got %v", got) + } +} + +// The composer sits inside a frame; a line wider than the terminal wraps and +// destroys every frame above it. +func TestComposerViewFitsEveryWidth(t *testing.T) { + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + for _, w := range []int{40, 72, 96, 126} { + a := composerApp() + a.Theme, a.Width = theme.New(mode), w + typeIn(a, "k") + for _, view := range []string{a.Composer.view(a), a.render()} { + for i, line := range strings.Split(view, "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } + } +} diff --git a/internal/tui/home.go b/internal/tui/home.go new file mode 100644 index 0000000..1d49504 --- /dev/null +++ b/internal/tui/home.go @@ -0,0 +1,397 @@ +package tui + +import ( + "context" + "fmt" + "strings" + + tea "charm.land/bubbletea/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" + "github.com/ferro-labs/gateway-cli/internal/version" +) + +// This file is the home screen and the command router — the two halves of +// "typing a verb does something". The router is the console's whole navigation +// model, so it reads as one table on purpose. +// +// Nothing here performs I/O. A verb that needs the gateway returns the tea.Cmd +// from msgs.go and its rows arrive later as a verbRowsMsg. + +// The verbs more than one place has to agree on. A fetched verb is named twice +// — route() dispatches it and verbRows() answers it — and a spelling that +// matches in one but not the other is an "unknown command" or a "has no +// fetcher" that neither file can see on its own. The console-only verbs are +// named for the same reason: the composer offers them (tuiVerbs), the router +// runs them, and the playground has to recognise them to tell a command from a +// prompt. `services` is handled in exactly one place and stays a literal there; +// there is nothing for it to drift from. +const ( + verbHelp = "help" + verbClear = "clear" + verbVersion = "version" + verbModel = "model" + verbChat = "chat" + verbPlayground = "playground" + + verbStatus = "status" + verbModels = "models" + verbProviders = "providers" + verbMCP = "mcp" + verbPlugins = "plugins" + verbSessions = "sessions" + verbAudit = "audit" + + verbLogs = "logs" + verbKeys = "keys" +) + +// Column headings more than one table draws. The same fact is spelled the same +// way everywhere — NAME is the object's own name, STATE the condition, PROVIDER +// the target that served it — so an operator who has read one table can read the +// next. A heading only one table has stays a literal at its call site. +const ( + colName = "NAME" + colState = "STATE" + colProvider = "PROVIDER" +) + +// homeView is the transcript, padded to exactly rows lines. +func (a *App) homeView(w, rows int) string { + if a.Transcript.Len() == 0 { + return fill([]string{"", a.Theme.Dim.Render("No output yet. Type a command below, or ? for help.")}, w, rows) + } + return a.Transcript.view(a.Theme, w, rows) +} + +// route is the dispatch table. Every branch either renders into the transcript +// or switches screens; none of them touches the network directly. +func (a *App) route(raw string) tea.Cmd { + line := strings.TrimSpace(raw) + if line == "" { + return nil + } + // A slash action is the same verb: /logs and logs are one command. Only the + // verb is case-folded — an argument like --model Claude-* is a glob, and + // lowercasing it would quietly change which rows match. + line = strings.TrimPrefix(line, "/") + fields := strings.Fields(line) + if len(fields) == 0 { + return nil + } + head := strings.ToLower(fields[0]) + rest := strings.Join(fields[1:], " ") + + // The playground's seam. On that screen a line that does not name a verb is + // a prompt, not a mistyped command — and the test cannot key on the slash, + // which the composer strips before this function is ever reached. It sits + // here, ahead of the echo, because a prompt is not a command and must not be + // written into the transcript as one. `line` is still exactly what was + // typed, case and all, which is what a prompt needs. + if a.Screen == ScreenPlayground { + if cmd, claimed := a.Play.route(a, head, rest, line); claimed { + return cmd + } + } + + line = strings.TrimSpace(head + " " + rest) + + if head == verbClear { + a.Transcript.Reset() + a.Screen = ScreenHome + return nil + } + + echo := line + if rest != "" && (head == verbChat || head == verbPlayground) { + echo = head + } + a.Transcript.Push(TranscriptRow{Glyph: kindCmd, Text: "ferro " + echo}) + + switch head { + case verbHelp, "?": + a.Screen = ScreenHome + a.Transcript.Push(helpRows(a.Composer.verbs)...) + return nil + + case verbVersion: + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindOK, Text: "ferro " + version.String()}) + return nil + + // Screens own their own data. The router only moves to them; Tasks 14–16 + // wire the fetch, so starting one here would be output with nowhere to go. + case verbLogs: + return a.Logs.start(a, rest) + case verbKeys: + return a.Keys.enter(a, rest) + case verbPlayground, verbChat: + return a.Play.enter(a, rest) + case "services": + a.Screen = ScreenHome + for _, line := range strings.Split(a.viewServices(), "\n") { + a.Transcript.Push(TranscriptRow{Text: line}) + } + return nil + + case verbStatus, verbModels, verbProviders, verbMCP, verbPlugins, verbSessions, verbAudit: + a.Screen = ScreenHome + return verbFetch(a.Client, head) + } + + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{ + Glyph: kindBad, + Text: fmt.Sprintf("unknown command %q — press ? for the verb tree", head), + }) + return nil +} + +// helpRows prints the verb tree from the composer's own vocabulary, which came +// from the cobra tree. Hand-listing it here is how a help screen starts naming +// verbs that no longer exist. +func helpRows(verbs []string) []TranscriptRow { + var top, nested, slash []string + for _, v := range verbs { + switch { + case strings.HasPrefix(v, "/"): + slash = append(slash, v) + case strings.Contains(v, " "): + nested = append(nested, v) + default: + top = append(top, v) + } + } + rows := []TranscriptRow{{Glyph: kindNote, Text: strings.Join(top, " ")}} + if len(nested) > 0 { + rows = append(rows, TranscriptRow{Text: strings.Join(nested, " "), Dim: true}) + } + return append(rows, + TranscriptRow{Text: "slash actions: " + strings.Join(slash, " "), Dim: true}, + TranscriptRow{Text: "every verb has a scriptable twin — run it with --format json for a pipe", Dim: true}, + ) +} + +// ------------------------------------------------------------ verb rendering + +// verbRows fetches one verb and renders it as transcript rows. It is called +// from the tea.Cmd in msgs.go, never from a view func. +func verbRows(ctx context.Context, c *api.Client, verb string) ([]TranscriptRow, error) { + switch verb { + case verbStatus: + // Status returns a report even when it fails, naming the URL it tried; + // rendering it is what makes state:"unreachable" visible. + r, err := c.Status(ctx) + if r == nil { + return nil, err + } + mcp := "-" + if r.MCP != nil { + mcp = fmt.Sprintf("%d/%d", r.MCP.Ready, r.MCP.Total) + } + // Targets is nil when the gateway did not report them — a 503 /readyz + // carrying only {status, reason}. "0/0" there would claim none are + // configured when the truth is that they are dead. + targets := "-" + if t := r.Targets; t != nil { + targets = fmt.Sprintf("%d/%d", t.Routable, t.Total) + } + return tableRows( + []string{colState, "URL", "LATENCY", "TARGETS", "PROVIDERS", "MODELS", "MCP", "AUTH"}, + [][]string{{ + r.State, r.URL, fmt.Sprintf("%dms", r.LatencyMs), targets, + table.CountOrDash(r.Providers), table.CountOrDash(r.Models), mcp, table.OrDash(r.Auth), + }}), err + + case verbModels: + models, err := c.Models(ctx) + if err != nil { + return nil, err + } + cells := make([][]string, 0, len(models)) + for _, m := range models { + cells = append(cells, []string{ + m.ID, table.OrDash(m.OwnedBy), table.OrDash(m.Mode), table.PositiveOrDash(m.ContextWindow), + fmt.Sprintf("%d", len(m.Capabilities)), table.OrDash(m.Status), + }) + } + return orEmpty(tableRows([]string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", "STATUS"}, cells), + len(cells), "this gateway routes no models"), nil + + case verbProviders: + health, _, err := c.Health(ctx) + if err != nil { + return nil, err + } + // Best effort: an unusable credential costs two columns, not the verb. + admin, adminErr := c.AdminHealth(ctx) + if adminErr != nil { + admin = nil + } + cells := providerCells(health, admin) + rows := tableRows([]string{colProvider, "STATUS", "CIRCUIT", "MODELS", "MESSAGE"}, cells) + if adminErr != nil { + // Name what actually happened. A refused credential and a timed-out + // or broken /admin/health cost the same two columns, but only one of + // them is fixed by looking at a credential. + why := "admin health unavailable" + if api.IsUnauthorized(adminErr) { + why = "no admin credential accepted" + } + rows = append(rows, TranscriptRow{Glyph: kindWarn, + Text: why + " — status and message come from /health only"}) + } + return orEmpty(rows, len(cells), "no providers reported"), nil + + case verbMCP: + servers, err := mcpServers(ctx, c) + if err != nil { + return nil, err + } + cells := make([][]string, 0, len(servers)) + for _, s := range servers { + cells = append(cells, []string{s.Name, table.BoolYN(s.Ready), table.BoolYN(s.Required), table.OrDash(s.LastError)}) + } + return orEmpty(tableRows([]string{colName, "READY", "REQUIRED", "LAST ERROR"}, cells), + len(cells), "this gateway has no MCP servers configured"), nil + + case verbPlugins: + configured, err := c.Plugins(ctx) + if err != nil { + return nil, err + } + catalog, err := c.PluginCatalog(ctx) + if err != nil { + // A build without the catalog route still lists what it runs; it + // just cannot say what fails open. + if !api.IsNotSupported(err) { + return nil, err + } + catalog = nil + } + cells := pluginCells(configured, catalog) + return orEmpty(tableRows([]string{colName, "TYPE", "ENABLED", "FAILS", "SUMMARY"}, cells), + len(cells), "this gateway has no plugins configured"), nil + + case verbSessions: + sessions, err := c.Sessions(ctx) + if err != nil { + return nil, err + } + cells := make([][]string, 0, len(sessions)) + for _, s := range sessions { + cells = append(cells, []string{ + s.Subject, strings.Join(s.Scopes, ","), + table.FmtTime(s.CreatedAt), table.FmtTimePtr(s.LastSeenAt), table.FmtTime(s.ExpiresAt), + }) + } + return orEmpty(tableRows([]string{"SUBJECT", "SCOPES", "CREATED", "LAST SEEN", "EXPIRES"}, cells), + len(cells), "no active dashboard sessions"), nil + + case verbAudit: + page, err := c.Audit(ctx, api.AuditQuery{Limit: auditRows}) + if err != nil { + return nil, err + } + cells := make([][]string, 0, len(page.Data)) + for _, e := range page.Data { + cells = append(cells, []string{ + table.FmtTime(e.OccurredAt), e.Action, table.OrDash(e.Actor), e.Outcome, table.OrDash(e.TargetID), + }) + } + return orEmpty(tableRows([]string{"TIME", "ACTION", "ACTOR", "OUTCOME", "TARGET"}, cells), + len(cells), "no audit entries in range"), nil + } + return nil, fmt.Errorf("verb %q has no fetcher", verb) +} + +// mcpServers prefers /admin/health: it alone carries last_error, which /readyz +// withholds because it is unauthenticated and the reason can quote a URL. +func mcpServers(ctx context.Context, c *api.Client) ([]api.MCPServer, error) { + if ah, err := c.AdminHealth(ctx); err == nil { + return ah.MCPServers, nil + } + ready, _, err := c.Ready(ctx) + if err != nil { + return nil, err + } + return ready.MCPServers, nil +} + +// providerCells merges the two listings: /health is unauthenticated and carries +// the circuit; /admin/health needs a credential and carries the status, the +// model count and the failure message. +func providerCells(h *api.HealthReport, ah *api.AdminHealth) [][]string { + circuits := make(map[string]string, len(h.Providers)) + for _, p := range h.Providers { + circuits[p.Name] = p.Circuit + } + if ah == nil { + cells := make([][]string, 0, len(h.Providers)) + for _, p := range h.Providers { + cells = append(cells, []string{p.Name, p.Status, table.OrDash(p.Circuit), fmt.Sprintf("%d", p.Models), "-"}) + } + return cells + } + cells := make([][]string, 0, len(ah.Providers)) + for _, p := range ah.Providers { + cells = append(cells, []string{ + p.Name, p.Status, table.OrDash(circuits[p.Name]), fmt.Sprintf("%d", p.Models), table.OrDash(p.Message), + }) + } + return cells +} + +// The two failure policies a catalog entry reports. Which one a plugin has is +// the single most consequential thing on the plugins table — it is the +// difference between a broken guardrail stopping traffic and waving it through +// — so the column says it in the catalog's own words. +// pluginCells merges what this gateway has configured with what this build +// ships — only the catalog knows whether a plugin fails open, and the +// scriptable table derives that cell from the same place. +func pluginCells(configured []api.PluginInfo, catalog []api.BuiltinPlugin) [][]string { + shipped := table.NewPluginCatalog(catalog) + cells := make([][]string, 0, len(configured)) + for _, p := range configured { + policy := shipped.For(p.Name) + cells = append(cells, []string{ + p.Name, p.Type, table.BoolYN(p.Enabled), policy.Fails, table.OrDash(policy.Summary), + }) + } + return cells +} + +// ------------------------------------------------------------------ helpers + +// tableRows renders headers and cells through internal/table's shared layout +// — the same one Printer.Table (internal/command/output.go) calls — so a verb +// read in the console and the same verb read through a pipe align identically. +// This is the only thing left here: the TranscriptRow wrapping, dimming the +// header and its rule because they are furniture, leaving the data alone. +func tableRows(headers []string, cells [][]string) []TranscriptRow { + lines := table.Rows(headers, cells) + rows := make([]TranscriptRow, 0, len(lines)) + for i, line := range lines { + rows = append(rows, TranscriptRow{Text: line, Dim: i < 2}) + } + return rows +} + +// orEmpty replaces a table with nothing in it by a row that says so. An empty +// gateway and a broken query look identical otherwise. +func orEmpty(rows []TranscriptRow, n int, empty string) []TranscriptRow { + if n > 0 { + return rows + } + return []TranscriptRow{{Text: empty, Dim: true}} +} + +// fill pads a body to exactly rows lines, truncating each to w cells. +func fill(lines []string, w, rows int) string { + out := append(make([]string, 0, rows), clampLines(lines, w)...) + for len(out) < rows { + out = append(out, "") + } + return strings.Join(out[:max(rows, 0)], "\n") +} diff --git a/internal/tui/home_test.go b/internal/tui/home_test.go new file mode 100644 index 0000000..67e9b20 --- /dev/null +++ b/internal/tui/home_test.go @@ -0,0 +1,421 @@ +package tui + +import ( + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// TableRows hands tableRows to the external test package. The layout is held +// equal to internal/command's Printer.Table there (verbs_cobra_test.go), +// because that assertion needs to import internal/command and this package +// never may. +var TableRows = tableRows + +// transcriptText flattens the transcript for assertions that do not care where +// a row's text sits on screen. +func transcriptText(a *App) string { + var b strings.Builder + for _, r := range a.Transcript.rows { + b.WriteString(r.Glyph + " " + r.Text + "\n") + } + return b.String() +} + +func lastRow(a *App) TranscriptRow { + if n := len(a.Transcript.rows); n > 0 { + return a.Transcript.rows[n-1] + } + return TranscriptRow{} +} + +func TestRouteEchoesEveryCommand(t *testing.T) { + a := composerApp() + a.route("status") + if got := a.Transcript.rows[0]; got.Glyph != "$" || got.Text != "ferro status" { + t.Fatalf("every command must be echoed as it would be run, got %#v", got) + } +} + +func TestRouteUnknownVerb(t *testing.T) { + a := composerApp() + if cmd := a.route("frobnicate --hard"); cmd != nil { + t.Fatal("an unknown verb must not reach the network") + } + row := lastRow(a) + if row.Glyph != "bad" || !strings.Contains(row.Text, `"frobnicate"`) { + t.Fatalf("an unknown verb must be named in a red row, got %#v", row) + } + if !strings.Contains(row.Text, "?") { + t.Fatalf("the refusal must point at the verb tree, got %q", row.Text) + } + if a.Screen != ScreenHome { + t.Fatal("an unknown verb leaves the operator on the transcript") + } +} + +func TestRouteHelpListsVerbs(t *testing.T) { + for _, raw := range []string{"help", "?"} { + a := composerApp() + a.route(raw) + text := transcriptText(a) + for _, want := range []string{"status", "logs", "playground", "keys", "keys create", "/providers"} { + if !strings.Contains(text, want) { + t.Fatalf("%q must list %q:\n%s", raw, want, text) + } + } + if !strings.Contains(text, "--format json") { + t.Fatalf("help must point at the scriptable twin:\n%s", text) + } + } +} + +func TestRouteStatusEchoesAndFetches(t *testing.T) { + a := composerApp() + cmd := a.route("status") + if cmd == nil { + t.Fatal("status must return a fetch command") + } + if !strings.Contains(transcriptText(a), "ferro status") { + t.Fatalf("status must echo its scriptable form:\n%s", transcriptText(a)) + } + if a.Screen != ScreenHome { + t.Fatal("status renders into the transcript, so it must land on home") + } + // The command must run without a client rather than panicking on nil. + msg, ok := cmd().(verbRowsMsg) + if !ok || msg.err == nil { + t.Fatalf("a verb fetched with no connection must report the failure, got %#v", msg) + } +} + +func TestRouteSwitchesScreens(t *testing.T) { + for raw, want := range map[string]Screen{ + "logs --model claude-*": ScreenLogs, + "logs": ScreenLogs, + "keys": ScreenKeys, + "keys create": ScreenKeys, + "playground": ScreenPlayground, + "chat": ScreenPlayground, + } { + a := composerApp() + a.route(raw) + if a.Screen != want { + t.Fatalf("%q must switch to screen %v, got %v", raw, want, a.Screen) + } + } +} + +func TestRouteClearResetsTranscriptAndScreen(t *testing.T) { + a := composerApp() + a.route("status") + a.Screen = ScreenLogs + a.route("clear") + if a.Transcript.Len() != 0 { + t.Fatalf("clear must empty the transcript, got %d rows", a.Transcript.Len()) + } + if a.Screen != ScreenHome { + t.Fatal("clear returns to the transcript") + } +} + +func TestRouteStripsSlashAndIgnoresVerbCase(t *testing.T) { + a := composerApp() + a.route("/STATUS") + if !strings.Contains(transcriptText(a), "ferro status") { + t.Fatalf("a slash action is the same verb, lowercased:\n%s", transcriptText(a)) + } + a = composerApp() + a.route(" ") + if a.Transcript.Len() != 0 { + t.Fatal("a blank line is not a command") + } + a.route("/") + if a.Transcript.Len() != 0 { + t.Fatal("a bare slash is not a command") + } +} + +func TestInlineChatPromptIsNotEchoedToTranscript(t *testing.T) { + a := composerApp() + a.route("chat SENTINEL_SECRET_DO_NOT_STORE") + if strings.Contains(transcriptText(a), "SENTINEL_SECRET_DO_NOT_STORE") { + t.Fatalf("chat prompt leaked into transcript:\n%s", transcriptText(a)) + } +} + +// Arguments keep their case: a --model filter is a glob, not a verb. +func TestRouteKeepsArgumentCase(t *testing.T) { + a := composerApp() + a.route("logs --model Claude-Sonnet") + if !strings.Contains(transcriptText(a), "Claude-Sonnet") { + t.Fatalf("arguments must survive verb normalisation:\n%s", transcriptText(a)) + } +} + +func TestVerbRowsLandInTranscript(t *testing.T) { + a := composerApp() + a.update(verbRowsMsg{ + verb: "status", + rows: []TranscriptRow{{Glyph: "ok", Text: "STATE URL"}, {Glyph: "ok", Text: "connected http://x"}}, + took: 41 * time.Millisecond, + }) + text := transcriptText(a) + if !strings.Contains(text, "connected http://x") { + t.Fatalf("fetched rows must land in the transcript:\n%s", text) + } + if !strings.Contains(text, "Completed in 41ms") { + t.Fatalf("every async verb must report its duration:\n%s", text) + } + if !lastRow(a).Dim { + t.Fatal("the duration row is dim furniture, not output") + } +} + +func TestVerbFailureAppendsARedRow(t *testing.T) { + a := composerApp() + err := &api.Error{Status: 401, Message: "missing credential"} + a.update(verbRowsMsg{verb: "keys", err: err, took: time.Millisecond}) + + var found bool + for _, r := range a.Transcript.rows { + if r.Glyph == "bad" && strings.Contains(r.Text, err.Error()) { + found = true + } + } + if !found { + t.Fatalf("a failed verb must carry the gateway's own error text:\n%s", transcriptText(a)) + } +} + +// The pane is the shell's anchor: exactly rows lines on every screen, so the +// composer never moves. +func TestPaneIsExactlyRowsLinesOnEveryScreen(t *testing.T) { + a := composerApp() + a.route("status") + for _, screen := range []Screen{ScreenHome, ScreenLogs, ScreenKeys, ScreenPlayground} { + a.Screen = screen + for _, rows := range []int{1, 5, 18} { + body := a.paneView(60, rows) + if got := len(strings.Split(body, "\n")); got != rows { + t.Fatalf("screen %v pane at rows=%d returned %d lines", screen, rows, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > 60 { + t.Fatalf("screen %v pane line %d overflows: %d cells %q", screen, i, lw, line) + } + } + } + } +} + +// Every screen now says something. An empty pane would read as "this gateway +// has nothing to show", which is a claim none of them can support before their +// first fetch lands. +func TestEveryScreenSaysSomethingBeforeItsFirstFetch(t *testing.T) { + a := composerApp() // no client + for raw, want := range map[string]string{ + // With nothing to ask, the pane names the reason rather than looking + // like a gateway with no logs and no keys. + "logs": errNoConnection.Error(), + "keys": errNoConnection.Error(), + // The playground needs no fetch to accept a prompt; the failure + // surfaces on the turn, where it can be read. + "playground": "Type a prompt", + } { + a.route(raw) + if body := a.paneView(70, 8); !strings.Contains(body, want) { + t.Fatalf("%q must say %q rather than render blank:\n%s", raw, want, body) + } + } + + // And a real, genuinely empty listing says THAT, which is a different fact. + a = composerApp() + a.route("logs") + a.Logs.lastErr = nil + if body := a.paneView(70, 8); !strings.Contains(body, "no rows") { + t.Fatalf("an empty log window must say so:\n%s", body) + } + a.route("keys") + a.Keys.err = nil + if body := a.paneView(70, 8); !strings.Contains(body, "no API keys") { + t.Fatalf("a gateway with no keys must say so:\n%s", body) + } +} + +// The whole shell, with a transcript in it, still fits every width and mode. +func TestRenderWithTranscriptFitsEveryWidth(t *testing.T) { + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + for _, w := range []int{72, 96, 126} { + a := composerApp() + a.Theme, a.Width = theme.New(mode), w + a.route("help") + a.update(verbRowsMsg{verb: "status", rows: []TranscriptRow{ + {Glyph: "ok", Text: strings.Repeat("a very wide row ", 20)}, + }, took: 12 * time.Millisecond}) + for i, line := range strings.Split(a.render(), "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } +} + +// stubGateway serves just enough of the admin API for the transcript verbs. +func stubGateway(t *testing.T) *api.Client { + t.Helper() + mux := http.NewServeMux() + body := func(path, json string) { + mux.HandleFunc(path, func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = io.WriteString(w, json) + }) + } + body("/health", `{"status":"ok","providers":[ + {"name":"openai","status":"healthy","circuit":"closed","models":1104}, + {"name":"anthropic","status":"degraded","circuit":"half_open","models":412}]}`) + body("/readyz", `{"status":"ready","targets":[{"name":"openai","routable":true}], + "mcp_servers":[{"name":"filesystem","ready":true,"required":false}]}`) + body("/admin/health", `{"status":"ok","scopes":["admin"],"providers":[ + {"name":"openai","status":"healthy","models":1104}, + {"name":"anthropic","status":"degraded","models":412,"message":"rate limited upstream"}], + "mcp_servers":[{"name":"filesystem","ready":true,"required":true}, + {"name":"search","ready":false,"required":false,"last_error":"handshake timeout"}]}`) + body("/v1/models", `{"object":"list","data":[ + {"id":"claude-sonnet-4-6","owned_by":"anthropic","mode":"chat","context_window":200000, + "capabilities":["chat","tools"],"status":"available"}]}`) + body("/admin/plugins", `[{"name":"rate-limit","type":"ratelimit","enabled":true}, + {"name":"request-logger","type":"logging","enabled":false}]`) + body("/admin/plugins/catalog", `{"data":[{"name":"rate-limit","type":"ratelimit","summary":"caps request rate","fails_open":false}, + {"name":"request-logger","type":"logging","summary":"records requests","fails_open":true}]}`) + body("/admin/sessions", `{"data":[{"id":"s1","subject":"alice","scopes":["admin"], + "created_at":"2026-08-08T09:00:00Z","expires_at":"2026-08-09T09:00:00Z"}]}`) + body("/admin/audit", `{"data":[{"occurred_at":"2026-08-08T09:00:00Z","action":"key.create", + "actor":"alice","outcome":"ok","target_id":"ak_1"}],"summary":{"total_entries":1,"returned_entries":1}}`) + + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "test-key") + if err != nil { + t.Fatalf("client: %v", err) + } + return c +} + +// mustLocalRFC3339 renders the UTC wire timestamp the sessions and audit +// fixtures carry (stubGateway) the way verbRows actually renders it: through +// fmtTime, in the reader's local time. Asserting this rather than a literal +// RFC3339 string keeps the test honest about what the column shows without +// hardcoding a timezone-dependent value — the repo convention is to assert +// UTC for persisted/admin timestamps, but this cell is deliberately local. +func mustLocalRFC3339(t *testing.T, utc string) string { + t.Helper() + parsed, err := time.Parse(time.RFC3339, utc) + if err != nil { + t.Fatalf("bad fixture timestamp %q: %v", utc, err) + } + return parsed.Local().Format(time.RFC3339) +} + +// The transcript's verbs are the scriptable verbs: same sources, same columns, +// same alignment. This is the test that fails when one of them drifts. +func TestVerbRowsRenderEveryTranscriptVerb(t *testing.T) { + c := stubGateway(t) + // Both fixtures (stubGateway) carry this same UTC instant as their + // administrative timestamp; verbRows renders it through fmtTime, which + // converts to local time (home.go). Without this, a regression in that + // conversion — or in which field feeds the column — passes silently. + localCreatedAt := mustLocalRFC3339(t, "2026-08-08T09:00:00Z") + for verb, want := range map[string][]string{ + // One provider's circuit is half-open, so the report is degraded — the + // derivation lives in api.Status and the transcript must not soften it. + "status": {"STATE", "URL", "LATENCY", "degraded", "1/1", "admin"}, + "models": {"ID", "OWNED BY", "claude-sonnet-4-6", "anthropic", "200000"}, + "providers": {"PROVIDER", "CIRCUIT", "openai", "closed", "half_open", "rate limited upstream"}, + "mcp": {"NAME", "READY", "REQUIRED", "filesystem", "yes", "handshake timeout"}, + "plugins": {"NAME", "FAILS", "rate-limit", "closed", "request-logger", "open"}, + "sessions": {"SUBJECT", "SCOPES", "alice", "admin", localCreatedAt}, + "audit": {"ACTION", "OUTCOME", "key.create", "ok", "ak_1", localCreatedAt}, + } { + rows, err := verbRows(t.Context(), c, verb) + if err != nil { + t.Fatalf("%s: %v", verb, err) + } + var text strings.Builder + for _, r := range rows { + text.WriteString(r.Text + "\n") + } + for _, w := range want { + if !strings.Contains(text.String(), w) { + t.Fatalf("%s output missing %q:\n%s", verb, w, text.String()) + } + } + // The header and its rule are furniture, so they are dim; the data is + // the output and must not be. + if len(rows) < 3 || !rows[0].Dim || !rows[1].Dim || rows[2].Dim { + t.Fatalf("%s: header must be dim and data must not be: %#v", verb, rows[:min(3, len(rows))]) + } + } +} + +// A gateway that does not serve an endpoint must surface its own words, not a +// paraphrase and not an empty table. +func TestVerbRowsSurfaceGatewayErrors(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusUnauthorized) + _, _ = io.WriteString(w, `{"error":{"message":"missing credential","code":"unauthorized"}}`) + })) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "") + if err != nil { + t.Fatalf("client: %v", err) + } + if _, err := verbRows(t.Context(), c, "sessions"); err == nil || + !strings.Contains(err.Error(), "missing credential") { + t.Fatalf("the gateway's own error must survive, got %v", err) + } + if _, err := verbRows(t.Context(), c, "frobnicate"); err == nil { + t.Fatal("a verb with no fetcher must not report success") + } +} + +// An empty listing and a broken query look identical unless the empty one says +// so in words. +func TestVerbRowsNameAnEmptyListing(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/admin/sessions", func(w http.ResponseWriter, _ *http.Request) { + _, _ = io.WriteString(w, `{"data":[]}`) + }) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "k") + if err != nil { + t.Fatalf("client: %v", err) + } + + rows, err := verbRows(t.Context(), c, "sessions") + if err != nil { + t.Fatalf("an empty listing is not an error: %v", err) + } + if len(rows) != 1 || !strings.Contains(rows[0].Text, "no active dashboard sessions") { + t.Fatalf("an empty listing must say so, got %#v", rows) + } +} + +// The runCmdMsg arm is the composer's only route into the router. +func TestRunCmdMsgReachesTheRouter(t *testing.T) { + a := composerApp() + a.update(runCmdMsg{raw: "frobnicate"}) + if !strings.Contains(transcriptText(a), "frobnicate") { + t.Fatalf("runCmdMsg must be dispatched:\n%s", transcriptText(a)) + } +} diff --git a/internal/tui/keys.go b/internal/tui/keys.go new file mode 100644 index 0000000..b81ff67 --- /dev/null +++ b/internal/tui/keys.go @@ -0,0 +1,720 @@ +package tui + +import ( + "fmt" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +// The keys screen is the console's only destructive surface, and every choice +// here follows from that: +// +// - Rotate and revoke are gated on typing the key's exact name. The wording +// of each gate is the approved blast-radius copy, because what an operator +// needs at that moment is not "are you sure" but "here is what breaks". +// - A secret exists in exactly one place: the modal that was handed it. It is +// never pushed to the transcript, never recorded in history, and is gone +// from the process the moment that modal closes. What the transcript gets +// instead names the key and its scope, so the action is on the record and +// the credential is not. +// - The table shows the wire's masked `key`, never a full secret — reads are +// masked head8…tail4 by the gateway and this screen does no unmasking. +// +// There is no state field on the wire; api.KeyState derives revoked/expired/ +// active from revoked_at, expires_at and active. Nothing here re-derives it. + +// defaultExpiry is the wizard's prefilled ceiling. An unexpiring admin key is +// a decision, so it costs a deliberate edit rather than a default. +const defaultExpiry = "720h" + +// The actions this screen can be asked to perform. One string travels a long +// way — from the subcommand the operator typed, through pendingVerb, into +// modalResultMsg.kind in msgs.go, and back out to the arm that decides whether +// a secret modal opens — and every hop is a plain string comparison. Naming +// them keeps the three switches on one vocabulary. The alternative spellings +// (`new`, `delete`) stay literals where they are accepted: they are input the +// operator may type, not values this package passes around. +const ( + actionGet = "get" + actionCreate = "create" + actionRotate = "rotate" + actionRevoke = "revoke" +) + +// The labels the modals share. A field named one thing in the create wizard +// and another in the detail strip reads as two different fields. +const ( + kvName = "name" + kvScope = "scope" + kvLastUsed = "last used" + + labelNext = "next" +) + +// The create wizard's three step titles. One prefix, three steps: the title is +// the only thing telling an operator where they are in the chain. +const ( + titleCreateName = "Create API key · name" + titleCreateScope = "Create API key · scope" + titleCreateExpiry = "Create API key · expiry" +) + +// keysScreen is the API keys pane: a table, an optional detail strip, and the +// modal flows that mutate it. +type keysScreen struct { + keys []api.Key + sel int + detail bool + err error + + // gen invalidates in-flight work from a visit the operator has left or a + // command that has been superseded, the same contract the shell's pollGen + // has. + gen int + + pendingVerb string + pendingArg string + + draft keyDraft +} + +// keyDraft is the create wizard's accumulated answers. It holds no secret: +// the secret does not exist until the gateway answers, and then it lives only +// in the modal built from that answer. +type keyDraft struct { + name, scope string + expires *time.Time +} + +// ------------------------------------------------------------------ lifecycle + +// enter opens the pane and dispatches the subcommand the operator typed. +// `keys` alone lists; `keys create|rotate|revoke` opens a flow. +func (s *keysScreen) enter(a *App, rest string) tea.Cmd { + if a.Screen != ScreenKeys { + s.detail = false + } + s.gen++ + s.pendingVerb, s.pendingArg = "", "" + a.Screen = ScreenKeys + cmd := s.fetch(a) + + f := strings.Fields(rest) + if len(f) == 0 { + return cmd + } + arg := strings.Join(f[1:], " ") + switch strings.ToLower(f[0]) { + case "list": + case actionGet: + s.pendingVerb, s.pendingArg = actionGet, arg + case actionCreate, "new": + s.openCreate(a) + case actionRotate: + s.pendingVerb, s.pendingArg = actionRotate, arg + case actionRevoke, "delete": + s.pendingVerb, s.pendingArg = actionRevoke, arg + default: + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, + Text: fmt.Sprintf("keys: unknown action %q — list, get, create, rotate or revoke", f[0])}) + return nil + } + return cmd +} + +// leave drops whatever the visit had in flight. There is no stream and no tick +// here, so bumping the generation is the whole of it — a list fetch that lands +// after the operator moved on must not repopulate a pane they are not looking +// at, and a modal must not outlive its screen. +func (s *keysScreen) leave() { s.gen++ } + +// refresh re-reads the list. It is the only way rows change: this screen never +// patches a row locally from a mutation's response, because the gateway is the +// authority on a key's state and a local guess is how a revoked key keeps +// rendering as active. +func (s *keysScreen) refresh(a *App) tea.Cmd { + s.gen++ + return s.fetch(a) +} + +func (s *keysScreen) fetch(a *App) tea.Cmd { + if a.Client == nil { + s.err = errNoConnection + return nil + } + return fetchKeys(a.Client, s.gen) +} + +func (s *keysScreen) update(a *App, msg tea.Msg) tea.Cmd { + switch m := msg.(type) { + case keysListMsg: + if m.gen != s.gen { + return nil + } + s.err = m.err + if m.err == nil { + s.keys = m.keys + s.sel = clampIdx(s.sel, len(s.keys)) + return s.runPending(a) + } + s.pendingVerb, s.pendingArg = "", "" + return nil + + case modalResultMsg: + if m.gen != s.gen { + return nil + } + return s.result(a, m) + } + return nil +} + +func (s *keysScreen) runPending(a *App) tea.Cmd { + verb, arg := s.pendingVerb, s.pendingArg + s.pendingVerb, s.pendingArg = "", "" + switch verb { + case actionGet: + if s.selectNamed(arg) { + return nil + } + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, Text: fmt.Sprintf("keys get: no key named %q", arg)}) + case actionRotate: + s.open(a, verb, arg, s.openRotate) + case actionRevoke: + s.open(a, verb, arg, s.openRevoke) + } + return nil +} + +// key returns the selected row. +func (s *keysScreen) key() (api.Key, bool) { + if s.sel < 0 || s.sel >= len(s.keys) { + return api.Key{}, false + } + return s.keys[s.sel], true +} + +func (s *keysScreen) selectNamed(arg string) bool { + for i, k := range s.keys { + if k.Name == arg || k.ID == arg { + s.sel, s.detail = i, true + return true + } + } + return false +} + +// handleKey is the pane's own keyboard. It claims a key only when the composer +// is empty, so typing a verb from this screen always beats moving a cursor. +func (s *keysScreen) handleKey(key string) bool { + switch key { + case keyUp: + s.sel = clampIdx(s.sel-1, len(s.keys)) + case keyDown: + s.sel = clampIdx(s.sel+1, len(s.keys)) + case keyEnter: + s.detail = s.sel >= 0 && s.sel < len(s.keys) + case keyEsc: + if !s.detail { + return false // esc means "back" once there is no strip to close + } + s.detail = false + default: + return false + } + return true +} + +// -------------------------------------------------------------------- flows + +// open resolves the key a destructive verb names — by name, by id, or by the +// current selection — and refuses rather than guessing when it names none. +func (s *keysScreen) open(a *App, verb, arg string, f func(*App, api.Key)) { + if arg != "" { + for _, k := range s.keys { + if k.Name == arg || k.ID == arg { + f(a, k) + return + } + } + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, + Text: fmt.Sprintf("keys %s: no key named %q", verb, arg)}) + return + } + k, ok := s.key() + if !ok { + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, + Text: fmt.Sprintf("keys %s: no key selected — run keys, pick a row with ↑/↓, then keys %s", verb, verb)}) + return + } + f(a, k) +} + +// openCreate is step 1 of the wizard. Each step's OnConfirm builds the next, +// so the flow is a chain of modals rather than a step counter to keep in sync. +func (s *keysScreen) openCreate(a *App) { + s.draft = keyDraft{scope: api.ScopeReadOnly} + a.Modal = &Modal{ + Title: titleCreateName, + Body: "Names are how log rows resolve after a key is revoked.", + Input: true, + Placeholder: "prod-ingest", + OKLabel: labelNext, + OnConfirm: func(a *App, v string) tea.Cmd { + if v == "" { + s.openCreate(a) // a nameless key is the one thing this step exists to prevent + return nil + } + s.draft.name = v + s.openScope(a) + return nil + }, + } +} + +func (s *keysScreen) openScope(a *App) { + a.Modal = &Modal{ + Title: titleCreateScope, + Body: "Scope is always sent explicitly, so the key carries the scope you\n" + + "chose rather than the gateway's default.", + Rows: []ModalKV{{K: kvName, V: s.draft.name, Bold: true}}, + Options: []string{api.ScopeReadOnly, api.ScopeAdmin}, + OptionLabel: kvScope, + OKLabel: labelNext, + OnConfirm: func(a *App, scope string) tea.Cmd { + s.draft.scope = scope + s.openExpiry(a, "") + return nil + }, + } +} + +func (s *keysScreen) openExpiry(a *App, errMsg string) { + a.Modal = &Modal{ + Title: titleCreateExpiry, + Body: "Default 720h. An unexpiring admin key needs a written exception.", + Rows: []ModalKV{ + {K: kvName, V: s.draft.name, Bold: true}, + {K: kvScope, V: s.draft.scope}, + }, + Input: true, + Value: defaultExpiry, + Placeholder: "720h · empty for no expiry", + Err: errMsg, + OKLabel: actionCreate, + OnConfirm: func(a *App, v string) tea.Cmd { + exp, err := parseExpiry(v) + if err != nil { + s.openExpiry(a, err.Error()) + return nil + } + s.draft.expires = exp + return createKey(a.Client, s.gen, api.KeyCreateRequest{ + Name: s.draft.name, + Scopes: []string{s.draft.scope}, + ExpiresAt: exp, + }) + }, + } +} + +func (s *keysScreen) openRotate(a *App, k api.Key) { + a.Modal = &Modal{ + Title: "Rotate " + k.Name + "?", + Body: "Blast radius: every client holding the current secret fails immediately\n" + + "until it is redeployed with the new one.", + Rows: []ModalKV{ + {K: "id", V: k.ID}, + {K: kvScope, V: strings.Join(k.Scopes, ",")}, + {K: kvLastUsed, V: lastUsed(k), Warn: true}, + }, + Input: true, + Placeholder: `type "` + k.Name + `" to confirm`, + Confirm: k.Name, + OKLabel: actionRotate, + Danger: true, + OnConfirm: func(a *App, _ string) tea.Cmd { + return rotateKey(a.Client, s.gen, k.ID) + }, + } +} + +func (s *keysScreen) openRevoke(a *App, k api.Key) { + a.Modal = &Modal{ + Title: "Revoke " + k.Name + "?", + Body: "Revocation is immediate and cannot be undone. Existing log rows keep\n" + + "their api_key_id and will render with a revoked badge.", + Rows: []ModalKV{ + {K: "id", V: k.ID}, + {K: kvScope, V: strings.Join(k.Scopes, ",")}, + }, + Input: true, + Placeholder: `type "` + k.Name + `" to confirm`, + Confirm: k.Name, + OKLabel: actionRevoke, + Danger: true, + OnConfirm: func(a *App, _ string) tea.Cmd { + return revokeKey(a.Client, s.gen, k.ID, k.Name, strings.Join(k.Scopes, ",")) + }, + } +} + +// result turns a finished mutation into the next thing on screen. A failure is +// pushed to the transcript in the gateway's own words and the operator is +// returned to it, because a red row on a pane nobody is looking at is a +// failure that happened silently. +func (s *keysScreen) result(a *App, m modalResultMsg) tea.Cmd { + if m.err != nil { + s.err = m.err + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, Text: "keys " + m.kind + ": " + m.err.Error()}) + return nil + } + switch m.kind { + case actionRevoke: + a.Transcript.Push(TranscriptRow{Glyph: kindOK, Text: "revoked " + m.name + " (" + m.scope + ")"}) + return s.refresh(a) + case actionCreate, actionRotate: + s.openSecret(a, m.kind, m.key) + return nil + } + return nil +} + +// openSecret is the one place a secret is ever rendered. Confirm and cancel run +// the same closure: leaving by esc still records what happened and still drops +// the secret, because esc is a real way out and not an error path. +func (s *keysScreen) openSecret(a *App, kind string, k *api.Key) { + if k == nil { + s.err = fmt.Errorf("keys %s returned no key", kind) + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, Text: s.err.Error()}) + return + } + scope := strings.Join(k.Scopes, ",") + // The list is re-read rather than patched from this response: it carries a + // secret we are about to forget on purpose, and the gateway is the + // authority on what the key now looks like. + done := func(a *App) tea.Cmd { + a.Transcript.Push(TranscriptRow{Glyph: kindOK, Text: summarize(kind, k, scope)}) + a.Screen = ScreenKeys + return s.refresh(a) + } + + if kind == actionRotate { + a.Modal = &Modal{ + Title: "Rotated " + k.Name, + Body: "The previous secret stopped authenticating immediately.", + Rows: []ModalKV{ + {K: "new secret", V: k.Key, Accent: true, Bold: true}, + {K: "id", V: k.ID}, + {K: "blast radius", V: "every client using the old secret", Warn: true}, + }, + OKLabel: "done", + OnConfirm: func(a *App, _ string) tea.Cmd { return done(a) }, + OnCancel: done, + } + return + } + + a.Modal = &Modal{ + Title: "Key created", + Body: "Shown exactly once. Copy it now — the gateway stores only a hash.", + Rows: []ModalKV{ + {K: kvName, V: k.Name, Bold: true}, + {K: "secret", V: k.Key, Accent: true, Bold: true}, + {K: "copy", V: "it will not be shown again"}, + }, + OKLabel: "done", + OnConfirm: func(a *App, _ string) tea.Cmd { return done(a) }, + OnCancel: done, + } +} + +// summarize is the transcript row a finished flow leaves behind. It names the +// key, its scope and its ceiling — everything except the credential. +func summarize(kind string, k *api.Key, scope string) string { + verb := map[string]string{actionCreate: "created", actionRotate: "rotated"}[kind] + out := verb + " " + k.Name + " (" + scope + if k.ExpiresAt != nil { + out += ", expires " + k.ExpiresAt.Local().Format(time.DateOnly) + } else if kind == actionCreate { + out += ", no expiry" + } + return out + ")" +} + +// --------------------------------------------------------------------- view + +// keyColumns is the table, widest-useful first. NAME flexes because it is the +// column an operator reads down; everything else is a fixed field. +func keyColumns() []column { + return []column{ + {head: colName, w: 18, flex: true}, + {head: "KEY", w: 17}, + {head: "SCOPE", w: 10}, + {head: "EXPIRES", w: 10}, + {head: colState, w: 7}, + } +} + +func (s *keysScreen) view(a *App, w, rows int) string { + th := a.Theme + lines := []string{s.subLine(a, w)} + + if s.err != nil { + return fill(append(lines, "", th.Bad.Render("keys: "+s.err.Error())), w, rows) + } + + var strip []string + if s.detail { + if k, ok := s.key(); ok { + strip = detailStrip(a, "Key "+k.Name, keyDetail(a, k), w) + } + } + + // The table gets whatever the sub-line and the strip leave. It never + // scrolls off its own header: the header is dropped last, not first. + body := max(rows-len(lines)-len(strip), 0) + cols := layout(keyColumns(), w) + if body > 0 { + lines = append(lines, th.Dim.Render(headerLine(cols))) + body-- + } + if len(s.keys) == 0 { + lines = append(lines, th.Dim.Render("this gateway has no API keys")) + } + for _, i := range window(len(s.keys), s.sel, body) { + lines = append(lines, s.row(a, cols, i, w)) + } + return fill(append(padTo(lines, rows-len(strip)), strip...), w, rows) +} + +func (s *keysScreen) subLine(a *App, w int) string { + th := a.Theme + left := th.Dim.Render("keys create · keys rotate · keys revoke") + right := th.Dim.Render(fmt.Sprintf("%d keys", len(s.keys))) + if len(s.keys) == 0 { + right = "" + } + return gapPad(w, " "+left, right) +} + +func (s *keysScreen) row(a *App, cols []column, i, w int) string { + th, k := a.Theme, s.keys[i] + state := api.KeyState(k) + + stateStyle := th.OK + switch state { + case api.KeyStateRevoked: + stateStyle = th.Bad + case api.KeyStateExpired: + stateStyle = th.Warn + } + expires := "never" + if k.ExpiresAt != nil { + expires = k.ExpiresAt.Local().Format(time.DateOnly) + } + + line := rowLine(cols, []cell{ + {v: k.Name, style: th.Bright}, + {v: k.Key, style: th.Dim}, + {v: strings.Join(k.Scopes, ","), style: th.Text}, + {v: expires, style: th.Dim}, + {v: state, style: stateStyle}, + }) + if i == s.sel { + return th.Selected.Render(padRight(line, w)) + } + return line +} + +// keyDetail is the strip's rows. Every value is from the wire; the actions row +// names the verbs rather than binding a key to them, because the composer is +// the console's only action surface. +func keyDetail(_ *App, k api.Key) []ModalKV { + state := api.KeyState(k) + row := ModalKV{K: "state", V: state} + switch state { + case api.KeyStateRevoked, api.KeyStateExpired: + row.Warn = true + } + return []ModalKV{ + {K: "id", V: k.ID, Bold: true}, + {K: "key", V: k.Key}, + {K: kvScope, V: strings.Join(k.Scopes, ",")}, + {K: "created", V: table.FmtTime(k.CreatedAt)}, + {K: kvLastUsed, V: lastUsed(k)}, + {K: "expires", V: table.FmtTimePtr(k.ExpiresAt)}, + row, + {K: "actions", V: "keys rotate · keys revoke", Accent: true}, + } +} + +func lastUsed(k api.Key) string { + if k.LastUsedAt == nil { + return "never" + } + return fmt.Sprintf("%s · %s requests", table.FmtTime(*k.LastUsedAt), comma(int(k.UsageCount))) +} + +// ------------------------------------------------------------------ helpers + +// parseExpiry reads the wizard's ceiling. Empty is a real answer — no expiry — +// so it is not an error; anything else must be a duration Go can parse. +func parseExpiry(v string) (*time.Time, error) { + v = strings.TrimSpace(v) + if v == "" { + return nil, nil + } + d, err := time.ParseDuration(v) + if err != nil { + return nil, fmt.Errorf("%q is not a duration — try 720h, 30m, or empty for no expiry", v) + } + if d <= 0 { + return nil, fmt.Errorf("%q expires in the past", v) + } + t := time.Now().Add(d).UTC() + return &t, nil +} + +func clampIdx(i, n int) int { + if n == 0 { + return -1 + } + return min(max(i, 0), n-1) +} + +// ---------------------------------------------------- shared table furniture +// +// Used by this screen and by logs.go. Both draw a fixed-width table into a +// pane that owes an exact line count, so the one thing neither may do is wrap: +// a folded line breaks the count and every frame below it. Columns are +// therefore dropped, right to left, until the row fits. + +type column struct { + head string + w int + flex bool // absorbs the width the fixed columns leave + right bool // numerics align right +} + +type cell struct { + v string + style lipgloss.Style +} + +// layout returns the columns that fit w cells, with the flex column resized to +// whatever is left. It keeps at least the first column, which is the one that +// identifies the row. +func layout(cols []column, w int) []column { + const gap = 1 + fits := func(c []column) int { + total := 0 + for i, col := range c { + total += col.w + if i > 0 { + total += gap + } + } + return total + } + out := append([]column(nil), cols...) + for len(out) > 1 && fits(out) > w { + out = out[:len(out)-1] + } + if slack := w - fits(out); slack != 0 { + for i := range out { + if out[i].flex { + out[i].w = max(out[i].w+slack, 4) + break + } + } + } + return out +} + +func headerLine(cols []column) string { + parts := make([]string, 0, len(cols)) + for _, c := range cols { + if c.right { + parts = append(parts, padLeft(c.head, c.w)) + continue + } + parts = append(parts, padRight(c.head, c.w)) + } + return strings.Join(parts, " ") +} + +func rowLine(cols []column, cells []cell) string { + parts := make([]string, 0, len(cols)) + for i, c := range cols { + if i >= len(cells) { + break + } + v := cells[i].v + if c.right { + v = padLeft(v, c.w) + } else { + v = padRight(v, c.w) + } + parts = append(parts, cells[i].style.Render(v)) + } + return strings.Join(parts, " ") +} + +// window returns the indices of the n rows to draw, scrolled so the selection +// stays on screen. A table that cannot show its selection is a table whose +// cursor keys do nothing visible. +func window(total, sel, n int) []int { + if n <= 0 || total == 0 { + return nil + } + start := 0 + if sel >= n { + start = sel - n + 1 + } + if end := min(start+n, total); end-start > 0 { + out := make([]int, 0, end-start) + for i := start; i < end; i++ { + out = append(out, i) + } + return out + } + return nil +} + +// detailStrip is the bottom-anchored inspector both tables share. +func detailStrip(a *App, title string, rows []ModalKV, w int) []string { + th := a.Theme + out := append(make([]string, 0, 2+len(rows)), + th.Border.Render(a.rule(max(w, 0))), + gapPad(w, th.Bright.Bold(th.Mode.Color).Render(title), th.Dim.Render("esc close")), + ) + for _, r := range rows { + out = append(out, th.Dim.Render(padRight(r.K, modalKeyCol))+kvStyle(th, r).Render(r.V)) + } + return clampLines(out, w) +} + +// padTo pads or trims to exactly n lines, so a view can reserve the space a +// bottom-anchored strip will occupy before it appends one. +func padTo(lines []string, n int) []string { + if n <= 0 { + return nil + } + for len(lines) < n { + lines = append(lines, "") + } + return lines[:n] +} diff --git a/internal/tui/keys_test.go b/internal/tui/keys_test.go new file mode 100644 index 0000000..3b902dc --- /dev/null +++ b/internal/tui/keys_test.go @@ -0,0 +1,392 @@ +package tui + +import ( + "net/http/httptest" + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/fixture" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// fixtureApp is a shell wired to the stateful fake: create/rotate/revoke +// actually mutate a key store, so the wizard is exercised end to end rather +// than against a canned response that can never disagree with it. +func fixtureApp(t *testing.T) *App { + t.Helper() + srv := httptest.NewServer(fixture.Handler(fixture.Default())) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "fgw_test") + if err != nil { + t.Fatalf("client: %v", err) + } + a := composerApp() + a.Client = c + return a +} + +// runCmd runs one command and applies its message, failing rather than +// returning nil so a broken flow names the step it stopped at. +func runCmd(t *testing.T, a *App, cmd tea.Cmd, what string) tea.Msg { + t.Helper() + if cmd == nil { + t.Fatalf("%s returned no command", what) + } + msg := cmd() + a.update(msg) + return msg +} + +func loadKeys(t *testing.T, a *App) { + t.Helper() + runCmd(t, a, a.route("keys"), "keys") + if a.Keys.err != nil { + t.Fatalf("key list failed: %v", a.Keys.err) + } + if len(a.Keys.keys) == 0 { + t.Fatal("the fixture seeds keys; an empty list means the fetch did not land") + } + if a.Screen != ScreenKeys { + t.Fatalf("keys must switch to the keys pane, got %v", a.Screen) + } +} + +func keyNamed(a *App, name string) (api.Key, bool) { + for _, k := range a.Keys.keys { + if k.Name == name { + return k, true + } + } + return api.Key{}, false +} + +func TestKeysTableUsesMaskedKey(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + view := a.paneView(120, 18) + + for _, k := range a.Keys.keys { + if !strings.Contains(view, k.Name) { + t.Fatalf("key %q missing from the table:\n%s", k.Name, view) + } + } + // The wire's `key` field is masked head8…tail4 on every read; the table + // shows that, never a full secret and never a bare row id in its place. + masked := a.Keys.keys[0].Key + if masked == "" { + t.Fatal("the fixture serves a masked key on reads") + } + if !strings.Contains(view, masked) { + t.Fatalf("the table must show the masked key %q:\n%s", masked, view) + } +} + +func TestKeysTableRendersEveryDerivedState(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + view := a.paneView(120, 18) + // There is no state field on the wire — api.KeyState derives it. + seen := map[string]bool{} + for _, k := range a.Keys.keys { + seen[api.KeyState(k)] = true + } + for _, want := range []string{"active", "revoked", "expired"} { + if !seen[want] { + continue // the fixture may not seed every state + } + if !strings.Contains(view, want) { + t.Fatalf("state %q must appear in the table:\n%s", want, view) + } + } +} + +func TestNewKeysCommandIgnoresEarlierListResult(t *testing.T) { + a := composerApp() + a.route("keys list") + oldGen := a.Keys.gen + + a.route("keys rotate target") + newGen := a.Keys.gen + if newGen == oldGen { + t.Fatal("a newer keys command must invalidate the earlier list request") + } + + a.update(keysListMsg{gen: oldGen, keys: []api.Key{{ID: "old", Name: "target"}}}) + if a.Modal != nil { + t.Fatal("an earlier list result must not open the newer command's modal") + } + if a.Keys.pendingVerb != "rotate" || a.Keys.pendingArg != "target" { + t.Fatalf("stale result cleared the newer pending command: %q %q", + a.Keys.pendingVerb, a.Keys.pendingArg) + } + + a.update(keysListMsg{gen: newGen, keys: []api.Key{{ID: "current", Name: "target"}}}) + if a.Modal == nil || a.Modal.Title != "Rotate target?" { + t.Fatalf("the current list result must resume the pending command, got %+v", a.Modal) + } +} + +func TestWizardHappyPath(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + + a.route("keys create") + if a.Modal == nil { + t.Fatal("keys create must open the wizard") + } + if a.Modal.Title != "Create API key · name" { + t.Fatalf("step 1 title drifted from the expected wording: %q", a.Modal.Title) + } + if !strings.Contains(a.Modal.Body, "Names are how log rows resolve after a key is revoked.") { + t.Fatalf("step 1 body drifted from the expected wording: %q", a.Modal.Body) + } + typeModal(a, a.Modal, "ci-readonly") + a.Modal.handle("enter", a) + + if a.Modal == nil || !strings.Contains(a.Modal.Title, "scope") { + t.Fatalf("step 2 must be the scope step, got %+v", a.Modal) + } + if !strings.Contains(a.Modal.Body, "Scope is always sent explicitly") { + t.Fatalf("step 2 body drifted from the expected wording: %q", a.Modal.Body) + } + // The gateway defaults an omitted scope to read_only. This panel told the + // operator it was granted admin, which is the opposite. + if strings.Contains(a.Modal.Body, "granted admin") { + t.Fatalf("step 2 must not restate the old backwards claim: %q", a.Modal.Body) + } + if a.Modal.Option() != "read_only" { + t.Fatalf("the wizard defaults to read_only, got %q", a.Modal.Option()) + } + a.Modal.handle("space", a) // → admin + if a.Modal.Option() != "admin" { + t.Fatalf("space must toggle the scope, got %q", a.Modal.Option()) + } + a.Modal.handle("enter", a) + + if a.Modal == nil || !strings.Contains(a.Modal.Title, "expiry") { + t.Fatalf("step 3 must be the expiry step, got %+v", a.Modal) + } + if !strings.Contains(a.Modal.Body, "Default 720h. An unexpiring admin key needs a written exception.") { + t.Fatalf("step 3 body drifted from the expected wording: %q", a.Modal.Body) + } + if a.Modal.Value != "720h" { + t.Fatalf("the expiry step is prefilled with 720h, got %q", a.Modal.Value) + } + + before := time.Now() + msg := runCmd(t, a, a.Modal.handle("enter", a), "create") + res, ok := msg.(modalResultMsg) + if !ok || res.err != nil { + t.Fatalf("create must reach the gateway, got %#v", msg) + } + if res.key == nil || res.key.Key == "" { + t.Fatal("create returns the full secret exactly once") + } + secret := res.key.Key + + if a.Modal == nil || a.Modal.Title != "Key created" { + t.Fatalf("a created key must land in its own modal, got %+v", a.Modal) + } + if !strings.Contains(a.Modal.Body, "Shown exactly once. Copy it now — the gateway stores only a hash.") { + t.Fatalf("the secret step body drifted from the expected wording: %q", a.Modal.Body) + } + if !strings.Contains(a.paneView(110, 18), secret) { + t.Fatalf("the secret must be visible in its modal:\n%s", a.paneView(110, 18)) + } + + // Closing it refreshes the list, which is where the request's own values + // come back: the scope the toggle chose and the expiry it parsed. + runCmd(t, a, a.Modal.handle("enter", a), "close secret modal") + created, found := keyNamed(a, "ci-readonly") + if !found { + t.Fatalf("the created key must appear after the refresh: %+v", a.Keys.keys) + } + if len(created.Scopes) != 1 || created.Scopes[0] != "admin" { + t.Fatalf("the toggled scope must be what was sent, got %v", created.Scopes) + } + if created.ExpiresAt == nil { + t.Fatal("720h must have been sent as an expiry") + } + if d := created.ExpiresAt.Sub(before); d < 719*time.Hour || d > 721*time.Hour { + t.Fatalf("expiry must be ~720h out, got %v", d) + } +} + +func TestWizardSecretNeverInTranscriptOrHistory(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + + a.route("keys create") + typeModal(a, a.Modal, "ci-readonly") + a.Modal.handle("enter", a) + a.Modal.handle("enter", a) // keep read_only + msg := runCmd(t, a, a.Modal.handle("enter", a), "create") + secret := msg.(modalResultMsg).key.Key + if secret == "" { + t.Fatal("nothing to assert about if no secret was issued") + } + runCmd(t, a, a.Modal.handle("enter", a), "close secret modal") + + if strings.Contains(transcriptText(a), secret) { + t.Fatalf("the secret must never enter the transcript:\n%s", transcriptText(a)) + } + for _, h := range a.Composer.History { + if strings.Contains(h, secret) { + t.Fatalf("the secret must never enter the command history: %q", h) + } + } + if strings.Contains(a.render(), secret) { + t.Fatal("the secret must be gone from the screen once its modal closes") + } + // What it does leave behind is the key and its scope, so the operation is + // on the record without the credential being on it. + if !strings.Contains(transcriptText(a), "ci-readonly") || + !strings.Contains(transcriptText(a), "read_only") { + t.Fatalf("a completed create must name the key and its scope:\n%s", transcriptText(a)) + } +} + +func TestRotateFlowSecretOnce(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + a.Keys.sel = 0 + name := a.Keys.keys[0].Name + + runCmd(t, a, a.route("keys rotate"), "refresh before rotate") + if a.Modal == nil { + t.Fatal("keys rotate must open a confirmation") + } + if !strings.Contains(a.Modal.Body, + "Blast radius: every client holding the current secret fails immediately") { + t.Fatalf("rotate body drifted from the expected wording: %q", a.Modal.Body) + } + if a.Modal.Placeholder != `type "`+name+`" to confirm` { + t.Fatalf("rotate placeholder drifted: %q", a.Modal.Placeholder) + } + if cmd := a.Modal.handle("enter", a); cmd != nil { + t.Fatal("rotate must not fire before the key's name is typed") + } + if a.Modal == nil { + t.Fatal("an unconfirmed destructive modal stays open") + } + + typeModal(a, a.Modal, name) + msg := runCmd(t, a, a.Modal.handle("enter", a), "rotate") + res, ok := msg.(modalResultMsg) + if !ok || res.err != nil { + t.Fatalf("rotate must reach the gateway, got %#v", msg) + } + secret := res.key.Key + if secret == "" { + t.Fatal("rotate returns the new secret exactly once") + } + if !strings.Contains(a.paneView(110, 18), secret) { + t.Fatal("the rotated secret must be visible in its modal") + } + + runCmd(t, a, a.Modal.handle("enter", a), "close rotate secret modal") + if strings.Contains(transcriptText(a), secret) { + t.Fatalf("the rotated secret must never enter the transcript:\n%s", transcriptText(a)) + } + if strings.Contains(a.render(), secret) { + t.Fatal("the rotated secret must be gone once its modal closes") + } + if k, _ := keyNamed(a, name); k.RotatedAt == nil { + t.Fatal("the refreshed row must show the rotation") + } +} + +func TestRevokeUpdatesStateColumn(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + + // Pick a key that is currently active, so "revoked" is a change. + idx := -1 + for i, k := range a.Keys.keys { + if api.KeyState(k) == "active" { + idx = i + break + } + } + if idx < 0 { + t.Fatal("the fixture seeds at least one active key") + } + a.Keys.sel = idx + name := a.Keys.keys[idx].Name + + runCmd(t, a, a.route("keys revoke"), "refresh before revoke") + if a.Modal == nil { + t.Fatal("keys revoke must open a confirmation") + } + if !strings.Contains(a.Modal.Body, "Revocation is immediate and cannot be undone.") || + !strings.Contains(a.Modal.Body, "revoked badge.") { + t.Fatalf("revoke body drifted from the expected wording: %q", a.Modal.Body) + } + typeModal(a, a.Modal, "not-the-name") + if cmd := a.Modal.handle("enter", a); cmd != nil { + t.Fatal("a wrong phrase must not revoke") + } + a.Modal.handle("ctrl+u", a) + typeModal(a, a.Modal, name) + + runCmd(t, a, a.Modal.handle("enter", a), "revoke") + // The result arm refreshes the list; run that fetch too. + runCmd(t, a, a.Keys.refresh(a), "refresh") + + k, found := keyNamed(a, name) + if !found { + t.Fatalf("a revoked key keeps its row: %+v", a.Keys.keys) + } + if got := api.KeyState(k); got != "revoked" { + t.Fatalf("state column must read revoked after a revoke, got %q", got) + } + if !strings.Contains(a.paneView(120, 18), "revoked") { + t.Fatalf("the table must render the new state:\n%s", a.paneView(120, 18)) + } + if !strings.Contains(transcriptText(a), name) { + t.Fatalf("a completed revoke must name the key:\n%s", transcriptText(a)) + } +} + +func TestKeysDestructiveVerbsNeedASelection(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + a.Keys.keys, a.Keys.sel = nil, -1 + for _, verb := range []string{"keys rotate", "keys revoke"} { + a.route(verb) + a.update(keysListMsg{gen: a.Keys.gen, keys: nil}) + if a.Modal != nil { + t.Fatalf("%q with nothing selected must not open a destructive modal", verb) + } + if lastRow(a).Glyph != "bad" { + t.Fatalf("%q with nothing selected must say so: %#v", verb, lastRow(a)) + } + } +} + +func TestKeysScreenKeepsThePaneContract(t *testing.T) { + a := fixtureApp(t) + loadKeys(t, a) + a.Keys.sel, a.Keys.detail = 1, true + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + a.Theme = theme.New(mode) + for _, rows := range []int{1, 4, 9, 20} { + for _, w := range []int{30, 60, 92, 126} { + body := a.paneView(w, rows) + if got := len(strings.Split(body, "\n")); got != rows { + t.Fatalf("mode=%+v w=%d rows=%d returned %d lines", mode, w, rows, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } + } +} diff --git a/internal/tui/logs.go b/internal/tui/logs.go new file mode 100644 index 0000000..99591dd --- /dev/null +++ b/internal/tui/logs.go @@ -0,0 +1,495 @@ +package tui + +import ( + "errors" + "fmt" + "strconv" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" +) + +// The logs screen is a live tail, and everything here is shaped by the one +// rule a tail must obey: a poll that fails does not erase what is already on +// screen. It keeps the rows, says how old they are, and probes less often the +// longer the gateway stays unreachable. Blanking the table because one request +// timed out would claim the traffic stopped, which is the opposite of what +// happened. +// +// The three measurements are pointers on the wire because the gateway sends +// null for "not measured" — a request that failed before reaching a provider, +// or one served by a provider with no price in the catalog. They render as a +// dash. Collapsing null into 0 would draw a real zero-cost, zero-latency +// request, which is a claim no row here can support. + +const ( + // logsRing is the display ring. A console that tails for a day must not + // grow without limit, and 200 rows is more than the tallest pane can show. + logsRing = 200 + + // logsPoll is the tail cadence. A failure doubles it up to maxPoll and the + // first success resets it. + logsPoll = 2 * time.Second + + // logsPage is the default page size per poll. + logsPage = 100 + + // traceCell is the trace-id column: "tr_" plus eight bytes of the id, which + // is what /admin/logs and the playground's attribution both key on. + traceCell = 11 +) + +// keyRef is what a log row's api_key_id resolves to. Revoked is carried +// separately because a key revoked SINCE it served the traffic still names the +// rows it served — that is the whole reason keys have names. +type keyRef struct { + Name string + Revoked bool +} + +// logsScreen is the request-log pane: a filtered tail, a selection, and a +// detail strip. +type logsScreen struct { + rows []api.LogEntry // newest first, bounded at logsRing + sel int // -1 when nothing is selected + detail bool + follower *api.Follower + filters api.LogsQuery + // raw is the filter arguments exactly as typed. The sub-line renders it + // rather than reconstructing one from the parsed query, so what is on + // screen is a line the operator could run again — "--since 15m", not the + // "14m59s" a round trip through time.Duration turns it into. + raw string + tailing bool + + // keyNames comes from one Keys() read at start. A caller without the + // credential for it gets an empty map and raw ids, which is strictly better + // than refusing to show the logs they can read. + keyNames map[string]keyRef + + lastErr error + staleAt time.Time // when the data went stale; zero while polls succeed + backoff time.Duration + // truncated records that the LAST poll hit the follower's page bound. The + // rows it returned are real, so this is a readout beside them and not an + // error: what is missing is the oldest end of that one window. + truncated bool + + gen int +} + +// ------------------------------------------------------------------ lifecycle + +// start parses the filter arguments and opens the tail. A bad argument never +// enters the screen: the refusal belongs in the transcript, which is on the +// home pane, and switching away from it would hide the reason. +func (s *logsScreen) start(a *App, args string) tea.Cmd { + q, err := parseLogFilters(args) + if err != nil { + a.Screen = ScreenHome + a.Transcript.Push(TranscriptRow{Glyph: kindBad, Text: err.Error()}) + return nil + } + + *s = logsScreen{gen: s.gen + 1, filters: q, raw: strings.TrimSpace(args), + sel: -1, backoff: logsPoll, keyNames: map[string]keyRef{}} + a.Screen = ScreenLogs + if a.Client == nil { + s.lastErr = errNoConnection + return nil + } + s.tailing = true + s.follower = api.NewFollower(a.Client, q) + // No tick is armed here: the first poll arms the second. See rearm. + return tea.Batch(fetchLogKeyNames(a.Client, s.gen), pollLogs(s.follower, s.gen)) +} + +// leave stops the tail. The generation bump is what actually stops it: a tick +// already in flight carries the old one and schedules nothing when it lands. +func (s *logsScreen) leave() { + s.gen++ + s.tailing = false + s.follower = nil +} + +func (s *logsScreen) update(a *App, msg tea.Msg) tea.Cmd { + switch m := msg.(type) { + case tickLogsMsg: + // Three independent reasons to stop: a newer visit, a pane that is no + // longer on show, and a tail that was never started. + if m.gen != s.gen || a.Screen != ScreenLogs || !s.tailing || s.follower == nil { + return nil + } + return pollLogs(s.follower, s.gen) + + case logsBatchMsg: + if m.gen != s.gen { + return nil + } + // api.ErrFollowTruncated is the one error that arrives WITH rows: the + // poll succeeded, the cursor moved past what it read, and what was lost + // is the oldest end of that single window. Treating it as a failed poll + // would discard rows the gateway did return and back the tail off + // against a gateway whose only problem is that it is busy. + if truncated := errors.Is(m.err, api.ErrFollowTruncated); m.err == nil || truncated { + s.lastErr, s.staleAt, s.backoff = nil, time.Time{}, logsPoll + s.truncated = truncated + s.prepend(m.rows) + return s.rearm() + } + s.lastErr = m.err + if api.IsNotSupported(m.err) { + // A gateway with no request-log store answers 501. That is an + // absent feature, not a failed poll: it will not become a 200, + // so the tail stops instead of backing off against it forever. + s.tailing = false + return nil + } + if s.staleAt.IsZero() { + s.staleAt = time.Now() + } + s.backoff = backoff(s.backoff) + return s.rearm() + + case logsNamesMsg: + if m.gen != s.gen { + return nil + } + s.keyNames = m.names + return nil + } + return nil +} + +// rearm schedules the next poll, and it is called from exactly one place: the +// arm that handles a finished one. That is what serialises the tail. +// +// api.Follower is one-per-tail-loop state — its cursor, its dedupe map and its +// row slice are unsynchronised — so two polls in flight against the same +// follower race, and a gateway whose /admin/logs takes longer than the poll +// interval is all it takes to have two. Arming the next tick only once the +// previous poll's rows have landed makes that unreachable. The generation +// counter cannot do this job: it discards a stale result after the fact, which +// is a different thing from never running two polls at once. +func (s *logsScreen) rearm() tea.Cmd { + if !s.tailing || s.follower == nil { + return nil + } + return tickLogs(s.backoff, s.gen) +} + +// prepend puts a poll's ascending rows at the head, newest first, and trims to +// the ring. The selection follows its row rather than its index, so a batch +// arriving under the cursor does not silently re-point the detail strip at a +// different request. +func (s *logsScreen) prepend(rows []api.LogEntry) { + if len(rows) == 0 { + return + } + var selected string + hadSelection := false + if k, ok := s.row(); ok { + selected = k.TraceID + hadSelection = true + } + + next := make([]api.LogEntry, 0, min(len(rows)+len(s.rows), logsRing)) + for i := len(rows) - 1; i >= 0; i-- { + next = append(next, rows[i]) + } + next = append(next, s.rows...) + if len(next) > logsRing { + next = next[:logsRing] + } + s.rows = next + + if !hadSelection { + return + } + for i, r := range s.rows { + if r.TraceID == selected { + s.sel = i + return + } + } + s.sel, s.detail = -1, false +} + +func (s *logsScreen) row() (api.LogEntry, bool) { + if s.sel < 0 || s.sel >= len(s.rows) { + return api.LogEntry{}, false + } + return s.rows[s.sel], true +} + +// handleKey is the pane's own keyboard; see App.screenKey for why it is only +// ever offered a key while the command line is empty. +func (s *logsScreen) handleKey(key string) bool { + switch key { + case keyUp: + s.sel = clampIdx(s.sel-1, len(s.rows)) + case keyDown: + s.sel = clampIdx(s.sel+1, len(s.rows)) + case keyEnter: + s.detail = s.sel >= 0 && s.sel < len(s.rows) + case keyEsc: + if !s.detail { + return false + } + s.detail = false + default: + return false + } + return true +} + +// -------------------------------------------------------------------- filters + +// logFilterHelp is the vocabulary a refusal names. It is one string so the +// parser and its error message cannot drift apart. +const logFilterHelp = "filters are --since --model --provider --stage --key --limit" + +// parseLogFilters walks `--flag value` pairs. An unknown flag is refused rather +// than ignored: a filter silently dropped shows a wider log than was asked for, +// and the operator has no way to tell. +func parseLogFilters(args string) (api.LogsQuery, error) { + q := api.LogsQuery{Limit: logsPage} + f := strings.Fields(args) + for i := 0; i < len(f); i++ { + name := f[i] + if !strings.HasPrefix(name, "--") { + return q, fmt.Errorf("logs: unexpected argument %q — %s", name, logFilterHelp) + } + if i+1 >= len(f) { + return q, fmt.Errorf("logs: %s needs a value — %s", name, logFilterHelp) + } + v := f[i+1] + i++ + switch name { + case "--since": + t, err := api.ParseSince(v) + if err != nil { + return q, fmt.Errorf("logs: %w — %s", err, logFilterHelp) + } + q.Since = t + case "--model": + q.Model = v + case "--provider": + q.Provider = v + case "--stage": + q.Stage = v + case "--key": + // "none" is the gateway's own sentinel for rows with no credential + // and is passed through untouched. + q.APIKeyID = v + case "--limit": + n, err := strconv.Atoi(v) + if err != nil || n <= 0 { + return q, fmt.Errorf("logs: --limit %q is not a positive count — %s", v, logFilterHelp) + } + q.Limit = n + default: + return q, fmt.Errorf("logs: unknown flag %q — %s", name, logFilterHelp) + } + } + return q, nil +} + +// filterLabel renders the active filters the way they were typed, so what is +// on screen is a line the operator could run again. +func (s *logsScreen) filterLabel() string { + if s.raw == "" { + return "no filter · terminal rows only" + } + return strings.Join(strings.Fields(s.raw), " ") +} + +// --------------------------------------------------------------------- view + +// logColumns is the table. MODEL flexes because it is the only column whose +// content has no bound; everything else is a field of known shape. +func logColumns() []column { + return []column{ + {head: "TIME", w: 8}, + {head: "TRACE", w: traceCell}, + {head: colProvider, w: 10}, + {head: "MODEL", w: 14, flex: true}, + {head: "STAGE", w: 13}, + {head: "MS", w: 6, right: true}, + {head: "COST", w: 8, right: true}, + } +} + +func (s *logsScreen) view(a *App, w, rows int) string { + th := a.Theme + lines := []string{s.subLine(a, w)} + + // A 501 falls through to the empty note, which names the missing store. The + // gateway's raw words are right for a failure and wrong for an absence. + if s.lastErr != nil && len(s.rows) == 0 && !api.IsNotSupported(s.lastErr) { + return fill(append(lines, "", th.Bad.Render("logs: "+s.lastErr.Error())), w, rows) + } + + var strip []string + if s.detail { + if r, ok := s.row(); ok { + strip = detailStrip(a, "Request "+r.TraceID, s.rowDetail(a, r), w) + } + } + + body := max(rows-len(lines)-len(strip), 0) + cols := layout(logColumns(), w) + if body > 0 { + lines = append(lines, th.Dim.Render(headerLine(cols))) + body-- + } + if len(s.rows) == 0 { + lines = append(lines, th.Dim.Render(s.emptyNote())) + } + for _, i := range window(len(s.rows), s.sel, body) { + lines = append(lines, s.line(a, cols, i, w)) + } + return fill(append(padTo(lines, rows-len(strip)), strip...), w, rows) +} + +// emptyNote distinguishes "nothing has arrived yet" from "this gateway keeps no +// log": a tail against a gateway with no store would otherwise look identical +// to a quiet one. +func (s *logsScreen) emptyNote() string { + switch { + case s.lastErr != nil && api.IsNotSupported(s.lastErr): + return "this gateway has no request-log store configured" + case s.tailing: + return "no rows yet — the tail is live and will fill as traffic arrives" + default: + return "no rows in range" + } +} + +// subLine carries the active filters on the left and the tail's own health on +// the right. Staleness is a readout, not an error: the rows below it are real, +// they are just older than they look. +func (s *logsScreen) subLine(a *App, w int) string { + th := a.Theme + right := "" + switch { + case !s.staleAt.IsZero(): + right = th.Warn.Render(fmt.Sprintf("stale %ds · retrying in %s", + int(time.Since(s.staleAt).Seconds()), s.backoff)) + case s.truncated: + // The rows below are real; the gateway was simply busy enough that one + // poll could not reach the far end of its window. Saying which end was + // cut is what stops the table reading as the whole range. + right = th.Warn.Render("tailing · older rows in that window skipped") + case s.tailing: + right = th.Accent.Render("tailing…") + if th.Mode.ASCII { + right = th.Accent.Render("tailing...") + } + } + return gapPad(w, " "+th.Dim.Render(s.filterLabel()), right) +} + +func (s *logsScreen) line(a *App, cols []column, i, w int) string { + th, r := a.Theme, s.rows[i] + + stage, stageStyle := r.Stage, th.OK + if r.ErrorMessage != "" { + stageStyle = th.Bad + } + line := rowLine(cols, []cell{ + {v: r.CreatedAt.Local().Format(time.TimeOnly), style: th.Dim}, + {v: shortTrace(r.TraceID), style: th.Accent}, + {v: table.OrDash(r.Provider), style: th.Text}, + {v: table.OrDash(r.Model), style: th.Bright}, + {v: table.OrDash(stage), style: stageStyle}, + {v: msCell(r.DurationMs), style: th.Text}, + {v: costCell(r.CostUSD), style: th.Dim}, + }) + if i == s.sel { + return th.Selected.Render(padRight(line, w)) + } + return line +} + +// rowDetail is the strip. It carries the full trace id (the table's is cut), +// both measurements, and the credential resolved to a name — which is the one +// thing the table cannot show and the reason a row is opened at all. +func (s *logsScreen) rowDetail(_ *App, r api.LogEntry) []ModalKV { + name, revoked := s.resolveKey(r.APIKeyID) + out := []ModalKV{ + {K: "trace", V: r.TraceID, Bold: true}, + {K: "provider", V: table.OrDash(r.Provider)}, + {K: "model", V: table.OrDash(r.Model)}, + {K: "stage", V: table.OrDash(r.Stage)}, + {K: "duration", V: msUnit(r.DurationMs)}, + {K: "ttft", V: msUnit(r.TTFTMs)}, + {K: "tokens", V: fmt.Sprintf("%d in / %d out", r.PromptTokens, r.CompletionTokens)}, + {K: "cost", V: costCell(r.CostUSD)}, + {K: "api key", V: name, Warn: revoked}, + } + if r.ErrorMessage != "" { + out = append(out, ModalKV{K: "error", V: r.ErrorMessage, Warn: true}) + } + return out +} + +// resolveKey turns a row's api_key_id into something an operator can act on. +// Three cases, all real: the master credential carries a synthetic id with no +// key row behind it, a named key may have been revoked since it served the +// traffic, and a deleted key keeps its rows but loses its name. +func (s *logsScreen) resolveKey(id string) (string, bool) { + switch { + case id == "": + return "none", false + case strings.HasPrefix(id, "master-key:"): + return "master key", false + } + if ref, ok := s.keyNames[id]; ok && ref.Name != "" { + if ref.Revoked { + return ref.Name + " [revoked]", true + } + return ref.Name, false + } + return id, false +} + +// ------------------------------------------------------------------ helpers + +// shortTrace cuts a trace id to the table's column without inventing a shape: +// it keeps the head, which is what /admin/logs?trace= matches on. +func shortTrace(id string) string { + if id == "" { + return "-" + } + if len(id) <= traceCell { + return id + } + return id[:traceCell] +} + +// msCell and costCell render an absent measurement as a dash, never as a zero. +func msCell(v *float64) string { + if v == nil { + return "-" + } + return strconv.FormatFloat(*v, 'f', 0, 64) +} + +func msUnit(v *float64) string { + if v == nil { + return "-" + } + return msCell(v) + "ms" +} + +func costCell(v *float64) string { + if v == nil { + return "-" + } + return "$" + strconv.FormatFloat(*v, 'f', 4, 64) +} diff --git a/internal/tui/logs_test.go b/internal/tui/logs_test.go new file mode 100644 index 0000000..55f1e7c --- /dev/null +++ b/internal/tui/logs_test.go @@ -0,0 +1,440 @@ +package tui + +import ( + "errors" + "fmt" + "strings" + "testing" + "time" + + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +func f64(v float64) *float64 { return &v } + +// logRow builds one entry with everything measured, so a test that wants an +// absent measurement removes exactly the field it is about. +func logRow(trace string, at time.Time) api.LogEntry { + return api.LogEntry{ + TraceID: trace, Stage: "response", Model: "claude-sonnet-4-6", + Provider: "anthropic", APIKeyID: "ak_1", + PromptTokens: 412, CompletionTokens: 189, TotalTokens: 601, + CreatedAt: at, DurationMs: f64(934), TTFTMs: f64(210), CostUSD: f64(0.0031), + } +} + +func TestLogsStartParsesFilters(t *testing.T) { + a := composerApp() + before := time.Now() + a.route("logs --since 15m --model claude-* --provider anthropic --stage response --key none --limit 25") + + if a.Screen != ScreenLogs { + t.Fatalf("a valid filter set enters the screen, got %v", a.Screen) + } + q := a.Logs.filters + if q.Model != "claude-*" { + t.Fatalf("--model must keep its case and its glob, got %q", q.Model) + } + if q.Provider != "anthropic" || q.Stage != "response" { + t.Fatalf("provider/stage filters dropped: %+v", q) + } + if q.APIKeyID != "none" { + t.Fatalf(`--key none is the gateway's own sentinel and passes through, got %q`, q.APIKeyID) + } + if q.Limit != 25 { + t.Fatalf("--limit dropped, got %d", q.Limit) + } + if d := before.Sub(q.Since); d < 14*time.Minute || d > 16*time.Minute { + t.Fatalf("--since 15m must be 15m into the past, got %v before now", d) + } + if !strings.Contains(a.paneView(120, 10), "--model claude-*") { + t.Fatalf("the active filters must be on screen:\n%s", a.paneView(120, 10)) + } +} + +func TestLogsStartRejectsUnknownFlag(t *testing.T) { + for _, args := range []string{"--frobnicate x", "--since", "--limit banana", "claude-*"} { + a := composerApp() + if cmd := a.route("logs " + args); cmd != nil { + t.Fatalf("%q must not reach the network", args) + } + if a.Screen != ScreenHome { + t.Fatalf("%q must leave the operator on the transcript, got %v", args, a.Screen) + } + row := lastRow(a) + if row.Glyph != "bad" { + t.Fatalf("%q must be refused in a red row, got %#v", args, row) + } + if !strings.Contains(row.Text, "--since") { + t.Fatalf("a refusal must name the filters that do exist: %q", row.Text) + } + } +} + +func TestLogsBatchPrependsBounded(t *testing.T) { + a := composerApp() + a.route("logs") + now := time.Now() + + seed := make([]api.LogEntry, 0, 195) + for i := range 195 { + seed = append(seed, logRow(fmt.Sprintf("tr_seed%03d", i), now.Add(time.Duration(i)*time.Second))) + } + a.update(logsBatchMsg{gen: a.Logs.gen, rows: seed}) + + batch := make([]api.LogEntry, 0, 10) + for i := range 10 { + batch = append(batch, logRow(fmt.Sprintf("tr_new%03d", i), now.Add(time.Duration(200+i)*time.Second))) + } + a.update(logsBatchMsg{gen: a.Logs.gen, rows: batch}) + + if got := len(a.Logs.rows); got != logsRing { + t.Fatalf("the ring is bounded at %d, got %d", logsRing, got) + } + // Newest first: the last row of the newest ascending batch leads. + if a.Logs.rows[0].TraceID != "tr_new009" { + t.Fatalf("rows must be newest first, got %q", a.Logs.rows[0].TraceID) + } + if a.Logs.rows[9].TraceID != "tr_new000" { + t.Fatalf("a batch must keep its own order when prepended, got %q", a.Logs.rows[9].TraceID) + } +} + +func TestLogsSelectionAndDetail(t *testing.T) { + a := composerApp() + a.route("logs") + now := time.Now() + rows := []api.LogEntry{logRow("tr_aaaaaaaa", now), logRow("tr_bbbbbbbb", now.Add(time.Second))} + rows[0].APIKeyID = "ak_revoked" + rows[1].APIKeyID = "master-key:0f21" + a.update(logsBatchMsg{gen: a.Logs.gen, rows: rows}) + a.update(logsNamesMsg{gen: a.Logs.gen, names: map[string]keyRef{ + "ak_revoked": {Name: "laptop-old", Revoked: true}, + }}) + + if !a.screenKey("down") { + t.Fatal("the logs pane must take ↓ while the command line is empty") + } + if a.Logs.sel != 0 { + t.Fatalf("↓ with nothing selected takes the newest row, got %d", a.Logs.sel) + } + a.screenKey("down") + if a.Logs.sel != 1 { + t.Fatalf("↓ must move the selection, got %d", a.Logs.sel) + } + a.screenKey("up") + if a.Logs.sel != 0 { + t.Fatalf("↑ must move it back, got %d", a.Logs.sel) + } + + // Row 0 is the newest, which is tr_bbbbbbbb with the master credential. + a.screenKey("enter") + view := a.paneView(120, 20) + if !strings.Contains(view, "tr_bbbbbbbb") { + t.Fatalf("the strip must carry the full trace id:\n%s", view) + } + if !strings.Contains(view, "master key") { + t.Fatalf("a master-key:* id must resolve to `master key`:\n%s", view) + } + + a.screenKey("down") + a.screenKey("enter") + view = a.paneView(120, 20) + if !strings.Contains(view, "laptop-old") { + t.Fatalf("a resolvable api_key_id must render as its name:\n%s", view) + } + if !strings.Contains(view, "[revoked]") { + t.Fatalf("a key revoked since it served the traffic must carry the badge:\n%s", view) + } + + if !a.screenKey("esc") { + t.Fatal("esc must close the strip before it means back") + } + if a.Logs.detail { + t.Fatal("esc must close the detail strip") + } + if a.screenKey("esc") { + t.Fatal("with no strip open, esc belongs to the composer") + } +} + +// An unresolvable id is rendered raw. A deleted key keeps its log rows, and +// that is exactly the case this question is most often asked about. +func TestLogsUnresolvableKeyRendersRawID(t *testing.T) { + a := composerApp() + a.route("logs") + row := logRow("tr_cccccccc", time.Now()) + row.APIKeyID = "ak_deleted" + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{row}}) + a.Logs.sel, a.Logs.detail = 0, true + if v := a.paneView(120, 20); !strings.Contains(v, "ak_deleted") { + t.Fatalf("an id no key store can name must render as itself:\n%s", v) + } +} + +func TestLogsPollFailureKeepsRowsShowsStale(t *testing.T) { + a := composerApp() + a.route("logs") + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{logRow("tr_keepme0", time.Now())}}) + + base := a.Logs.backoff + a.update(logsBatchMsg{gen: a.Logs.gen, err: errors.New("connection refused")}) + if len(a.Logs.rows) != 1 { + t.Fatal("a failed poll must never blank the table") + } + if a.Logs.backoff != 2*base { + t.Fatalf("a failure must double the cadence, got %v", a.Logs.backoff) + } + if a.Logs.staleAt.IsZero() { + t.Fatal("a failed poll must record when the data went stale") + } + view := a.paneView(120, 12) + if !strings.Contains(view, "tr_keepme0") { + t.Fatalf("the rows already shown must survive:\n%s", view) + } + if !strings.Contains(view, "stale") || !strings.Contains(view, "retrying") { + t.Fatalf("stale data must say so and say it is still trying:\n%s", view) + } + + for range 10 { + a.update(logsBatchMsg{gen: a.Logs.gen, err: errors.New("still down")}) + } + if a.Logs.backoff != maxPoll { + t.Fatalf("backoff must cap at %v, got %v", maxPoll, a.Logs.backoff) + } + + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{logRow("tr_backnow", time.Now())}}) + if a.Logs.backoff != logsPoll || !a.Logs.staleAt.IsZero() || a.Logs.lastErr != nil { + t.Fatalf("one good poll clears the staleness: backoff=%v stale=%v err=%v", + a.Logs.backoff, a.Logs.staleAt, a.Logs.lastErr) + } +} + +func TestLogsNullsRenderDash(t *testing.T) { + a := composerApp() + a.route("logs") + row := logRow("tr_nulls000", time.Now()) + row.DurationMs, row.TTFTMs, row.CostUSD = nil, nil, nil + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{row}}) + a.Logs.sel, a.Logs.detail = 0, true + + view := a.paneView(126, 20) + line := findRow(view, "tr_nulls") + if line == "" { + t.Fatalf("the row must render:\n%s", view) + } + for _, bad := range []string{"0.0000", "$0.00", " 0 ", "0ms"} { + if strings.Contains(line, bad) { + t.Fatalf("an unmeasured value must never render as %q: %q", bad, line) + } + } + if !strings.Contains(line, "-") { + t.Fatalf("an unmeasured value renders as a dash: %q", line) + } + for _, label := range []string{"duration", "ttft", "cost"} { + if r := findRow(view, label); !strings.Contains(r, "-") { + t.Fatalf("strip row %q must render a dash for an absent measurement: %q", label, r) + } + } +} + +func TestLogsTickIgnoredAfterLeave(t *testing.T) { + a := fixtureApp(t) + a.route("logs") + gen := a.Logs.gen + if !a.Logs.tailing { + t.Fatal("entering the logs screen starts the tail") + } + + // esc is how an operator leaves, and it goes through the composer. + a.update(runCmdMsg{raw: "help"}) + if a.Screen != ScreenHome { + t.Fatalf("help must leave the logs screen, got %v", a.Screen) + } + if a.Logs.tailing { + t.Fatal("leaving the screen must stop the tail") + } + if cmd := a.update(tickLogsMsg{gen: gen}); cmd != nil { + t.Fatal("a tick from a screen the operator has left must schedule nothing") + } + if cmd := a.update(tickLogsMsg{gen: a.Logs.gen}); cmd != nil { + t.Fatal("a tick while the pane is off screen must schedule nothing either") + } + // A batch that lands late must not repopulate a pane nobody is watching. + a.update(logsBatchMsg{gen: gen, rows: []api.LogEntry{logRow("tr_late0000", time.Now())}}) + if len(a.Logs.rows) != 0 { + t.Fatalf("a late batch must be dropped, got %d rows", len(a.Logs.rows)) + } +} + +// A gateway with no request-log store answers 501 to every poll. That is an +// absent feature, not an outage: the pane names it, and the tail stops rather +// than backing off against something that will never succeed. +func TestLogsNoStoreStopsTailingAndSaysWhy(t *testing.T) { + a := fixtureApp(t) + a.route("logs") + a.update(logsBatchMsg{gen: a.Logs.gen, err: &api.Error{ + Status: 501, Code: "not_supported", Message: "no request log store configured", + }}) + + if a.Logs.tailing { + t.Fatal("a 501 will not become a 200 — the tail must stop") + } + if !a.Logs.staleAt.IsZero() || a.Logs.backoff != logsPoll { + t.Fatalf("an absent feature is not stale data: stale=%v backoff=%v", a.Logs.staleAt, a.Logs.backoff) + } + view := a.paneView(110, 10) + if !strings.Contains(view, "no request-log store configured") { + t.Fatalf("the pane must name the missing store:\n%s", view) + } + for _, bad := range []string{"stale", "retrying", "501"} { + if strings.Contains(view, bad) { + t.Fatalf("an absent store must not read as a failure (%q):\n%s", bad, view) + } + } +} + +func TestLogsNoConnectionSaysSoWithoutTailing(t *testing.T) { + a := composerApp() // no client + a.route("logs") + if a.Logs.tailing { + t.Fatal("there is nothing to tail without a connection") + } + if v := a.paneView(110, 10); !strings.Contains(v, errNoConnection.Error()) { + t.Fatalf("the pane must say why it is empty:\n%s", v) + } +} + +func TestLogsSelectionClearsWhenItsRowIsEvicted(t *testing.T) { + var s logsScreen + base := time.Now() + for i := range logsRing { + s.rows = append(s.rows, logRow(fmt.Sprintf("tr_%08d", i), base.Add(-time.Duration(i)*time.Second))) + } + s.sel, s.detail = len(s.rows)-1, true + s.prepend([]api.LogEntry{logRow("tr_new", base.Add(time.Second))}) + if s.sel != -1 || s.detail { + t.Fatalf("evicted selection must close its detail strip: sel=%d detail=%v", s.sel, s.detail) + } +} + +func TestLogsScreenKeepsThePaneContract(t *testing.T) { + a := composerApp() + a.route("logs --since 15m --model claude-sonnet-4-6") + now := time.Now() + rows := make([]api.LogEntry, 0, 12) + for i := range 12 { + r := logRow(fmt.Sprintf("tr_%08d", i), now.Add(time.Duration(i)*time.Second)) + if i%3 == 0 { + r.ErrorMessage = "upstream error from provider anthropic" + r.Stage = "on_error" + } + rows = append(rows, r) + } + a.update(logsBatchMsg{gen: a.Logs.gen, rows: rows}) + a.Logs.sel, a.Logs.detail = 4, true + + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + a.Theme = theme.New(mode) + for _, rowsN := range []int{1, 4, 9, 20} { + for _, w := range []int{30, 60, 92, 126} { + body := a.paneView(w, rowsN) + if got := len(strings.Split(body, "\n")); got != rowsN { + t.Fatalf("mode=%+v w=%d rows=%d returned %d lines", mode, w, rowsN, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } + } +} + +// api.Follower is one-per-tail-loop state — its cursor, dedupe map and row +// slice are unsynchronised — so the tail must never have two polls in flight. +// The next tick is armed by the arm that handles a finished poll, and nowhere +// else: a gateway whose /admin/logs takes longer than the interval is all it +// would take to overlap two otherwise. +func TestLogsPollsAreSerialised(t *testing.T) { + a := fixtureApp(t) + a.route("logs") + + // A tick asks for ONE poll and schedules nothing. If it also armed the next + // tick, this command would answer with a batch instead of a poll result. + cmd := a.update(tickLogsMsg{gen: a.Logs.gen}) + if cmd == nil { + t.Fatal("a tick on a live tail must poll") + } + if msg := cmd(); !isLogsBatch(msg) { + t.Fatalf("a tick must produce exactly one poll, got %T", msg) + } + + // The finished poll is what arms the next tick — on both of its outcomes. + if cmd = a.update(logsBatchMsg{gen: a.Logs.gen, + rows: []api.LogEntry{logRow("tr_serial01", time.Now())}}); cmd == nil { + t.Fatal("a finished poll must arm the next tick") + } + // Read the armed command on the failure path, where the cadence is ours to + // shrink: a good poll resets it to logsPoll and running that would sleep. + a.Logs.backoff = time.Millisecond + cmd = a.update(logsBatchMsg{gen: a.Logs.gen, err: errors.New("connection refused")}) + if cmd == nil { + t.Fatal("a failed poll must arm the retry") + } + if msg := cmd(); !isTickLogs(msg) { + t.Fatalf("a finished poll arms a tick, not another poll, got %T", msg) + } +} + +func isLogsBatch(msg any) bool { _, ok := msg.(logsBatchMsg); return ok } +func isTickLogs(msg any) bool { _, ok := msg.(tickLogsMsg); return ok } + +// A tail that has stopped arms nothing, or the loop outlives the screen. +func TestLogsStoppedTailArmsNothing(t *testing.T) { + a := fixtureApp(t) + a.route("logs") + if cmd := a.update(logsBatchMsg{gen: a.Logs.gen, err: &api.Error{ + Status: 501, Code: "not_supported", Message: "no request log store configured", + }}); cmd != nil { + t.Fatal("a 501 stops the tail — it must not arm another poll") + } +} + +// ErrFollowTruncated arrives WITH rows: the poll worked and the cursor moved, +// and what was lost is the oldest end of that one window. It is a readout +// beside real rows, not a failure — backing off or dropping the rows would +// punish a gateway whose only problem is that it is busy. +func TestLogsTruncatedWindowKeepsRowsAndSaysSo(t *testing.T) { + a := fixtureApp(t) + a.route("logs") + a.update(logsBatchMsg{ + gen: a.Logs.gen, + rows: []api.LogEntry{logRow("tr_trunc001", time.Now())}, + err: api.ErrFollowTruncated, + }) + + if len(a.Logs.rows) != 1 { + t.Fatalf("the rows a truncated poll did return are real, got %d", len(a.Logs.rows)) + } + if a.Logs.lastErr != nil || !a.Logs.staleAt.IsZero() || a.Logs.backoff != logsPoll { + t.Fatalf("a truncated window is not a failed poll: err=%v stale=%v backoff=%v", + a.Logs.lastErr, a.Logs.staleAt, a.Logs.backoff) + } + if !a.Logs.tailing { + t.Fatal("a truncated window must not stop the tail") + } + if view := a.paneView(110, 10); !strings.Contains(view, "older rows") { + t.Fatalf("the pane must say which end of the window was cut:\n%s", view) + } + + // The next clean poll takes the notice back down. + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{logRow("tr_trunc002", time.Now())}}) + if a.Logs.truncated { + t.Fatal("a clean poll clears the truncation notice") + } +} diff --git a/internal/tui/modal.go b/internal/tui/modal.go new file mode 100644 index 0000000..a6bb9cc --- /dev/null +++ b/internal/tui/modal.go @@ -0,0 +1,275 @@ +package tui + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// This file is the console's one overlay. It renders in place of the pane +// rather than over it: a terminal has no transparency to dim with, and a modal +// drawn on top of live content is a modal whose scrim is a lie about what is +// underneath it. +// +// Two things here are load-bearing rather than cosmetic: +// +// - Confirm gates the OK arm on typing an exact phrase. A destructive +// operation confirmed by one keypress is not confirmed, it is acknowledged. +// - Nothing in this file writes to the transcript or the composer history. +// A secret shown in a modal is shown here and nowhere else, which is what +// makes "shown exactly once" true rather than aspirational. + +// modalKeyCol is the label column of a key/value row, wide enough for the +// longest label the flows use ("blast radius"). +const modalKeyCol = 14 + +// ModalKV is one key/value row of a modal card. The three flags are the only +// emphasis a modal can apply — a row is never styled by matching on its text. +type ModalKV struct { + K, V string + Accent bool + Warn bool + Bold bool +} + +// Modal is a titled card that owns the keyboard while it is open. +// +// A modal has at most one editing surface: Input (a one-line editor) or +// Options (a left/right toggle). OnConfirm receives the typed value, which for +// a gated modal is exactly Confirm — the caller does not have to re-check it. +type Modal struct { + Title, Body string + Rows []ModalKV + + Input bool + Placeholder string + Value string + + Options []string + Opt int + // OptionLabel names the toggle row. Empty falls back to "option". + OptionLabel string + + // Err is a refusal to accept what was typed — a duration that does not + // parse. It renders under the input rather than replacing the body, so the + // instruction that was misread stays on screen next to the mistake. + Err string + + OKLabel string + Danger bool + + // Confirm is the phrase Value must equal before OK is enabled. Empty means + // enter confirms immediately. + Confirm string + + OnConfirm func(a *App, value string) tea.Cmd + // OnCancel runs on esc. A flow that must finish something on the way out — + // recording that a secret was shown and closed, refreshing the list behind + // it — hangs it here, because esc is a real way to leave and not an error + // path. + OnCancel func(a *App) tea.Cmd +} + +// Option is the currently selected toggle value, or "" when there is no toggle. +func (m *Modal) Option() string { + if len(m.Options) == 0 { + return "" + } + return m.Options[m.Opt%len(m.Options)] +} + +// collected is what this modal gathered: the selected option for a toggle, the +// typed value otherwise. OnConfirm reads one field rather than branching on +// which editing surface it was given. +func (m *Modal) collected() string { + if len(m.Options) > 0 { + return m.Option() + } + return strings.TrimSpace(m.Value) +} + +// ready reports whether enter may confirm. +func (m *Modal) ready() bool { + return m.Confirm == "" || strings.TrimSpace(m.Value) == m.Confirm +} + +// handle is keyed on the key's string form, exactly as the composer is: the +// mapping from a tea.KeyPressMsg to that string is untested glue either way, +// and keeping it out of here is what makes a confirmation flow testable. +func (m *Modal) handle(key string, a *App) tea.Cmd { + switch key { + case keyEsc: + a.Modal = nil + if m.OnCancel != nil { + return m.OnCancel(a) + } + return nil + + case keyEnter: + if !m.ready() { + return nil + } + a.Modal = nil + if m.OnConfirm != nil { + return m.OnConfirm(a, m.collected()) + } + return nil + + case keyLeft: + m.cycle(-1) + return nil + + case keyRight: + m.cycle(1) + return nil + + case keySpace: + if len(m.Options) > 0 { + m.cycle(1) + return nil + } + if m.Input { + m.Value += " " + } + return nil + + case keyBackspace: + if m.Input { + m.Value, m.Err = trimLastRune(m.Value), "" + } + return nil + + case keyCtrlU: + if m.Input { + m.Value, m.Err = "", "" + } + return nil + } + + if r, ok := printable(key); ok && m.Input { + m.Value, m.Err = m.Value+string(r), "" + } + return nil +} + +func (m *Modal) cycle(d int) { + if n := len(m.Options); n > 0 { + m.Opt = ((m.Opt+d)%n + n) % n + } +} + +// view draws the card into the pane's exact-line contract: rows lines, none +// wider than w. Below the width or height a border can close in, the card +// degrades to its bare content rather than emitting a frame with a hole in it. +func (m *Modal) view(a *App, w, rows int) string { + if rows < 4 || w < 14 { + return fill(m.lines(a, w), w, rows) + } + return a.Theme.FrameRound(fill(m.lines(a, w-4), w-4, rows-2), w) +} + +// lines is the card's content, in order: title, body, rows, editor, actions. +// Blank separators are dropped as the pane gets shorter, so a 4-line modal +// still shows its title and its OK arm. +func (m *Modal) lines(a *App, w int) []string { + th := a.Theme + out := []string{th.Bright.Bold(th.Mode.Color).Render(m.Title)} + for _, line := range strings.Split(m.Body, "\n") { + if line == "" && m.Body == "" { + continue + } + out = append(out, th.Dim.Render(line)) + } + + if len(m.Rows) > 0 { + out = append(out, "") + for _, r := range m.Rows { + out = append(out, th.Dim.Render(padRight(r.K, modalKeyCol))+kvStyle(th, r).Render(r.V)) + } + } + + switch { + case m.Input: + g := th.Mode.Glyphs() + field := th.Accent.Bold(th.Mode.Color).Render(g.Prompt) + " " + if m.Value == "" { + field += a.Composer.cursor(a) + " " + th.Dim.Render(m.Placeholder) + } else { + field += th.Bright.Render(m.Value) + a.Composer.cursor(a) + } + out = append(out, "", field) + case len(m.Options) > 0: + label := m.OptionLabel + if label == "" { + label = "option" + } + out = append(out, "", th.Dim.Render(padRight(label, modalKeyCol))+m.options(th)) + } + + if m.Err != "" { + out = append(out, th.Bad.Render(m.Err)) + } + return append(out, "", m.actions(a, w)) +} + +// kvStyle resolves a key/value row's emphasis. Shared with the detail strips, +// which draw the same row shape outside a modal. +func kvStyle(th theme.Theme, r ModalKV) lipgloss.Style { + s := th.Text + switch { + case r.Accent: + s = th.Accent + case r.Warn: + s = th.Warn + case r.Bold: + s = th.Bright + } + if r.Bold { + s = s.Bold(th.Mode.Color) + } + return s +} + +// options draws the toggle. The selected value carries the accent AND the +// brackets: colour never carries state alone, here or anywhere else. +func (m *Modal) options(th theme.Theme) string { + parts := make([]string, 0, len(m.Options)) + for i, o := range m.Options { + if i == m.Opt { + parts = append(parts, th.Accent.Bold(th.Mode.Color).Render("["+o+"]")) + continue + } + parts = append(parts, th.Dim.Render(" "+o+" ")) + } + return strings.Join(parts, " ") + th.Faint.Render(" space toggles") +} + +// actions is the footer: cancel on the left, OK on the right. A gated OK that +// is not yet armed renders faint and says what is missing, so the arm reads as +// disabled rather than broken. +func (m *Modal) actions(a *App, w int) string { + th := a.Theme + label := m.OKLabel + if label == "" { + label = "ok" + } + if len(m.Options) > 0 { + label = m.Option() + " " + a.arrow() + " " + label + } + + style := th.Accent + if m.Danger { + style = th.Bad + } + right := style.Bold(th.Mode.Color).Render("[ "+label+" ]") + th.Dim.Render(" ↵") + if a.Theme.Mode.ASCII { + right = style.Bold(th.Mode.Color).Render("[ "+label+" ]") + th.Dim.Render(" enter") + } + if !m.ready() { + right = th.Faint.Render("[ " + label + " ] type the name to enable") + } + return gapPad(w, th.Dim.Render("esc cancel"), right) +} diff --git a/internal/tui/modal_test.go b/internal/tui/modal_test.go new file mode 100644 index 0000000..24c78cd --- /dev/null +++ b/internal/tui/modal_test.go @@ -0,0 +1,179 @@ +package tui + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// typeModal types a literal string into the open modal, mapping the space bar +// to the key name the runtime sends. It is the modal's twin of typeIn. +func typeModal(a *App, m *Modal, s string) { + for _, r := range s { + key := string(r) + if r == ' ' { + key = "space" + } + m.handle(key, a) + } +} + +func TestModalEscCancels(t *testing.T) { + a := composerApp() + confirmed := false + a.Modal = &Modal{ + Title: "Revoke ci-pipeline?", + Input: true, + OnConfirm: func(*App, string) tea.Cmd { confirmed = true; return nil }, + } + a.update(tea.KeyPressMsg{Code: tea.KeyEscape}) + if a.Modal != nil { + t.Fatal("esc must close the modal") + } + if confirmed { + t.Fatal("esc must never confirm") + } +} + +func TestModalEscRunsCancelCallback(t *testing.T) { + a := composerApp() + cancelled := false + a.Modal = &Modal{OnCancel: func(*App) tea.Cmd { + return func() tea.Msg { + cancelled = true + return nil + } + }} + cmd := a.Modal.handle("esc", a) + if cmd == nil { + t.Fatal("cancel callback command was dropped") + } + _ = cmd() + if !cancelled || a.Modal != nil { + t.Fatal("esc must close the modal and run OnCancel") + } +} + +func TestModalUsesConfiguredOptionLabel(t *testing.T) { + a := composerApp() + a.Modal = &Modal{Options: []string{"one", "two"}, OptionLabel: "mode"} + if view := a.paneView(80, 12); !strings.Contains(view, "mode") || strings.Contains(view, "scope") { + t.Fatalf("option label must be generic and caller-defined:\n%s", view) + } +} + +// An open modal owns the keyboard. A typed confirmation that leaks its keys +// into the composer is a confirmation racing a command line. +func TestModalTakesEveryKeyFromTheComposer(t *testing.T) { + a := composerApp() + a.Modal = &Modal{Input: true} + a.update(tea.KeyPressMsg{Code: 'x'}) + if a.Composer.Input != "" { + t.Fatalf("the composer must not see a key while a modal is open, got %q", a.Composer.Input) + } + if a.Modal.Value != "x" { + t.Fatalf("the modal input must receive the key, got %q", a.Modal.Value) + } +} + +func TestModalTypedConfirmGate(t *testing.T) { + a := composerApp() + calls, got := 0, "" + m := &Modal{ + Title: "Revoke ci-pipeline?", Input: true, Confirm: "ci-pipeline", + OnConfirm: func(_ *App, v string) tea.Cmd { calls, got = calls+1, v; return nil }, + } + a.Modal = m + + m.handle("enter", a) + typeModal(a, m, "ci-pipe") + m.handle("enter", a) + if calls != 0 { + t.Fatalf("a partial phrase must not confirm (%d calls)", calls) + } + if a.Modal == nil { + t.Fatal("a gated modal stays open until the phrase matches") + } + + typeModal(a, m, "line") + m.handle("enter", a) + if calls != 1 || got != "ci-pipeline" { + t.Fatalf("the exact phrase must confirm once with the typed value, got %d calls %q", calls, got) + } + if a.Modal != nil { + t.Fatal("a confirmed modal closes") + } +} + +func TestModalOptionsToggle(t *testing.T) { + a := composerApp() + m := &Modal{Options: []string{"read_only", "admin"}} + a.Modal = m + if m.Option() != "read_only" { + t.Fatalf("the first option is the default, got %q", m.Option()) + } + m.handle("space", a) + if m.Option() != "admin" { + t.Fatalf("space must advance the toggle, got %q", m.Option()) + } + m.handle("right", a) + if m.Option() != "read_only" { + t.Fatalf("the toggle wraps, got %q", m.Option()) + } + m.handle("left", a) + if m.Option() != "admin" { + t.Fatalf("left steps back, got %q", m.Option()) + } +} + +// The modal renders in place of the pane, so it owes the pane's contract: +// exactly rows lines, none wider than the frame it sits in. +func TestModalViewKeepsThePaneContract(t *testing.T) { + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + a := composerApp() + a.Theme = theme.New(mode) + a.Modal = &Modal{ + Title: "Create API key · name", + Body: "Names are how log rows resolve after a key is revoked.", + Rows: []ModalKV{{K: "name", V: "ci-readonly", Bold: true}, {K: "scope", V: "read_only", Accent: true}}, + Input: true, + Placeholder: "prod-ingest", + OKLabel: "next", + Danger: true, + } + for _, rows := range []int{1, 3, 6, 14, 22} { + for _, w := range []int{30, 60, 92, 126} { + body := a.paneView(w, rows) + if got := len(strings.Split(body, "\n")); got != rows { + t.Fatalf("mode=%+v w=%d rows=%d: modal returned %d lines", mode, w, rows, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } + } +} + +// A modal body can carry intentional line breaks; rendering must preserve them +// instead of collapsing the wording into one run-on line. +func TestModalRendersEveryBodyLine(t *testing.T) { + a := composerApp() + a.Modal = &Modal{ + Title: "Rotate ops-laptop?", + Body: "Blast radius: every client holding the current secret fails immediately\nuntil it is redeployed with the new one.", + OKLabel: "rotate", + } + view := a.paneView(110, 16) + for _, want := range []string{"Blast radius", "until it is redeployed with the new one."} { + if !strings.Contains(view, want) { + t.Fatalf("modal body lost %q:\n%s", want, view) + } + } +} diff --git a/internal/tui/msgs.go b/internal/tui/msgs.go new file mode 100644 index 0000000..2a9b65b --- /dev/null +++ b/internal/tui/msgs.go @@ -0,0 +1,544 @@ +package tui + +import ( + "context" + "errors" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +// This file is the shell's message vocabulary and the only place network I/O +// is started. A screen never calls the client from its view func: it returns a +// tea.Cmd built here, and the result arrives as one of the typed messages +// below. Screen-specific message types live alongside the shared poll results. +// +// Every poll result carries the generation it was requested under. The App +// drops a message whose gen no longer matches, so a slow in-flight response +// cannot overwrite state fetched against a newer profile. + +// statusMsg is one /health + /readyz + /admin/health round trip. report and err +// are both meaningful: a failed poll annotates the header, it never blanks it. +type statusMsg struct { + gen int + report *api.StatusReport + err error +} + +// trafficMsg carries the 5-minute log-stats window the TRAFFIC panel derives +// RPS, P95 and the error rate from. A gateway with no log store answers 501, +// which is not an error state — stats is simply nil and the panel renders "—". +type trafficMsg struct { + gen int + stats *api.LogStats + err error +} + +// railMsg is the fan-in of the four rail sources (admin health, plugins, +// sessions, audit). Partial failure is normal and already encoded in RailData: +// AuthError for a 401, a -1 count for an endpoint this gateway does not serve. +type railMsg struct { + gen int + data RailData + err error +} + +// runCmdMsg is a composer submission. The shell forwards the raw line to the +// router in home.go, which is the only place a verb is interpreted. +type runCmdMsg struct{ raw string } + +// verbRowsMsg is one finished transcript verb. rows and err are both +// meaningful: `status` renders a report even when the call failed, naming the +// URL it tried. took is measured around the request so the transcript can end +// with a duration the operator can trust. +type verbRowsMsg struct { + verb string + rows []TranscriptRow + err error + took time.Duration +} + +// The tick messages drive the two poll cadences. They carry no payload: the +// handler re-reads the current generation when it issues the next fetch. +type ( + tickStatusMsg struct{} + tickTrafficMsg struct{} +) + +// errNoConnection is what a screen reports when it was opened with no client +// to ask. It is a state, not a failed request: nothing was attempted. +var errNoConnection = errors.New("no gateway connection configured") + +// keysListMsg is one GET /admin/keys. Every row's `key` is masked by the +// gateway; nothing in this package ever holds an unmasked one from a read. +type keysListMsg struct { + gen int + keys []api.Key + err error +} + +// modalResultMsg is one finished key mutation. +// +// key carries the FULL secret for create and rotate — the only two responses +// that ever will. It goes straight into the modal that shows it once and is +// dropped when that modal closes. It is never pushed to the transcript, never +// recorded in history, and never logged. revoke has no row to answer with, so +// it carries the name and scope it was run against instead. +type modalResultMsg struct { + gen int + kind string // create | rotate | revoke + key *api.Key + name, scope string + err error +} + +// playModelsMsg is the playground's completion source and its default model. +// A failure is not surfaced: the pane still works, the gateway is simply the +// only authority on which names it accepts. +type playModelsMsg struct { + gen int + models []string + err error +} + +// chatOpenMsg is a stream that has begun. A non-2xx arriving BEFORE the stream +// starts is an error here; once streaming has begun the status is already 200 +// and every failure arrives on the channel instead. +type chatOpenMsg struct { + gen int + stream *api.ChatStream + err error +} + +// The three in-stream messages. One event becomes one message and the handler +// re-issues the reader, which is the whole pump. +type ( + chatDeltaMsg struct { + gen int + text string + } + chatUsageMsg struct { + gen int + usage *api.Usage + } + // chatEndMsg is terminal, and its three shapes are distinct: an error + // frame, a [DONE], or a channel that closed with neither — which is a + // truncated answer and must not be mistaken for a clean finish. + chatEndMsg struct { + gen int + err *api.Error + done bool + } + // chatMetaMsg carries the request-log row that names the provider and the + // cost, PLUS the turn, usage and elapsed time the fetch was issued for. + // Those three are pinned by fetchAttribution's caller at issue time and + // travel on the message rather than being resolved against screen state at + // arrival, because a second turn's fetch can be issued before the first + // turn's has landed (see playScreen.metaCmd) — carrying them here is what + // lets the handler match each arriving message back to its own turn. row + // is nil for every "cannot know" case and the meta line drops the segments + // it cannot support. + chatMetaMsg struct { + gen int + turn int + usage *api.Usage + took time.Duration + row *api.LogEntry + } + flushTickMsg struct{ gen int } +) + +func tickFlush(gen int) tea.Cmd { + return tea.Tick(flushEvery, func(time.Time) tea.Msg { return flushTickMsg{gen: gen} }) +} + +// fetchChatModels lists what this gateway advertises. Its failure is swallowed +// into an empty list: a playground that refuses to open because /v1/models was +// unreachable is worse than one that cannot pre-validate a model name. +func fetchChatModels(c *api.Client, gen int) tea.Cmd { + return func() tea.Msg { + if c == nil { + return playModelsMsg{gen: gen, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + models, err := c.Models(ctx) + if err != nil { + return playModelsMsg{gen: gen, err: err} + } + ids := make([]string, 0, len(models)) + for _, m := range models { + ids = append(ids, m.ID) + } + return playModelsMsg{gen: gen, models: ids} + } +} + +// openChat starts one streamed completion. The context is deliberately NOT +// bounded by fetchTimeout: a long answer is not a stuck request, and the +// gateway already applies its own idle bound. ChatStream.Cancel is what ends it. +func openChat(ctx context.Context, c *api.Client, gen int, req api.ChatRequest) tea.Cmd { + return func() tea.Msg { + if c == nil { + return chatOpenMsg{gen: gen, err: errNoConnection} + } + st, err := c.StreamChat(ctx, req) + return chatOpenMsg{gen: gen, stream: st, err: err} + } +} + +// readStream turns the next event into a message. Err and Done are both +// terminal and mutually exclusive — a stream that fails mid-flight ends with an +// error frame and NO [DONE] — so this reads until the channel closes and treats +// a bare close as its own terminal case rather than waiting for a Done that is +// never coming. +func readStream(gen int, ev <-chan api.StreamEvent) tea.Cmd { + return func() tea.Msg { + e, ok := <-ev + switch { + case !ok: + return chatEndMsg{gen: gen} + case e.Err != nil: + return chatEndMsg{gen: gen, err: e.Err} + case e.Done: + return chatEndMsg{gen: gen, done: true} + case e.Chunk != nil && e.Chunk.Usage != nil: + return chatUsageMsg{gen: gen, usage: e.Chunk.Usage} + } + var b strings.Builder + if e.Chunk != nil { + for _, c := range e.Chunk.Choices { + b.WriteString(c.Delta.Content) + } + } + return chatDeltaMsg{gen: gen, text: b.String()} + } +} + +// fetchAttribution resolves which provider served a streamed answer and what it +// cost. The log row is written after the stream ends, hence the one retry. +// Every failure answers a nil row: attribution is a detail beside an answer the +// operator already has, and failing over its absence would turn a cosmetic gap +// into a broken chat. +// +// turn, usage and took are the caller's pinned facts about the turn this fetch +// was issued for (see playScreen.metaCmd) — they are echoed back on every +// returned chatMetaMsg, success or failure alike, so the handler can match the +// message to its turn without consulting screen state that a second, later +// fetch may have since moved on from. +func fetchAttribution(c *api.Client, gen, turn int, usage *api.Usage, took time.Duration, traceID string, since time.Time) tea.Cmd { + return func() tea.Msg { + miss := chatMetaMsg{gen: gen, turn: turn, usage: usage, took: took} + if c == nil || traceID == "" { + return miss + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + for attempt := range 2 { + if attempt > 0 { + select { + case <-ctx.Done(): + return miss + case <-time.After(attributionRetry): + } + } + row, err := c.TraceAttribution(ctx, traceID, since) + if err != nil { + return miss + } + if row != nil { + miss.row = row + return miss + } + } + return miss + } +} + +// logsBatchMsg is one tail poll. rows and err are both meaningful: a failure +// annotates the table, it never empties it. +type logsBatchMsg struct { + gen int + rows []api.LogEntry + err error +} + +// logsNamesMsg resolves api_key_id → name for the detail strip. Its failure is +// swallowed into an empty map on purpose: a caller who can read the logs but +// not the key store still gets the logs, with raw ids. +type logsNamesMsg struct { + gen int + names map[string]keyRef +} + +// tickLogsMsg drives the tail. It carries the generation it was scheduled +// under, so a tick outliving its screen schedules nothing. +type tickLogsMsg struct{ gen int } + +func tickLogs(d time.Duration, gen int) tea.Cmd { + return tea.Tick(d, func(time.Time) tea.Msg { return tickLogsMsg{gen: gen} }) +} + +func pollLogs(f *api.Follower, gen int) tea.Cmd { + return func() tea.Msg { + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + rows, err := f.Poll(ctx) + return logsBatchMsg{gen: gen, rows: rows, err: err} + } +} + +// fetchLogKeyNames reads the key store once per tail so the detail strip can +// name a credential. A key revoked since it served the traffic still names its +// rows — that is what key names are for — so the revoked flag travels with it. +func fetchLogKeyNames(c *api.Client, gen int) tea.Cmd { + return func() tea.Msg { + names := map[string]keyRef{} + if c == nil { + return logsNamesMsg{gen: gen, names: names} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + keys, err := c.Keys(ctx) + if err != nil { + return logsNamesMsg{gen: gen, names: names} // raw ids beat no logs + } + for _, k := range keys { + names[k.ID] = keyRef{Name: k.Name, Revoked: api.KeyState(k) == api.KeyStateRevoked} + } + return logsNamesMsg{gen: gen, names: names} + } +} + +func fetchKeys(c *api.Client, gen int) tea.Cmd { + return func() tea.Msg { + if c == nil { + return keysListMsg{gen: gen, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + keys, err := c.Keys(ctx) + return keysListMsg{gen: gen, keys: keys, err: err} + } +} + +func createKey(c *api.Client, gen int, req api.KeyCreateRequest) tea.Cmd { + return func() tea.Msg { + if c == nil { + return modalResultMsg{gen: gen, kind: actionCreate, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + k, err := c.CreateKey(ctx, req) + return modalResultMsg{gen: gen, kind: actionCreate, key: k, err: err} + } +} + +func rotateKey(c *api.Client, gen int, id string) tea.Cmd { + return func() tea.Msg { + if c == nil { + return modalResultMsg{gen: gen, kind: actionRotate, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + k, err := c.RotateKey(ctx, id) + return modalResultMsg{gen: gen, kind: actionRotate, key: k, err: err} + } +} + +func revokeKey(c *api.Client, gen int, id, name, scope string) tea.Cmd { + return func() tea.Msg { + if c == nil { + return modalResultMsg{gen: gen, kind: actionRevoke, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + // RevokeKey answers with no row: the gateway confirms {"status": + // "revoked"} and the refreshed listing is what shows the new state. + err := c.RevokeKey(ctx, id) + return modalResultMsg{gen: gen, kind: actionRevoke, name: name, scope: scope, err: err} + } +} + +// Poll cadences and the failure backoff ceiling. A failing poll doubles its +// interval up to maxPoll and resets on the first success, so an unreachable +// gateway is not hammered every 5s while its stale-data age keeps climbing. +const ( + statusPoll = 5 * time.Second + trafficPoll = 10 * time.Second + maxPoll = 30 * time.Second + + // fetchTimeout bounds one poll. It is longer than the client's own 15s + // request timeout would need to be for a single call because a rail fetch + // makes four. + fetchTimeout = 20 * time.Second + + // trafficWindow is the log-stats window; RPS divides by its seconds. + trafficWindow = 5 * time.Minute + + // auditRows is one transcript page of the audit trail. The gateway caps at + // 200; the transcript ring is 60, so asking for more only drops rows. + auditRows = 50 +) + +func fetchStatus(c *api.Client, gen int) tea.Cmd { + return func() tea.Msg { + if c == nil { + return statusMsg{gen: gen, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + r, err := c.Status(ctx) + return statusMsg{gen: gen, report: r, err: err} + } +} + +func fetchTraffic(c *api.Client, gen int) tea.Cmd { + return func() tea.Msg { + if c == nil { + return trafficMsg{gen: gen, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + s, err := c.LogStats(ctx, api.LogsQuery{Since: time.Now().Add(-trafficWindow)}) + if api.IsNotSupported(err) { + // No log store configured. Not an error state — just no numbers. + return trafficMsg{gen: gen} + } + return trafficMsg{gen: gen, stats: s, err: err} + } +} + +// fetchRail collects the left rail in one command. Each source degrades on its +// own: an unsupported endpoint leaves its count at -1 ("—") and a credential +// problem sets AuthError, because the rail is exactly where an operator should +// see that ferro is connected but not authorized. +// +// prev is the rail's last good snapshot. Each of the four sources overwrites +// only ITS OWN slice/counters when it succeeds; a source that fails this round +// leaves prev's values for it untouched rather than zeroing them, so one +// flaky source no longer blanks CONNECTED PROVIDERS or MCP just because the +// other three answered fine. The caller still learns the round had a problem +// via railMsg.err — this only stops a transient failure from being drawn as +// "nothing to report" instead of "the last good answer, aging". +func fetchRail(c *api.Client, gen int, prev RailData) tea.Cmd { + return func() tea.Msg { + d := prev + // AuthError is a verdict about THIS round, not a running tally: it is + // re-earned every poll, or a since-fixed 401 would stay stuck on + // screen after the credential is corrected. + d.AuthError = false + if c == nil { + return railMsg{gen: gen, data: d, err: errNoConnection} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + var firstErr error + // note reports whether this source failed. A 404/501 is not a failure — + // it is a gateway that does not serve that endpoint, which leaves the + // counter at unknownCount and renders as a dash. + note := func(err error) bool { + if err == nil { + return false + } + if api.IsUnauthorized(err) { + d.AuthError = true + } + if firstErr == nil && !api.IsNotSupported(err) { + firstErr = err + } + return true + } + + type result struct { + kind string + health *api.AdminHealth + plugins []api.PluginInfo + sessions []api.Session + audit *api.AuditPage + err error + } + results := make(chan result, 4) + go func() { + value, err := c.AdminHealth(ctx) + results <- result{kind: "health", health: value, err: err} + }() + go func() { + value, err := c.Plugins(ctx) + results <- result{kind: verbPlugins, plugins: value, err: err} + }() + go func() { + value, err := c.Sessions(ctx) + results <- result{kind: verbSessions, sessions: value, err: err} + }() + since := time.Now() + since = time.Date(since.Year(), since.Month(), since.Day(), 0, 0, 0, 0, since.Location()) + go func() { + value, err := c.Audit(ctx, api.AuditQuery{Since: since, Limit: 1}) + results <- result{kind: verbAudit, audit: value, err: err} + }() + + for range 4 { + r := <-results + if note(r.err) { + continue + } + switch r.kind { + case "health": + d.Providers = r.health.Providers + // Recount from this round's body instead of adding to the last + // one's. d starts as prev so a failed source keeps its previous + // value, which makes every ++ here a running total unless the + // counter is cleared first — two good polls would report twice + // the MCP servers that exist. Providers above overwrites, and + // PluginsActive below clears for this same reason. + d.MCPTotal, d.MCPReady = 0, 0 + for _, s := range r.health.MCPServers { + d.MCPTotal++ + if s.Ready { + d.MCPReady++ + } + } + case verbPlugins: + d.PluginsActive = 0 + for _, p := range r.plugins { + if p.Enabled { + d.PluginsActive++ + } + } + case verbSessions: + d.Sessions = len(r.sessions) + case verbAudit: + d.AuditToday = r.audit.Summary.TotalEntries + } + } + return railMsg{gen: gen, data: d, err: firstErr} + } +} + +// verbFetch runs one transcript verb off the render path. Timing lives here, +// where the clock is; formatting the duration and the failure into rows is the +// update arm's job, which keeps it pure and testable. +func verbFetch(c *api.Client, verb string) tea.Cmd { + return func() tea.Msg { + start := time.Now() + if c == nil { + return verbRowsMsg{verb: verb, err: errNoConnection, took: time.Since(start)} + } + ctx, cancel := context.WithTimeout(context.Background(), fetchTimeout) + defer cancel() + rows, err := verbRows(ctx, c, verb) + return verbRowsMsg{verb: verb, rows: rows, err: err, took: time.Since(start)} + } +} + +func tickStatus(d time.Duration) tea.Cmd { + return tea.Tick(d, func(time.Time) tea.Msg { return tickStatusMsg{} }) +} + +func tickTraffic(d time.Duration) tea.Cmd { + return tea.Tick(d, func(time.Time) tea.Msg { return tickTrafficMsg{} }) +} diff --git a/internal/tui/panetitle_probe_test.go b/internal/tui/panetitle_probe_test.go new file mode 100644 index 0000000..d275741 --- /dev/null +++ b/internal/tui/panetitle_probe_test.go @@ -0,0 +1,41 @@ +package tui + +import ( + "strings" + "testing" +) + +// A demo recording showed "COMMAND OUTPUT" rendered twice in the pane after +// navigating to another screen and back. mainFrame prepends the title and +// homeView returns only the transcript, so the pane title must appear exactly +// once in a render — on Home, and after any round trip through another screen. +func TestPaneTitleRendersExactlyOnce(t *testing.T) { + a := testApp(126, 34) + a.Transcript.Push(TranscriptRow{Glyph: "$", Text: "ferro status"}) + + count := func(where string) int { + n := strings.Count(a.render(), "COMMAND OUTPUT") + t.Logf("%s: %d occurrence(s)", where, n) + return n + } + + if got := count("home, first render"); got != 1 { + t.Fatalf("pane title must render once on Home, got %d", got) + } + + // Round trip: Home -> playground -> Home, which is what the recording did. + a.Screen = ScreenPlayground + _ = a.render() + a.Screen = ScreenHome + if got := count("home, after a playground round trip"); got != 1 { + t.Fatalf("pane title duplicated after returning to Home: %d occurrences", got) + } + + // And through the logs screen, the other transition the demo makes. + a.Screen = ScreenLogs + _ = a.render() + a.Screen = ScreenHome + if got := count("home, after a logs round trip"); got != 1 { + t.Fatalf("pane title duplicated after returning from logs: %d occurrences", got) + } +} diff --git a/internal/tui/playground.go b/internal/tui/playground.go new file mode 100644 index 0000000..f7c2119 --- /dev/null +++ b/internal/tui/playground.go @@ -0,0 +1,656 @@ +package tui + +import ( + "context" + "fmt" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +// The playground is a streamed chat with the route metadata a gateway operator +// actually needs beside the answer. Three things here are not obvious: +// +// - Deltas are BATCHED. Each one appends to a buffer and a tick moves the +// buffer into the turn every flushEvery, which is where the single markdown +// re-render happens. Rendering per token turns a 400-token answer into 400 +// full re-layouts and the terminal into a slideshow. +// - A streamed body names no provider and carries no price. Both come from +// the request log, matched on the response's X-Request-ID — so the meta +// line is assembled from two sources and every segment it cannot support is +// dropped. An invented provider is worse than a shorter line. +// - Answers are rendered as predictable, word-wrapped plain text. The +// renderer remains replaceable without changing the stream state machine. + +const ( + // flushEvery is the re-render cadence. Fast enough to read as streaming, + // slow enough that one render covers many tokens. + flushEvery = 80 * time.Millisecond + + // attributionRetry is the single re-ask. The log row is written after the + // stream ends, so the first look can legitimately be too early. + attributionRetry = 500 * time.Millisecond + + // attributionSlack widens the log window backwards from the moment the + // request started. created_at is stamped with the GATEWAY's clock and the + // cursor with ours, so a gateway running even slightly behind writes a row + // that looks older than the request that produced it — and attribution then + // fails permanently and silently for that deployment. The window is only a + // prefilter: the row is still matched on its exact trace id, which is + // unique, so widening it cannot select the wrong request. + attributionSlack = 2 * time.Minute + + // modelSuggestions is how many near misses a rejected /model names. + modelSuggestions = 5 + + // playTurnMax bounds both rendered transcript work and the conversation + // retained in memory. It is intentionally a turn count, not a byte count. + playTurnMax = 60 +) + +// The two sides of the conversation. Who is compared against these all over +// this file — to find the turn being written into, to decide a label's style, +// to map a turn onto an API role — so the strings are named rather than +// repeated: a misspelt one reads as a third speaker nothing ever matches. +const ( + whoYou = "you" + whoGateway = "gateway" +) + +// chatTurn is one side of the conversation. lines is the rendered body, cached +// at flush time: the view is called once per message and must not re-run a +// markdown pass to answer. +type chatTurn struct { + Who string // whoYou | whoGateway + Text string + Meta string + Bad bool + Note bool + + // id names this turn for as long as it exists. Attribution arrives after + // the turn it describes has stopped being the last one, and appendTurns + // trims from the head, so a position is not a name. + id int + + lines []string +} + +// playScreen is the chat pane. +type playScreen struct { + turns []chatTurn + lastID int // last id handed out by appendTurns + pending strings.Builder + + // queued holds a `chat ` prompt while model discovery is in + // flight. submit snapshots s.model into the request, so submitting before + // the first playModelsMsg lands sends an empty model. + queued string + + stream *api.ChatStream + openCancel context.CancelFunc + requestID string + started time.Time + took time.Duration + usage *api.Usage + busy bool + + model string + models []string + + width int + // renderer lays an answer out. It is a field so another renderer can be + // introduced independently, and so tests can count layout passes. + renderer func(text string, w int) string + + gen int +} + +// ------------------------------------------------------------------ lifecycle + +func (s *playScreen) enter(a *App, rest string) tea.Cmd { + if a.Screen != ScreenPlayground { + s.gen++ + } + a.Screen = ScreenPlayground + s.resize(a.paneWidth()) + + var cmds []tea.Cmd + discovering := len(s.models) == 0 && a.Client != nil + if discovering { + cmds = append(cmds, fetchChatModels(a.Client, s.gen)) + } + // `chat ` is one line that opens the pane and asks: the scriptable + // verb takes a prompt, so the console's twin of it must too. + // + // It waits for discovery when discovery is running. submit copies s.model + // into the request there and then, and until playModelsMsg picks a default + // that field is empty — so the first console chat would be sent naming no + // model at all and refused by a gateway that would have served it. + if rest != "" { + if discovering { + s.queued = rest + } else { + cmds = append(cmds, s.submit(a, rest)) + } + } + if len(cmds) == 0 { + return nil + } + return tea.Batch(cmds...) +} + +// leave cancels the stream and invalidates the visit. Cancel is what releases +// the reader goroutine and the connection, and it is safe to call more than +// once — so it is called here whether or not the turn finished cleanly. +func (s *playScreen) leave() { + s.gen++ + s.cancel() + s.busy = false + s.queued = "" + s.pending.Reset() +} + +func (s *playScreen) cancel() { + if s.openCancel != nil { + s.openCancel() + s.openCancel = nil + } + if s.stream != nil { + s.stream.Cancel() + s.stream = nil + } +} + +// resize re-wraps every turn. The markdown pass runs off the render path, so a +// width change is the only other thing that can invalidate it. +func (s *playScreen) resize(w int) { + if w <= 0 || w == s.width { + return + } + s.width = w + if s.renderer == nil { + return + } + for i := range s.turns { + s.turns[i].lines = s.wrap(s.turns[i].Text) + } +} + +// --------------------------------------------------------------------- input + +// route is the playground's half of the command/prompt decision. +// +// It reports whether the playground claimed the line. The check cannot key on a +// leading slash: the composer strips it before route() is reached, so `/status` +// and `status` are the same string by then. What is asked instead is whether the +// head names a verb — the console's vocabulary is the cobra tree's, so "does +// this name something ferro can run" is a question with an exact answer. +func (s *playScreen) route(a *App, head, rest, line string) (tea.Cmd, bool) { + switch head { + case verbModel: + s.setModel(a, rest) + return nil, true + case verbClear: + s.reset() + return nil, true + } + if knownVerb(a.Composer.verbs, head) { + return nil, false + } + return s.submit(a, line), true +} + +// knownVerb reports whether head names something the router can run. +func knownVerb(verbs []string, head string) bool { + switch head { + case verbHelp, "?", verbClear, verbVersion: + return true + } + for _, v := range verbs { + if v == head || strings.HasPrefix(v, head+" ") { + return true + } + } + return false +} + +// setModel switches the model the next turn is sent to, refusing anything the +// gateway does not advertise. A model chosen here and refused by the gateway +// would fail one turn later with an error naming neither. +func (s *playScreen) setModel(a *App, id string) { + id = strings.TrimSpace(id) + if id == "" { + s.note(a, "model is "+s.model, false) + return + } + for _, m := range s.models { + if m == id { + s.model = id + s.note(a, "model is "+id, false) + return + } + } + if len(s.models) == 0 { + // Nothing to check against is not the same as a bad name; adopt it and + // let the gateway be the authority, which it is either way. + s.model = id + s.note(a, "model is "+id+" (this gateway advertised no model list)", false) + return + } + s.note(a, fmt.Sprintf("no model named %q — try %s", id, strings.Join(s.nearest(id), ", ")), true) +} + +// nearest offers the models closest to what was typed: shared prefix first, +// then the head of the list, so a refusal always names something runnable. +func (s *playScreen) nearest(id string) []string { + var out []string + for _, m := range s.models { + if strings.HasPrefix(m, id[:min(len(id), 3)]) { + out = append(out, m) + } + } + if len(out) == 0 { + out = s.models + } + return out[:min(len(out), modelSuggestions)] +} + +// note is how the playground answers a command: as a turn in the conversation, +// because that is where the operator is looking. The transcript is on another +// pane and a red row pushed there would not be seen. +func (s *playScreen) note(_ *App, text string, bad bool) { + s.appendTurns(chatTurn{Who: whoGateway, Text: text, Bad: bad, Note: true, lines: []string{text}}) +} + +func (s *playScreen) appendTurns(turns ...chatTurn) { + for i := range turns { + s.lastID++ + turns[i].id = s.lastID + } + s.turns = append(s.turns, turns...) + if len(s.turns) <= playTurnMax { + return + } + s.turns = s.turns[len(s.turns)-playTurnMax:] + // A chat answer belongs with the user prompt immediately before it. If a + // one-turn note pushed only that prompt out, discard the orphaned answer. + for i, turn := range s.turns { + if turn.Note { + continue + } + if turn.Who == whoGateway { + s.turns = append(s.turns[:i], s.turns[i+1:]...) + } + break + } +} + +func (s *playScreen) reset() { + s.cancel() + s.gen++ + s.turns, s.usage, s.busy, s.requestID = nil, nil, false, "" + s.queued = "" + s.pending.Reset() +} + +// submit opens a turn. The operator's line lands immediately and an empty +// gateway turn is opened beside it, so the answer streams into a slot that is +// already on screen rather than appearing all at once at the end. +func (s *playScreen) submit(a *App, prompt string) tea.Cmd { + prompt = strings.TrimSpace(prompt) + if prompt == "" { + return nil + } + if s.busy { + s.note(a, "a turn is still streaming — wait for it, or run clear", true) + return nil + } + if s.renderer == nil { + s.renderer = wrapPlain + } + if s.width <= 0 { + s.width = a.paneWidth() + } + + s.appendTurns( + chatTurn{Who: whoYou, Text: prompt, lines: s.wrap(prompt)}, + chatTurn{Who: whoGateway}) + s.usage, s.busy, s.started, s.requestID = nil, true, time.Now(), "" + s.pending.Reset() + + ctx, cancel := context.WithCancel(context.Background()) + s.openCancel = cancel + return openChat(ctx, a.Client, s.gen, api.ChatRequest{ + Model: s.model, + Messages: s.history(), + }) +} + +// history is the conversation as the gateway sees it. Failed turns are left +// out: a turn that ended in a stream error has no answer, and sending its +// partial text back as though the model had said it is a fabrication. +func (s *playScreen) history() []api.ChatMessage { + out := make([]api.ChatMessage, 0, len(s.turns)) + for _, t := range s.turns { + if t.Text == "" || t.Bad || t.Note { + continue + } + role := "assistant" + if t.Who == whoYou { + role = "user" + } + out = append(out, api.ChatMessage{Role: role, Content: t.Text}) + } + return out +} + +// -------------------------------------------------------------------- update + +func (s *playScreen) update(a *App, msg tea.Msg) tea.Cmd { + switch m := msg.(type) { + case playModelsMsg: + if m.gen != s.gen { + return nil + } + if m.err == nil { + s.models = m.models + if s.model == "" && len(s.models) > 0 { + s.model = s.models[0] + } + } + // A queued prompt is released either way. A failed listing leaves the + // gateway as the only authority on which names it accepts, which it is + // regardless — refusing to ask would be worse than asking and being + // told why. + if q := s.queued; q != "" { + s.queued = "" + return s.submit(a, q) + } + return nil + + case chatOpenMsg: + if m.gen != s.gen { + // A stream opened for a visit the operator has left still owns a + // connection and a goroutine. Cancel it rather than leak it. + if m.stream != nil { + m.stream.Cancel() + } + return nil + } + if m.err != nil { + return s.fail(a, "gateway: "+m.err.Error()) + } + if m.stream == nil { + return s.fail(a, "gateway: stream opened without a response") + } + s.stream, s.requestID = m.stream, m.stream.RequestID + return tea.Batch(readStream(s.gen, m.stream.Events), tickFlush(s.gen)) + + case chatDeltaMsg: + if m.gen != s.gen || !s.busy { + return nil + } + s.pending.WriteString(m.text) + return s.next() + + case chatUsageMsg: + if m.gen != s.gen || !s.busy { + return nil + } + s.usage = m.usage + return s.next() + + case chatEndMsg: + if m.gen != s.gen || !s.busy { + return nil + } + s.flush(a) + s.took = time.Since(s.started) + s.cancel() + s.busy = false + switch { + case m.err != nil: + s.markFailed(streamFailure(m.err)) + return nil + case !m.done: + // The channel closed with neither a terminator nor an error. The + // answer is truncated and saying so is the whole job. + s.markFailed("gateway: the stream ended with no terminator — the answer above is truncated") + return nil + } + return s.metaCmd(a) + + case chatMetaMsg: + if m.gen != s.gen { + return nil + } + for i := range s.turns { + if s.turns[i].id == m.turn { + s.turns[i].Meta = metaLine(m.usage, m.row, m.took) + break + } + } + return nil + + case flushTickMsg: + if m.gen != s.gen { + return nil + } + s.flush(a) + if !s.busy { + return nil + } + return tickFlush(s.gen) + } + return nil +} + +// next keeps the reader pumping. One event per command, re-issued until the +// stream ends — the standard Bubble Tea channel pump. +func (s *playScreen) next() tea.Cmd { + if s.stream == nil { + return nil + } + return readStream(s.gen, s.stream.Events) +} + +// answer is the index of the turn currently being written into. +func (s *playScreen) answer() int { + for i := len(s.turns) - 1; i >= 0; i-- { + if s.turns[i].Who == whoGateway && !s.turns[i].Note { + return i + } + } + return -1 +} + +// flush moves the batched deltas into the turn and re-renders it ONCE. +func (s *playScreen) flush(_ *App) { + if s.pending.Len() == 0 { + return + } + text := s.pending.String() + s.pending.Reset() + i := s.answer() + if i < 0 { + return + } + if s.renderer == nil { + s.renderer = wrapPlain + } + s.turns[i].Text += text + s.turns[i].lines = s.wrap(s.turns[i].Text) +} + +// markFailed turns the open answer into a visible failure, keeping whatever +// text arrived before it broke. +func (s *playScreen) markFailed(text string) { + i := s.answer() + if i < 0 { + return + } + s.turns[i].Bad = true + if s.turns[i].Text != "" { + text = s.turns[i].Text + "\n" + text + } + s.turns[i].Text = text + s.turns[i].lines = s.wrap(text) +} + +func (s *playScreen) fail(_ *App, text string) tea.Cmd { + s.busy = false + s.cancel() + s.markFailed(text) + return nil +} + +// metaCmd resolves the route metadata a streamed body cannot carry. It reads +// the turn and the two measurements the answer will be labelled with HERE, +// because everything it reads is about to become the PREVIOUS turn's, and +// hands them to fetchAttribution to carry on the returned command's eventual +// message rather than pinning them in screen state. +// +// That distinction matters because chatEndMsg clears busy before this +// command's result lands, so the operator can submit and finish a SECOND turn +// while the first turn's fetch is still in flight — two fetches really can be +// outstanding at once. A single screen-level slot would let the second turn's +// metaCmd overwrite the turn id, usage and duration the first turn's fetch was +// issued for, so its answer — arriving later — would be applied to the wrong +// turn. Carrying the values on the message and matching on turn id when it +// arrives keeps the two independent regardless of arrival order. +func (s *playScreen) metaCmd(a *App) tea.Cmd { + var turn int + if i := s.answer(); i >= 0 { + turn = s.turns[i].id + } + return fetchAttribution(a.Client, s.gen, turn, s.usage, s.took, s.requestID, s.started.Add(-attributionSlack)) +} + +// streamFailure is the operator-facing wording for each stream error code. It +// matches `ferro chat`'s, so the same failure reads the same in both. +func streamFailure(e *api.Error) string { + switch e.Code { + case api.CodeStreamTimeout: + return "gateway: stream idled out (gateway bound: 2m)" + case api.CodeStreamIncomplete: + return "gateway: stream ended mid-answer with no terminator — the answer above is truncated" + } + if e.Message == "" { + return "gateway: stream failed: " + e.Error() + } + return "gateway: " + e.Message +} + +// metaLine assembles the route readout from the two sources that have it: the +// usage chunk the stream sent, and the request-log row the response's +// X-Request-ID matched. Every segment whose fact is missing is DROPPED — a +// gateway with no log store gets a shorter line, never a guessed provider and +// never a $0.00 that was really "unpriced". +func metaLine(u *api.Usage, row *api.LogEntry, took time.Duration) string { + var parts []string + if row != nil && row.Provider != "" { + parts = append(parts, row.Provider+" → served") + } + parts = append(parts, fmt.Sprintf("%.2fs", took.Seconds())) + if u != nil { + parts = append(parts, fmt.Sprintf("%d in / %d out", u.PromptTokens, u.CompletionTokens)) + } + if row != nil && row.CostUSD != nil { + parts = append(parts, costCell(row.CostUSD)) + } + return strings.Join(parts, " · ") +} + +// --------------------------------------------------------------------- view + +func (s *playScreen) view(a *App, w, rows int) string { + th := a.Theme + // One sub-line plus at most rows-1 body lines: the tail below is cut to + // exactly that before it is appended. + out := append(make([]string, 0, rows), s.subLine(a, w)) + + body := make([]string, 0, rows) + for i, t := range s.turns { + if i > 0 { + body = append(body, "") + } + label := th.Accent.Bold(th.Mode.Color).Render(t.Who) + if t.Who != whoYou { + label = th.Bright.Bold(th.Mode.Color).Render(t.Who) + } + body = append(body, label) + + lines := t.lines + if len(lines) == 0 && t.Text != "" { + lines = strings.Split(t.Text, "\n") + } + for _, line := range lines { + if t.Bad { + line = th.Bad.Render(line) + } + body = append(body, line) + } + if t.Meta != "" { + body = append(body, + th.Hairline.Render(a.rule(min(lipgloss.Width(t.Meta), w))), + th.Dim.Render(t.Meta)) + } + } + if len(s.turns) == 0 { + body = append(body, "", th.Dim.Render("Type a prompt to start. /model switches models, clear resets.")) + } + + // The transcript of a conversation is read from the bottom. + return fill(append(out, tail(body, max(rows-len(out), 0))...), w, rows) +} + +func (s *playScreen) subLine(a *App, w int) string { + th := a.Theme + model := s.model + if model == "" { + model = "gateway default" + } + right := "" + if s.busy { + right = th.Accent.Render("streaming…") + if th.Mode.ASCII { + right = th.Accent.Render("streaming...") + } + } + return gapPad(w, " "+th.Dim.Render("/model "+model+" · clear resets · esc home"), right) +} + +// tail keeps the last n lines. A chat scrolls up, so what falls off the top is +// what the operator has already read. +func tail(lines []string, n int) []string { + if n <= 0 { + return nil + } + if len(lines) <= n { + return lines + } + return lines[len(lines)-n:] +} + +// ---------------------------------------------------------------- rendering + +func (s *playScreen) wrap(text string) []string { + if text == "" { + return nil + } + w := max(s.width, 8) + out := text + if s.renderer != nil { + out = s.renderer(text, w) + } + return strings.Split(strings.TrimRight(out, "\n"), "\n") +} + +// wrapPlain folds an answer to the pane width. It is ANSI- and grapheme-aware, +// so a wrapped line still measures what it draws. +func wrapPlain(text string, w int) string { return ansi.Wrap(text, max(w, 8), "") } diff --git a/internal/tui/playground_test.go b/internal/tui/playground_test.go new file mode 100644 index 0000000..5148cfc --- /dev/null +++ b/internal/tui/playground_test.go @@ -0,0 +1,614 @@ +package tui + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// stubStream is a ChatStream whose events the test writes itself. Cancel is +// counted rather than asserted once, because leaving a screen and finishing a +// turn can both reach it and both must be safe. +func stubStream(events ...api.StreamEvent) (*api.ChatStream, *atomic.Int32) { + ch := make(chan api.StreamEvent, len(events)+1) + for _, e := range events { + ch <- e + } + close(ch) + var cancels atomic.Int32 + return &api.ChatStream{ + RequestID: "tr_stub0001", + Events: ch, + Cancel: func() { cancels.Add(1) }, + }, &cancels +} + +func delta(text string) api.StreamEvent { + return api.StreamEvent{Chunk: &api.ChatChunk{ + Choices: []api.StreamChoice{{Delta: api.MessageDelta{Content: text}}}, + }} +} + +func usageEvent(in, out int) api.StreamEvent { + return api.StreamEvent{Chunk: &api.ChatChunk{ + Usage: &api.Usage{PromptTokens: in, CompletionTokens: out, TotalTokens: in + out}, + }} +} + +// pump drains a stream into the app exactly as the reader command does. +func pump(a *App, st *api.ChatStream) { + for range 64 { + msg := readStream(a.Play.gen, st.Events)() + a.update(msg) + if _, done := msg.(chatEndMsg); done { + return + } + } +} + +func lastTurn(a *App) chatTurn { + if n := len(a.Play.turns); n > 0 { + return a.Play.turns[n-1] + } + return chatTurn{} +} + +func TestSubmitAppendsTurnsAndStreams(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.submit(a, "which target serves sonnet?") + + if len(a.Play.turns) != 2 { + t.Fatalf("a submission opens the operator's turn and the answer's, got %d", len(a.Play.turns)) + } + if a.Play.turns[0].Who != "you" || a.Play.turns[0].Text != "which target serves sonnet?" { + t.Fatalf("the prompt must be echoed verbatim, got %#v", a.Play.turns[0]) + } + if !a.Play.busy { + t.Fatal("a submitted turn is busy until the stream ends") + } + + st, cancels := stubStream(delta("Ferro "), delta("routed "), delta("this."), + usageEvent(318, 142), api.StreamEvent{Done: true}) + a.update(chatOpenMsg{gen: a.Play.gen, stream: st}) + pump(a, st) + + if a.Play.busy { + t.Fatal("[DONE] ends the turn") + } + if got := lastTurn(a).Text; got != "Ferro routed this." { + t.Fatalf("every delta must land in the turn, got %q", got) + } + if a.Play.usage == nil || a.Play.usage.PromptTokens != 318 { + t.Fatalf("the usage chunk must be kept, got %+v", a.Play.usage) + } + if cancels.Load() == 0 { + t.Fatal("Cancel releases the reader and the connection even after a clean Done") + } + if v := a.paneView(120, 20); !strings.Contains(v, "Ferro routed this.") { + t.Fatalf("the answer must be on screen:\n%s", v) + } +} + +func TestLeavingPlaygroundCancelsStreamBeforeHeaders(t *testing.T) { + requestStarted := make(chan struct{}) + releaseServer := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { + close(requestStarted) + <-releaseServer + })) + defer func() { + close(releaseServer) + srv.Close() + }() + c, err := api.New(srv.URL, "") + if err != nil { + t.Fatal(err) + } + a := composerApp() + a.Client = c + a.route("playground") + cmd := a.Play.submit(a, "hello") + done := make(chan struct{}) + go func() { + _ = cmd() + close(done) + }() + + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + select { + case <-requestStarted: + case <-ctx.Done(): + t.Fatal("the stream-opening request never reached the server") + } + a.Play.leave() + select { + case <-done: + case <-ctx.Done(): + t.Fatal("the stream-opening command did not return after cancellation") + } +} + +// The whole point of the flush tick: one markdown render per batch, never one +// per token. +func TestFlushCadenceBatchesDeltas(t *testing.T) { + a := composerApp() + a.route("playground") + + var renders atomic.Int32 + a.Play.renderer = func(text string, _ int) string { + renders.Add(1) + return text + } + a.Play.submit(a, "hello") + renders.Store(0) + + for range 10 { + a.update(chatDeltaMsg{gen: a.Play.gen, text: "word "}) + } + if n := renders.Load(); n != 0 { + t.Fatalf("a delta must not re-render; %d renders before the flush", n) + } + if lastTurn(a).Text != "" { + t.Fatal("deltas are batched, not written straight into the turn") + } + + a.update(flushTickMsg{gen: a.Play.gen}) + if n := renders.Load(); n != 1 { + t.Fatalf("one flush is one render, got %d", n) + } + if got := lastTurn(a).Text; got != strings.Repeat("word ", 10) { + t.Fatalf("the flush must move every batched delta, got %q", got) + } +} + +func TestMetaLineFromUsageAndAttribution(t *testing.T) { + u := &api.Usage{PromptTokens: 318, CompletionTokens: 142, TotalTokens: 460} + row := &api.LogEntry{Provider: "anthropic", CostUSD: f64(0.0031)} + + got := metaLine(u, row, 930*time.Millisecond) + for _, want := range []string{"anthropic", "served", "0.93s", "318 in / 142 out", "$0.0031"} { + if !strings.Contains(got, want) { + t.Fatalf("meta line missing %q: %q", want, got) + } + } +} + +// A gateway with no log store answers 501, which TraceAttribution reports as +// (nil, nil). The line must lose the segments it cannot support and keep the +// ones it measured itself — never invent a provider or a cost. +func TestMetaWithoutLogStore(t *testing.T) { + u := &api.Usage{PromptTokens: 318, CompletionTokens: 142} + got := metaLine(u, nil, 930*time.Millisecond) + if !strings.Contains(got, "318 in / 142 out") || !strings.Contains(got, "0.93s") { + t.Fatalf("what was measured must survive: %q", got) + } + for _, bad := range []string{"served", "$", "→"} { + if strings.Contains(got, bad) { + t.Fatalf("an unattributed turn must not carry %q: %q", bad, got) + } + } + + // And with no usage chunk either, the elapsed time is all there is. + if got := metaLine(nil, nil, time.Second); got != "1.00s" { + t.Fatalf("a bare turn reports only what it timed, got %q", got) + } +} + +func TestSlashModelValidates(t *testing.T) { + a := composerApp() + a.route("playground") + a.update(playModelsMsg{gen: a.Play.gen, models: []string{ + "claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5", "gpt-4o-mini", "gpt-4o", + }}) + if a.Play.model != "claude-sonnet-4-6" { + t.Fatalf("the first advertised model is the default, got %q", a.Play.model) + } + + a.update(runCmdMsg{raw: "model gpt-4o"}) + if a.Play.model != "gpt-4o" { + t.Fatalf("/model must switch to an advertised model, got %q", a.Play.model) + } + if a.Screen != ScreenPlayground { + t.Fatal("/model is a playground action, not a command that leaves it") + } + + a.update(runCmdMsg{raw: "model claude-nope"}) + if a.Play.model != "gpt-4o" { + t.Fatalf("an unknown model must not be adopted, got %q", a.Play.model) + } + turn := lastTurn(a) + if !turn.Bad { + t.Fatalf("an unknown model must be refused visibly, got %#v", turn) + } + if !strings.Contains(turn.Text, "claude-sonnet-4-6") { + t.Fatalf("a refusal must suggest the models that do exist: %q", turn.Text) + } + if strings.Contains(transcriptText(a), "ferro model") { + t.Fatalf("a playground action is not a shell verb and must not be echoed:\n%s", transcriptText(a)) + } +} + +func TestPlaygroundNotesNeverEnterModelHistoryOrReceiveDeltas(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.renderer = wrapPlain + a.Play.width = 80 + a.Play.appendTurns( + chatTurn{Who: "you", Text: "hello"}, + chatTurn{Who: "gateway", Text: "answer"}, + ) + a.Play.note(a, "model is gpt-4o", false) + + history := a.Play.history() + if len(history) != 2 || history[0].Content != "hello" || history[1].Content != "answer" { + t.Fatalf("console notes must not be sent as assistant messages: %+v", history) + } + a.Play.pending.WriteString(" delta") + a.Play.flush(a) + if lastTurn(a).Text != "model is gpt-4o" || a.Play.turns[1].Text != "answer delta" { + t.Fatalf("stream deltas must target the chat answer, not the note: %+v", a.Play.turns) + } +} + +func TestPlaygroundTranscriptIsBounded(t *testing.T) { + s := playScreen{} + s.appendTurns( + chatTurn{Who: "you", Text: "old prompt"}, chatTurn{Who: "gateway", Text: "old answer"}, + chatTurn{Who: "you", Text: "kept prompt"}, chatTurn{Who: "gateway", Text: "kept answer"}, + ) + for i := 0; i < playTurnMax-3; i++ { + s.appendTurns(chatTurn{Who: "gateway", Text: "note", Note: true}) + } + if len(s.turns) > playTurnMax || len(s.turns) < 2 || s.turns[0].Who != "you" || s.turns[1].Who != "gateway" { + t.Fatalf("retention must remove orphaned answers and preserve pairing: %+v", s.turns[:min(3, len(s.turns))]) + } +} + +func TestNilOpenedStreamFailsVisibly(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.submit(a, "hello") + a.update(chatOpenMsg{gen: a.Play.gen}) + if a.Play.busy || !lastTurn(a).Bad || !strings.Contains(lastTurn(a).Text, "without a response") { + t.Fatalf("nil stream must become a visible failed turn: %#v", lastTurn(a)) + } +} + +func TestLeaveCancelsStream(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.submit(a, "hello") + st, cancels := stubStream(delta("one "), delta("two ")) + a.update(chatOpenMsg{gen: a.Play.gen, stream: st}) + gen := a.Play.gen + + a.update(chatDeltaMsg{gen: gen, text: "one "}) + a.update(runCmdMsg{raw: "help"}) // leaves the screen + + if cancels.Load() == 0 { + t.Fatal("leaving the playground must cancel the stream in flight") + } + if a.Play.busy { + t.Fatal("a cancelled turn is not busy") + } + before := lastTurn(a).Text + a.update(chatDeltaMsg{gen: gen, text: "two "}) + a.update(chatUsageMsg{gen: gen, usage: &api.Usage{PromptTokens: 9}}) + a.update(chatEndMsg{gen: gen, done: true}) + if lastTurn(a).Text != before { + t.Fatalf("a delta from a screen the operator has left must be dropped, got %q", lastTurn(a).Text) + } + if a.Play.usage != nil { + t.Fatal("a late usage chunk must be dropped too") + } +} + +// Every stream failure ends as a turn an operator can see. stream_incomplete +// is the one most easily lost: it is ferro's own synthesis for a connection +// that ended with neither a terminator nor an explanation. +func TestStreamErrorRendersRedTurn(t *testing.T) { + for _, tc := range []struct { + code, message, want string + }{ + {api.CodeStreamError, "upstream error from provider anthropic", "upstream error from provider anthropic"}, + {api.CodeStreamTimeout, "idle bound elapsed", "stream idled out"}, + {api.CodeStreamIncomplete, "", "terminator"}, + } { + a := composerApp() + a.route("playground") + a.Play.submit(a, "hello") + st, cancels := stubStream(delta("partial "), + api.StreamEvent{Err: &api.Error{Status: 200, Code: tc.code, Message: tc.message}}) + a.update(chatOpenMsg{gen: a.Play.gen, stream: st}) + pump(a, st) + + turn := lastTurn(a) + if !turn.Bad { + t.Fatalf("%s must render as a failed turn, got %#v", tc.code, turn) + } + if !strings.Contains(turn.Text, tc.want) { + t.Fatalf("%s must say %q, got %q", tc.code, tc.want, turn.Text) + } + if a.Play.busy { + t.Fatalf("%s ends the turn", tc.code) + } + if cancels.Load() == 0 { + t.Fatalf("%s must still release the stream", tc.code) + } + if v := a.paneView(110, 20); !strings.Contains(v, tc.want) { + t.Fatalf("%s must be visible on screen:\n%s", tc.code, v) + } + } +} + +// A channel that closes with neither Done nor an error frame is the same +// truncation, arriving a different way. +func TestSilentStreamCloseEndsTheTurn(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.submit(a, "hello") + st, _ := stubStream(delta("partial ")) + a.update(chatOpenMsg{gen: a.Play.gen, stream: st}) + pump(a, st) + + if a.Play.busy { + t.Fatal("a closed channel ends the turn") + } + if turn := lastTurn(a); !turn.Bad || !strings.Contains(turn.Text, "partial") { + t.Fatalf("a truncated answer keeps what arrived and says it was cut: %#v", turn) + } +} + +// The seam the plan got wrong: the composer strips the leading slash before +// route() sees the line, so "is this a command" cannot key on it. +func TestPlaygroundRoutesVerbsAndPromptsApart(t *testing.T) { + a := composerApp() + a.route("playground") + + a.update(runCmdMsg{raw: "status"}) + if a.Screen != ScreenHome { + t.Fatal("a line naming a verb is a command, even on the playground") + } + if !strings.Contains(transcriptText(a), "ferro status") { + t.Fatalf("a verb must still be echoed:\n%s", transcriptText(a)) + } + + a.route("playground") + a.update(runCmdMsg{raw: "which target is serving Sonnet right now?"}) + if a.Screen != ScreenPlayground { + t.Fatal("a prompt keeps the operator in the playground") + } + if got := a.Play.turns[0].Text; got != "which target is serving Sonnet right now?" { + t.Fatalf("a prompt must reach the model with its case intact, got %q", got) + } + if strings.Contains(transcriptText(a), "which target") { + t.Fatalf("a prompt is not a command and must not be echoed as one:\n%s", transcriptText(a)) + } +} + +func TestPlaygroundClearResetsTurnsNotTranscript(t *testing.T) { + a := composerApp() + a.route("status") + a.route("playground") + a.Play.submit(a, "hello") + st, cancels := stubStream(delta("hi")) + a.update(chatOpenMsg{gen: a.Play.gen, stream: st}) + + a.update(runCmdMsg{raw: "clear"}) + if len(a.Play.turns) != 0 { + t.Fatalf("/clear empties the conversation, got %d turns", len(a.Play.turns)) + } + if cancels.Load() == 0 { + t.Fatal("/clear must cancel a stream it is discarding the answer of") + } + if a.Screen != ScreenPlayground { + t.Fatal("/clear stays in the playground") + } + if a.Transcript.Len() == 0 { + t.Fatal("/clear on the playground is not the transcript's clear") + } +} + +// End to end against the fake: real SSE framing, real decode, real attribution. +func TestPlaygroundStreamsAgainstTheFixture(t *testing.T) { + a := fixtureApp(t) + a.route("playground") + a.Play.model = "claude-sonnet-4-6" + + msg := a.Play.submit(a, "hello")() + open, ok := msg.(chatOpenMsg) + if !ok || open.err != nil { + t.Fatalf("opening a stream against the fake must succeed, got %#v", msg) + } + a.update(open) + pump(a, open.stream) + a.update(flushTickMsg{gen: a.Play.gen}) + + if got := lastTurn(a).Text; !strings.Contains(got, "Ferro routed this through the fake gateway.") { + t.Fatalf("the fake's whole answer must arrive, got %q", got) + } + if a.Play.usage == nil || a.Play.usage.PromptTokens != 24 { + t.Fatalf("the usage chunk must be decoded, got %+v", a.Play.usage) + } + + // The end arm returns the attribution fetch; run it and apply the meta. This + // is the whole loop the plan calls out: a streamed body names no provider, + // so the answer's X-Request-ID is matched against the request log. + a.update(a.Play.metaCmd(a)()) + meta := lastTurn(a).Meta + for _, want := range []string{"anthropic → served", "24 in / 7 out", "$0.0031"} { + if !strings.Contains(meta, want) { + t.Fatalf("the meta line must carry %q, got %q", want, meta) + } + } + t.Logf("meta against the fixture: %q", meta) +} + +func TestPlaygroundKeepsThePaneContract(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.submit(a, "a fairly long prompt that will need wrapping at every width we test") + a.update(chatDeltaMsg{gen: a.Play.gen, text: "# Heading\n\nSome **markdown** with a list:\n\n- one\n- two\n\n```go\nfmt.Println(\"hi\")\n```\n"}) + a.update(flushTickMsg{gen: a.Play.gen}) + a.update(chatEndMsg{gen: a.Play.gen, done: true}) + a.update(chatMetaMsg{gen: a.Play.gen, turn: lastTurn(a).id, row: &api.LogEntry{Provider: "anthropic", CostUSD: f64(0.0031)}}) + + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + a.Theme = theme.New(mode) + // The renderer must be REAL: resize returns early without one, so a nil + // renderer would leave every turn wrapped for whatever width came + // before and this loop would measure a cache instead of the wrapping + // it exists to check. + a.Play.renderer = wrapPlain + for _, rows := range []int{1, 4, 9, 20} { + for _, w := range []int{30, 60, 92, 126} { + a.Play.width = 0 // force the re-wrap regardless of the previous width + a.Play.resize(w) + body := a.paneView(w, rows) + if got := len(strings.Split(body, "\n")); got != rows { + t.Fatalf("mode=%+v w=%d rows=%d returned %d lines", mode, w, rows, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > w { + t.Fatalf("mode=%+v w=%d line %d overflows: %d cells %q", mode, w, i, lw, line) + } + } + } + } + } +} + +// Attribution is resolved from the request log AFTER the stream ends, with one +// retry 500ms later, so the operator can easily submit the next prompt inside +// that window. Everything the meta line is built from — which turn is last, the +// usage chunk, the elapsed time — is about to describe a different turn by the +// time the answer lands, so all of it is pinned when the fetch is ISSUED. +func TestAttributionStaysOnTheTurnThatEarnedIt(t *testing.T) { + a := composerApp() + a.route("playground") + + a.Play.submit(a, "which target serves sonnet?") + a.update(chatUsageMsg{gen: a.Play.gen, usage: &api.Usage{PromptTokens: 24, CompletionTokens: 7}}) + a.update(chatEndMsg{gen: a.Play.gen, done: true}) // issues the attribution fetch + turn := lastTurn(a).id + + // The operator does not wait for it, and the second prompt resets both the + // usage and the answer position the old code resolved against. + a.Play.submit(a, "and haiku?") + a.update(chatMetaMsg{gen: a.Play.gen, turn: turn, usage: &api.Usage{PromptTokens: 24, CompletionTokens: 7}, + row: &api.LogEntry{Provider: "anthropic", CostUSD: f64(0.0031)}}) + + if n := len(a.Play.turns); n != 4 { + t.Fatalf("two prompts and two answers, got %d turns", n) + } + first := a.Play.turns[1].Meta + for _, want := range []string{"anthropic", "24 in / 7 out", "$0.0031"} { + if !strings.Contains(first, want) { + t.Fatalf("the answered turn must keep its own attribution %q, got %q", want, first) + } + } + if got := lastTurn(a).Meta; got != "" { + t.Fatalf("the turn still streaming has earned no attribution, got %q", got) + } +} + +// Two turns' attribution fetches CAN be outstanding at the same time: chatEndMsg +// clears busy before its fetch lands, so nothing stops the operator from +// submitting and finishing a second turn before the first turn's fetch has +// answered. Both fetches are issued here before either's chatMetaMsg is +// delivered, delivered out of submission order, and each must still land on +// the turn that earned it. +func TestOverlappingAttributionsResolveToTheirOwnTurn(t *testing.T) { + a := composerApp() + a.route("playground") + + a.Play.submit(a, "which target serves sonnet?") + a.update(chatUsageMsg{gen: a.Play.gen, usage: &api.Usage{PromptTokens: 24, CompletionTokens: 7}}) + fetch1 := a.update(chatEndMsg{gen: a.Play.gen, done: true}) // turn 1's fetch is now in flight + turn1 := lastTurn(a).id + + a.Play.submit(a, "and haiku?") + a.update(chatUsageMsg{gen: a.Play.gen, usage: &api.Usage{PromptTokens: 11, CompletionTokens: 3}}) + fetch2 := a.update(chatEndMsg{gen: a.Play.gen, done: true}) // turn 2 ends before turn 1's fetch has landed + turn2 := lastTurn(a).id + + if fetch1 == nil || fetch2 == nil || turn1 == turn2 { + t.Fatalf("both turns must issue their own attribution fetch, got fetch1=%v fetch2=%v turn1=%d turn2=%d", + fetch1 != nil, fetch2 != nil, turn1, turn2) + } + + // Turn 2's row lands first — arrival order is the opposite of submission + // order, and must not matter. + a.update(chatMetaMsg{gen: a.Play.gen, turn: turn2, usage: &api.Usage{PromptTokens: 11, CompletionTokens: 3}, + took: 2 * time.Second, row: &api.LogEntry{Provider: "openai", CostUSD: f64(0.0009)}}) + a.update(chatMetaMsg{gen: a.Play.gen, turn: turn1, usage: &api.Usage{PromptTokens: 24, CompletionTokens: 7}, + took: time.Second, row: &api.LogEntry{Provider: "anthropic", CostUSD: f64(0.0031)}}) + + if n := len(a.Play.turns); n != 4 { + t.Fatalf("two prompts and two answers, got %d turns", n) + } + first, second := a.Play.turns[1].Meta, a.Play.turns[3].Meta + for _, want := range []string{"anthropic", "24 in / 7 out", "$0.0031"} { + if !strings.Contains(first, want) { + t.Fatalf("turn 1 must keep its own provider, usage and duration, got %q", first) + } + } + for _, want := range []string{"openai", "11 in / 3 out", "$0.0009"} { + if !strings.Contains(second, want) { + t.Fatalf("turn 2 must keep its own provider, usage and duration, got %q", second) + } + } +} + +// `chat ` opens the pane and asks in one line, which means the ask +// races the model listing that same command starts. submit copies s.model into +// the request there and then, so a prompt sent before discovery lands names no +// model at all — and a gateway that would have served it refuses instead. +func TestInlineChatWaitsForModelDiscovery(t *testing.T) { + a := fixtureApp(t) + a.route("chat which target serves sonnet?") + + if len(a.Play.turns) != 0 { + t.Fatalf("nothing may be sent before a model is known, got %d turns", len(a.Play.turns)) + } + if a.Play.queued == "" { + t.Fatal("the prompt must be held, not dropped") + } + + a.Play.update(a, playModelsMsg{gen: a.Play.gen, models: []string{"claude-sonnet-4-6", "gpt-4o"}}) + + if a.Play.model == "" { + t.Fatal("discovery must name the default before the held prompt is sent") + } + if len(a.Play.turns) != 2 || a.Play.turns[0].Text != "which target serves sonnet?" { + t.Fatalf("the held prompt must be sent once discovery lands, got %+v", a.Play.turns) + } + if a.Play.queued != "" { + t.Fatal("a released prompt must not be sent twice") + } +} + +// A gateway that will not list its models is still the authority on which +// names it accepts. Holding the prompt for a listing that never arrives would +// swallow it silently, which is worse than asking and being told why. +func TestInlineChatReleasesThePromptWhenDiscoveryFails(t *testing.T) { + a := fixtureApp(t) + a.route("chat which target serves sonnet?") + a.Play.update(a, playModelsMsg{gen: a.Play.gen, err: errors.New("connection refused")}) + + if len(a.Play.turns) != 2 { + t.Fatalf("a failed listing must not swallow the prompt, got %+v", a.Play.turns) + } +} diff --git a/internal/tui/theme/theme.go b/internal/tui/theme/theme.go new file mode 100644 index 0000000..8e9479f --- /dev/null +++ b/internal/tui/theme/theme.go @@ -0,0 +1,196 @@ +// Package theme is the ferro console's visual vocabulary: palette, glyph set, +// cell-accurate frames, and the split-F mark. +// +// Every measurement here is in terminal cells (lipgloss.Width), never bytes and +// never runes: CJK is double-width, combining marks are zero-width, and ANSI +// sequences measure zero. A frame padded with len() breaks the first time real +// output arrives. +package theme + +import ( + "strings" + + "charm.land/lipgloss/v2" + "github.com/charmbracelet/x/ansi" +) + +// Console palette. Truecolor hex; lipgloss downgrades to the +// terminal's actual profile. Never paint a full-screen background — the +// terminal's own background is the ground. +const ( + colorAccent = "#d97757" + colorOK = "#77ba8d" + colorWarn = "#e4b354" + colorBad = "#dc6b67" + colorDim = "#7f817e" + colorText = "#e8e5df" + colorBright = "#fff8ef" + colorFaint = "#4a4b49" + colorBorder = "#3a3b38" + colorHairline = "#262726" + colorSelection = "#1a1717" +) + +// minFrameWidth is the narrowest frame that can still close around content: +// two border cells, two padding cells, and something in between. +const minFrameWidth = 8 + +// Mode is what the terminal will accept. Color is false under NO_COLOR, a +// non-TTY stdout, or TERM=dumb; ASCII is the --ascii glyph downgrade. +type Mode struct { + Color bool + ASCII bool +} + +// Glyphs is the whole status vocabulary. Color never carries state alone, so +// every state has a glyph here. +type Glyphs struct{ Dot, OK, Warn, Bad, None, Prompt string } + +// Glyphs returns the unicode set, or the ASCII set under --ascii. +func (m Mode) Glyphs() Glyphs { + if m.ASCII { + return Glyphs{Dot: "[+]", OK: "[OK]", Warn: "[!]", Bad: "[X]", None: "[-]", Prompt: ">"} + } + return Glyphs{Dot: "●", OK: "✓", Warn: "!", Bad: "✗", None: "·", Prompt: "❯"} +} + +// box is the border vocabulary for one frame style. +type box struct{ tl, tr, bl, br, h, v string } + +func (m Mode) box(round bool) box { + switch { + case m.ASCII: + return box{tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|"} + case round: + return box{tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│"} + default: + return box{tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│"} + } +} + +// Theme is the rendering surface every TUI file draws through. When +// Mode.Color is false every style is a plain no-op, so callers never branch on +// color themselves. +type Theme struct { + Mode Mode + Accent, OK, Warn, Bad, Dim, Text, Bright, Faint lipgloss.Style + Border, Hairline lipgloss.Style + Selected lipgloss.Style +} + +// New builds the theme for a mode. Under !m.Color every field is +// lipgloss.NewStyle(), which renders its input unchanged. +func New(m Mode) Theme { + fg := func(hex string) lipgloss.Style { + s := lipgloss.NewStyle() + if !m.Color { + return s + } + return s.Foreground(lipgloss.Color(hex)) + } + t := Theme{ + Mode: m, + Accent: fg(colorAccent), + OK: fg(colorOK), + Warn: fg(colorWarn), + Bad: fg(colorBad), + Dim: fg(colorDim), + Text: fg(colorText), + Bright: fg(colorBright), + Faint: fg(colorFaint), + Border: fg(colorBorder), + Hairline: fg(colorHairline), + Selected: lipgloss.NewStyle(), + } + if m.Color { + t.Selected = t.Selected.Background(lipgloss.Color(colorSelection)) + } + return t +} + +// Frame draws a square-corner frame exactly w cells wide, with the title +// embedded in the top border: +// +// ┌─ TITLE ────────┐ +// │ body │ +// └────────────────┘ +// +// Body lines are padded or truncated to fit. An empty title yields an +// unbroken top border. w < minFrameWidth returns the bare body: never emit a +// border that cannot close. +func (t Theme) Frame(title, body string, w int) string { + return t.frame(title, body, w, t.Mode.box(false)) +} + +// FrameRound is Frame with rounded corners and no title — the composer and +// modals. +func (t Theme) FrameRound(body string, w int) string { + return t.frame("", body, w, t.Mode.box(true)) +} + +func (t Theme) frame(title, body string, w int, b box) string { + if w < minFrameWidth { + return body + } + lines := strings.Split(body, "\n") + rows := make([]string, 0, len(lines)+2) + rows = append(rows, t.top(b, title, w)) + edge := t.Border.Render(b.v) + for _, line := range lines { + rows = append(rows, edge+" "+padCell(line, w-4)+" "+edge) + } + rows = append(rows, t.Border.Render(b.bl+strings.Repeat(b.h, w-2)+b.br)) + return strings.Join(rows, "\n") +} + +func (t Theme) top(b box, title string, w int) string { + if title == "" { + return t.Border.Render(b.tl + strings.Repeat(b.h, w-2) + b.tr) + } + // Cap the title so at least one trailing rule remains; w >= minFrameWidth + // leaves at least two cells for it. + title = ansi.Truncate(title, w-6, "") + fill := max(w-5-lipgloss.Width(title), 1) + return t.Border.Render(b.tl+b.h) + " " + t.Dim.Render(title) + " " + + t.Border.Render(strings.Repeat(b.h, fill)+b.tr) +} + +// padCell pads or truncates s to exactly w terminal cells. Truncation is +// ANSI- and grapheme-aware, so styled content keeps its escape sequences +// intact and a clipped double-width rune still leaves the line whole. +func padCell(s string, w int) string { + if w <= 0 { + return "" + } + s = ansi.Truncate(s, w, "") + if pad := w - lipgloss.Width(s); pad > 0 { + s += strings.Repeat(" ", pad) + } + return s +} + +// markStem is the F's stem: the three rows that carry no arm are the same row. +const markStem = " ███" + +// MarkRows is the split-F, sampled from f_logo.svg — canonical, do not redraw. +var MarkRows = []string{ + " ████████", + " ██████████", + markStem, + " ██████", + " ████████", + markStem, + markStem, +} + +// Mark renders the split-F in the accent color. +func Mark(t Theme) string { + if t.Mode.ASCII { + return t.Accent.Render("F") + } + rows := make([]string, len(MarkRows)) + for i, r := range MarkRows { + rows[i] = t.Accent.Render(r) + } + return strings.Join(rows, "\n") +} diff --git a/internal/tui/theme/theme_test.go b/internal/tui/theme/theme_test.go new file mode 100644 index 0000000..42a3292 --- /dev/null +++ b/internal/tui/theme/theme_test.go @@ -0,0 +1,82 @@ +package theme + +import ( + "strings" + "testing" + "unicode" + + "charm.land/lipgloss/v2" +) + +func TestFrameClosesAtExactWidth(t *testing.T) { + th := New(Mode{}) // no color → deterministic output + got := th.Frame("LOGS", "hello", 20) + want := "" + + "┌─ LOGS ───────────┐\n" + + "│ hello │\n" + + "└──────────────────┘" + if got != want { + t.Fatalf("frame drift:\n%s\nwant:\n%s", got, want) + } + for i, line := range strings.Split(got, "\n") { + if w := lipgloss.Width(line); w != 20 { + t.Fatalf("line %d width %d != 20 (cell measurement)", i, w) + } + } +} + +// Frame is pinned above in the default unicode box only, and that is one of +// three border sets: Mode.box answers differently under --ascii, and FrameRound +// is what the composer and every modal draw. All three do the same +// cell-accurate padding, so all three are measured. +func TestFrameVariantsCloseAtExactWidth(t *testing.T) { + const w = 20 + for _, m := range []Mode{{}, {ASCII: true}} { + th := New(m) + for _, got := range []string{th.Frame("LOGS", "hello", w), th.FrameRound("hello", w)} { + for i, line := range strings.Split(got, "\n") { + if got := lipgloss.Width(line); got != w { + t.Fatalf("mode=%+v line %d width %d != %d: %q", m, i, got, w, line) + } + } + } + } +} + +func TestFrameUnicodeContentDoesNotBreakBorders(t *testing.T) { + th := New(Mode{}) + got := th.Frame("T", "métriques ✓ 日本語", 26) + for _, line := range strings.Split(got, "\n") { + if lipgloss.Width(line) != 26 { + t.Fatalf("unicode content broke cell math: %q", line) + } + } +} + +func TestFrameTooNarrowReturnsBody(t *testing.T) { + th := New(Mode{}) + if got := th.Frame("T", "x", 6); got != "x" { + t.Fatalf("narrow frame must degrade to bare body, got %q", got) + } +} + +func TestGlyphsASCII(t *testing.T) { + g := Mode{ASCII: true}.Glyphs() + if g.OK != "[OK]" || g.Bad != "[X]" || g.Warn != "[!]" || g.None != "[-]" || g.Prompt != ">" { + t.Fatalf("ascii glyph vocabulary drifted: %+v", g) + } +} + +func TestMarkShape(t *testing.T) { + if len(MarkRows) != 7 { + t.Fatal("mark is exactly 7 rows — never redraw it") + } +} + +func TestMarkIsASCIIInASCIIMode(t *testing.T) { + for _, r := range Mark(New(Mode{ASCII: true})) { + if r > unicode.MaxASCII { + t.Fatalf("ASCII mark contains %q", r) + } + } +} diff --git a/internal/tui/transcript.go b/internal/tui/transcript.go new file mode 100644 index 0000000..d8766f6 --- /dev/null +++ b/internal/tui/transcript.go @@ -0,0 +1,168 @@ +package tui + +import ( + "strings" + + "charm.land/lipgloss/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +// transcriptMax is the ring depth. Bounded because a console that runs for a +// week must not grow without limit, and 60 rows is what the tallest pane can +// scroll through without paging. +const transcriptMax = 60 + +// The row kinds. A kind is resolved by glyphCell into a styled glyph, and an +// unrecognised one is rendered as written — which means a mistyped literal +// draws itself into the transcript instead of failing, so the vocabulary is +// named here and every caller spells it from this list. The empty kind ("") is +// a row with no glyph and needs no name. +const ( + kindCmd = "$" // an echoed command line + kindOK = "ok" + kindWarn = "warn" + kindBad = "bad" + kindNote = "·" +) + +// TranscriptRow is one line of command output. Glyph is a kind, not a +// character: the theme resolves it, so the same row reads correctly under +// --ascii and under NO_COLOR. +type TranscriptRow struct { + Glyph string + Text string + Dim bool + Bold bool +} + +// Transcript is the home screen's bounded output history. +// +// dropped is the honest half of the ring: when rows fall off the top the view +// says so. Silent truncation reads as "this is everything", which is exactly +// the wrong thing to believe while reading a gateway's output. +type Transcript struct { + rows []TranscriptRow + dropped bool +} + +// Push appends rows, dropping the oldest past the ring bound and recording +// that it did so, so the view can say output was lost. +func (tr *Transcript) Push(rows ...TranscriptRow) { + tr.rows = append(tr.rows, rows...) + if n := len(tr.rows) - transcriptMax; n > 0 { + tr.rows = append(tr.rows[:0], tr.rows[n:]...) + tr.dropped = true + } +} + +// Reset empties the ring, drop marker included: a cleared transcript has +// dropped nothing. +func (tr *Transcript) Reset() { *tr = Transcript{} } + +// Len reports how many rows are currently retained. +func (tr *Transcript) Len() int { return len(tr.rows) } + +// view renders exactly h lines at most w cells wide — the pane's contract, and +// what keeps the composer anchored to the bottom of the screen. +func (tr *Transcript) view(th theme.Theme, w, h int) string { + if h <= 0 { + return "" + } + rows, clipped := tr.rows, tr.dropped + if len(rows) > h { + clipped = true + } + if clipped { + // The marker costs a line, so the window it announces is one shorter. + if len(rows) > h-1 { + rows = rows[len(rows)-max(h-1, 0):] + } + } + + lines := make([]string, 0, h) + if clipped { + lines = append(lines, dropMarker(th, w)) + } + gw := glyphWidth(th) + for _, r := range rows { + lines = append(lines, r.render(th, w, gw)) + } + for len(lines) < h { + lines = append(lines, "") + } + return strings.Join(lines[:h], "\n") +} + +func (r TranscriptRow) render(th theme.Theme, w, gw int) string { + text := th.Text + switch r.Glyph { + case kindBad: + text = th.Bad + case kindWarn: + text = th.Warn + } + if r.Dim { + text = th.Dim + } + if r.Bold { + text = text.Bold(th.Mode.Color) + } + line := padRight(glyphCell(th, r.Glyph), gw) + " " + text.Render(r.Text) + // A row wider than the pane is cut, never wrapped — wrapping would break + // the pane's line count and every frame below it. The marker is what keeps + // the cut from reading as the end of the row. + return ansi.Truncate(line, w, cutMark(th)) +} + +func cutMark(th theme.Theme) string { + if th.Mode.ASCII { + return ">" + } + return "…" +} + +// glyphCell resolves a row's kind into a styled glyph. An unrecognised kind is +// rendered as written, which is how kindCmd and any future literal marker work. +func glyphCell(th theme.Theme, kind string) string { + g := th.Mode.Glyphs() + switch kind { + case "": + return "" + case kindOK: + return th.OK.Render(g.OK) + case kindWarn: + return th.Warn.Render(g.Warn) + case kindBad: + return th.Bad.Render(g.Bad) + case kindNote: + return th.Dim.Render(g.None) + default: + return th.Dim.Render(kind) + } +} + +// glyphWidth is the glyph column: one cell for the unicode set, four for the +// ASCII set's widest member ("[OK]"). Measured, never assumed — and measured +// over EVERYTHING glyphCell can put in the column, which is the four mapped +// glyphs plus the literal kinds it renders as written. A set that widens a +// glyph nothing measured shifts every row's text by the difference. +func glyphWidth(th theme.Theme) int { + g := th.Mode.Glyphs() + return max( + lipgloss.Width(g.OK), lipgloss.Width(g.Bad), + lipgloss.Width(g.Warn), lipgloss.Width(g.None), + lipgloss.Width(kindCmd), 1) +} + +func dropMarker(th theme.Theme, w int) string { + label := " older output dropped " + rule := "─" + if th.Mode.ASCII { + rule = "-" + } + fill := max((w-lipgloss.Width(label))/2, 1) + side := strings.Repeat(rule, fill) + return ansi.Truncate(th.Faint.Render(side)+th.Dim.Render(label)+th.Faint.Render(side), w, "") +} diff --git a/internal/tui/transcript_test.go b/internal/tui/transcript_test.go new file mode 100644 index 0000000..81f8f75 --- /dev/null +++ b/internal/tui/transcript_test.go @@ -0,0 +1,104 @@ +package tui + +import ( + "strings" + "testing" + + "charm.land/lipgloss/v2" + + "github.com/ferro-labs/gateway-cli/internal/tui/theme" +) + +func TestTranscriptRingAndDropMarker(t *testing.T) { + var tr Transcript + for i := range 70 { + tr.Push(TranscriptRow{Text: "row " + string(rune('a'+i%26))}) + } + if tr.Len() != transcriptMax { + t.Fatalf("the transcript is a %d-row ring, got %d", transcriptMax, tr.Len()) + } + v := tr.view(theme.New(theme.Mode{}), 60, 80) + if !strings.Contains(v, "older output dropped") { + t.Fatalf("dropped rows must be announced, not silently swallowed:\n%s", v) + } +} + +// A window narrower than the transcript hides rows too, and that is the same +// lie: what is on screen is not everything. +func TestTranscriptMarksAWindowThatClips(t *testing.T) { + var tr Transcript + for i := range 10 { + tr.Push(TranscriptRow{Text: "row " + string(rune('a'+i))}) + } + th := theme.New(theme.Mode{}) + if v := tr.view(th, 60, 10); strings.Contains(v, "older output dropped") { + t.Fatalf("a window that shows everything must not claim otherwise:\n%s", v) + } + v := tr.view(th, 60, 4) + if !strings.Contains(v, "older output dropped") { + t.Fatalf("a clipped window must say so:\n%s", v) + } + if !strings.Contains(v, "row j") { + t.Fatalf("a clipped window keeps the newest rows:\n%s", v) + } +} + +// The pane's height is the shell's anchor for the composer: exactly h lines, +// whatever the transcript holds. +func TestTranscriptViewIsExactlyHLines(t *testing.T) { + th := theme.New(theme.Mode{}) + for _, rows := range []int{0, 3, 40} { + var tr Transcript + for i := range rows { + tr.Push(TranscriptRow{Text: strings.Repeat("wide ", i)}) + } + for _, h := range []int{1, 2, 8, 20} { + if got := len(strings.Split(tr.view(th, 50, h), "\n")); got != h { + t.Fatalf("view(%d rows, h=%d) returned %d lines", rows, h, got) + } + } + } + if tr := (Transcript{}); tr.view(th, 50, 0) != "" { + t.Fatal("a zero-height pane renders nothing") + } +} + +func TestTranscriptGlyphColumnAndWidth(t *testing.T) { + for _, mode := range []theme.Mode{{}, {Color: true}, {ASCII: true}, {Color: true, ASCII: true}} { + th := theme.New(mode) + g := mode.Glyphs() + var tr Transcript + tr.Push( + TranscriptRow{Glyph: "$", Text: "ferro status"}, + TranscriptRow{Glyph: "ok", Text: "gateway ready"}, + TranscriptRow{Glyph: "bad", Text: "unknown command"}, + TranscriptRow{Glyph: "warn", Text: "degraded"}, + TranscriptRow{Text: strings.Repeat("long ", 40), Dim: true}, + ) + v := tr.view(th, 40, 6) + for _, want := range []string{"$", g.OK, g.Bad, g.Warn, cutMark(th)} { + if !strings.Contains(v, want) { + t.Fatalf("mode=%+v glyph %q missing:\n%s", mode, want, v) + } + } + for i, line := range strings.Split(v, "\n") { + if lw := lipgloss.Width(line); lw > 40 { + t.Fatalf("mode=%+v line %d overflows: %d cells %q", mode, i, lw, line) + } + } + } +} + +func TestTranscriptResetClearsTheDropMarker(t *testing.T) { + var tr Transcript + for range 70 { + tr.Push(TranscriptRow{Text: "x"}) + } + tr.Reset() + if tr.Len() != 0 { + t.Fatalf("reset must empty the ring, got %d", tr.Len()) + } + if v := tr.view(theme.New(theme.Mode{}), 40, 5); strings.Contains(v, "older output dropped") { + t.Fatalf("a cleared transcript has dropped nothing:\n%s", v) + } +} diff --git a/internal/tui/verbs_cobra_test.go b/internal/tui/verbs_cobra_test.go new file mode 100644 index 0000000..dae4a70 --- /dev/null +++ b/internal/tui/verbs_cobra_test.go @@ -0,0 +1,80 @@ +// This file is deliberately in the external test package: internal/command is +// the package that hands bare `ferro` off to internal/tui, so internal/tui must +// never import it back. An external test may, which is how the TUI's vocabulary +// gets asserted against the real scriptable tree with no import cycle. +package tui_test + +import ( + "bytes" + "slices" + "strings" + "testing" + + "github.com/ferro-labs/gateway-cli/internal/command" + "github.com/ferro-labs/gateway-cli/internal/tui" +) + +// The composer completes what the CLI can actually run. If a verb is added, +// renamed or removed in internal/command, this is where the TUI finds out. +func TestVerbsMatchTheScriptableTree(t *testing.T) { + v := tui.Verbs(command.NewRoot()) + for _, want := range []string{ + "status", "keys", "keys create", "keys rotate", "keys revoke", + "logs", "logs tail", "logs stats", "models", "providers", + "mcp", "plugins", "sessions", "audit", + "services", "chat", "version", + } { + if !slices.Contains(v, want) { + t.Fatalf("the TUI vocabulary has drifted from the cobra tree: missing %q\ngot %v", want, v) + } + } + if slices.Contains(v, "completion") || slices.Contains(v, "help completion") { + t.Fatalf("shell-plumbing commands are not TUI verbs, got %v", v) + } +} + +// tui.TableRows and command.Printer.Table both call internal/table's shared +// layout now (table.Rows and table.Write, the latter also underneath the +// former), so the two sides of this comparison can no longer drift on their +// own — the whole point of moving the layout into that leaf package. This +// test earns its keep anyway, cheaply, as the trip-wire against the failure +// mode that motivated the move: it fails the moment either call site stops +// routing through internal/table and grows a layout — or a special case — of +// its own again, which is exactly how the two copies drifted before. The +// Dim-row assertions below are independent of the parity question and still +// exercise the console's own furniture-vs-output contract. +func TestConsoleTableMatchesThePipedTable(t *testing.T) { + headers := []string{"NAME", "READY", "REQUIRED", "LAST ERROR"} + cells := [][]string{ + {"filesystem", "yes", "no", "-"}, + {"search", "no", "yes", "dial tcp: connection refused"}, + {"a-considerably-longer-server-name", "yes", "no", "-"}, + } + + var buf bytes.Buffer + (&command.Printer{Out: &buf}).Table(headers, cells) + piped := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n") + for i, line := range piped { + // The console trims the trailing padding the last column carries; + // nothing else about the two layouts may differ. + piped[i] = strings.TrimRight(line, " ") + } + + rows := tui.TableRows(headers, cells) + console := make([]string, 0, len(rows)) + for _, r := range rows { + console = append(console, r.Text) + } + + if !slices.Equal(console, piped) { + t.Fatalf("the console table has drifted from the piped one:\nconsole: %q\npiped: %q", console, piped) + } + if len(rows) < 2 || !rows[0].Dim || !rows[1].Dim { + t.Fatalf("the heading and its rule are furniture and must be dimmed, got %+v", rows[:min(2, len(rows))]) + } + for _, r := range rows[2:] { + if r.Dim { + t.Fatalf("a data row is the output, not furniture: %+v", r) + } + } +} diff --git a/internal/version/version.go b/internal/version/version.go new file mode 100644 index 0000000..c80e6f4 --- /dev/null +++ b/internal/version/version.go @@ -0,0 +1,19 @@ +// Package version holds build metadata injected via -ldflags, mirroring the +// gateway's internal/version so release tooling stays uniform across the two +// projects. +package version + +import "fmt" + +// Version, Commit, and Date are overwritten at link time by the release +// build. The defaults below are what a plain `go build` or `go run` reports. +var ( + Version = "dev" + Commit = "none" + Date = "unknown" +) + +// String renders the full build stamp for `ferro version`. +func String() string { + return fmt.Sprintf("%s (commit %s, built %s)", Version, Commit, Date) +} diff --git a/itest/itest_test.go b/itest/itest_test.go new file mode 100644 index 0000000..89df09f --- /dev/null +++ b/itest/itest_test.go @@ -0,0 +1,459 @@ +//go:build integration + +// Package itest checks ferro's typed client against a running gateway. +// A decode failure indicates that the client is incompatible with the +// gateway response. +// +// Every test skips cleanly when FERRO_ITEST_URL is unset, so +// `go test -tags integration ./itest/` is always safe to run. Boot a gateway +// and run the suite with ./scripts/with-gateway.sh. +package itest + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "strings" + "testing" + "time" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +func client(t *testing.T) *api.Client { + t.Helper() + u := os.Getenv("FERRO_ITEST_URL") + if u == "" { + t.Skip("FERRO_ITEST_URL not set") + } + c, err := api.New(u, os.Getenv("FERRO_ITEST_KEY")) + if err != nil { + t.Fatal(err) + } + return c +} + +// raw fetches a path with no decoding, so a failure can quote what the gateway +// actually sent rather than only how the typed decode objected to it. +func raw(t *testing.T, p string) (int, []byte) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + req, err := http.NewRequestWithContext(ctx, http.MethodGet, + strings.TrimRight(os.Getenv("FERRO_ITEST_URL"), "/")+p, nil) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Accept", "application/json") + if k := os.Getenv("FERRO_ITEST_KEY"); k != "" { + req.Header.Set("Authorization", "Bearer "+k) + } + resp, err := (&http.Client{Timeout: 15 * time.Second}).Do(req) + if err != nil { + t.Fatalf("GET %s: %v", p, err) + } + defer func() { _ = resp.Body.Close() }() + b, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + t.Fatalf("GET %s: read body: %v", p, err) + } + return resp.StatusCode, b +} + +func TestStatusAgainstRealGateway(t *testing.T) { + r, err := client(t).Status(context.Background()) + if err != nil { + t.Fatalf("status: %v (report %+v)", err, r) + } + // Providers is deliberately NOT asserted non-zero: a gateway booted with no + // provider credentials reports no_providers and zero targets, which is the + // state this suite runs in by default. + if r.State == "unreachable" { + t.Fatalf("expected a live gateway, got %+v", r) + } + if r.URL == "" || r.State == "" { + t.Fatalf("status report is not usable: %+v", r) + } + // Targets is nil when /readyz answered 503 — its not_ready body carries no + // targets array at all. That is the default state of this harness (no + // provider credentials), so this is the common path here, not the edge one. + targets := "—" + if r.Targets != nil { + targets = fmt.Sprintf("%d/%d", r.Targets.Routable, r.Targets.Total) + } + t.Logf("status: state=%s providers=%d models=%d targets=%s auth=%q warnings=%v", + r.State, r.Providers, r.Models, targets, r.Auth, r.Warnings) +} + +// A gateway with no routable targets must never report a target count. The +// client cannot know one: /readyz 503s with only {status, reason}. Reporting +// 0/0 would read as "none configured" when the truth is "none routable", and +// this suite runs in exactly that state, so the assertion is always live. +func TestNotReadyGatewayReportsNoTargetCount(t *testing.T) { + r, err := client(t).Status(context.Background()) + if err != nil { + t.Fatal(err) + } + ready, status, err := client(t).Ready(context.Background()) + if err != nil { + t.Fatal(err) + } + if status == http.StatusServiceUnavailable { + if len(ready.Targets) != 0 { + t.Fatalf("a not_ready body must carry no targets, got %d", len(ready.Targets)) + } + if r.Targets != nil { + t.Fatalf("Status must leave Targets nil when the gateway reported none, got %+v", r.Targets) + } + if len(r.Warnings) == 0 { + t.Fatal("a not-ready gateway must explain itself in warnings") + } + } +} + +func TestKeyLifecycle(t *testing.T) { + c := client(t) + if os.Getenv("FERRO_ITEST_KEY") == "" { + t.Skip("needs admin key") + } + ctx := context.Background() + exp := time.Now().Add(1 * time.Hour).UTC() + created, err := c.CreateKey(ctx, api.KeyCreateRequest{ + Name: "ferro-itest", Scopes: []string{"read_only"}, ExpiresAt: &exp, + }) + if err != nil { + t.Fatal(err) + } + // Deferred so a failure below never leaves a live credential behind. + defer func() { _ = c.RevokeKey(ctx, created.ID) }() + + if !strings.HasPrefix(created.Key, "fgw_") || strings.Contains(created.Key, "...") { + t.Fatalf("create response did not contain a valid one-time secret (length=%d, masked=%v)", + len(created.Key), strings.Contains(created.Key, "...")) + } + if created.ID == "" || api.KeyState(*created) != "active" { + t.Fatalf("created key is not usable: id_present=%v state=%s", created.ID != "", api.KeyState(*created)) + } + + got, err := c.Key(ctx, created.ID) + if err != nil { + t.Fatalf("read back %s: %v", created.ID, err) + } + if got.Key == created.Key || strings.Contains(got.Key, strings.TrimPrefix(created.Key, "fgw_")) { + t.Fatalf("read-back leaked the full one-time secret for key id %s", created.ID) + } + if !strings.Contains(got.Key, "...") { + t.Fatalf("read-back must be masked for key id %s", created.ID) + } + if s := api.KeyState(*got); s != "active" { + t.Fatalf("state after create = %q, want active for key id %s", s, created.ID) + } + + rotated, err := c.RotateKey(ctx, created.ID) + if err != nil { + t.Fatalf("rotate: %v", err) + } + if !strings.HasPrefix(rotated.Key, "fgw_") || strings.Contains(rotated.Key, "...") { + t.Fatalf("rotate response did not contain a valid one-time secret (length=%d, masked=%v)", + len(rotated.Key), strings.Contains(rotated.Key, "...")) + } + if rotated.Key == created.Key { + t.Fatal("rotate returned the previous secret") + } + + if err := c.RevokeKey(ctx, created.ID); err != nil { + t.Fatalf("revoke: %v", err) + } + after, err := c.Key(ctx, created.ID) + if err != nil { + if !api.IsNotSupported(err) { // a store that deletes on revoke would 404 + t.Fatalf("read back after revoke: %v", err) + } + return + } + if s := api.KeyState(*after); s != "revoked" { + t.Fatalf("state after revoke = %q, want revoked for key id %s", s, created.ID) + } +} + +// TestAdminKeysWireShape asserts the two shapes internal/fixture hard-codes. +// A disagreement here means the local fixture must be reconciled with the +// running gateway before it can support other CLI tests. +func TestAdminKeysWireShape(t *testing.T) { + c := client(t) + if os.Getenv("FERRO_ITEST_KEY") == "" { + t.Skip("needs admin key") + } + + status, body := raw(t, "/admin/keys") + if status != http.StatusOK { + t.Fatalf("GET /admin/keys = %d: %s", status, body) + } + var arr []json.RawMessage + if err := json.Unmarshal(body, &arr); err != nil { + t.Fatalf("/admin/keys is not a bare array (%v).\nredacted JSON: %s", err, safeBody(body)) + } + + ctx := context.Background() + created, err := c.CreateKey(ctx, api.KeyCreateRequest{Name: "ferro-itest-shape", Scopes: []string{"read_only"}}) + if err != nil { + t.Fatal(err) + } + defer func() { _ = c.RevokeKey(ctx, created.ID) }() + + listed, err := c.Keys(ctx) + if err != nil { + t.Fatalf("list keys: %v", err) + } + var found *api.Key + for i := range listed { + if listed[i].ID == created.ID { + found = &listed[i] + break + } + } + if found == nil { + t.Fatalf("created key %s is missing from the listing (%d rows)", created.ID, len(listed)) + } + if found.Key == created.Key { + t.Fatalf("SECRET LEAK: /admin/keys serves the full secret for %s", created.ID) + } + if !strings.Contains(found.Key, "...") { + t.Fatalf("listed key %s is not masked head...tail", created.ID) + } +} + +// contract is one endpoint of the parity table. +type contract struct { + path string + optional bool // may answer 404/501 on a build without the feature + call func(context.Context, *api.Client) (any, error) +} + +// TestContractParity calls every endpoint ferro reads through the typed client +// and asserts it decodes. A decode failure means internal/api's types have +// drifted from the gateway — the whole reason this suite exists. +func TestContractParity(t *testing.T) { + c := client(t) + + cases := []contract{ + {path: "/health", call: func(ctx context.Context, c *api.Client) (any, error) { + r, _, err := c.Health(ctx) + return r, err + }}, + {path: "/readyz", call: func(ctx context.Context, c *api.Client) (any, error) { + r, _, err := c.Ready(ctx) + return r, err + }}, + {path: "/admin/health", call: func(ctx context.Context, c *api.Client) (any, error) { + return c.AdminHealth(ctx) + }}, + {path: "/v1/models", call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Models(ctx) + }}, + {path: "/admin/keys", call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Keys(ctx) + }}, + {path: "/admin/logs", optional: true, call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Logs(ctx, api.LogsQuery{Limit: 5}) + }}, + {path: "/admin/logs/stats", optional: true, call: func(ctx context.Context, c *api.Client) (any, error) { + return c.LogStats(ctx, api.LogsQuery{}) + }}, + {path: "/admin/plugins", call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Plugins(ctx) + }}, + {path: "/admin/plugins/catalog", call: func(ctx context.Context, c *api.Client) (any, error) { + return c.PluginCatalog(ctx) + }}, + {path: "/admin/sessions", optional: true, call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Sessions(ctx) + }}, + {path: "/admin/audit", optional: true, call: func(ctx context.Context, c *api.Client) (any, error) { + return c.Audit(ctx, api.AuditQuery{Limit: 5}) + }}, + } + + authed := os.Getenv("FERRO_ITEST_KEY") != "" + for _, tc := range cases { + t.Run(tc.path, func(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + // /admin/* and /v1/* sit behind the same bearer middleware, so + // without a credential they answer 401 — which proves nothing about + // the payload contract this test exists to check. + if !authed && tc.path != "/health" && tc.path != "/readyz" { + t.Skip("needs FERRO_ITEST_KEY") + } + // The wire bytes, not the round-tripped struct: a decoded struct + // cannot show a field internal/api silently drops, and the point of + // this suite is what the gateway actually sends. + status, body := raw(t, tc.path) + t.Logf("HTTP %d %s", status, safeBody(body)) + + _, err := tc.call(ctx, c) + switch { + case err == nil: + case tc.optional && api.IsNotSupported(err): + t.Logf("absent on this build (expected for an optional endpoint): %v", err) + default: + t.Fatalf("typed client could not read %s: %v\nHTTP %d, redacted JSON: %s", + tc.path, err, status, safeBody(body)) + } + }) + } +} + +// TestPluginCatalogIsPopulated pins the one parity case an empty decode hides: +// /admin/plugins/catalog is fixed for the life of the binary and never empty, +// so a successful decode of zero rows means the envelope moved. +func TestPluginCatalogIsPopulated(t *testing.T) { + c := client(t) + if os.Getenv("FERRO_ITEST_KEY") == "" { + t.Skip("needs admin key") + } + got, err := c.PluginCatalog(context.Background()) + if err != nil { + t.Fatal(err) + } + if len(got) == 0 { + _, body := raw(t, "/admin/plugins/catalog") + t.Fatalf("catalog decoded to zero plugins — the {\"data\":…} envelope has moved.\nredacted JSON: %s", safeBody(body)) + } + for _, p := range got { + if p.Name == "" || p.Type == "" { + t.Fatalf("catalog row is missing name/type: %+v", p) + } + } + t.Logf("catalog: %d built-in plugins", len(got)) +} + +func TestChatStreamAndAttribution(t *testing.T) { + model := os.Getenv("FERRO_ITEST_CHAT_MODEL") + if model == "" { + t.Skip("FERRO_ITEST_CHAT_MODEL not set (needs live provider credentials)") + } + c := client(t) + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute) + defer cancel() + start := time.Now().Add(-2 * time.Minute) + st, err := c.StreamChat(ctx, api.ChatRequest{ + Model: model, + Messages: []api.ChatMessage{{Role: "user", Content: "Reply with the word ok."}}, + }) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + + var text strings.Builder + var sawUsage, sawDone bool + for ev := range st.Events { + switch { + case ev.Err != nil: + t.Fatalf("stream error: %v", ev.Err) + case ev.Done: + sawDone = true + case ev.Chunk != nil: + if ev.Chunk.Usage != nil { + sawUsage = true + } + for _, ch := range ev.Chunk.Choices { + text.WriteString(ch.Delta.Content) + } + } + } + if !sawDone || !sawUsage || text.Len() == 0 { + t.Fatalf("done=%v usage=%v answer_bytes=%d", sawDone, sawUsage, text.Len()) + } + + probeCtx, cancelProbe := context.WithTimeout(ctx, 5*time.Second) + _, err = c.Logs(probeCtx, api.LogsQuery{Limit: 1}) + cancelProbe() + if api.IsNotSupported(err) { + return + } else if err != nil { + t.Fatalf("probe request-log store: %v", err) + } + deadline := time.Now().Add(5 * time.Second) + for { + attributionCtx, cancelAttribution := context.WithTimeout(ctx, 5*time.Second) + entry, err := c.TraceAttribution(attributionCtx, st.RequestID, start) + cancelAttribution() + if err != nil { + t.Fatal(err) + } + if entry != nil { + if entry.Provider == "" { + t.Fatalf("matched log row should attribute a provider: trace=%s", entry.TraceID) + } + return + } + if time.Now().After(deadline) { + t.Fatalf("request-log store is enabled but trace %s was not attributed within 5s", st.RequestID) + } + select { + case <-ctx.Done(): + t.Fatal(ctx.Err()) + case <-time.After(250 * time.Millisecond): + } + } +} + +func safeBody(b []byte) string { + var value any + if json.Unmarshal(b, &value) != nil { + return fmt.Sprintf("<%d non-JSON bytes>", len(b)) + } + redact(value) + b, _ = json.Marshal(value) + const max = 600 + s := strings.TrimSpace(string(b)) + if len(s) > max { + return s[:max] + "… (truncated)" + } + return s +} + +func TestSafeBodyRedactsCompoundCredentials(t *testing.T) { + got := safeBody([]byte(`{ + "access_token":"one", + "nested":{"refresh_token":"two","client_secret":"three"}, + "items":[{"private_key":"four"}], + "apiKey":"five","X-API-Key":"six","sessionToken":"seven", + "note":"visible" + }`)) + for _, secret := range []string{"one", "two", "three", "four", "five", "six", "seven"} { + if strings.Contains(got, secret) { + t.Fatalf("safeBody leaked %q: %s", secret, got) + } + } + if strings.Count(got, "[REDACTED]") != 7 || !strings.Contains(got, "visible") { + t.Fatalf("every compound credential field must be redacted: %s", got) + } +} + +func redact(value any) { + switch value := value.(type) { + case map[string]any: + for key, child := range value { + normalized := strings.ToLower(strings.NewReplacer("_", "", "-", "").Replace(key)) + switch normalized { + case "key", "apikey", "xapikey", "privatekey", + "secret", "clientsecret", "token", "accesstoken", + "refreshtoken", "sessiontoken", "authorization": + value[key] = "[REDACTED]" + default: + redact(child) + } + } + case []any: + for _, child := range value { + redact(child) + } + } +} diff --git a/scripts/check-module-boundary.sh b/scripts/check-module-boundary.sh new file mode 100755 index 0000000..6ab129c --- /dev/null +++ b/scripts/check-module-boundary.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash +set -euo pipefail + +grep -Fxq 'module github.com/ferro-labs/gateway-cli' go.mod + +if grep -RIn --include='*.go' --exclude-dir=.git \ + 'github.com/ferro-labs/ai-gateway' .; then + echo 'gateway-cli must not import AI Gateway packages' >&2 + exit 1 +fi + +if grep -qE '^[[:space:]]*github\.com/ferro-labs/ai-gateway([[:space:]]|$)' go.mod; then + echo 'gateway-cli must not require the AI Gateway module' >&2 + exit 1 +fi diff --git a/scripts/smoke.sh b/scripts/smoke.sh new file mode 100755 index 0000000..2ea000b --- /dev/null +++ b/scripts/smoke.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +# Clean-machine sanity for a built ferro binary. Also the manual release gate. +# +# ./scripts/smoke.sh [path-to-binary] +# FERRO_SMOKE_URL=http://localhost:8080 ./scripts/smoke.sh # adds live checks +set -euo pipefail + +bin="${1:-./ferro}" +[ -x "$bin" ] || { echo "FAIL: $bin is not executable (run: make build)" >&2; exit 1; } + +"$bin" version +"$bin" --help >/dev/null + +# Exit codes are the API: an unknown verb must be a non-zero exit, or every +# `ferro ... || alert` in a pipeline silently passes. +if "$bin" definitely-not-a-verb >/dev/null 2>&1; then + echo "FAIL: unknown verb must exit non-zero" >&2 + exit 1 +fi + +# The full-screen console must never appear on a non-TTY stdout. This runs with +# stdout piped, so a bare invocation has to refuse rather than emit escape codes. +command -v timeout >/dev/null || { echo "FAIL: timeout is required for the non-TTY smoke check" >&2; exit 1; } +set +e +bare_output="$(timeout --signal=TERM --kill-after=1s 5s "$bin" /dev/null)" +bare_status=$? +set -e +if [ "$bare_status" -eq 124 ] || [ "$bare_status" -eq 137 ]; then + echo "FAIL: bare ferro blocked on a non-TTY invocation" >&2 + exit 1 +fi +if [ "$bare_status" -eq 0 ]; then + echo "FAIL: bare ferro must refuse a non-TTY invocation" >&2 + exit 1 +fi +if [[ "$bare_output" == *$'\e['* ]]; then + echo "FAIL: bare ferro emitted ANSI on a non-TTY stdout" >&2 + exit 1 +fi + +if [ -n "${FERRO_SMOKE_URL:-}" ]; then + FERRO_URL="$FERRO_SMOKE_URL" "$bin" status + # stdout must be exactly one JSON document — nothing else may leak into it. + FERRO_URL="$FERRO_SMOKE_URL" "$bin" status --format json | python3 -m json.tool >/dev/null + echo "[OK] live smoke against $FERRO_SMOKE_URL" +fi + +echo "[OK] smoke passed" diff --git a/scripts/with-gateway.sh b/scripts/with-gateway.sh new file mode 100755 index 0000000..c44da3f --- /dev/null +++ b/scripts/with-gateway.sh @@ -0,0 +1,99 @@ +#!/usr/bin/env bash +# Boot an AI Gateway checkout, run the ferro integration suite against it, and +# always tear it down. +# +# FERRO_GATEWAY_SOURCE=../ai-gateway ./scripts/with-gateway.sh +# +# This is the one check the fixture (cmd/fakegw) cannot perform. The fixture +# proves ferro is correct given a gateway that behaves as documented; only this +# proves the real server agrees. Any divergence found here is a FIXTURE bug: +# fix internal/fixture to match the gateway, then re-run. +# +# No provider credentials are required. The gateway starts with zero targets +# and reports no_providers, which is enough to exercise status, keys, logs, +# sessions, and audit — everything except live chat. +set -euo pipefail + +cli="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +gateway_source="${FERRO_GATEWAY_SOURCE:-}" +if [ -z "$gateway_source" ]; then + candidate="$(cd "$cli/.." && pwd)/ai-gateway" + if [ -f "$candidate/go.mod" ] && grep -q '^module github.com/ferro-labs/ai-gateway$' "$candidate/go.mod"; then + gateway_source="$candidate" + else + echo "FERRO_GATEWAY_SOURCE must point to an AI Gateway checkout" >&2 + exit 2 + fi +fi +gateway_source="$(cd "$gateway_source" && pwd)" +work="$(mktemp -d)" +port="${FERRO_ITEST_PORT:-18080}" +gw_pid="" + +# A hex master key of the shape the gateway expects (fgw_ + 32 hex chars). +key="fgw_$(od -An -tx1 -N16 /dev/urandom | tr -d ' \n')" + +cleanup() { + if [ -n "$gw_pid" ]; then + kill "$gw_pid" 2>/dev/null || true + wait "$gw_pid" 2>/dev/null || true + fi + rm -rf "$work" +} +trap cleanup EXIT + +echo "==> building ferrogw from $gateway_source" +(cd "$gateway_source" && go build -o "$work/ferrogw" ./cmd/ferrogw) + +echo "==> scaffolding a throwaway config" +# init writes a config and prints a master key once; we supply our own key via +# the environment instead, so a failure here is not fatal. +(cd "$work" && "$work/ferrogw" init -o "$work/gateway.yaml" --non-interactive >/dev/null 2>&1) \ + || echo " (init declined; starting with an empty config)" + +echo "==> starting gateway on :$port" +# A throwaway SQLite request log. Without it /admin/logs and /admin/logs/stats +# answer 501 and the suite can only prove they are absent -- and those two carry +# the most intricate types in internal/api (nullable duration_ms/ttft_ms/cost_usd, +# a nullable percentile block). One file in the temp dir turns two skipped rows +# into real decode checks. +MASTER_KEY="$key" GATEWAY_CONFIG="$work/gateway.yaml" PORT="$port" \ + REQUEST_LOG_STORE_BACKEND=sqlite REQUEST_LOG_STORE_DSN="$work/requestlog.db" \ + "$work/ferrogw" serve >"$work/gateway.log" 2>&1 & +gw_pid=$! + +# /health answers 503 with {"status":"no_providers"} when no provider credential +# is present -- which is exactly how this harness runs -- so `curl -f` is the +# wrong probe: it reports a serving gateway as dead. Ask for the status code +# instead and accept either answer the endpoint can give. +healthy() { + local code + code="$(curl -sS --connect-timeout 1 --max-time 1 -o /dev/null -w '%{http_code}' "http://localhost:$port/health" 2>/dev/null)" || return 1 + [ "$code" = "200" ] || [ "$code" = "503" ] +} + +startup_deadline=$((SECONDS + 15)) +while (( SECONDS < startup_deadline )); do + # A gateway that died is never coming up; fail fast instead of waiting out + # the whole loop or accepting another process already bound to the port. + if ! kill -0 "$gw_pid" 2>/dev/null; then + echo "gateway exited during startup; log follows:" >&2 + cat "$work/gateway.log" >&2 + exit 1 + fi + if healthy; then + break + fi + sleep 0.25 +done + +if ! healthy; then + echo "gateway did not become healthy within 15s; log follows:" >&2 + cat "$work/gateway.log" >&2 + exit 1 +fi + +echo "==> running the integration suite" +cd "$cli" +FERRO_ITEST_URL="http://localhost:$port" FERRO_ITEST_KEY="$key" \ + go test -race -tags integration ./itest/ "$@" From 22cdf29c266aa1c01d33d7885fcaf1b9003e9e31 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 15:26:34 +0530 Subject: [PATCH 02/28] docs: simplify v0.1.0 changelog for first release --- CHANGELOG.md | 106 +++++++++++++++++++-------------------------------- 1 file changed, 40 insertions(+), 66 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 620e6a4..290039d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,73 +8,47 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ## v0.1.0 — 2026-08-14 -First standalone release. The project ships a single binary, `ferro`, carrying -two surfaces over one HTTP client: scriptable commands and a full-screen -operations console. Requires AI Gateway v1.4.2 or later. +First release. One binary, `ferro`, with two surfaces over a single HTTP client: +scriptable commands for automation, and a full-screen console for operators. +Requires AI Gateway v1.4.2 or later. ### Added -- **Standalone distribution** from repository `ferro-labs/gateway-cli` and Go - module `github.com/ferro-labs/gateway-cli`. -- **Scriptable commands**, all honouring `--format table|json|yaml`: `status`, - `models`, `providers`, `mcp`, `plugins`, `services`, `sessions`, `audit`, - `keys list|get|create|rotate|revoke`, `logs list|stats|tail`, `chat`, and - `version`. -- **Full-screen console** on bare `ferro` at a TTY: a framed layout with a - connection header, a providers/services left rail, target and traffic - summaries, a bounded command transcript, and a command composer with - completion, ghost hints, history, and reverse search (`ctrl+r`). Screens: - Home, Request logs, Keys, Playground. -- **Request-log tail** — a since-cursor follower with deduplication and - exponential backoff, in both `logs tail` and the console's logs screen, with +- **Commands** — `status`, `models`, `providers`, `mcp`, `plugins`, `services`, + `sessions`, `audit`, `keys list|get|create|rotate|revoke`, + `logs list|stats|tail`, `chat`, and `version`. Every one supports + `--format table|json|yaml`. +- **Console** — run bare `ferro` at a TTY for a full-screen operations view with + four screens: Home, Request logs, Keys, and Playground. Includes a command + composer with completion, history, and reverse search (`ctrl+r`). +- **Request-log tail** — follow live traffic in `logs tail` or the console, with filters for time, model, provider, stage, and credential. -- **Key management** with derived state (`active` / `expired` / `revoked`) from - `revoked_at`, `expires_at`, and `active`; a create wizard and - typed-confirmation rotate and revoke in the console. -- **Playground** — streaming chat with batched rendering, `/model` and - `/clear`, and a metadata line carrying usage plus route and cost when the - gateway can supply them. -- **Connection profiles** at `os.UserConfigDir()/ferro/config.yaml`, holding - connection details only. Resolution precedence — URL: `--gateway-url` > - `FERRO_URL` > `profile.url` > `http://localhost:8080`; key: `FERRO_API_KEY` > - `profile.api_key_env` deref > `MASTER_KEY`. Credentials never enter process - arguments or shell history through a flag. -- **Persistent flags** `--gateway-url`, `--profile`, `--format`, `--ascii`; - `NO_COLOR` support alongside TTY and `TERM=dumb` detection. - -### Fixed - -- Request-log tails now drain every bounded page before advancing their cursor, - preventing bursts larger than one page from being skipped. -- Silent chat connections now end with a structured stream-timeout error, and - interrupted JSON or YAML chats emit their partial document before exiting. -- Playground action notes are excluded from model history, prompt history is - retained only for recognized commands, and long sessions remain bounded. -- Key actions entered on a newly opened console wait for the current key list, - so names and selections resolve against fresh gateway state. -- Stale profile selections now fail with a clear error instead of silently - falling back to the local gateway URL. - -### Contracts - -- stdout is the machine channel; narrative, warnings, and errors go to stderr, - so `--format json` output is always safe to pipe. -- Exit codes are the API: `status` exits 1 only when the gateway is unreachable; - a reachable-but-degraded gateway exits 0 and prints its degraded state. -- Redirects are surfaced, never followed; a non-2xx response is always a - failure; an empty 2xx body where a payload was expected is an error; 503 is - decoded rather than errored only where degraded-state bodies are the contract. -- Secrets from `keys create` and `keys rotate` are shown exactly once, on - stdout, and never enter the console transcript or command history. -- Absent measurements render `-`, never `0`. Endpoints the gateway does not - serve (404 / 501) disable a panel with a hint instead of ending the command. -- The console holds no durable state; everything re-derives from the API. - -### Notes - -- The console's gateway-version slot renders `—`: the gateway does not serve its - version over HTTP. -- The traffic panel and streaming route attribution are derived from the request - log, and render as unavailable when no request-log store is configured. -- Not in this release: the config viewer / history / rollback screen, the - provider capability matrix, the doctor checklist, and the init wizard. +- **Key management** — list, create, rotate, and revoke API keys, with derived + `active` / `expired` / `revoked` state. New secrets are printed once, to + stdout, and never enter the console transcript or history. +- **Playground** — streaming chat against the gateway with `/model` and + `/clear`, showing token usage plus route and cost when available. +- **Connection profiles** at `os.UserConfigDir()/ferro/config.yaml`. URL + resolution: `--gateway-url` > `FERRO_URL` > profile > `http://localhost:8080`. + Key resolution: `FERRO_API_KEY` > profile `api_key_env` > `MASTER_KEY`. Keys + are never passed as flags, so they stay out of shell history. +- **Global flags** `--gateway-url`, `--profile`, `--format`, `--ascii`, plus + `NO_COLOR`, TTY, and `TERM=dumb` detection. + +### Output contract + +- stdout carries data; narration, warnings, and errors go to stderr — so + `--format json` is always safe to pipe. +- `status` exits 1 only when the gateway is unreachable. A reachable but + degraded gateway exits 0 and reports its degraded state. +- Missing measurements render `-`, never `0`. Endpoints the gateway does not + serve disable that panel with a hint instead of failing the command. + +### Known limitations + +- The gateway does not report its version over HTTP, so the console's version + slot renders `—`. +- The traffic panel and route attribution come from the request log, and show as + unavailable when no request-log store is configured. +- Not yet shipped: config viewer / history / rollback, provider capability + matrix, doctor checklist, and init wizard. From 15b87b9cf3d2d88080b8edad8df8c29fc3181b80 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 18:18:48 +0530 Subject: [PATCH 03/28] feat(tui): rework the wide home header Fold the split-F two art rows to a text row with half blocks, so the canonical seven rows land in four and the mark stands level with the text beside it instead of towering over it. The fold is exact -- no art row is dropped or merged -- and it leaves room for the rounded panel that keeps the mark off the screen's corner. Move the connection readout to its own right-hand column: state, origin and round trip, one fact per line, measured to sit flush against the last cell of the screen at any width. The stack is the column that truncates, because it is the one that can lose a character without losing a fact. Both headers now read the state through a shared stateGlyph, so the compact one-line form and the wide block can never disagree about what the gateway is doing. --- docs/{demo.gif => console.gif} | Bin internal/tui/app.go | 98 ++++++++++++++++++++++++------- internal/tui/app_test.go | 19 ++++++ internal/tui/theme/theme.go | 82 ++++++++++++++++++++++++-- internal/tui/theme/theme_test.go | 35 +++++++++++ 5 files changed, 208 insertions(+), 26 deletions(-) rename docs/{demo.gif => console.gif} (100%) diff --git a/docs/demo.gif b/docs/console.gif similarity index 100% rename from docs/demo.gif rename to docs/console.gif diff --git a/internal/tui/app.go b/internal/tui/app.go index a63a01f..5ee847a 100644 --- a/internal/tui/app.go +++ b/internal/tui/app.go @@ -52,6 +52,7 @@ const ( mediumMin = 80 // compact brand + STATUS frame railWidth = 34 railGap = 2 + markGap = 3 // between the mark panel and the text stack beside it // minSplitWidth is the narrowest main frame that can carry the // TARGETS│TRAFFIC split header with both titles and a closing rule. @@ -375,18 +376,42 @@ func (a *App) render() string { return b.String() } -// viewBrandBlock is the wide home header: the split-F mark beside the text -// stack. Every value in it is real — see stateLine and originLine. +// viewBrandBlock is the wide home header: the split-F panel, the text stack, +// and the connection readout flush against the right edge. Identity reads +// left, live state reads right, and the two never compete for the same line. +// Every value in it is real — see stateBlock and originLine. func (a *App) viewBrandBlock() string { - stackW := max(a.Width-lipgloss.Width(theme.Mark(a.Theme))-3, 10) - stack := strings.Join(clampLines([]string{ + mark := theme.Mark(a.Theme) + state := a.stateBlock() + stateW := 0 + for _, l := range state { + stateW = max(stateW, lipgloss.Width(l)) + } + // The three columns are measured to total exactly a.Width, so the readout + // lands on the last cell of the screen however long the URL is; the stack + // is the column that gives, because it is the one that can truncate + // without losing a fact. + stackW := max(a.Width-lipgloss.Width(mark)-markGap-stateW, 10) + stack := clampLines([]string{ a.brand() + " " + a.Theme.Dim.Render(version.Version), a.Theme.Border.Render(a.rule(10)), a.Theme.Text.Render("AI Gateway"), - a.stateLine(), a.Theme.Dim.Render(a.originLine()), - }, stackW), "\n") - return lipgloss.JoinHorizontal(lipgloss.Top, theme.Mark(a.Theme), " ", stack) + }, stackW) + for i, l := range stack { + stack[i] = padRight(l, stackW) + } + // One blank row first: the readout sits against the stack's body rather + // than level with the wordmark, which owns the top line alone. + col := []string{""} + for _, l := range state { + col = append(col, padLeft(l, stateW)) + } + // Centred: the panel stands one row taller than the text at each end, so + // the stack sits inside its span rather than hanging off its top border. + return lipgloss.JoinHorizontal(lipgloss.Center, + mark, strings.Repeat(" ", markGap), + strings.Join(stack, "\n"), strings.Join(col, "\n")) } // compactBrand is the one-line header every other width and screen gets: the @@ -402,25 +427,54 @@ func (a *App) brand() string { return a.Theme.Bright.Bold(a.Theme.Mode.Color).Render("Ferro Labs") } -// stateLine is the connection readout: glyph and colour from the report's own -// state, then profile, URL and the client-measured round trip. When the last -// poll failed the line keeps its data and gains a staleness age. -func (a *App) stateLine() string { +// stateGlyph is the connection state as glyph, label and colour, taken from +// the report's own state. Both headers read it, so the compact line and the +// wide block can never disagree about what the gateway is doing. +func (a *App) stateGlyph() (string, string, lipgloss.Style) { g := a.Theme.Mode.Glyphs() - glyph, label, style := g.None, "connecting", a.Theme.Dim - if a.Status != nil { - switch a.Status.State { - case stateConnected: - glyph, label, style = g.Dot, stateConnected, a.Theme.OK - case stateDegraded: - glyph, label, style = g.Warn, stateDegraded, a.Theme.Warn - default: - glyph, label, style = g.Bad, a.Status.State, a.Theme.Bad + if a.Status == nil { + if a.StatusErr != nil { + return g.Bad, stateUnreachable, a.Theme.Bad } - } else if a.StatusErr != nil { - glyph, label, style = g.Bad, stateUnreachable, a.Theme.Bad + return g.None, "connecting", a.Theme.Dim } + switch a.Status.State { + case stateConnected: + return g.Dot, stateConnected, a.Theme.OK + case stateDegraded: + return g.Warn, stateDegraded, a.Theme.Warn + } + return g.Bad, a.Status.State, a.Theme.Bad +} +// stateBlock is the wide header's right-hand readout: state, origin, round +// trip — one fact per line so the eye lands on the state before the URL. Same +// data stateLine carries, laid out for a column instead of a line. +func (a *App) stateBlock() []string { + glyph, label, style := a.stateGlyph() + origin := a.url() + if a.Profile.ProfileName != "" { + origin = a.Profile.ProfileName + " · " + origin + } + lines := []string{style.Render(glyph + " " + label), a.Theme.Dim.Render(origin)} + // A failed poll takes the third line: how old the data is matters more + // than how fast the request that fetched it was. + switch { + case a.StatusErr != nil && !a.StatusAt.IsZero(): + lines = append(lines, a.Theme.Dim.Render(fmt.Sprintf("stale %ds", int(time.Since(a.StatusAt).Seconds())))) + case a.StatusErr != nil: + lines = append(lines, a.Theme.Dim.Render("stale")) + case a.Status != nil && a.Status.LatencyMs > 0: + lines = append(lines, a.Theme.Dim.Render(fmt.Sprintf("%dms round trip", a.Status.LatencyMs))) + } + return lines +} + +// stateLine is the one-line connection readout: glyph and colour from the +// report's own state, then profile, URL and the client-measured round trip. +// When the last poll failed the line keeps its data and gains a staleness age. +func (a *App) stateLine() string { + glyph, label, style := a.stateGlyph() parts := []string{} if a.Profile.ProfileName != "" { parts = append(parts, a.Profile.ProfileName) diff --git a/internal/tui/app_test.go b/internal/tui/app_test.go index ca43622..99db307 100644 --- a/internal/tui/app_test.go +++ b/internal/tui/app_test.go @@ -303,6 +303,25 @@ func TestHeaderRendersRealStatusOnly(t *testing.T) { } } +// The header's three columns are measured, not spaced by eye: the readout has +// to land on the last cell of the screen at any width, or it drifts away from +// the right edge the moment a URL or a profile name changes length. +func TestHeaderReadoutIsFlushRight(t *testing.T) { + for _, w := range []int{110, 126, 200} { + a := testApp(w, 40) + for i, line := range strings.Split(a.viewBrandBlock(), "\n") { + if got := lipgloss.Width(line); got != w { + t.Fatalf("width %d: header row %d is %d cells, must fill exactly %d:\n%q", w, i, got, w, line) + } + } + want := "23ms round trip" + row := findRow(a.viewBrandBlock(), want) + if !strings.HasSuffix(row, want) { + t.Fatalf("width %d: readout must sit flush right, got %q", w, row) + } + } +} + func TestUnreachableStateGetsBadGlyph(t *testing.T) { a := testApp(126, 40) a.Status = &api.StatusReport{State: "unreachable", URL: "http://localhost:8080"} diff --git a/internal/tui/theme/theme.go b/internal/tui/theme/theme.go index 8e9479f..700608b 100644 --- a/internal/tui/theme/theme.go +++ b/internal/tui/theme/theme.go @@ -183,14 +183,88 @@ var MarkRows = []string{ markStem, } -// Mark renders the split-F in the accent color. +// Mark is the split-F in a rounded panel, drawn two art rows to a text row. +// +// A terminal cell is about twice as tall as it is wide, so the art drawn one +// row per row stands seven lines high — nine inside a panel — beside four +// lines of header text, and reads as a billboard. Half blocks fold it: ▀ inks +// the top half of a cell and ▄ the bottom, so each text row carries two art +// rows and the panel lands six rows over fourteen columns, close enough to +// square on screen. The fold is exact, not a downsample; no art row is dropped +// or merged away. +// +// The panel is what keeps the mark off the screen's corner: without it the art +// starts on the first cell of the first row with nothing around it. +// +// Under --ascii there are no half blocks and no panel — 2h falls below +// minFrameWidth, so FrameRound hands back the letter the mark degrades to. func Mark(t Theme) string { if t.Mode.ASCII { return t.Accent.Render("F") } - rows := make([]string, len(MarkRows)) - for i, r := range MarkRows { + art := foldedArt() + widest := 0 + for _, r := range art { + widest = max(widest, lipgloss.Width(r)) + } + rows := make([]string, len(art)) + for i, r := range art { rows[i] = t.Accent.Render(r) } - return strings.Join(rows, "\n") + // widest + 4: the panel's two border cells and the padding cell FrameRound + // sets inside each of them. + return t.FrameRound(strings.Join(rows, "\n"), widest+4) +} + +// foldedArt is the canonical rows paired off into half-block text rows. +func foldedArt() []string { + art := markArt() + rows := make([]string, 0, (len(art)+1)/2) + for i := 0; i < len(art); i += 2 { + bottom := "" // an odd row count leaves the last text row a top half only + if i+1 < len(art) { + bottom = art[i+1] + } + rows = append(rows, fold(art[i], bottom)) + } + return rows +} + +// fold merges two art rows into one text row of half blocks: a cell is full +// when both rows ink it, a top or bottom half when one does, blank when +// neither. +func fold(topRow, bottomRow string) string { + top, bottom := []rune(topRow), []rune(bottomRow) + out := make([]rune, 0, max(len(top), len(bottom))) + for i := range max(len(top), len(bottom)) { + inkedTop := i < len(top) && top[i] != ' ' + inkedBottom := i < len(bottom) && bottom[i] != ' ' + switch { + case inkedTop && inkedBottom: + out = append(out, '█') + case inkedTop: + out = append(out, '▀') + case inkedBottom: + out = append(out, '▄') + default: + out = append(out, ' ') + } + } + return strings.TrimRight(string(out), " ") +} + +// markArt is MarkRows with the shared left margin the SVG sample carried +// measured off, so the mark starts on its own first inked column. The shape is +// untouched: every row loses the same count, so the split arms keep their +// overhang. Byte slicing is safe because the margin is all spaces. +func markArt() []string { + indent := len(MarkRows[0]) + for _, r := range MarkRows { + indent = min(indent, len(r)-len(strings.TrimLeft(r, " "))) + } + out := make([]string, len(MarkRows)) + for i, r := range MarkRows { + out[i] = r[indent:] + } + return out } diff --git a/internal/tui/theme/theme_test.go b/internal/tui/theme/theme_test.go index 42a3292..d8d989a 100644 --- a/internal/tui/theme/theme_test.go +++ b/internal/tui/theme/theme_test.go @@ -73,6 +73,41 @@ func TestMarkShape(t *testing.T) { } } +// The mark is folded two art rows to a text row so it stands level with the +// four header lines beside it. The fold must lose nothing: half the height, +// the full width, and every inked column still inked. +func TestMarkFoldsToHalfHeight(t *testing.T) { + rows := foldedArt() + if want := (len(MarkRows) + 1) / 2; len(rows) != want { + t.Fatalf("mark folded to %d rows, want %d", len(rows), want) + } + art := markArt() + widest, folded := 0, 0 + for _, r := range art { + widest = max(widest, lipgloss.Width(r)) + } + for _, r := range rows { + folded = max(folded, lipgloss.Width(r)) + } + if folded != widest { + t.Fatalf("fold is %d cells wide, art is %d — the shape lost columns", folded, widest) + } +} + +func TestFoldPairsRowsIntoHalfBlocks(t *testing.T) { + for _, c := range []struct{ top, bottom, want string }{ + {"██", "██", "██"}, // both inked → full cell + {"██", "", "▀▀"}, // top only → upper half + {"", "██", "▄▄"}, // bottom only → lower half + {"█ █", "██", "█▄▀"}, // mixed, decided per column + {"", "", ""}, + } { + if got := fold(c.top, c.bottom); got != c.want { + t.Fatalf("fold(%q, %q) = %q, want %q", c.top, c.bottom, got, c.want) + } + } +} + func TestMarkIsASCIIInASCIIMode(t *testing.T) { for _, r := range Mark(New(Mode{ASCII: true})) { if r > unicode.MaxASCII { From 55eacea0ae951e714765a94788709df22df1f571 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 18:18:49 +0530 Subject: [PATCH 04/28] docs: re-record the console demo as docs/console.gif --- README.md | 2 +- docs/console.gif | Bin 389044 -> 747328 bytes 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2cbb0e8..6cef23d 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ One static binary that is both a scriptable CLI and a full-screen terminal console — health, request logs, API keys, and a live playground, without opening a browser. -![ferro-cli console demo](docs/demo.gif) +![ferro-cli console demo](docs/console.gif) `ferro-cli` ships a single binary named **`ferro`**. Run it with a verb and it behaves like any other Unix tool — `ferro status`, `ferro keys list`, diff --git a/docs/console.gif b/docs/console.gif index 8862ba823081ae2d84acf4382d3fffafaf231e1c..9dd231f2f37139b4325fb480b1156b78fc917431 100644 GIT binary patch literal 747328 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 qM_#ip!0cL|54@pO82PDRJOZ0F;6 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%0D0s=+Vz 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%0D;Cn_Lt5ZPk$7T=_& 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 z

kw5nPLQEIJZ!pNa{52`7A^okY9M0?D(n%c)$i;3xSw-hj+!mJ*HZftX1P!U44} zzCRaYJ7&;Fq;lySU>p)kkUKuO5akD1L8F{Z`xfX+BIDvp)U$NcH=!)Po4WH1SP$#~ zBhRFrTs!M9r{Tc$Bo7pYx<(wesZA!BHWA4Ao!U$q8e7g$ibU zRm&lb^K|-1KwM6g8SKVK{vSFX|GkT&10aYz6twrxR>);c zLq-2jYh!KIGbQN%@ad4tLS^Ql5-Sbo{d~y_-8jl@$15yV=mW0w^W|~D?1CD2>?*o{d%*yTyn$~P2 zi*@X7r0B4YuKNI4^WXWzjh$tr{rR#?a3*65w9k-aa^1?r3e@sxEcI^@?qysZdmF@S zx8x9*bWdUS{>LJg;yk^0;hlVkJYlYM+`{sDB&JHK!gFZutO~Cxo{x&YQds+;IP~P> z2TQI(7Pee=I%S@`U2c)L0o)zT8|CJ7J(YGjZYLiq^PTEGR`Gmfsg7}5`5~O4{7r%V zq0c2|0-jW)Tl+9Bi8TK4FP{$g#uTQNn#weql`Z?*!*?qmu&7xSRM>>;*tHCN3i;eN zt0n50Szo2Zn;F|)C*t#SfwjIPsMXD_=AG%PQ+ITM%9ozKj?dzuQR2h=WyQkd9=$^$ zHMT^&>1+4ouMn|=KG5K{aCa^I_#r0P>DH$Vnq~`*7HXdu_ zkgEs<^{F{os2RktZ7;0*KDf8|^ZL}X6L(2N!OJ@mo+qze1U*G+G-Ke5tI)uQo_Lms z&u(u9zK5=RT^S^eH8!|Xh@Y*;mVo`8$u;JKwoUN!#6f z|HlVHg80wfiU(f*^y%o_|M{6XBK~Xd@siiCFI^v+e(m?3?*IDQM@y*C?7;2QVAeIY(L!cAev>808tq2 zrwKWTK~a@LwXp+qg$J=h`lWEQ(E+BOgE-05QYvTcKYcoA0!Ifg{X9rOQ(`a5$v#Z;bE$aemUFH z=&*dxVVX~BImZX=i1Nx|deCI~KYcnPsVYzuI-_cA-|&h06+Fyiqgu+}GV!Sue1bY- zx|ZLv@+T_<6voD`hkVN>P*n

x>%}e#@!RuM{yG8#nFwmP<^n6m!;@_@_@t;Mj!q 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 literal 389044 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
MkN$nk+Zsh#_3C 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 z zDSIj4pbFPm$XcM5U`w^Zm<fop%_`um3q|?plfK6~Nn4ol|sF*nn(C*s^-Q%1$ZBim2-i=DI+MK2Y`;7oFR2!(G zz2P=ElR8xvKd60^4VUHYo>nDk0^rZ6s8qb>bGtE8*{=k^jR_fTQkQD3dz0#%a_f%a zF!YbM{CunzwQDx>s**{7Ya=~9$8IOP5#>IzVwhD74~fem(9v+b#~L^_m_cy&bjgsl zdY~b}s~RR=F>JocwSbEQ5W)r@>20O+U4|=Rcr`w}mn8(#*aBJomfJO#3&p@HAhwQt z#E?nT-{SO9`e&D~N+=TD19IJXc^=zIBKlu`#3#0C0!|=?2r3VQ=3cJDlwAPML@-Z8 zQ-7ls z)=-r*iGI@4f?o{hVke&K_WR@VO8>JCeaHxx6A`vDlB6m6DNh)4_@m!({2y4_@4?HZ9L`LR51*)nVaV=lRuSdqOlpW)4N|d6li3w~0`C z3N2kkZhGH#lGx@Y6laTWu3cA0<=Zr{5r)Wx+pd-8j zejci?Up52d%qm7w}h-A+sjVqCnX$`_a9eOZPK*{J-DOM(a|GxS3 zU{kuv?`#E8c>SDyxh+xzxxb~xc{hszWkSpPth-cxJGy+j;t6DU_*Ge1XT7B5b4db} z*&PRkipYSP1!6#(&^ZC+Dwtck23oagI;}h$%&7nKmxcP*N$@$5J750jDMP{Q9;g-u zdab)Y3PQ2+SGTyalU#iv(sf}2^4Qv)M>2)CFuhxtzsb@@9|mtQDuja7<`w2w2v$hc zv@C?9qCp%JUGl?^PPv;1dl7%ySY}dTKXaQre=)tQ$Fz#hXq#wo2{`z&W}`5BZ`!Jy z^>6RJCObUKRe^irKfsUn3t36FyaD4w334E`6dhJ*Bd*8~8~CzS2Uzh6#k zC;47)SA7}!zSux`aGf;kN_r4Y`lz2*b-*?Mog5*_dL^Nx61}h>u z5y9153EushD1a*_JSH}0f+E4qunF+)4yX7Mx6!fMy}o8LeJgNS`J!HisKzWDR9c0} zUPhHd2}lFe6#72klnEdzt7pF>0-Em$dHe+T-I~{5OBpSP&IqLUegoe1WW5eb8r@ZT z&2ttLF5g#B1}qZ=EJU@7>vY~JkGw$$SKk;T3J)H2mGMRaTd5MH3N z{j%6kR{*2)>ix5BjC$@8;$J7y`C#*)h5 zU>R<*?_dnT81E*s0TYu4M)C+}-XRqI$r?zC7!!l)ew?axo?%VoE9P{QwEyq~izG3i zK!G(-z)L%>g$VFc!<{64#i9=m`Tr0D)p8kL?(j|>uat(5>73>@Ly&i4hH zG2DXTj9;TGcW-GOt2JufXAIwO{Z+vD49A#y(};cUA`u`eeZ80v#uFV`^LD=G+)e!v z;DQPpnB9<-B*5BfePQ$p*=A;l;FS1lr>NdRjKu~XjUWl%WC+!3wUn8v!ib(C{c6+T zz=|0|bOGa9aILn+48tgebiiB@4V848{s7U{XX6U8B1i@+HM5cUC$#B#n%ggTaO6B- zg-kW~^uGE)ZfzHe0W#H#FX8_@N}ND3Lm*pXnGtm*`xPYxN9v**N#BA>4tj;Ajgw@8 zyJVF)^%wPqG#`yU8Xs6@1lU1Z&C+Vql&V8y#{y4W!HmQ)qZE?Jh?=K&u926^W|{-K zriL=GNP^X+R|l=jB?5cZL1Rn!B4y>vr{G1L#f3TzUFypE;(0ZRNYP z%#(BG#c-MJDjAAJ?TqxG)*MZ@RI(2n`17eSfn&Hze8k35n?dTa<;-LFJi1Pz4+TUU zGa&~6HZ`FFDDN9xSr+sAtmZ2jo2b?Y+rB=nP@oj^%`cE<|%!_j_@3t=_kfq8O z4Co@yS4~UV_>y;tN#%=)wTyNMFf+TKSa3Y$ld7tbOOoBLx==KYQKeQd zWF`nGQdgtLVYe?jUcK~$Bb`<-O9|UwAWBI1$jCY&drE@yimsc*Ed#1HMgRizvF^zy zDw5U+sm~{RNYBTUt^Bgp$XdpLv~B`$>8aCV({)M0fI0Gg*?X}*g~my%6-lqVS{{7# z4mR*}K`&*hNz(o#?;G$39VWerbqS0w*GSgO4QYLv_P;qSgu%fFsjOXB;P&$siqoX# zB@^<3VOdpXl~FUlI#KYW{mSEfg27x!pI$}^rzW!O8%4JI2u%!brO2~>`=bdwa)97% z<6iN=5k#e%Mk-36y?8dv&uH?=!~{vUQkyk1_CDA^q`@}E^B^;8dM(j}M=gQ1)R(wd1m49eN zuv@Vxjebx-PZTE9wvw9rWgXCaCGW0_JjTh=o-+YxTL7|b;!VM=MC#neo2MIubvE!x z#$$SRaC%#U&Nl_zo~c>`R9^8U2+SwgXgJ-SzxP#X_M_h3QIVij#qaYYEa*8|!6G4l zlFJdp2@O5I{hH~CmObj-g(*E>!(M6b38m+{E#4ylm1jRiF6f6&PqA7?cCsAqJQ3tr)4Wk55!k~t61`jMREyb+?i)e{a2MIwMLTHP`2HpjDzl^?WR;K@O)A8^Tz zDoBmA?(de3v7aWgNs}E~Zaod8f=H5104Z7Tye<32zcpLwUb2^AUeYdW+O93MRm#(E zbAs_&?|0=9o2`)&)@o^bwr$xgz~zMZ{EJ?-Gn`4l%*UWj&)iR2_iFNPsmvT*-HP_` zJfdi&D3)g7t*sj1Gkus33>T&us==IH@m_onG6U> zaRkL@1n08$*pV1;-XCxI3XnJ31E!NQ0DW-3v#*ok04i{>ny3ao&ReH&`3#)rt=ac6)9B2a!uZ=Ldnv;%b~P54VEDt>+C6_bpAlTm z$gp|LKWEN=qm0y11JCCq6+~R+cNjyUVyP$KsG2ht0`g;$VQPV+60whrFLVFtN$~Bh zf%02v5RcLdxqJg#_9->8{L(VT_oa#-|01#KiGDWx;CuITtv&}5QGHT|w+aG9XTUEV z2Y;j9K0+7wYL^XH48sNO3VtZ! z9sdGJvG`3Nk)_?Och#KdhjtZj(5cce7Y9r7ec$A%%v_f7<8&bf~?3x%~DQm3MXGd6D#A5+J?pnI^>rXKBdW33Hy7 z$Y-lE7_oa5Gj5mTc>*#IQrm2t7Iw^ZR$yyHMh@P=at+%$cxzr=f9@ zVNn;uP7^#26Uu+bmxm=@J0x_4B@G?Mq#ve@hox^FrgI-NL8-;ws4SnwmXNWsjZD`o<#t-!Qh6g-_bA`gi zSYMRn-`NRxF}`~=*9ou9H+fX<1OF0~K>p)=+k|{Cz~bh}K+V}8R*arn&QC7wzhuHT z5B!0beVx!9f7v^fd-x2x5dZAd z=k%k*N#&W7{7)QQU+yLbkk8*bdG#XknFpLc!q`R0qG~m=YdiAIyCA14p~6bT!MR|@ z;ioj~%iZZ7a&*$Y+`of2qAD7r&bh!n&Io63=k9}{JE~&C-2dK|e=cVV;P)UwH2!Mn zYt+a5?xG_h0a`mFz!Nnhj0E0T5)RO#B&4Kuqt{oFu@pYlp#5#D2ZVHy^R!al-^8YJ zWS}X2JKw}-3eI{iaPT5OBnqS5V-Ih-u0EFv^IL)uX2uvl}S7jiX1RLt^2TxefL$@W9dAUzI%JeA@S3?CIxqJ)FuSLu=NtF!%ix#zGx7QHN#D!L_iqVw;hEb(#{O-h291u?+T1`w&gK`&CjPP`rjiBuTn{VxGib*(s8uG^OT-mtP1I zO;g_uD^DFNJah}xWKgg2mme?^%QBYfaZNYXI1 zUX7wR6=^|p2SNsv{qWe=c<9m^!Fb@lvL7(OU@B({s1amoSeU9BTi|bt_L?5GIW}~@ zU7dW`_5K%qz(p1k5Dn5YVJH|F(}6<2`0yVEn7EZ9f#wMdMi=-zYl;b^b6+EZ)Y`}| zeT!wqpL^Hijhh~`#n88oa^@Si8uH;N!|ikeOqu-vo#k*Zh*u<>(o4LZCK}T*;VH%} zOaQ1S1YK*w^6^kwAE`JCh>u-hOm&~r=l|qB&wYaufK|J|(PqrUW0?i=6;ypSR(R~U zK#Mv!$yh|3kNlBqoPAd%#pA(%N~+K0jbWN=q8z_4mic10jV0W13k!}zk=DJ)`BcQ4 zphxCauM=byuB<0(HkFg%MrjyEX|pJGNS`H^S_Ywv{xr-@iW;WwyGMru2OGLp z+jhloU~VmzrVoO;Um{qJv3)q5@Q*{61CG87b6aR_j!CAUe4J8!rgbo9`Z@B)$mI(I zKOQ@m|NXflJfwa2&VnTyc%D2IdAMDE8hO0m95{IVweQS@)06M7uU+`J+*LmG`^Vnt zztfYKLw{&82+)mdzmXFIG@qLZaIDLbfYdPbk|mM33Pmdqr!bwx$MA8i(J}Lk(7E7a zIrmX;D=9tBthpFDt@j&PaRTo`OZ@qzY^(qda{C6wnq92kB#ENG8`lUT0b1A5y8juL9NLyCn7wLrN)%9T2nlAucDM|=X2ymTW$|8^yC@qCzj8Z%gU78MbeozF$ zRDooHvzh6|%wv4NC#|yDa*|}+%}P|%`qTlK$SMCTfaE}w7*hcF4%|6Zy)%ak7tU1f ziz~)R&sbMli}gb(v|1HLvCHxRVgi`n=pcev_KWHA(!y7OoK^VN{JW%zS5q20&yRtJ&ta?PhCs%70l{go7 zw!M=5HN1xfH5n{;1I1y)ZMf%6K9J+e0XyZHSo z8M{X&m#iFR6s@&0?QSeQ&rCVr=%KxLYCWCwqNA0HdZ9b%YJJpr{NASAUY^nk-K z^<3%|;LUr`0As`^gr@_xam-V3(Kpo_-hNV;d<0i#qK83v7s?2*3y3eeC0PLV)yExa6TdoO?EVNvE9OKkTmgC+)K$r@1+%?O`_@X=b+DU)%i zOA`vA=NhjIgy$yEwFhj*YB~ zE%0MIQK)1Pt{7pY5)$h&AKV!}f^os^$y#1#Jf^`QIxVlsP&bWiCw^iYGu|QohKLN` zxK%8yn0acirpDNef%BwPY*E*}S0Ytr9Q5!p2!PP;E3NDXU}BK=u?l*drk00oP+mC? zx=1!S^Px6^cMg#HA~-Sl=Wk%V7-pg&Z-T=?elKb5H-qDgFO1}jk7DnBp>0~^ff^u| zxMtsFItS5f!qafrI*YJ6KsgEkwvGDAO&n`tJ4?4YMD`@PYNy*%}zXpbc!Go+S!Z?<|udpZ*yG!O339Zx6 z?YyCrYe@my(E@Sp7mVZ=O=ASuP2K6}5vea<53D@5`?1SP50Y%PGoCl+oo%{E+Oayt zljMjD?2did1O7}nV(5?!2tl-CXjT>Oq3#O9vwazXb2exL`Sc0s;9mx*ZPaUy!tdDq zid!?;Lnq#y6M0O35eqV?_R7FUMvl3kuWDEIzDALlfz;q*i;Z7!rL>dh<$-1;2tRP` z310)vyEnS96=N8p@eKwq0GtTwDZXO&BO-udq{F)-$71{rz|%&h!tdr72d84ToOb8x^J1WU=b0k zCL*Tus!@JTe~r6&`R}ae!bC!Qc88{3jx~e1Ai&r%-4M}ZV-wPYNR+;5q93m z?FQ^Uv*iQj;OZQFn1UnYc(3$wDD|RtNjJxUj z8G2o2_o^rui1gBB4?xRBh?#b}n;KQ&?h^bm#flzQnXZama*ZV`V=f)jSPYI@{Hn5K z5!a*Mz6gn1OH^Ach+kIu*l;D+G@$D8rRtBvVzxT5HZIk6yM?wUSegTX)vMI#0El!< zDZFcJ7qkHLW1wrSu4(_6MfqrlOuF(S9@~p?odBpcD$L47kOJ7bQY=ozG^1cNf>Xlb zc`EMnk_`x$;IM8IHEs->?$J!9$`W_k-qBG`i(GX!-K{-5Arg98peM^UZ&zcd&G>1t z8n1YdjBbhRWfPa~diX}bXmFXhZl;tsn}!E9p4&B9fG0_@#*<}JWOCEye2s5J6*Obk z0Pbn=u);vV@D{0nqF!S|@^BaN@YJAl<&q4NkaRGvsZ6O2*YWU$c(^GLd6zKESBAg) z*LuoqW!Y}%6L_7X#N3-C!UiS$eYV0CHm&A8FY*A3!L-5mNyLEB=zlc|;>OWB@S9v) zoU`^42(+O?x|!xHhlAMlW0*;9!XLKlV)O z^a@Zmjf<*vUETIQ_Dn@?KKdz@N_&cV`x6NL1t0~SX;x~DMiY)eEvSmDBGLfTHDU2I+ewm=8#%*O&KlZ%>m^w;W& z26s%`cQD&K2BUR`Gdue5dZ#Jo3Toc>*f1kx6Zemtx=y}f=j|WjPJ<(GYH!7uU>{h+ zDtFyU)}u^GPxNv|6GcWdOUU<2U06;qmthniV@!tDlm2j;YcRr&b}6HdPv)vu8eeTy zkaTE}boHRb8{R!H{E*A8vvjq5L7^5Z~rt&o|!-=meM8?OM?S|In%f9mudSMHA@>lAIuCe0q|g!XDB9) zqvYXP7(Q?BO@-`uqi^5f9%g2-KV&!Ov+2!L-8b3uKcQ z)O)2eAx*(f&|!uAz^39MZ;eTBnjuhQdi9V_c5X-k%d{3hXdUqn_1W~3dU*fTrr64I zo4P-H_jwMs`imNZx0n+RZjcJKKLlMcs1v+iur;_glot=W|%zY|mj2EN%^{S<@lsVGhIetTeM@}0Bg zSL*JM?}Z0ZJ0PKN#;!_7@bKOCCU}WF6w3YIrEkYyKmY1#>Cu*3Tnh}xo%Wl5(9*sR zpJjXLLIyg*|9kRnb3n;zTM3DwtQ=sIu6@|oJLiUL9e|xIJLIyw< zxVninUirMU@FF07cjp8A5}o%R&)yFBp2<)cL%v{HX5B0p=v}t(tU;ZC?fQlmf&H8% zCRrK$CTrM(qr^esZcH_lELGT5U<-r1v^n zB(zzKMP~e+EsKbhd>6S{L>BoXFYsVWz{%;>dZS=DRI-%3`D*{ttg`sqNPymk8J!oo z%~o~1Z{ezh|$^E6tTLS>QPaG_vj z#cCPfS1LHB4jhN7GGB)>g!KBrO0V8h0TLy0Q3X4hi*0N#tH@-MCOOa2E@$ug;Z0+^ z-lj%G`*pQC#Ya0;knFbs(dCEiT#S$fUfIC*+WDvlIlqGqUNtuJB<*h&x6XYw7HSKT zYqLNY^5B)ZZks^W1jG9-q6L58Cdnt1<)kkF{N2K{kr3HPIJy1eRs1HkZ9EuiH-sy*ZUZ+Dj!I8`1+|5Tr zB2j8VQO}9(EN!|TV zj0IU;Ht({-!lTm*P+>U3zX6=0HFNiTdUQCYOPyLCl9ZSWM0hE8NIu`DC3l zGY2i#M}H=2=OkrqUcGos=#nH19DdiAe1-iVFBya+PyF0`)u|~t*?+Y1@z_hT*{W^v>rY=T^L8OD8hq1nb<$HrnVoo7&Tl4 zU&`bl3ve^qIvpy5&m~G0Rfo2bQTB@e(nx!WR zm^O*yU?*Q@?5JKL1#)IR-DTD1cm!{qLhf!!Wz@c3%DycAgz-L$bUSW*K5np4zBIuIU&R};a^hjRA)%N`H91YHm^&DSLmwb>FVwG&fM%BZ0Wt$(lmK4W+F}3Xe?ox zl=~_w*aX!#VE{#V0tk}Li*LP+ItlYmdJ9?5htcGR0W$Zs!=C)<2pKIpeJzBOU0=AO23@rO0Wh8`F+b>|K|}-lnq;=D#wSNhb{jyzl44Cx^ht? zWZ#XkqB!}KH!u-?gXU+{7#aqG?(*rmY!x`j%YPOBCV8N9=~AV=?0EOSS_aMR^`!3; zwxm>iR zT`&Bs)%CiWLIfLr!~pu^dDfUu%y*@mKdiLPjGtR0zHAwP`z?5L8t-7*ad7l4&P4b5 z-^uOk*9?wXPvhADTSfCRuzS=qw^q+%$(r%jK_3r0-Ck zv|iOvcY&YPZ6)uKBCSGyoANV}NC_h86DSeNF6KNoyE>Qz#gy5{djm5S>Q)3AKb=7) zb8<9VBJ5X*W)0_f6fiQ0p>Gl;*fbNLR}Fb70Ru8um3y#P9My& zGeMr$+SqPyF;821^7!)YFNJy1&vn+0)=~G)-S#SMv3b(_=jvqRe@9{#ieLuBrXMB{ zI@`|_$r675$9D)`uNqE$Ve}J2-Xk{xbr?{+w!+*HmxHx~DNHFMc$m*EhJhXtxEGvn zc8a;zVO03a_S~pw*xxx-X3jCgRA?y5aa^)A^t%)U4kYSG-y}O)%H8gavQ#jb%%4>1 zXLGWKKN8}qt!q+onpS`FcU$B4a>D+!rguf5?SH#dPBVHpI}2wFKkLr{^YZ4cX5wI#`^3x#;xsFZau{ZecH9p7TE8 zK+pO;eCfg@k1>G@(1Er|^nR4Rl8AI*bu!XdAgP}bEQssJN$rI$J+2Ka0BTO^WZ#A| z^IyU+A*ggL%M%#>ZO9zEMvE>-@7dWXZ*e*`dd}4HZTkABvHJso9gN2FCZ~_rl32^A z&EQ1rhNT8r5kuF$DtrU67E=FEzW;%gS!QzjM`7ez+E&Wr3oP`hC9Oo}SFQagTl4%t zlri$0PrO&In}1=wL{u7#7h$L{3%1951A7ytp|#^{gx1eWm+YLA=a@7L+QeY%s#Mx$4<<7WjA zUNBW*4na5^X$z!F6ojHTRNsX~mj@?!F!Aw;kl2^}8FjG`T_%t1mxT}Rgw0&Poj)!V zNE$oW2=i52PL$%W45n7{)*C#l6=BF$f2dWNVAW4+t^{p({H3xCxLhLz9r}1#AN(^v zqy8ob62JBCHO7d2yjX($-E0B zF)9b)%QYqB0FD&>4Gu|Rw^S=IhTU`4mq}*nxzJ9&`HyIJZdOjx!!QaMg#e&3#4|19 z1zrp}QPykRcu=lv7;NgTF||$*Rrm0+R0if1pvLJ3&P+qkk(i_k62*;Zq3SVJTGI1P zbJ!n}bJlclGTHXtM#Npz=I3uKJ%g*a>dHsQy-irar1M5KcW0qux42PYd>xswj~K`%fct$1%F@nN*G6u@{q?Uy7Q z#ur~}c$#wx;!6tQ^&N*wmK1=LCjc@2WRn|w`InxcGBZsdkf8FeCF?)1BHaL@IC=8s z-5*%pbrM2_usm_$$fV;D!O&u?@QG!>qkYJN3$27Cyh0RL8GDbXr?23eSpk_G1yj-? z3bqYM=-AWngsVxJG8l{L^NQhrm;1nnb-dBU48gyes53D{i~=!v;RP)vF^0}2wr?mP z;^WlHsEzJJRh}}}rl;mLos;fT`Vp~1sJl>RTJVKs7q2t)hl01;Xo{| zyV3HonHp{cpWAiagDNaid5H?XV$ySW*#|3_G#>l#PJSNo5iCm%&HkwLF%~0G5}{Qe zYA^0&ahmlQWF|jvDl}CJXVyFkFi>WidsOi&pLy=h@V!ekIl!{I?t-~n(J)WGne!_@ zplt#{-S5)bLJ<(F39A0RuG@VOLmXf>o2Zd}l|wwD%q9&_brfoZP!C#us}uyav{D&t zVxULu+MN2npFr&nTOrBJs1wuJmb9wcG~2>jApk7|3+h)!Xb!CqM@oH*5g zN7XU0fRFi8BwCH{CLA!ncxDdb7USuBDXPe+yx;N$g+t*T=f0lrg5FMygX(uDUWMzM zA3EyK%k4lKkA7kq_s3?{*PJ}^Fhky$WPa$TS`SDgML&)5&N`y!o`f&an(+n?6!j@1 zHLsOiDEQPVf9%l_P;L>+b;c+Bt;cAyYQNm#&pT@NFQ%4N-#;7XLyg*Y_gy4+o@m&D zg_+{_5qHxBXDdD`6&!PC=uaC3{mEsPJDv#lR7`C~Fq;HZ6V-}(I@1(0;NO#X!PIp% zrt#@37q8uIWPK}F_EpZUpffF@uP+><{Tf1Ays6h`;D_@w%{>gxO;2RI@at+~5Ap(K zDJH>8m9Z{pf^Yk00zLoK#V;}KS>JaKL*LQr_Z%}npIwySXX-_iV#j<~zO{Wny$6=`IXop%Hf9aw|MHKq+;X7VY5^v7 z>-#X>po&>Gf5O*5@oP}xHwFJzcsPexAO^a-ebQ;%joSIiZv!_3Gnrb?Q{iT{nGf8> zo)!5ay6J4oAy9wfGwmF%PS!LQWrpReTnJy&D$Ip~K7V^zybNf^? z$c3r!+`wqwF(VG0+>crwkbSpZ(>ZtfC?R~hKF{AdEx;G+oUWD z0jfyE{%wIUVWhfd_TGyeTn05C{m`kJph9~gJmJWx5k)0u!qk@3HoD!c^)_oNfZ2=@N z5f?B6Llou!7##c1iX11{io98p%dF&sm?y#JX+hbSz-5YJ>%`3jK+SYPDS@b_&IL#j z;UyFDnhUB<>=KS#im6n!pdTlTUP=*;=7F^#7tB0ulfW{7=X#ZAM5;#3={zF`QtqY;m!4)C_5KhapXe9Un6hdY?tvv^Qb9Bla9PdA`eZxjA+i44oN)xLf5;17(v z*^Jd=jNMusB#Mj+H+2|>F(#@-CN>8qc0)!lYwGP|%uG5>%@4G^W6Xj&&B6}Ml%35Y zW6ZB~nqNOKPgEnM#1Jx^#aQTsd^L+(F&3qr7IzLTD%C9S$5_^PT0T6mY*Vv(6l2xX zY1OxAX=7rZ6=OZ#X&t_1HK%6tGREdjr_H+qn^iSiR*dy@r|r&xt$>N`VT|3cPP=~x zcA!JcO>R48b!$r!Q`e|uDDfwJAUo5{I@}lB>}RF8X1YniDHxf`zqHbzUQuweSnuSt z2Vinodz(XN2lcaOA6a@-f#ILu`3_hqkURso{u}wUQ?cL}-~;X=gNbJeV}S4nRVA7F zZQV#~1G@5Z%?m~@s}$)Q_QH$LKD$zCx6B4=V~Yy_(*rT3g2>st$l3v`8(*AKOl-vs zITW!hy=pAE#Ix@X&#$UqxKkwg*B`PwZ6Hy_%%*r+eZWJ1Jm{y zm!C;27cKG{9u4W!VG3g4V3I8X&*!)1rYxo)b07RQ?VZMDk8;@f??JD7>-v%pxeeGH zt$gjO@#miwo&R*%Kd8$ebW0K}Cyf}AK9!~aTYbsQM;dOAAKoOkNqE1MdzgB3KSIq1 zmO}WRtt8lygW&=$5t*8Jk1dHWBJglgpBG($F9^PQW5u4MLy+ESF%39?p?PSG=;=Cp@A7{bnwBRdv<%s1~V8A_ZYF2Mo|AXo2G%`z%!x-!Y5RY9!K-Te12ur{zLqI zmwB!lr!@#>jpd{`bMUXC?CCs6ti>UQ&+Ia1?SbE|PPCM_bF?9c_RnbJxR|^cPN`L1 zds?jb&nVTn=!<+Yrmy`|;^H$NTPPcOl&ra*V!gS?YnUAE4bKbXa0!1Hs>b%}Y;=&OasIlpGaq}<)}<+NFg!T_g&8LOGU}Y8Q#2jQ4tfx=bWTYatx?px^PmANJYu< ziZPm~D192I{xR$Vo>lA!rtg|;n}ca^cl)1s@LWyST)KqC z4FE``1en!`$4fy61}cZFjW1ooqfDb_VTca9EQsK8FEeQtsNz(ND zQEDX5T!je10O*7G(2)@jmVs!MQCS3#V1vm{9=olU1a8PMXQ860RE}IK2bCC?2e2rv zBIH&wKmjia}{1UukUC z<6Gz5F66~Y&zt#^%pvo+nS=V>-n`!mix!#6gvHH*D ztFK+eIr2neBb1o(GLkcy=_Mc_>vVY5uQ&G+ADBv*XL_x}n(449B8$uswip90rm+>% zS>OZYdQ8f>C9>#mY#rW*X@KoyE`OECDyC8O5MyFYgP$;68UtyM+Z@`u=J?{r_N-J4w#9~@-E(lK@F!;h$y=uDj zbHB+~rs?hc(^5<3EOhQ!z(T2#L;n}()GEOa1j{W#i_k3@vON|HS0BE80{jM=^PT+* z7n|nXAF|RBOUn;`{l10PX|uZ}xsuVCkvtsx>spEQ)$##|1}3`qQ-H%j$PEa1c}7~3 z7H(!-9=`Sn2`;M~H^pB|P5pRJQzspDO8PUV56qS@bfP+Zz|#K2QIf+)qB@Vtz$C3fDidZr2tC(UutB4V6F%i>D zhls3^3oT4KlL#x|+KiGpyj-o<$J!ra3b~Z!tA&2y5+$$Bbzm@KQg|=f-Bg7anx~9t z%qv6#A5RFT;dJiBy&d%%#b-?Dk+W0KQ!A#lPwtE)-!o-4o#VfGm(_0>{Nkh(aesaS zh^>O85~J%ooAZkE3tn)5)4+cH`;$&#aq5bmBYfzS1roSPz$ri5h$#a6h6b7tV^;B~0 zDF}lQBjObPDT`526zYPgUMU@OA~<;An>)Am2OGh0tTFJ+>tbfA;D_#8&jW_Q{Ed<| zOqbbcniYTI`R%E}Os}IM(^snc9|}p#+lDZn5eFJi$w*LnevtLLvCk7$m0 zTHM8eYiVSyrdj+HJOK?%XUzPL~imnc>3pn*ACcoL%+TF&KaN#z+)o*uGB@U zE1Y=`TEFlrvI>~Rzs&>KP8{0jZns((S}yz>&0BmYd1dsE``f(E{Y0VfOxJ#V>ib~B zIDlQ2TnQRamf1l95E(j85a;DwnE{c6d$<5kD0uB@ud15kb&#;CzG4O8A)!iP0!x9r#{3#&w{TxU8lSk;cT!ha_r~Du{-;d&&`nQY7R{g@C3v^p}7*Jhucy|2GVL7jDNGv_fuVq5gc> z)^>;!2^tj!R2X4H1y;B_F=b{inGskrT34BZ@<_nhqqw3D`Za_4n}H9;FI&wr}1E{CILmY#|;qX zisUb3e8LL=ruf_33F`oY&mK3zXRWnZX6l{m_PJEO-<6Js`tF%VMH%7yp&tF~_bg%4 zZeJqdr{d4&KoURz97BK^!ny59i6Q7xe3_k_zZ*$}qqkr}o?|1Qm%pvXX9AK|bIVF@ zJbszquk4u$bDfW2zNK87C)gEao^IJtA7|)o+2q%^y!oIq*Zpff_4H(D#|wSdu+Djg zrIdTbXd<;gRD|%Uz@hs3_y^0S;x~>aq~+2R525|uFu?Oy18+Ete!UWCxEb4GdSsNw zW8R8UY9WyjcohC`uOGY67*wc#rV#_O%XkDv=R1E~Q@7 zi9gc=Y68W(E*kTQD$GxCnte$4#2!(?mX-%}Q%T@6-T06AGl-$sw~7k*xOW^d+)r@a zH@$net~)Wu(yK08Xm*QewJwKD|0`}W7Lq_FMlsm~AFBl%X75MwN;D@%U1$7G(|Q89 z(u&}`MCU}?yre(zwmjA%Xe*uyh4?r>(|L35>n7mWXa^jpDfa{~%0jaLC$`b=s!$}k zX_Q~7S0rKc_qDyj!C}OY@sG_q--6C6{q0=Kv%B%@^F6yA^Rb}LE9*Umrhqka=-%9T zxgfRwDOZZ37OehtoeKExI0!@)y=)RE1Qm&he4$+NTu8-0tDk(MRWSWis0LJJ!yKs! z%;49lqN3?2fQx8o=!#1Os3<_6n8@mNg3=EJk`EilzF5LF%g>?!J}7>R`->1vOi?;N znfNjIu^85R6(ZVd#4fXrlBaI4xQwMQ6l+lA^}~XZ^&sB1E+|9FHZh2hZI6Wc)~hr` z<|J8(3x1FhM$zVC3-*P7?-t0OJOZN0u=V3bU4^ZPXnaYf&QX zX7gV+^NWbg=!$iP2U;_wlYtGnXupgn#ZNfh-DrBC_bp>4;cN80zf(0j4CYx9 zON{$Jg*roy%vrKrOeI@bov|p3gTg#^N@h%r#OZnq zyUck78@2liVf9vCEKceoj_js1PMhaGveI>i?6&kVo4zEATO-`nLV;k=r8jqOCEZWU zQ=?l-p{$~Q1Ns_+u7bKU-OSb`agUejE?R3q-G%x_`QKl~yognm4VNFDQzZDoayk^E;rMSZ&=I8Sr8=*^y+<`!LSd-AIt4vyUO&f2k?L~n< zOSWZA5CvR~opowHZ>G1w8A0}oTAQfbxK|Oi!a%TT0cax00wPA3{&XtKIY*P!)pg(E zqSv(!NxXwNhNUSokCjsn9#X z%QQxEpvRNy8bSdSDFeo9a^c5XRL3253#6e{J_WX0*Cv$nAL)nWZJD&^Zz5k`eXH{% zB#Im(MOloTkfi6~minWr@Hg4nx;T1C;_4`HoB`Wf61U+4+dxIb0+Np~FcuETfYF(> zg)*cGlZ3vp)YLm zP&oDF1d$+V9`zj{33M9r8b>e)BFpxfW;)sz^Sj2NmUF4h5xf${t)_yZ*dWeS zZ$$gpfysg3U0w1ipy3%O;;xUNTK|Yx3%rxs&nXQIJ(2A=A~dTyZslQCgR=H;uXy*9 zd^n)Y1i%Pea>oUW6J#ENlR6u(ho!N3ym8*uAVBC)85{`q(Iq`*_3OR8W)d>q56qp8 zLy1-BG$Y;Oo_^5#s6a|wIo3GC@>e4~y@|LYgNJbYHbJic5PW~LT*X{J>wI`xAsD`g z4}SlJ#1=XU5u0W9_Jee&Y)z{3%+Qh?;XFC#dOzwRNnz<=zu7g4C9NMAJzogQUzccq zi=~x}hvuLEkgeyNUc%4N)*&NJLXm!mrvf0}K0I|a6B&47#_(kVPwF4CT)ZnnboLag3kA){(y!Jg83}U_MDSNW{RDFF zzfejfXK!D|G(R}A9h3(be=f$#A<%C0S@m`1;tfooD`@xf%(Z8w=;zflUjkKp%3Z|mV@tr_4837nRDZxfA|Vkc}bGH@HF1h=p%msq9h;lEBcz` zQMci|hhHMU#0~>~Z0PS3Ap%6eqw%Qi%F9BlH*++g&<$lCE+B|WMVKggf=?hL;WaR< zVx=F19*qq=jdTE|h}}F$1Est|_rQ~cFiAH?(UN2MQ;G2>zXeYASc{LS$}gx>M_6Ad zU=<^#i2#)Fu#r@;=?7#K>=FmjXBh@G@=1b6p@&C6yLouGbiz3VU{6edRf0Wbd>0OV zJD32-7nIB%3uHBg51kt0?>hCEe0Y$+3rY&C;^Lu1@1AqZ?uP(w26u5D`5z-Qub*Dhwj;a86}8hBq$q#$rj%T zxp_vL_6fb<&n){Linb5a?C=(JxB~HpNrC}!M^m5`_7(xCqd?JhxvZDZB^06@2`F0% z?8gR_xee@loXYE+`f~&I>lk1lC>)fl^Jk46N>Ty{sZfCw(62nUGhCBQep{}#gMq@o zJA}3SIgv!L2oWssD~+SZ)iE(@*AX4*h!P`RcdRWCL|@2H7oI@ebXArXNGwR=$`nur zYtT7)R9ElAi<^zgpX4hZ6H=4M@wq$FwXN$h!7g;4qQpOEoQca)*s8k2PXRifWJKq zi3TOgme6JLQ^xI@zvOa)@<8@bIeLjoDh0U;_0dHAA*2?%mB#K-{&S%em!>Wp0%eX7`FBy=_d-k2p3FIdAgC9F0a&<_H^;D_OVIB$QC1P^csdq> z27Qb#<9K4{O$guYD(UP1+Y@~*18~tA%2bt-8(=$q`V7 zVzI5y$kvbHfq+1XaG)gct{77RpR6=)A<}J*OD&T}k*}N&?E;nXvuN<(qSmM<3-`MT z;*zT$Mb?bf7x8+F2)0!q`(ejecr!n+)<*hinuX&earPJeGIT$6Ad2+9qib zBMykT<(UDx+z{e?^}bMk$n`U*bIhDQwGR@O(d=JQ?i8_&y4!jLDz7&cpkg=1k^ul} zf~YQcw*%oX#hxT5!~_5jl{o^MNerKK$p{W2)Rf2+Mrf$bY_PyzYx>&IdMZ`zJ|q^` zuzw8LQlKg>4Hgj%^_di06{W`=`gFPRCIqW8TE9|MrZ@-X0zg?Rs3J#BL0a~qxL~I& zkEEt{HMT$i2VY$DP`he!Gb-J&ODXQ65;Le`#2e(U4!m4GOPhlV;ovQPJi{@vnKyQQ5aNH^yCGl6hFfRQ4xCzXdC%$#lHJW{h|Pw})Np z{URZ)ps#*UG)nLDVws{Tg+3HG1P%A06#BN-0+@F3)>KB}{ zK??Ot?e`1mrXh*mx}AbN3Il%J@GCSJtYkomZLoB`Uy6kjD>TR%0D80q8r?j5&Y0VXBBg!k|Ud&`EJ}M~%%JiGC%CVa3Ivv!TQ1vWMN8hCQZ+&u^&Y0gRnRtA|0i5<)axTk+F!fEhul(DwO z*#*`%@jW;}!Q%F$>$R^QZ9-O`0`eu}qjD~TzQTxYFCTWSPnH2JmQ-jR4n-lpwcKOY z(?eL&5y(}9C3OKnA)X2&^w@!KY(O# zSItl=T*J=mEH;7J&Ow7c8WS5Kfe}}OWKP-^;d^G#?dz!=bjJI=f9Qj-56ACj1tQO> zUuNQTCuV@s7xkn*as=H9zp%94@LgD^*CeystsC9J!Y$Qk0m2Z4ZiHb@ z%!RtX>-yx?Js)5Mbgz4TGNEoFziezoC%(4RwR2C!};eGd0CH+K0$U?!PzO8&h zR(|sQZ>8rBLOX}Wvh|&Yc=VM^MamDRuHU$kTep~7e(BTcjVqTn(sDO4nm4jeRHnNd zdC1ND3*%wK8^-<{W_#fv{0E#PlRZvyE>tC+RlMW^166(jbtiYD>H?}Jw_EDsRb0}! z0>!Nk+pR~JwjSqh^)zp#>7SCicmdab8iWU(l*K=?#*=F{7?zT^2%Ju9oI=EnTkTsz z{jME9q{-=AWCYM!v_t)Lec=L1&=uu}hvQV-K{OF=RS2)DBxk&l51~=h(M}R@n zZ@6F%NwEEG5Rs>d3lO7x1GRo*HZ1sYVe8p8LaGqa2#61!N0m{bCktuG085!YDglMS zaUwG9QO`mV)Yg66{2oUO6b52JdZ99COj-ICiVXA()%UA?rB>&ESYJPHn6jrc^F#03 zkF*=IIhQtZ^DjZAn?Diav3tP1XJDxx48X<<)y#KT+T3l$k*aeaE=Rp;-?HiAg);U+ zJzxH6V0YvfeiV>*l=^|j zDu2SrJ6e$iDS5|IKX$tHp?B^SElJBNUDSOswWbt*G zZ6IbOovI3C+c!`)jd<}~ywh$kzrHMz2X$I&(uP2-L@by@?U#V2To}x>kwI^HbW66$ zFxNvld3)oTB-v_MNDX+F9XYZIAI;OI4llr&E!T1ZuoRMAAC$iI0=R7sA7dkRjLk3` zU;C`<-nluCwF%#CdUF`E)aEx+JKcIYtisG5mq0Yf7QO>qW*xfM`i;2d`BjvwW)X$t z!7Ndw@fEEY#+QDcB!|0{+}M@X;XG-t_X+V}2!GNN)qcn_Nd$=R&L{+@m$AINbe+Ed zf&lA+>vh?2W0qJp`zR6sXWk>}Gx0XGXjF1vHI~zGwNGcQrnp>Pu0c5)Us|+Zcte%Uc=jGR4Ji%)&8SXViQkKNLWhIZKXRL-s zu*Fy!x<)%W3kwjc-GN-ouY)N@68k0%`aBlHx8zRYs#EaY05(OgA>&<_kNP>qL0(6; zEHb>*y3$^s*$+$Lh0sv;HM&!+hDNfE$|Jzu?G}?GBhw7Ikmw%`%8$0Yt(Bje>|9JC z{1-K~p#3b)ulU=$5?x{YczWXQZcQ>$>g!k`v)V>HDZ`LQ44hN?bYb-tQ^F0&4W9TT zfxwDf+uw=z`7(Pp$T38*AT?6RuaMTkBQ@u2XZ4pr2S7;&1G&PKngcjR$CV-ERng{* zR>a+U)AQx%(Yf-Ze^1{%Q|Hfuu))WGWTS9*K&luwd>}UQ&R^`tddv70T z^Lxk4kE$z&#_%i?0W{|W^~#rCX?HHaKI}NRonq>4nqk82FrbtYtJLmwHlEQpE&&3* ze|UH8T-BIif?dte?4WCJB}T`P@@1t2+#CG@=r39$)-mv};cO?~Yv}t1r=3Xip>CWDMxj223=8{(Rkt z(~qCfjTCT7t?NtxuPdu7?{}KVX=n=8t&+)jjKZ3peZ>)(7xMeAxpSRr@ zAor&k2TriH`wd}s?K5mPD~-tf8cgdCQkgTnS?UAj8KmJ%VYLsKV@XaWA1oK!{u;l4 z4?@AD$;-<+9lOYHrYZ+jVsffJJQZ)Q`+3gtQ=?bt?>cil+>z3~N_*&;(r;Lh1`%s@ z5EK4IAoxgL&#&>7)KRyv{kN}P*6Ay)H;&IB(!m0O>(X8qfu1Y0%vxVR`N=ekb0dz$ zOY$H7`dplJ`|No8%N$+Kbe@w4k1m!lSy#-tV(lyCR66PFuX^W~b)cD3*+PxK`ok+W zq5e+gZ`W%@yx-VFv~QNLN(5+4U$Kq(996OD8xZ>Hjcxph)7>A8nlEMV-Ru&Qr0)G$ z4>0)mYo?(_DWTfo&A3a)^mb%WLWOo6_}gaLJQc446AmtNiA`NRDZTAbs0L9RQD?f=Z_k0*t^v)mpPD_}eO}w<=My)_SApNEkH}lKW%A>*goEZmVTJMbFLN_8Oum6);}KbZ z-aVCzdvZhllDFFxg?;NWHymue%_Lrbat+?`$ih3@)enqvMM0$qgzL$l-Z#?EJ^!no zk;pmUU4U?P`D241F)_Qe!Hb?u@+igqazFPi#o71H{)U%Ug^OL!A@$PP=_7?@@2!Hv zo)dEBXp!FGMtH3%H)b@yND&b8?MHCbK>!gVc`=k-8zX4L+YZ3A`QI>CRkr0sHeD3? zc5G)`H>e;2z-CBsz5*JGZpN>Cex&Ar`B41;k>Mi_F8akP7?=kSET<$EneC*% zd$2$cR5ZRs{1^UgUu)Q(N2CUO&h3;?dRui8Gt{xTd77L7wlh2Nca_)JR@IL5y;Pkbt*QiKw%@rHX-iyIyd!?mX9Y~r)B z7P(bF!+za?`Dq%jnA3mOSIA&5MI;-|)8I=(=`?{2o;SF)TjZKMb$rC91Wi#*&6_4+ z0y28WwswcJjdu>FkCM38S~Cos|DZ1reoFP?F3HCCb3JB26gUSmHHRu2*&Lopgytbk z0Q|46(d&=UiMyKdi~-i?FH6XSozahCT`MJ<_h^0D(X38Oe&7IuBbVqKk8Zqfk{lHt zjGULzPxL+mnr$is8~YiCl;HiD`W^ z+dunJY4(&HuLSTo9Zj*BIm}v4+HJ4<(vNl0zA1GmNik@%DHR6pR@QV9T|8 z2MbWpP{w4Jfjz?YIN4lAKLw%hLO|G|V5zRpQtY2?cp!|O)3>Y;4w@z|$B^BQYWi<| zq=NFk@$hNm?mc6!>#7DQR%P6#*5Sv-J!8!dx#wT6N~(jjQYg(+V_2Y|eN5Kpg8C~8z3TK9{YEdtln5>4VLT@m?UIPBc4?_5Lw49s%GWbbJ z609e)Oy=%!ZueWozV)tJ#Vs;C1~H`a3Q~oH5u_C`tQb!oVpc*yW#cW~_mWa*FeO?_ z3I)7t46XM>SUDp;WtlX`Sk|prD&d}yDUWyMO;;OCBi9SIe&bUd+sIDCT~qn!=)xxw z-8Uc#5sN+Up#p#8Gu|JY?%MQ7^pfDC@sbwq)cB-v5OQ9d$6= zi9?wejrz!J8E8!iFX6@dHnR#5BDz#5_qVuSrZ*p>o3cSz0F5s&yb&t#5a2lDbvFn4 zi8f&0l!BUxy&^nQ4G_N@e^;{uFp@9(`{5yWDe-pk0=7%?%&XTd8S7+o^5e#J{ZALu zo1Gs&T(=DVVJ8dBHk(*E);vDm>gkQK>T}lol=S>~tC>YT?Bq>3NWZ)XIXMI2%VSiW2SqWQ~0~SThA};@up%d z@?{{|MJ!v^>1U|6`K>}J7>M%N3+1BT4c~NT{zM$f=`}->w`)t?#|dG4XWqAPkb-yi z+sb_57EHK_vv<2(J;HP19O<^9Oe1WZ!_*3dv0cKp#^SWmbPF&MJCMwxFjoYZp>4e7x=`W z9X9sG#QDH`A~~WXP5A#^W@f0Y8ORlP9+K zTne4kAP77-)u9;H%8FR(5^&}J`nue*qdNJu%Go|8;Vf1{SJw~9$*qPuAc`s$a2xdo z_jM||i$evH07_Lfs}4isZd7w ziDnc^N*~U!MZsF3001M|7j>ChFVh9j8oIuO+9{_TirS*}m=BeND~BYL2b{+8;}JM62KP=3y2CAfHKKH6lU=m*fTjdt)ObY$UM_ zfk4yb+-jG+KcxyK)(Lh$G5O3=vI+{K!=Ay6f+#LQUKoz&Z7-yh z02*|PbPcaUFWYe9|46&5pg01zUGO8gyUXAXgM{D?!6mo`cZc91gIf|T1PJaL++6|$ z2=49#_n?8{qpC&(_xVU0?KFS6BD1-}iZ9_zUu<#1%y{(VtxKcXiG7O@I7z z$*T3k$9Ip`XG7nedpDuHzUN|AloBqP8=s@Heu-b^q}YjWRG%6hlJOn01Sf!k@jIx|%nGAEEm;$5BV6JRxlNCM4n}Wbc#cC)4pizhmeW5l@t`2qc@1z&_5|U3?%+ z>Vr*-JsZlUEKcsOP!qaQla2DX-MK!Syeq4BdgkVX(PraA35($+a^Z?WNNhqzdI_QH zeah;7BZbI_e-V=^$!qJQDS+Hkx?=$D+7(Lsy^bFzd(ikZVVxT`~IutVAxhxBX*8)b*@XN(zL z4q59C*$Ty(XAW;39dc&RjBQ zR;RgLce)t*B*?MEyFVW}P5L;w1-M-8a4%=O(!qZ?MfIIF37$+U49s@X5D>l*n3t~= zcfFQ4U%_!2*mor`Jv-v&SRgrFd>QQ)SXle!8a#i7@vKReJ%Br)sVjC|^WN<;$?ZnM z9ckid^!EImWZGTK`CzbM@Jt1`pmM>$8R5hIZ~vSY#rWp!vN!sqZ=38xID_t1oXa>up`z ze9nxE+?2n&52H*GSI^PD`7`n|*RktyjN?hiBM;hGMLG9mmmbmc{B00?ujlsObHw|t?_Wkz z7Q^cI#L7XE3tLLhY|I!JR|7&-v}Gd*69PocsGX_-1atmW>3SsJ^NTr~Y@I zt&!f5e7;}&i--aTg#V~~c-IXY+S;kQoFKVx!FD+xnQQ8ExA=U&K3^jl^%>XX{NcDR zjB;$`2@fXiDT{^WC%Zzaw#2b{;hj+-qw%9Ekk5heT{R>J)iPW1ZYXxIkX z7vF~nmZ_|#i_zSBlg@i>BHCC~7d`QZeOEv2AZHmn{y3>~W4C^_sAW&;{oTB-VY!*=dLq@M4BAInRgZ<(+6;yH3&2Svf{(p$MLbK$zfXPy04rTvF!uDwLHgrNbXs`rl{}o9It=qC7J)(9;@)>+33%)a=+}8tbUYsZEsao@6r)d|9 zGc6Hb>SOKA&Kqx0dGwwGTd!M-m0nj@eGt7n>iBFW@uKw#@%6<(r~xN??^v;vW0e~G znqR*uvwP!(%hy}Ic%f`ufjTI*u{aa9b|?S|oXTTKH@-u*BMl8sN6r1%%cXA;elnJt z=e@3GKoWq}rE3{IZ_%4|vh8tsI|*xf0N?&SU11QxyFRhua$~-QQTb<0 z>QVjF!3YZ4`m1aQ!&>Li<8{}$>2l66L=UNbswNI5O?`?j#(HN>Y{f+DQF81h)!taSft3%=6G5OjLr;YinL$aKli!RStPV(?~OiJp7&xh(K zB*D}Tld^=S4O4HtUc;f&D#jxX-_>QQ8)vn(O&jO*pDG3B-<$_E&KrkOH!WHvn>H=s ze*Dn1tWeU~wBpuJ-Ms2GW7@ptyOY(t9(cXhyzvoC)3O;xXx6e7RUOf?J>J;avJ)>$ z)4H3lX7*70%__TfKf`#vC6nH3+-t!h!mRDEq(HrSn%zpJ_>cM@%IyOn=HE88vYqVq zv-UTgZS^>zu1)=Z%M#3{L|54zSEKyz+)pdrf;v_weIH9dPsWo|BrX=rcHC`*(MmXj z-^3l2b&jt;rSOkAowr;KaMt#;KCVa{ZtvuDzdXt6v==7ZI!YfVQ~W9{DjMoww}^8b zE+JVgX#!k)tlxsuB6HaH?sZ~@hAESt&KK7~#qngm(=Yw0`^qZuDprlugbvfVv=uAK zF|3yoGAm&~4rZ^AESR-Vq7KItyRgScFH1^L^GhzmrZ| z+(f=n&NtN-K27{1h+nM4f(#8<8YvbUJDm6knl+sWGLlNPt=J|O$ipx__(8_r5J)qS zN07xTzot7?`Fxg7vBvsF^k^zRRG^TanoUW?ae6$9D4WfcO+`O?^4kbbF<%zjy_xdN z>EcbX$XeN^=g7?Ep^M$QiT7B%>8anB-{bRfBwW zm1UjPh3p2Aeqh%^(nU@Frxd}tMgt`?EGzm^D;j-x)uH!^f4zI`_2+QCi!ZfB zF@h|3dU?od>vi|z8qde4;|(}Ss0Ty?4Z(EY1mn)CFK1{YO>j^aDKyov?o5lVFd73N z-Nh@B+@RAq=3}bMqQxPK30K|L%)jbEd!p~`a7Y`>WT2m&oOdX9goZ@cJw8Vr zu4>q}{t`EgRG8iAfl|}S1gw?jHtY;tRvJ^0k`1OU? z)fE|^*jfpFw1#*lFFZce;Kpn*K-F_8nfzqUw7kB#xX9_3(T<&j#$1=mc)Ilu6x(f6 zgF);0jZpbT3+4B%g(0tcb1z7!2NV9_`@dYQ_*Lu6i-%^86Ff!2J0_lh08zR8-?J-TGSoIO$@!2TTF}C zm3ZAmj7V3T%ZhjpDfz6m$4(&>Q1o|K$H~m(JUw}d>%C)Mg{f|!SKEG-W!mc4ud~4v zxXHEC4-2^@KK*OakgEcoz)lqV&>UQ7k~~YR>;j*L8*Ab#Ps?6?Jv*A%W<@Jz1RGFh z1qA%tS^aQN#^kE>u^(#_cvq9sZ**BsO|{kS?Me4;{UW3J{pYYj|F{0!nyyb`2dM-i zQ*o|0BW3>%l;4TWWSrfU$ci7m%@LWaaQ$0hC4OwQA+peZ_P07r{6r-1l4WPbfH_wD z)Umo~Y|Tg}ZU-|->7D4>F^#Y>=FMpUE$!0j*>zxJ(n*hCXOF7&Uv6~N!L zB5{56aKnG!oH~C)!$R}40q%CKpWw?-%jsXy$X=XS?<{>Hyxx?Re9Xta&H1}@NaqC| z_P3QNiQ(})43qp9Nm5mI2zDrImM2AV5t(l{$pES8X)QV z05%7VP&rNwcMtsP3PAzYk=E>*9s9pqK{rQIHlOlaM>5((K2t}w+(hw&{INGj4K+uL z-9$?=NB_Qwo^Os(zKKz1j@h<}*=LS5lB+VeI$OGgwGF{~{L+NK8o9TLTW&sZ3GsM< z;8D<_f5~`Gk8bWEfpcxWJ5(B($~;ehr%$~_jPg#QWo|Q%#DvMBO^t?CDGt8>VIe@A zmL%U|xswe2G_p!~Qily~DdXEi^3+QU zdXe>BeDcDrbVyy!am~il9OW5#G`*!IZ6xK<0NDezViX#Mr>14{*fP28Hk+O)9#iU- zVLTFDB*%+J@Zwfm5dCD{HrLrKJRQBCh$aW9Rf(11y+<2aM$b)Q#g4I6POX}`roHEZ zPM4JDcS;VWv3lj0#l@ZS%FznT(rV0k=XGd-PmsA#l9llH9pQW{k@6jpIxEq(9nn53 zv5_6IX)E#N9W=dEe0lWdNpht8IkG|2KLhz}%-H*Tab$Yr{drjlRO|4sQ}oiYE6w4V z{E=zz*9va-a>$h#y>(SbnIg%HGofj{v4w()6%PWP?Yal$SjM^xv?$)u9QDh{XQv7@Xog%F4QPrbfjBhUS~X^ z!~9B3UR_JYS*05*Y+?=F(S45FNRDXxbr>ww){m3b&73f!jqp5ifC+DyU}ON`1WcMp>=zi z0#mk5O-!D#h)mf((Kf{ciuO0+u@zW*9lHB}ZLsi_mYY^L7RRiE#tVmbvl7!_EmDDJ?HAODZoKpDhVE zD*H~g5yM`gH{&_%ST*lhaq3v+>R7()ShH?i(dJl7aa>F9RL6c?$LCZpa$GOt)S!Ia z@Ybo(=(y3+smbxU$K8s>@Y3 z+i0~((?-Es|FBnzTnRgSvp@CrZK|ptk(wJ-J8n!m#ao8+yo`6P`fW&1~tPCf7h|PXbt}Pz<6oN z#JN&s=A_FMrNv?<$b}TfU1@%Smz<$jX9FLax=>j+Vp^&^zbc$Fsyf3S0;yNd&q7$8MQ2_Or5$8c3)EGlWI(b`M8po2HtY{ELppq@o`&a3eZB__Rj=T zwNPoxHj<#_uC;s{tFObZh2oioGwRo(uZ1hFMe4mo5p|6HUSgxyVl!Ui=cT>t72-Mk zP>$90M%o}|U6Et20ttR8N^gl{9{9!nm6T+KR;bI4?Mm2^{v%#8TPmw;V8t$wk=Kgz z%~Ktj{(j{1ilEg^lgNsK#-BA5{9&@0p0|}nyK?QU_Db)LFM642qgdFxPm_0VRP=Ie zr@a+2?4Gv-c24tSwD=B~{{}qJN}@K_E;lq1|GhkPhv!up%~|$C?4>1N=>+Cq58UW% zKqBkbKVH$CTDacASL0GqLd-I} zo$+7I%5c(IDRbo)CJ}GCi2OTy@fl^AXam4U3Pq2k8fSCecYaI-N3%?n0M}kz8;i!9t^&o z9RHPFA^Kl|7Akk%+P?3N@7`Pa`Z(SBc=`GU-uZ_4`o-P(CHwkk-1!&y22|Vy)cXdu z-v##j294eY&G>#;x%;r=8+?2h948q6aQ6}H2gAIF5&DHt-iI*wg>u}7^81B}-hbT6 z1&G~;Yx_kQ-$z*aMLOL_dig~KwtPYF!HN|6$TAT+d7q8`@_`PANW z`0E~H{{EBK_~(+`FFStw7x(Bde)0P13905_H2)*AheVEtBz}JlJpW{l@#Og2ud=OM zn*L~J{wcWX-$qU0-9G$L0j22iM5#`~n+g6>fpp6JOi*22zJ=-ZRR4{hhx*LM@7;8| zk<&7wvzbG!>lY7_8u?lLdBkTo8qfYY8)JE*_UxBYmgRPT^ITQfMDl0GlJ8Pq=ugPj zz42c+X?(md2@42O@+(aaD9d;(D+nmBcr33Eh%y%W$kc%9)aFTYnI-F5u@g`hA5e82 zQ2q2+4Gyfqe5yGnYoD#)EMf64UC1RB(NGg9!W}<`6#2ZhAeNcOPhP5*4ct_0*Ij5t zv%Ag_XESg>%tU@Z6>xJeuPD=+$xmr-y~CE-`g8iD9daxz-znO0{yD?gwCgx<{UUJg z;i((55)DTT-pdfw#~~()(xE|Wn#2>dFVL}ovDW+M--_x#qQ}gEcO9r7_TJhG@_Tf6 zwR?Z}{LIy-xgHuc7(estwePSKpIBbU3SGnAdi$GJF|YoPC5qYKGymK%YM&4Er}lz8 zhnV%NEhn|H7*ITiUp+%!eH~ZA<&EFPr4;$_x?0{0b1p+eUb1rd%5&Hj|Kgi9W1okM zt{Avf9IFSm-2S}W{JhfNxjG@fRxiHB-?O&zVRf`~{Z4$NyK@6oVza$-lT>1B;dx`H zbBpC=lSg9vkN7Ts@UCR=-g)O9$IG5m@V-~qj$79s->gO6Q@QNcR}!G{&W z$J#H4?Jw}%(XQQ@mxJn;)1lzg{+HttiSzod^BswcKV7G|-K*f96H3W*FaXRcxxxeA zkdy>NV9Rg9&bm8s?myhvNnUFQ-z+@e6uex$?*2qtg65?cbTVPs4BVM$m-#;< zarli^4HC_V5@_W;8U2$il@ge>^M4+^wNgpvu^TM(pRrYsf91P(c8L@dCWX(Rv(ItW9hA8e^R~05&5yGMFlQka`E~25x=_ zVgP*E2049dZiKT^sxAy27e|w6t@ zRKX7v?;YnV44ZwPDSVul>KzuEK2Z9)uC;5t8x(8hvmH+?RMk0f9mUxG#>)~9xpZf!fAqo9eh%*mWv))58P!*7UuW={-Y2~UE?^R< zDu{{`&*|uzrp)QRVoDj&#HReKEkXC5c){fTTFQdihtAV^1H@a6MR1mC9)X%+4ywaAi?xh7Tua;eA`X8s zP!H4=g@AFfpsgG@P(UvL4@#B>1Ij^E!hvW)Qnue+m@z|v5He>Nkm5^gMQ#|$79b(T z?E7JHmb%974An(?Wg!p>3=iW1ga81Rw^B}6&V%IOAL5Ix6U;rotF-T8!w;q1ch$|J24T3|Y!iSuTbDz^l zML#~D@vqth{K=buKO9_dz(2lZ&;U?br4I2gU?{UWpp2*<7Z_9r<|8X+JqVYh&KsSdwOu zDe&2934k@KtLl9EO+!Ph*ZJys<{Ww>@WK}wm<9=qX^vVIrA zx7x3JoDNG0Yo%Y_n;v7_0X6~Pn^BL>e>Q*G=7m61gf5~hFqCKo)jDUG*GTfdK$)SM zCpiu;1Z{0w3L=&}^#v;04;$9`6S5}kRrVp(Vaq1$>zWiEJ>rNupCzb2h{A9?_ zgF5bph_)qyU?MyIQ3X_f_OfRv-P>Q%jFKSA|8}%QigtnA_m=?a_pH=>$C8G0aB}YZ zjPFv!6b<>N0FdRishr{R+tjXEIbs;>hztXO`I`uYT>ujuwnY5fhn1LKvH_cxh|#>q zN+P^Uj>s0EX%fWcS}8|5Wk$LcX2cbUQGC7DW!>svIB}%~@v*_MkzRc^@ec>xW1}Aw zSY{n5q;2NMCWl7)PHz#V%cmgblV$zx7hN~MIgWQgV}pL0TjNF$%=}u}K%GrcfC$gt zmCF71u;77N5uMbUvo8Bz`%?4F(@%7Fd*8t(^ZXz#7gtD}!NR&)?WeU0J1ld76_gag zAILhkqG6-6xnI@7x1>UYSV>oVgJuQp)II^d z4b#9#a1G`KpygU8kFJ^3J%id1?bv?W*7D2RK&rJ^Ug11hr7i}q9#37+R zbz@GP$v!;3F(E$c8H1faeOlX9S&5%{=fTT|OKHkb*Nl2sp{JE$*3NuyO7pe3E+5eq zf3mp{SZ1p38X#?S*CTj*7Gah5+ER+#2?%Zo>@r z8!7>JdA`lyBt6)#<1J_dG8qeYMrxr_%|+p5~Uee|vgcPh!S=k@y=Vd61c^p4U* ztS{L1=~KW|8gM#rF%a+l;{e&D?lWJ%>ER?`Xt!Q_97J?(668ecD>afem?#`LMWN>j zD7=Ago(bh7@XtsQN9HK}?dgFF)!YeMal6}WBn@!a`!=c+Tg1`1xAz%(oHw;x<~==H z{xd6>kTSn?-C!OU!1E`V_?}CYHW_y`^w3=*aT6AGz0kgW2MTL#Grbb_@tbJRKl^rJ zpCcZ7eeH;W-!&&}gcomc<9!@=z&mgt!}CJ;zViw(e=-$No{Ta%9FWQzld2icM`BB2 z8krkx`$zdTv_5_$Yg@=lb$Yie?Y5mTh!ecE&CJ)}(yLkNi4zZgc4^=R~&`wHYoOcciyDPe)xlcXCv zyy1D6pXkWSCw_L}5_)TiRzU$(YBqZ1L>!t#e-oskQed+FXGdP5`m&x`Xx^eG{O6yu zq(O?5Sj@{w92>YBvHaw2BqFcUBegiusc8z+E|GJjmZMH9@u$^$$N+wOs1qa+ljU+w z!ir`GpU@wle|CaI)>>b>8tLST9p@TmJ7Xco_^?{WN@sJO+0TrR zLkX;*rp5Ol5Uvxw&(}i$xOhu%j8DDfkP+YlHsR&V{mjw~RjE-| zGan#phu1x+^R*}w(CEJ958(v_Uw;4mx9tWqr*~>pl`|-SRzmo?h?*y+HF&Qz|BXkr|E?FQprhmQx;=RV zV$w{Ut{2(xAR$G3`>;9eD!gO2dW|TW3bw^^z2J4gMZe~Mz`2mr#+$n07YOv==hx{E zpCS$2+NH4)K#zc`&cuU`_!=tgP|ShN$l zzXRu{GYN}=N+LVB$Jds&c$haE={w!h(3u z4!zRDnL?3QaN{MksYN8QYQ7?RJ5j*Y4#5y+kkepzVfN(CDQuiqlWCJd3UZf#>bw?9 z(X&i^-SAah@zq;nVng*40Rjc2FB-a55xS@h;BVdsX(v5`a(rV9`WnQ#+V8b{ReDT_ z4ULiYwCw;`QZJ70m4j2zigYDP-)mIrO62|(t9fPEuB#utMcVh5^n0)I=$r{ZSO5Y5 z&^;g_V*vmFPHcc6$P39B5QR7)AS7aDVHOb;g7Wfw3<nD*Wtj6?pYZN?H2R%SRL)V^(>ogD1w=;@_pWVTml**Q1@{JhoG zR5-b~NJz<`P-sa(RzppBT}>qoE#$X{_QBr9^w^+Tq8o&cuCcMPr>7_FYl4Zf;fJ6A zSxzPgNj@!pHeNnHCT5mURgqpN4S72)Y8o0v#Wx0qh8KrhSy|crT`jZ}Vbhls%mO(Zthl=7G-5+w5*J5?Ci`etQiI}Nl8gk(lSKE zB<1Dh*57@Y_&GjDhe=9^uR7VOsVXxtGI5CW4feDKS_!Cl7zn+Ukz-?XDh_@dWWHOk z<53eiHZnj(O~a=sVi0LBDk|bw6zowQF+MsN7aJ8F5wg56otB#H?&h+xI3sDI^dZQf zmYkxvF!zlpBON_mcW0}vu1-%^D+MKGO`P1DHwrqMYF5_PlvGso4D{u?+AVdJso#?4 z%QO>|6|3XqEX|Dd4Ge`C87(w8-JR|G%}tw(4YUHy0|Ep21q5CT@Cj*2L#WB#@^Fjr zLVP79%hdxDxanjIoaB^gPOEeP@(2-{)CL!fwp^9-4`sOQEru%ln*79S3 zkA9@xq^;#}j%s;f_V<*8=GqD;5n(qcdrJ%REKRj=dD+;QNHATlV3G?{ZV)f%9)C_`2%re{5XrhY72(qA+oVlN_B<9$*kJtCc||_ zqp47xx@(-ES)&=L$OZ{E8qv(;Lc>*={T-|CGn*ysx}Roba}f5Z-= z6PwJ#Y9NY^rRyoJZf7)!V`a^x`P%aLH~z5we})Z*lch>;)KC2zkA|yXHAkv7m7T7% zcpa~gwOhj0d%`ej)jL`)cYY;vyc_Qjp4k{LP{~oJX1h6BtasWN?`*$2-|XLkcX4-h zJY35U7rdM3>U_Gp*coN13hsJ-T0Gv_nCR|?!vQFM8NnbD`%Nt*n$pcsEWv}#u-{B* zTj6-hidzw6wxwH<#GVIRAtb@9+tG~Q>@B_NvP&)f*s2b;W#dLF9_)IqaoKzm2i^YUFyjmumiPaZk=% zOtS|K6~Rkr$k9D8DW?Ev0;;PSBs3E=^}w9zO28P3Ms~qAnL{sCW0$t^Ip!e$lb~a6 zK3+@$5R3^0gh*i$0eV4rL^X&eJR(i0Trz9T9$>nyRC%cbhV?!eDF)tVR|+CF?*Yoe_u%M8Dkce$wXl-%EQ}CA=FCb`}1U6PPW0P!QMEdRUnAa(5KmOyhr4Q@|~H zTs?6X@TXxXIPjqLx-0Oo6AW)Z>K~#JyKJO&3%YD#nFzYT#)kCVpff_B|1O9oOd_Rv zR^F60P*C>Hrh_0av-@tCfTqBtK#qm2?YIQ+qSd<(&$Gty@aL!Fcam`Ub;U359x5-)e>;N^McVY0@~Z7cg2Ab5!YrUV@~HaC$5{B(*dd zk}A9i9%ni%o>Cc#w#i8ThFlzuU;X$a7g4-e^f>SkAvwCU$tZ;r3v7f>Fs&!VXn0%V z6e-HFs^iDV|IR0_P#j>i^oTQa-X?9gmyN>Oq{kIi9J*kt(n!<@c4gErkz*=9ON;~B zC%x+zgaWhBhirqf3L&U53H(NkI;-r_gD3>m=>sG0u9daX1sehCDY-VFVOTm89e|~p zl+X@jWPPKg{GGgxz9;}tHmLstWC8%}%cLzB>2Q6Ai$zji%QyZ)*U1efgzlD#svT+P zG|W{|@M8i@e}UL*zGAq;z}7bEI;d9>ta5bpEHy_mHOt!7>fvQRV-+dvQW_DT8rg^y zk3Hwv6L?JWs&HeDb^T)vIz^DGzkEJPx<5+j=3}ZEqpOtq5)k%tBn2X@7>bdU00vCz zRwNZ^IqFl^_I#HDrxBwe{~iHi!#6!EIT3pku!OIR`~1jMia-fo8xT$n47tA(hBD5+ zm}jpC(X$6&i5Vxbl=h%XUW8zHx*N@x&$n+r<5@Gv05J+7D0>6T$VO5joF*{vy$Jwy zG7w0317PbSR>T(4M8;?UbnWp;W8&b0aawpWsqBF$pP(jxWPa9QCxprpsU#4JSwSX* zq<#CH5&(Yp{Schm=r^j{1R3`~S=DP}^?z@ZwBHXvztn!RQ{AChK|}+O*M9N+y+iYK zKP2_S`%WGUhC7-IqRB=^4ZX-9OUwPmmJROH!~*;dZ2|E?`I5l7A!J0tXv_w%C}2;> zM#JJK{B#-cmr27&O+Prq#JyL_BsUb>D-9w&UY~vU`;Wxa!vqYcAs1EcK!!440s!Gi z1RDbvzZgyd-DT5NuqK%}w@5W4Jn}iDV7Oq&j8(Qk5H0rJvmO9V#hlk7ha-XVL;wlf zzg|iQViz*GH10dzSoHx(aRg)cH7B$ec_h$U75%nTS`)2+Jj*=t{`NHrO>_`)UkC-( z&jo-x027uGYW?PX1usMzT)CNmMH-H(P8Ln*2Rk-xe_Au>Ymy58aN58Put?hm$XQB7 zL=t5{D9n4M3}EN>m~!9_o04AgI>%^5i?Mg^(U{J;;83iPZNOv*cI2e1U*NwT<#Jdm zI)QBnMCgYOd{c`4x;+7M^NQ~7wn@q|H^dq>Z*^kkqPj&V zgBFI}p=ks_3qhr92I7WKdL$S>A4x2`VX(s{RtI7G@Gjp}ZF7(o1Q}et*Cqwc4dHI4 zb|O;*I=@N)ywMGp7q+5QXf$QSW&A|v z8LBX9fN|k@Z}0P2ltz%R7G(2I9jE}qrP?BeKTP`S;LWzeQ1ruVFv!M9WqO|R8iXG= zaX-S@>UmzSGT=ubq3*{8x0xHvtmljPZpCyS_~Xh(-pxmXXjFpjckxT`CsY`C%K_|1 z4JU=&rNS`o=^t3|s9~lKhkQHf= z{9v}lA=HbZ+=~#}7Jd=~n1Es^gKa3GJ&Xa3nnWm!=RQmd4Z?eG@HiF5A!N%$22(5z zQ#tr3Ko+h^79mG0&MJtyv=1;yi{O9(4HqMf7b6T8mCU0f-U&t8phempM3~q|I-x~^ zcq4HVB8?U!9nqpZ6(hZcqI}Y#{92-de?@+bjtnA;3iFE!CyRcM79GnP9bFm~2TzOs zbRYeNEaod(%r~K!)WxWz(wLO!nCxFM>3-1}tg%^Wu{nyddG^ue2GNy^(Z%<%rGBv$ z2eGwiarHv6%?7cJEpe@Bu|J~Yx=Z6aS>t*S;u?fLH5q*R>Gx?Q?bGl3Pd#X#`-Gx# zps1|HhOEWnXbqoN(}LITKQA)iZ3=x^SNyW?_vIk%%Tddhlf^G*_g^l^;;)3_Zw%sZ z{o?P_;vZY$|1HKN_ys_o01{3>GEBHU0O;6KN*si%w}ij(3n%jn!%q(tVT~a1Ph_Y| zAX`j03V~5AeIzUk)rd}HG)yAw3#AlJMBYji_6wy{N+h*U;uB7WfRbJxgmJ>rlko17 z*ncGnJS0oC(uz1FQxAsTtQWCLbm;h75mmJp4vj!z+;g)zdJPfG+*3KjrrryrFG8nuJuj z7Q8I~bZm=seEjctdEcoOAYn^*MP-zg{-LZ7>F%C@WdAgh%kMviGZM(Z(R@?D3u$%EYzEnigj2BFJhE$-){Ag0!@L39D^F4S<+PbGn5sYcu39){uahaE3v|BmtRj{x4r-#A z{Bu;uSlt|elO8#^03eAuFlIO5@gWU4FZ<*$8wo$>ItCHMmm4=6E@7WzrI$x&lo#WV zM{FEeiYU{NT>z4Wfw)pY8U-K|6c{7`q6`Bv^oS#}e8|gl zxY-hWhtr54#VAt6F+aIJAOW1)eB3aA9^dnb(0N4K%iyG zPqyrgC8dColDd>)r{&^JPd4&|T*zUuyGVIAepxd6cS;Q24{~KrEX5qjz?R*_Z^~cM zMDWOJ%50X)93Q!Ik4g)aGqQ`zarrsO%>h9=pcro;u2qI+WNu+BjG!z_PVdKTdf5I_ zkw$t22nZyUVqe{{7@jUnuj3sA`Q9s)Y_KIw#gMq`EWlty|DZc zLJK)OvQTrh#nCP(T(06R!<+I4l=J1UUjHb!u09Z9?*?j$qEQ1y^W_Ec)(z9=V`_<3 zlzs@85T)ln$CiTWsPQ6)qmqEK-$>e*x*tqiMoM zU!_NX7#;oqTmb%V0~t0gO89K!zDn?<)`({$v8O4(OB%fLIW>+gt}HouqLQ@BlgKfe z)C>?wrpaid31jJH%1;)mqe@DmwU*zqupF9Dr)pD|YW<8eSq&2PGIFQN8vQ}s2RrQE zqfJp|%>Y0VWkT7cQGL2&_|pj9SIU+Xk)##J2Gzsrs1;6i4%;&2bV^MC69iPL(@Is= z8mdxc)uhl!-*%{kR}|P*R*`5G*wkRyUfLesoZloSoP>ed>hMH~6{hlQ7!f7W0t5q^ z+VlAMGY`o-L3tevqiwNHFh$JvozMTShBgP~zfQVOea@m? zNS6RgsBL^kSK9Z!OQ%+tXqpgP*OhS!jZ_iUlWP32#g0h+og*F-UZo3?SuIUX~B6X}`)4wl(|Iie)&&81#MS zxOrTqQ#Rx4HsxT#_kNnDen8EDhI5D?d^MF?6!GT4!80_tXxu-I`K$P_JHz;=WEmGN ztT2-*XKC9a(-}yaQ0d+WSiJ&HiVS>I`I^}w;rgu<$($~_mVa-DeRC8v&0${Nx6z>`nSD`{&ei4=oGfq z6f$h8yLgJQXNm?J5lS)1Y+CSdIgTeEWJ9aQH-KqFCRGXs_hJ7?ofq~@TdlN6+*cIf zl4v(l_^VQ4Lii`SG*GpC^y?Tsn`c@YHEX%aIAA+0=f@JFH75PvqTZneY3}@bQX7u_ z*PqkN`Fy|{YDmNLGEve>lNw#wk7XVIvL5kOV{*Lz;!X?%5OGQX^guF5BL63MB8U?K zoe1Sb;3h&a5sr!QO@wkHSQDX{2);z%CIU1O(20;ugo^&hJrTHxKvD#iB8U@Vnh457 zh$lib5r~P9O$3!9#1o;M2+c&eCxSQ;Scx!AgmNNq6JeAH%0vhw0wocSi7-tBry^7o zA)W{cMQ|qqJrRhBP(lQ2BIpw#n+VWE04Tyk5fqCMNd!kCAQHi#|8YzNgCdL!ftv_} zLqP3+xhE|`T@gfxpihK>BIxr!?unpM1bQOm5kZ^?IsFfDB774eZU|TXpR$Q?*#C~3 z|6Ml!1DgL`GZB=DKuiRW{_hyi_p^lI3|LC|Kpel#QYCmA|Mz6%?QLqsPumv6M?h; z)1VQi`5%BruqJ|r5weM}T7>^19QpsJZ2m7VM{p+?jS4Ln!JWwMCk8EHn0^19I~`a5 z_uQ$L4n}|b6PC*oit{=QgZlsC&W5s?63qhTziHa$^4St0>T4s76${no{jt<4O_fXa zZ!1t*j;>jjo85OtvQ(O@*4iy}g<1@H07@08*iiG$JILmDEFAOMxVKy@m3|B=*{ZE| zd!uRH6s$eXHNW~p#7U9FXJ8ngGAQ*wtZF;$FVt9#W~;Re?#+@sy_h~t!t4Qs>Dz+B z35vKla-m4Pzw(h$aU|@`U0mAR{vQ7i?sT2LL&4~xBZ7-T(tyb0$WM{xHFQXGa|Pgg z2`WG+I^YgBa$X!ETvFHdU#n+4?0e%W{(3Ea;||TOi9=b*wJ{O@5r?a!9$m{M+0C|K?L%hI0o7N zWO~m#*s1hOGs;?s=4(y{ljTW;AV;#1QMhA_)XW>9RLb{aA?MXdTad7lzk8$SF>G8E z2U1{6U_zhG(`6`C0(%>(YE5SNHXR*R)C|H!N`UxcM8Hsdkb8wRn*l{47$3=44qw5! zM>Z&uo(O18$@zr$1?2(71Sy<6#J-LMztBN?mcl$7BYPerGaTp+K`L_uY0BbpxYvNt zD@WMRJ8tHks!jbtHMB@vXX)8?s8CIFIW&5qBI!c>C027Rmb?jpw4B7YW%UBYk#!j}e zWhqRBB-P9iV;@2k8M`b+R1`I&8f(ZF(iB>hLM3UL>-GM;Kfmw!{c)Y^`v3aZaSnet z&g1@^+w<|XF(DCbdw)LF{5EPh=i>R$#koQ*4N=K%IbeX#Cf$bq;w?jc(JI5yd*nnn z&+*H#qsy#e?S4Zl?V#0cvugz3YI`uIM zd=Ld8rNLnt15_T%$FCt0MkK&AQjPvhz*kvq!23Bl(Gfb?Zp&-sS$)bzxwvPL$C|k) zUJ-L8Ztr8$vxOEE*J^jzgy?RI5~AR0JEXMiooE$I+P89r*(JS7MzP(9R6g_P1oFm( zQ=-&(%v|5SZQ#U2FTQV2ZoS;L9Y26n7PY6Mm5Yfm6hN=s+xvX)>%T++83H*JQBS}_ zw%#WLaDgT3&2!&T_;2V8sxKanP$L68q%`L5N+MaB!u*?HXu~|f2MEd(;dk^OZLHx= zXwqqW%LfO9uWqI{UG~f;-PSwxhJmp6wdM8JEflKR%rF_P7Wk9^@T3#tf1S(<soub4L%fW2Bke*wI z+vhaEaoa8`8?93@9vV8FvVEDsR}UU{4!d97E^czESN9nj_P)Pe(w*9#rb2`?tztUB_T>bRmR1T*>{5X%-3PjMKh*DDBxJt@wo} z%2=1LV}3FAddzn<-;8;;T(gfq=0DX$;QC*Xk@5WQ1x55c?AqUBy@qhu)DfsiJ_Q zBj9CD_3n_m(+c|?4HYL20i!cDC;L7eEMFhL7ZlS-PYgW*>6*;s5rp%XkpX=oJuilM z9qQXizhCZ=WrBx(J3)pw48Pp^J%JNA`HoLh3@Cg72IKD{T zO{)E5p#>z2_)o=@bY!lLMJuaA(qynOev;M+^HWO`;<#=oR{Jj&e`Mro=5;g4jXO8H zeRrGYI%wIgsb@_5(#s?OI0nCR*Q|@)FsIIuEjp+&L4InA?L?I06B7-AbSwO$;~hAA zxd1HpAHjy%JRPdgS}@Zh*-+eJHcD#!MrN1jBgDH~Hlj=2P{Um%jNEe@Ba5rQhrIyE z!&2I_HTTD&&2>4Ix9IV{uhW)(_7m0BoEwe0WG~u7*4m%+k7h}itr|0OlQc66TaVL+K0@>ktVV^ z9{UAZ~*Z0vk ztugdhUxH3Y%bt5nk`7;jss23La9$`mnEgVFAE=7XJ`t~B&a%GQHMmc1BfD_}w$I4% zPFoSBBu@I}=ks^71hvsA@$(QJPTZ+y2DeXnF8+jgztnE+*|<>(Gp)`T*mV&MLSKhr zJH4Gu&v>|Qc#QPUUz##yaksteh3tJK-0PkmDv|3!NRTI;`qVg>1cfq@Ng?x>`l(pg4Z=K;u@7{*eq6A**K0t-;=&pYoe4=^5`tNAUr zsBsAoi{U`tDSh7SY>`-z)1d|i<87@ z!kBJ}bI<+$bW+)Eq;yX7%|ybHI9%sJf$wrU{_kEviSOnnc+`ApeskrT@tie&8B# z8omShUxfkI#ecH|Ob#$nz|sKw1T2%Lpo8Fi4;BSD(}S7u-`)VHc`yvX$sU~k!E^yb z<-e5zPXAzafEfd(0vI-6tNb@qz@+&v!~iP=Y#T5zz@7nf1swXpBp5sC0oD#!CSY&m zyIX-E0t^+9NPvX^0tc{6K>Gj&3Fr|(2LTSOV5op{0c;X*ln3ntIL?9tE0_e}SPzl} zFg8H2ka)ldgbAQ=0JTL|#37I^fPDgb5HNl~76H}~SP@_;{kLa2!w-Q_0<0G>b-+pi zu>+_cK+6DX2rx6iMgo-tNF+df0fGpSOMv_V%%T6*1*jpwW&m3V)DxhI0M!E+Q6Pc< zg8{S*0j64@TmWMUtP#*YfT95`ACNqN(>e8!892v-1_1;JAcz3R{b*}F&{Ke;Jm?od z3IS>b&_sZd24V*gGJw(nq!9m=DIiSvFJS<&0~ljqas8j%vcg+~iUdq7Fs}apsR-yq zz``^(HI275JaEwA|74Y%BnC7Z%Cgd+#Q^067#{z(v-|&tzxe;6Fk&>R?GA;iQvc5i zqnz+KjRK)Uk)$wo9$*J6V{J2TaMfAVI#)X1X`X5E?Tq=~EV;2KiV=I)?ba>yY>1J8CD?UpF|Yof=Ldd=k0i>2B`lhOAL-L%S`PHrwAJI z$?#&ohc#7rv;>Xazw-&qlE$4}sqY@u)@Rza{Qd8Kef_@*gEU!nyi8#I#h|~4%{fQo z!+rmoCHY0|gvHv6>YO9e_{VuwOD|gft1zg2wHNR{*yz28*8~4Qg%KqbP5;$ihS%H0 zPVgUD&Ad)VJE*=%7xmt~dgMTOSv6h-U}RCG zE)ecwPCjVq>AQW-ov_ZM(U#7GM+?CXzBiCN;iyYrdqa8lH`!3Q)+bP~?gwq)@A|vk z)~1B5>i0SO5W0sumZ3!;I0dKz!dK9z>>#Nw=ql;p(amZ>kI#BG2x-rjyV4ehw{2jj zWp0h~ST7np@ADfy89U9xPfGkDm++Af|7k?$8INBKeHt$xh=Xtub(wd#VB~&$@V-k& zL*N1Dv;c6o{P9Oiws-df@gfWo(CEF{Kf8}Mwm6|B&8fS)z~=GXnN`BL`~;F#VmA;# z011N3<*qk^hDV;?KydlA??=K!1w0q&TRXC^fO-Bi%aGLbvGWS7u|<>u@_Qn(;#w|! z)<2A>J1ci0&-4jH$qR}UD~{*~#8buZf8fiqGW#}c{pgIlXu(+T%%U>m@6HaCp0=Zb zV?*nqu~jE*ev9L%zh2ugn7j-AHqk(^uMkHVjbF3av7w%`1!Mu6Wv;jTc*$5&N=nen zjJNlEAc)v$CEk|9FumiFoICye>2@vNaBb4!S zKU{vuav)eT%pPA2#dKG@&{Hn`%Duw@NX>juGJsXZ&Rd{u_;iKhF4XuBwkug&A;*n+!TQwD9TIr^6F&<(^6vg4hyDTTylXK_W`HwA;+I*1R13$G�PpEoV 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

-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

`Qf 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

Ku_Jr*XwxJAf$ zFvca_k`!`Pr2sLKVHu5q6sMwM2Pxu%z*)+6GEI0zg380sqkD{4~yu%BIggO2*p=~MBu0>COoVybft+DEv`Uh zZns6PQ_oSTZh=s6NJMiGWH)$R00$3e#H@uxhACnu*CJSmSCw58d0kWauoRElNFE>m z4@Kc#b<`JvDX*<87b&4JIQWF3uejWm6zGc9&X72NNSun`bFyO6427H!ANAP+iUMOE zh41SKMlwi-v4=REQaKi5oLJJ5Dgp`LgGta|T+0ezM%4*&MrfjV|3|?E^j83_0+0oq z3V;#gVFbc>FP%nT{fYgAk zLFoh_GN9gnR8Ii!0x|~33m_GM?4KISzvond@1TPMF!w*BYS;-k&_n^K8guR>pjAN3 zfM@|pgH{UYrhsC~zhWzZ{(oRAAoV{bm48pJfOJ7s1@Jm(s{r8sQ&<7Q;J@sw0EGZ* zE13#powUf2);DM*lrv8O% zOK0YWHn$<<-&_lAd_7ah@ei(*Zsv_RO}Ex;iQzI=@F3fPyG`ct|KQp?D0^smf*g^{2URSuo?C*lh1>TjWC>j=jL11`i6ZVk@NBaLLxWE`&&8A^wF%%SCp{!d5 z3NEy<&YT~9W!P%(V2OsAr1IYd7dDCPGjr&(lFRagBR49>UI4BQQfY6C!NNhxr{~UB z{l&FGiq_0=TpA6u!LCQ&rhXS(ZtpthgpuMkGp-|8GcWYJ`uxSU0S9Ny=tUy2=ljQg zbFGOxHIhpwFC4Gcv2*n=uKgL<9L3fpcUkf;uHD1$(0qV)71mh%i)#tEf66!sXb<89 z$_k1G|Ei#s2SN+P704tIS0KGW2!TujF6>WL52P0e9x%rsmOu`Hv;fom+nRY;f}{a4 z^RTiMgb?WRfeZub1;P)+0|+?~P9Ri3qJRJZ`3Hg!1OsTSfouRl2(s-@68v$0V5~tn zfsk`{bq2u(1{$Q=9|;Iz3o9sUi zTi@Gv{R4wT!~bE}rl$WZiS+C5VZ+^kFuaCZrnyp4JWRhO((6NJQG1y%gNihK+i!_f z7Ra5;n<%y`=`V@2OAeVmKDc!6w?s;c-Klf0XZyEB+S9BfW1nsg>STu6C^M80_@TZg z%9Jd{Elqn*Nh=0*vhJgGRJ18rx0DT`f=6kHNK`ZySMl)lAdpD=Wk%3aBsO`C)+LtRb?>zl2kuZ-0$h=}gF$_Wkl?8`$_h&G6 zy37EHl#y0JA|rWjaBcWA=qMB>@BxrW*JydRQz~?i_D3DGdYCw{J6mmc8`e*9FbSLjO0V5A`0Jv|EKOnw9fc)+Nd+r5k0740* z3P_AUfdG;OL=A|A|LrH-5|{>31V){!`W4?nx~KMiuQ!0tFPVNKb87-WO%>L)vOnJ)fqkS{-w ze|5*`3gSP7LyHQU)XBCh9T_v@DooaH~`NOpK*`9L! zlk;;Tk9;DE&Vwqc=*fAjM=mbqM;~9B{hSrm$N5q8)4~_CnHVYkQP^l= z=wqRg;BSL`?Ukro#xCQ>Kfb@z3k!aby|xiDy#NgI?)?W2#+KFIJdJEF%n8THyW+e? zrIx#aL0-4}7lSMoG?lBmox_784WwX(f)%BOL?c;v1{qS4z#uE}_WX-MzN?f(wT>mO zzSegm-Dashx*e>_IdIHqW7ltktSmh)+ZCn22>4noa3`MN;Wn}NkfjrramX^9U2O!u4|k1CzH~7_ngZIfIJsoPSEm_azNmdEE^@ z0St2YuFm4UaaVysK6TmljBW01V37A`b(UBcKmDH!azjd~^yPXV*QWw!%k1b^Wy=aG zC4fQRmYscFmAQir7~~$A`|@2K=I8GApH`VaU}0GIRWnlJ;QUF`@>|38&E)S z(jLoIMQY%Gln?nmn`tsiYK(t#cA*Im`+nNVI@?zfO22d#^N=LLEV>=-bg*qwbqa_(K+u^a@ z{Do!J6~??<+C3_4bGYuU9n<;sQ9W+nzH>_YcV44;ackhI-E(V$r|u*^8a`WXzheZ| z_%&$w%*&(tAG}6#^go`S{hu zbL{+*efDboWR@Uj=wx0-&-!G6MtQ^MGH~g3wzxKFb2_)rq2X)An8f4R$9FmDGmW#i z4WQG!*BX{cGF;(HPX_#gsnk$qr4&0AZ>5(Tq21bp6i&t##3Z!1wY@%?ynSWkOQgot z&8b_TOg3g8OYZ(TU3zT$$Kp?CS;Yc?(J z?{&F;Fy(@PUNOtp1aD94H)YTDE^_-O9Q`)bb`WKy(O+pAGWS{9{h?Y`)IRHUkukAt zgUZ4y_dR{=@}(7c+SlFH2w`te%5d3O8+j}wMZdk9UbC)opt5p1@mO3|cI#Au=IGq< zc)NSbKe(+E+%8xotmmIopQzqbLBvz(KKl(=Vj9*t1(L zhH!~C-8Z(DvPM=;(Hni9&!tq~(K0_}$ZXqt3|>i*Gn~?1&txb4I&hm)oZE!W_I2E8 z**uo0A~V6x?h}Nx{VVSkyHsu8qDbgG#-P((MqrKlTV7Pz^pZ^Rhd^_9+5dtYU6CKg6fFO<%TeqECgNEgMCyq2b-OV zHS+i}+`&bNU$?)yXb;iT@hq|}La&<6G4HyAEtWlmP!dJOW0<%R^i4fj7{W8D_Z~*M z;~M(X&mA}V5n+nMp)gaWelYF`lu4{?wto=%!0f%1F$0cKJny-62BzE6s>yrsS785R zL#Js7s0beze1ya{9#k8Po(mQ1BHXJhfw1cMZKM!(lvR+C20NLe@LH}8U4k%Nghwc2 zi8Imb2-$gmNR~>1z}4bxp)w}I+<<-2U>lAT4XKKavV3!G=KE5a93|$-#x>Nwr+hIb zJ$qb2U$}X1&~ox!_6Y^#oGW6 z?WdDHsXA%+z^(g8(zl$|Y%jxwp;uQPU8HTRdaH>VzNDPi$rao+Whr_1b&`YbZOL6e zHs7+|WIWQPX+80=7aZis<}!^IiG##l)SYV_dV3p1*y9 zkNqY}bYC!pa_-?F*4Zr1Fd{n8?E>LgVWIPp3Jw9ay5F%9_y>Wz{29-`)M6?3>F%G-BB0%k)p2_& zaLUl9xW_*yPAip>*tlWzw~R{8@AEHq`5{r>1guE!LJRCPveda_>O)lhn~Wa*wiz63 z=vw}4SMMS=;nA3(!lM_Fzeaj~{hUfl_XTCzVOVEt&O4@)O?vTTJ~%z=n~ZnS>s>ZA z#v^%)9^>Y3Ly2tCh{7jE7mxhE&mMJ#ETggk<~5p+%O zJXusZ76yT_5Obo>-@6B)f10eeBtQM^10jWe60@n^zm}^P!rz)7+hptpUspkt(%p|0 z#WgWGRYY*GTmPu>f#>(&klpPx^y)J^wgloYej08|mLdF|8Iq%4)z%c&_D3rEBgxdO z*?0tufu1s&;jaY4M+Zpif{-2^S?uB%1;IMhaB(_6X zbc8@VjHR>aGq$1mT3D41Ya1Xt^@ZgakOCCBLy;s-4HxT$1u)>;70V(sIJO{`xLup$gKQ*2;0*&LX6IG zx;@&_KtatZP6b0OhwFL7D_h=Wt{tQFDH3`8UYya*W6XAQ0$6;U{Q z<0G+A!$M@ndi)Dac&AWuR+O+o1!U}m?8QLw-eHsNl)H-YN}8BL1B^5sp-qhcgh5R! zCT$srP820?)g{kUl18l)%E5P_VzP+a!CT-8dIcoe8%u^@CMC=sYmCBTvcR-3UPxG- z5Y3H&VlhxzJGE0QAwrY7DU<;Brf$|HMbP1T>+7nENuO#{tTzta0&=MWx!Njx+5jQy z4|@IasA)*07a>pti4)vppvaT}aN#xKXJ)z*bi-^4dLe~yjU{bipq+IHSt9r)GLLYS zsy|Xx6LBdk#bzU82S2nbgw!M0JJlz0;>kqWs0r&dgg7-*0hbav7#D>@*i4ZxSQF25 z;P4CtCj)`UONZN#XX>btxEq|B2$88PVwlYGjr|h!(5pcVkB?nNU^+7eBTh)4Vq`qn zxFxWv`Os}Iu1#3B7okJVnzFhERUi!8IiIp*zuD>3JRP6M=Omj4UCO!@iARW0GsWn{ z-j17nZnq~kkS5gICQhg?L${@P|5Uwh047pph1j4VR5ar6suuvoKVyd!g{`9#3 z90IuwfD<4kaMxfN5|Ag@oCMej&=Ck{V4lIMBv_;bsyQ_^6FL0iXptlK@bG7Xzjmpe(@4-R?HPg@GMTuxtrv77#3eUcjQjMFWctHb23> zB_LQJ;laWu*yjZMpI|iT3xFF~&gn0&B)38)yTc!0z}cmZn- zc00jhC%=H;AKV4op_wWKt%Jtv3t?Tb$wh}*;Xs?s zdTs$t5C7erXe7L=^mR7{jQOGm`6!lz<27{me(V7rWj5TVpli!va6aKDRm0%N@&;e1w&OZlTg^uYu%RnEbN>!oe z(BLR4D|fw+z^AMfPbl&7>p{U0rsHkFBl}xTFCY&(HFxG`VXAE9iwDmHF*BDHG;PbX)0>z_ zY6D&%K0#HShM8io%@$IaNO*olcKTxjUYtnJ&g6pm$NWU)UKF>TKbBcU=&R40L=hC+ zgT-v&(N0`jewa>{D~jlTh01AH$sF| zd_PiyJrd4ZnkOEsLtxH~)vFdZJ95GdFy}?W-?#3w+^9^Xa$W}Bl zN;^H4iJ%LyItBAL((vq>#5#=P0S>X_?DnTj5l#$?fN4>*r6TodhdmOpG+Mk(bglbS zwUQ2gsv`l}I`#dcM~Z_TWy1_!8R2XnOw&k|V?Sn@X% z&B%H%&XF)d#pt0>qICn1h?&&o*JlyWbtv4a-!)_u^D&(5O-`S6P_H2Z#;_uj_l_ZkXotLEYbJ^@ zWj%VY7L6q$PhBBm@L1ANwq8!8nlJp(=GAk{dZAqUdA_jjVK zL^|$qkfy(T-n6-?{=Go$N)vm5(FbjC02Y7lPO}&dJ>wkgY0Hl}(Bb`VuK$h2TprJ% zks8SzNBQ;LPR*IcUBqs(cJA{$r3w>muyyGe#Mvkf?QcI6S@1ZNva%C9{|RNpOJ(Ph z&@|YV;erkzH1j8wMeBEsa$23LLT;Q8YN>N0COt~zSd``~z2_8lZwIs&FHG4A>M!jUmIJh6zV%mjGbqWt`b&;wo>1HU+Lm5^FGLclx}W1uDB%o z)>(wdF{$JN_(Wdz7ztj+5fWZm`q38&<{{oSy}{rb)lJv9aT-98z_5L`=Dv-mQNxp(sb z4K=N5x+9qR6=}YjTq+qHj83s#=Eg}}4f;Urh;63?AuBad)gZvG|~ z;dkj1am1X0*qXEYxSUsCeAn$k@sxlwTkCA`FYuy$no^7H$xz%46G~NK^(WRdbOY8J zs7Mw^Wp=YS<8{PptK9C1e^6loZ5tLewak zpmJbi&NPdDgx+|hka4M=Z$w?2#557|IAKUX#LPi_ksOmaQoked!Yw9YbY#x?`Ag5j z%tIje3{I26XhFd>rNPe!OsS*u!`oR(6^d|_OXFL3NN)?=RpO9*y1 z#RDQ7VXA~o6|vlOe`E@oE#P?OG9(d*butjQq=*EKDw&2vP3wvuphWGXV6E17A2%S^ z?ja)sj_fgrK9m{V!gtkgJ=$L=MxjX}&^1P1F@^;W7lvJ5rQrjkVu(VN2m{JTub60S zVR9WdG?S7rNJ-jWr(_3FQWg2Au7WE2V>2^jZ`Q?T560eJkEIF41}So|$}NU-D<`v{p# zAGTk|3#WmdOAEI&%Z}rzA!)YtX?FE|HbZGn!s+{W@;dHJcfOqNx>Lys5AixFQBRns zzQLX!#qO8Bao`R1lrXe^S-{sulC2{BXqJQT&J5qm8yA(ZzC$sX;~7StN|&dV^!b#| zyw13RkPg4B2;r1nQ+Hpq$-KB>CsvV;@{f%$5KQb4+Z@ZtIDzHTgi#P08IWn@nH8vn zP3aIx%SyK~z3JN_knBdL_}olX%A~%@OudkqxqQRDIHSZ(oQVc=^GJb(%xHeyns;Vj ztE}Kf^{y}K9a%ekmTon6-XRh~biBd>7}~;_uVqKVPLTk#XDjqVlVZ@NaH+s^8wS z$-QH6KxEVnyJdqNiP0(Am)m7SyHjgMcY~TcXoE0r;QOJ_bO+-{*=IAdUnm*(2t#VD z+|r@Ze6~3MAncVEcxNFc0UacQQ!*iIJa0Or^j2g=8qcc@nYEa;0=X|X;f&0Gu%WI?%%o&#*RwcfUdR#@6?zj=g)K(p*Ym`7({FK%GRw?X;zk}yidG%{@$jU| zBbmLAyv{z7j(>Ev^pVHxBk`Ay6kb0f?5$!mExjQi?yd9i&`Yyg<-LaSJ^`T*xv39X zn;sHgK01G^&R_IV!jHOBZ1p}W^?{=GH;n2tj?`y9uD>}_AAhU<&dd7T+4_Kyy0{|^ zX+{kt@eQ=uO1V;Ob7$?vGd`jf#e7HLePNI5UzXP_`?HYh?$6dWg*7y*G?blfY}?z= z@wnk-SYzkj#@@3HZ*Dd8yli~E_euAyCj&-}eYfhxr69((=+nppv7QObsIQVXv{q%=u4wiv%}G5Oho7i%>$Znbc4wG3~y@@-y=-vM=rDRmX8*92+X zRbn;U8pFy(b6cz%+uYx`dHif6h&?|c*7|8L&#Sn$#m;xLPma-=%~sgSiE&E0=X#~M--=bfvhIebeDrXsWgQ~D!fNj{Oy8lU z`h}NtP4JKjaWACnB0zKDv6tfK80d(7cJ6e)x4jRGSj#t23ma>_r$)s;&Q?sl?D9RD zciudl&lcM1uzxu;fTUU_)pY)pvWVQJk79^sHMZZ3dGKSnI?Hxh?9IQmcdc0TQtoH{a$@YQucT4`Q1xc{eFP)>hM4v*(9?29K@ zCVAm&KOl$+_I-^-L)P>b^}esz1D#f1-}kIkzDI8_)=nRU`n2GYL|kemEJwY`n_t<- zAznBB{_-Q~@hf)YPd-@Q^_UX>khkyCh?@Qj3n;Kp>T8!##$-up=YyQ1jBuV|`IPsp zOVH;hO17?Th0CAnT4BCyFS+JVU*BKmz8Ve53mdqll|ws``q#-JcoA1{fgr?O2V2ZjSXmxTg*#y`i)Dz9-|HRrDl&=-Bz)c zm>5nO*KHcVGj-mCW8$EM%z=*+dp>dt`A@{GQ&0NwcyWHwPW^Ib9#Hxhe~C%?;#S*~ z)H>@)8Pep1a`DiolUi>kS(YYFN~P9;6JZ4Ke1il(<@QwY@rfNaQ?=ex@jX-aTGMF` z{7K+RU^*mENKj|MZe?|LMIc(|ei_)jcMlWdEE3v14Zjo6K0NpsP2-=ZBiV$KH_)c&_bW z)Zu%Yg&V?bfj6<ZyKZW zJ+hbIW1JQ-RQM=uo+%m9@-LOdBAGtH9lx%y6QSj&SP3jrn6UKGd(I*Snl7K~nvZ8+ zgnO@w&*tH{2(TPfDX$HuepY8}i_dR7#lD~4;oNCF=JCzU;ad`Up0#>@_$fDw{}LKr zUNu=}BrSZaTz~{ibCwW$2uE$w`wsi1pzeTMgpeu`Qo~_qpRR&?m%@uMkQL%|2yq<2 zyKqI*X+>BH*21H82`eL0O9Q8wH3-Zv?_#yFvquSQh*6kl5k9y$jg*?xq#~L*XW)vt z=!ZFIY%AXOF-JIBB6@|hzs~H=k;i|MH@ma0 zj$KDBeIL+RM{e(1$;n+$&_GH+Yb=B{3K!ILb+h1DkDzLg@$Qur;~t;>5@Y~M+Pp`? zW>Ja@TH;)rQ^!KD5ik-G=Y#N>PNQbg9O5Qqp?#k%;`r4J4`R(tBjQ*LJW#^>$E{Q4 z>~EJT((^iFjWZ319b_vDv^Y;|dv6oc46SSYqJIC z5(K_(s0FznEgbiT5chVBUSMq>xH!$L)JZ*c%QjFHI__Q%AyhGyL_Dd%o^A2#5$Bd@ zasUi^iKZwDD_R#f?qq5KbMp(}+-bQ>pAl3UvZ9k|3o`1OprruZWQIXrI^U~umVxTTSI~u%Mb;l3{BwJGx7TLl_CO~L z;N1JE*{>h|oNLyGKg}rbD=)^Lkcwu$2*G$S99Q$VK=5_C( zGi5Ds$^^2*6Ir)-Y++K4F}Vpn=DVlAiI>xinrCx8YR9l=z!l1HRCI;rh?Hzzo zkqD|gM(c4S3i`~7G51Ddu_81ZvWU6$C|S%wv2&-CN0GJZHv0q5B?qR1xeM5kq=qf_ z!?Q{Q4e6stZ1@khzZvREpOv@T{SzWhLC&k6Tz}}kn>ciblYUQdTj-a=;nD}sH>J-C zn$gap3=JC0Q4R)DksiF-QqkoPI~&fW7PS)hsLGk1wvDd0*Udt4d$V@z_X)HO1lRc{NU5?{1r&Lq>yooOmKb ztyi2AIx!?@8ApW2rG=qBX$e~Jr~7Yn_D87-;Uh6gdkh`ZZUu=PBKz;syHIaz(SCL| zQS@hhUXb&Umz4hDvu_|CXi;_l^#>v=6bFy9Z|4b*rQ)PguS%Z(u~3`7Fmr%Fi?Uul zKt$Nlq@rqQ$i(Jj2>v%R5rN)**y39VxlH_)skgM@x~N??#Jw$)aCTpG3)d^2Ns-0a zdlwvI*}AW`q<1crcIw+wQ3B7-r1gV(8X${tC2srK^AqXjJ1XR3Ldr7gY_j@# z3JcYKsa%L_-M3=KLj2kkjlOt5rp#86PoIg7!(ey>TIy?5Shx?BDDz8R@<)0sze#1@ z<1MI^SGuQ7EkSo0Z#J?9GaXEWm1r>d@hg_Aok)~Q^S1VhvVo?OnXT4GxIHGQWg&E= zQbp{0JZl*{rRi>=?s4U@W)8A)R`a(ZoqZF=eeFCIb~n9-IeOWiZ>x4!Q_}(+FiOS}0eDnMSmL z%2t{A>gfP*S&gZ_6Fu%!=Z+so-vYcyD!JFGq2DhCX_uE=J%u%)z=kk z&z*HPGuD+R2eL6~PW1=eGm=boUd$KR?_$UcafWTZc=BJiX zms64-PezPSm|)W%?7HM!d;j>>%B6RGZ4NQE<2ju5KAEQr_#rt=6J+LuSn{O>V>9zm z%DqP1X#^=$X2o;a_m5?M>BL{EnK{#;87<}G}g}-%w}5dm4)a{=nV|@a7a(*tTuX?cxlVI8C|5k zJaO7|toD`kIh})BUAjExFN?N~0`uiKQjHyl-(>WEwS|sO;dyWNt+oWp@m^73Nz#V{ zIWLuH9Q8R=JN(X7W*WU?%jfXG=DWzWRhtV}&U$*M#27aHyk&zrr(9sB8AU9&9-8OIpoOHr>x>lPG9inip@AG-VLOXBCk z9N&L_@vfE#sZVvm@2`rj!zgKdC57ldE^E~e&RY{PI5CJ#=rXZj3foMS@98;U-6oj$ zf=vC2Qkp`9dk*T@n#e}{rAb0-Pi!~w2HO(!>_uuSOCX{J4n6g+F^N(UJrWWMCQ^xU_oki`;KfmVOdVX)iPpjnH z9mn8TuUUI&Y{btSJHK&IXi9Ih51`kyxjCJP$O)G(nO(1_XeWH|6=sNV50h#9@YB{W zRkxF(iGf=eJwkajZ$?d(MQN7AI6XaS8t2FIBq>i}+1n&)s_6BZ+XtFVM28z=rqamm z#7f?$hNU##A4+4I>az^I%GkrZY@9{7do80`0yJ3Vz*8=YDJG$u(?a0$MT)2p%qC0{ zrBVpfH~HE#ZWBolH}nM;Z}JM6eK&)I+66sqn!_*WCymwqh`5PmgCx(Wm6&1rrgHmD z<8(-gueFE@`*d3~D=^?J9Tv~4vm}lw;^lO$hw<`$RXHDHi7VgCmS`&6Q{pQ1_Y17c zBuW#deq0|YVVhA=Oygl;5S6D(vA9I$Da{?DL`ad;U`Amf zBx*Gk7-S`GU$f(F8Ebqf)OyM`HEG3qWY9WWr*dn`5?Z(9oQ}h7D4{RMp>P;39EQoj zDv}Y)J{X%`6Ys}Pyq+x~1Vh=VBr5EzW3LB8BG`{}Bb3 zkv$e>7?vqWkO~VDo{$MJ#QmIvr3fgBj5!JZ!tA;yi}iM=*mvSqH5;76_mmH2LzFn) zfQ-X8v&#)K!~)osLZxQTHf|WG-mZ=hnbTUM#`n0!C-}7Uv|Eueu-5d8X#Y%7p!|mp zc^#jYruC1^Z5wbV@{v>h9 z%;=DLlfg3W&WcFs^(ToUFK47ETv^rAKOgPBj$!Wv&m;A4=L&W#oA5GNi)cQq`C7_ziHz<(1>Em_BDwbaH z93|liu`hx8@lzaJ6-Lu(juxd3$=0Nbj@wnj8qw4gXJ0)&V_1Y%T~ueu>8Z7yHEjQV zoFjsoGBjJP+@@oH9iza=muYvLn0eW$)dNj&#Fr=v2s?esCs}cKxk-1SyJd*V>}|U2 z-26OeO4txWLamCg!Rr}g0rkoCIn^^xvWR`-LpiV_OxTp;+m%CRKrBQeR*2&rU+ekL z_4&fBZ3i)X!c%5)5%_nCA2GMQDzl=5`e;}UErinU4~Os{6hErIIbUMZW3(rQ)_pVW zz)W_Vk1#Ozs`ohFXzh;>67<-h2o5P`vqQD_Dzz@`xr6F_)yBL1+Fm3@aW91V_#j=e zz!#ID-9cc9Q_rlrQ)0V3E?j&HGc(8{e3`c9+c$TLNK?F7A>~n#I6zU1c%~FVS%)5K z-QtfGe4u&%n#%n$JmmcORd%RMW(On^qEJcEXw-3)8Wa2Eme=g6!lYsgF;zgcQi@N` z7t%8+!}s0e&}W#`N@-z1k~$gk%qJ7zDZ6|IQSWtTwCuhZJ44xN_d_d{Js+B9mTn5+ zXy4V$IF+1Gix@6e=O_mM1Nx`rb;}=H7LDXAp&RiM{iC778n~9`LkSdumZ;{|N4q13 zqcfX1sj}9~hwb7u1a|b6>E4p=A{MrM43wkXY2GJt^~ClDW+aLM%Lu_Tu1a51ZFml6 z$HlS54Sy_HBwq4S-W6@b+i^0V3VF!6`t7Ywk{y=Tde`DaaX#7}y&<>fcKl0MXz=~P zCBW#>hJ$_8Pu?oxEGLq_$R42i9G=I$OecjUr%)#EuvE)r+j*!%K zF-NQ1F=J;++y$*M*LXK|9>c2!-<(uIdGb23IvM<#L~^&_3D;s{gm9u$+)UlQa!(oRoj$m?a^n9eGgzWHeS*7ND?{^^`AKH$-; z#MxVc3Jzmyj8COsw4=t(WIvjD z;4obF$e1QDOIGoUqe6nXw1BJFE74qaJ)P+eCXa&PgGRIHVjPoV+SAjI&t500`@;+A z6fU7TG68z_YqrtDepAdR$kR8`;cToXRWQM};WQQHKYP7*Zu-fIc*j~-Bz zsO8d3dV3mkKU`rVl*VTOWP)Y+qp#QL=f-YeiVG;)kU+66Ea3E8n4g^|Ym%hN;IHS8DfF)v7VR=o|KdSmb1ZkaBU&s&F`F~9J7VXY7tbu6`O)iW zVG8}yq6vhtqNncMxzF-zlppCuscL#6z`z^bm@N!x`e-DATe!pH*~BPPtSeU(D^}zR zrrfdb6u8DUb`B%+B7oOGMBVDb=vV%8a&NXj7+=ts?74jcLesu-aXpQqA(Diakel_i zMM*&-DRL1K4EabaS7(P-M2cX%!U|q;#Y{iY!ZC1JApPDfws>A z_bLS1eG0TcwqhF`=&-$F$92i^THpb})dL!6sv{mGZ+)qP9E1;R}! z?r7p2bJ60mSf#yCoS%RF(|1dAY6#u6h5rYDK!3lQ8)Fadkm!xFq*5$@@kQEVA2sk~ z?->MVUBc#-Lj!R~`O4&?g6^sbSmF->5`%B?@!GbC3xM|vumKy0_j;fAdXM*e$9H+B z_kGuQeE)ZQ?{|P7c!A${en0qt&-a2~_=IP8|9Dq;h<|v5_xFj9c#0=@hu8Ru-}sE@ z_>cGakT-acA9;AM_B_>(VNsB8AC$fh7WQm%h?w@rLUvtOh-qhbuF2(R2Z=v*$(g72 z-L6hRMV_a?>)pg_E3XN}wt0>k8!BjX=?eE=XY%76K@V^N{AGaUyXvrBXtNG_He09| zSJRrE@z)C=mB&1cK=Fns^49H&hRFG2_w15TdZ`S1w$Sp3-tyL^TBdIZ3Fwq2JbEe% zcK|E{LqYG*%MS^F4&f~dcZF)Nk7uyY`}nA!4DcXcR{&)Et>R{gxqpbCDttEW<<^bQ zg%Ewy@0ri8hy+jY%kOIBUWgk$eTInH{|xj|h`8}PJN($riOyb#2y)3?IZvaee34*r z+1Gp0L-!sjL3KTWkLYcVDtiz|N9(8i+fQjLH{Itq#!JaZ_ezcZ|nYVqw zUkKSXNl0t|0#OLiud}0@x^_=44FN!_Lx_w52mmb-04QkiAi{(S7cy+<@FB#A5+_ou zXz`(diy9>c=;-ky$dDofY%FQ=B+8U3SF+TY5#k3L8BS!N@u8rC3>{Ly=pdnB%$;Rm z5Cov0D1Zb=8Jg$-!$pjuEKZz20E4PQ1_%^3eHyi(hYlHHWXK?us#UB8TckB{F=mDo zHE*`8YxgeRym}eFe5e2c)xcS||0dL$&_h|d89WS5m@|coo^YdGGh zB$QDa#AHLvNqHrfS?Z=G|Ce2QxfhkHIqBh-Wv+ODnQ5xICPHYk`6irfx)~>(b=r9+ zo_XrIC!c*TG-ii>3W^d2gBp4$YlR}ZD5I+>Dj%S;H9BcSVN!Z2rU+S@DW{ztv?*ng z%I4{%ppts3pQfU^>Y=J?!~qlp{P2K53s7(?t{ve@!2%xH3KFjY*t%=4BmuBMtP?Cy z(6GB21gosHvRbCA(^~sxwbyD}XSNhA073`_6fgh*1raa+y6JY5F1iqOG{FE5_&UG@ z0i4S&0kj#Qfd~ckYc9L!G7GM_MTR|gnqM;{LIhYFq;)|_ceHdz zC1~Ig(Nd%Qk+=%6Z4laOlil;*fhTFU;DsY-=>dr!fC34MJAQy440Sv}1V1bba0Ho0 zu)(?z+zP?n0Xz_|=%kw*dPf?xY&7MXZ&1+Wm0!M)ACD`}xb2HKZaeP0@BVo2!2j-e z@Wc;)`|*hvk9_XSE1$gX%|q{e^u9}fz4eNtBmnc-3y=Nx-Ww18_~LgTKKkXSf4=(d zv;Y3{|6x6Apz$xQ-{k109Y-rTl;5NwQN1K6Pih={rX zSfG+f|CFRd_QpxOG>mYwyd^GkS+#H2N|sm*QX$&(s!nyf%q0)XN0hQwT1DJ?JnrkRWYpo0Jbs0IMg`G5dE zumCyBSrBmkK%CrENiF{=(18*ZVZ1Df0TL;$pA=*Q;(91M3!uY}5a4O=lITYq3Q--x zZe|5ws74`Lkc2*zp#|MYKu@aDm9i8@-pq@rV$;&qq;#e>y(vy_^HRLTbR;4gR*kGRt!{nmCfmvvxOy$9biFHH$+pwH0Hh1;B_Q9NaAw1Pcwo0sveLV-#~202a>eiEoUA2wUL`* zuvrrzz_3Okj6e|JAcl0o1ul>QLS*2AE(GWUSZ06=0OaM#jM*Ss=JG+j%%CvSH~AxbaA!lc%;#}N_+RD+?{SLm=5uAtps zuiPL&fVHY|9rH~`R|Q~z@r`SI1q}nc=fEcNL7JU`7GwYbn;i?Yp`3yyH-s&1rb|xf z5`z;ACI)n2ObV!8kQ1Z;C;BbO)T@5=D7RVO3K_z@^WBgEKY`E%et{DRO=s60#0jkh zzz}p$kO9Zm2vIP|6P^Gfjw{6D*FA2?H=JEB%(@`Sl>&GH;OQA7|0L!vUT&^wp81@s zpu;(@HK%ePeL1 zd$v3qH)^N11CpSS<1b{u2R{fCE)IYJA4CY&r$cNVAbkM4*4_bkKw>xE;Ep#y3Q{nG za&e82Hz=^ zfYxOthm$Ep46xS;_@2>;mS{25?IA=4AX&T>1O|$hactm0OkieM;B6eA5jep@FrPwD zA3`{Q49=hf92^fsffLMD4i<#>6~vvf7653$5rhcgB?NA%|9}c$!TV_*Lb%u#Q~{<@ z-p3)=i}}`dMc0mP0T^Ug&4FGQ${chd0TKux6BeKu{?!3K8A2$Vv0YY0^hN^o9tfh~ zL6D$9uz<0_KD0QeciofQES z+<*=k0TGU0;f03}Xr=7~HKEA|?b39)u3uT?{H; zK~P*lIDsYx91{fC5g38S4IU>Np(hTYc3~a>6xWZH|Dr)40nd>dEz)B_*y5_G8~^|T z7Xkp|eIXctf&X!rr?FfvCZt*IqBFAIwuu1)h=G3aVnmog7chnx{GwL4fCqelL6;=7nD*ts4eY_iIe`x3 zKn~17zabnG>_Jhc)y7p2UJCsDnPJMl>jd zPAG*|sD)lAhGytVITeH!p@x1ae)1=X&Xs|VsEMYhh$e&t$bby!o<_*PemzX2F^qt+ z#sm10LOj5&NQ*}3C4^@GusMVY1jY#fNI|dwwIzT@4AVzg zsj=jUM@X5Leh8M*hD<3H09@5Wh^d#h&6SR+u~?~^lIefR;0W9snv&_6wrQ0bL=nj8 zBI;?Bcxah|ggIfUAf@S?20#H6jZy``>x6)v7HW<##0C^VxTwUTvd9EH5kxG&=0F4o zw9)`n0FK&4q)zIPTxy1dDVf3yJFTgmUa3!ssiP+8Yk22h5Qma!-IyxHotkNv&S`OU zX{vq*s?uqy!iJaf>Q&uoo3?6>7=aedzzjS=4;7$%ZVe za%`4b9LZ)(09aoR^lA zLkJPrvP9G(#MDx4s8;Pl1TDVa?T?misCI2an5{ve?Xld-T>vh#5N^gS%j}G-s)`N; ztZ7GlEz(pB&_LpD102DBwha%UrVQR4XKLTx&7hv% z03%}DIljOQjsSq#r%5Et$7nz_oy@pIKm~+A1+)$5v`fwS5xP{s+P2NTP>$L(t;ddS z1*FUB>=Ps%1iTDD2*|Iw>@U*pFZ+J#`vMHQq|HO9lL!cmL8LFs)JzklFU15f1!GP8 zDlh;9%n>mJ2hb4PIz$1y&Rsmf{kF^53h>&biw5`a|7tJ*K$8Zb%Q!WJ4AU?I18_kw zumk6?26J%H000le|I$iiFxCw5L74Ccv&_oo$ON}<%@h;u=%d=25WG~YVPI^ zSwv7Iv8k!UnjTU(Y)+)o!lrIVaH+BU1r-E9Sj1j3E(gmxEwKjgpFr-w0x$21Y{#Ok z5ZHmgIh>fz!1LvR%8n_;{n-uN<_Od*5Ax{~XyXt(;%D9)Ce~+)*#&$5cT64zL|REdYQ3%>V!gM3ep^gaJs)C>2cz4{$*M z6DzxN2waRG&9XwAjI`VgywJ)6kP^U*(+(0pFfdc|NUhVwEC8k^g!uOJ#dNbhuZ}a1ltB>m zGJ~@(#|uJdsyi!$Lf`X2$M8YG^T$LJ<7V@*Y;!{afV@m|xlD~HlQICj@|Z4k?{aY$ zM}z>}$X{65(m7!0BF*Sh>F=?CN0`N&va#2BL;@5elf~%AI%=;H@9iF|x$5!m4y+vu z(hMd+mMXPJpq=%;>=r+=xZ2xCjOPsm03jAZM?`@Uctplo6v?d@wJc%(|ou z${;Nxk;M51z&W?gCxZazbVSFba4kP-$M_Q7tg1*P5=E_Q)8chs2LKRt1YdhZ$IJ%F zgv26w{{#dak|%q_Wp8%VFj8du^(k?7DM`xJ*o$G0!~keO32=Y}kdlYkkcYrau~>F$ zhqfsl_Ns1hDm}>n^tMOf_GAY@WrKupk9O0PHgPZ0n8zZpEr7^w|cKPd$;#TYzj;xfKsFYbkuavl`&4sp?%Ya zPa6e(1BFh+07uqw{nqamZ)~t8c)0HIpn9xrj(5P#0S(4h!Zj+*ZuJa�?yQSbKFx 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⁣leqmRxpQZOr>GhUAp5Vo-K@FVw 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�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 KR-XtAX#58QQ!{q} From fa20b274da2fb3e2d794dd1cafef4d78db013c36 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 22:34:52 +0530 Subject: [PATCH 05/28] fix(tui): preallocate the header readout column, unexport the mark art Two findings from CodeRabbit on PR #1. The readout column grew from a one-element literal, which failed the lint job on prealloc. The capacity is known: one blank row plus the readout. markRows was an exported mutable package variable and markArt indexes row zero to measure the shared margin, so any caller that emptied it would panic a header render. It is now an unexported array, which makes the length a compile-time fact and removes the panic path rather than guarding it. --- internal/tui/app.go | 3 ++- internal/tui/theme/theme.go | 18 +++++++++++------- internal/tui/theme/theme_test.go | 4 ++-- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/internal/tui/app.go b/internal/tui/app.go index 5ee847a..97436a1 100644 --- a/internal/tui/app.go +++ b/internal/tui/app.go @@ -403,7 +403,8 @@ func (a *App) viewBrandBlock() string { } // One blank row first: the readout sits against the stack's body rather // than level with the wordmark, which owns the top line alone. - col := []string{""} + col := make([]string, 0, 1+len(state)) + col = append(col, "") for _, l := range state { col = append(col, padLeft(l, stateW)) } diff --git a/internal/tui/theme/theme.go b/internal/tui/theme/theme.go index 700608b..18ab8da 100644 --- a/internal/tui/theme/theme.go +++ b/internal/tui/theme/theme.go @@ -172,8 +172,12 @@ func padCell(s string, w int) string { // markStem is the F's stem: the three rows that carry no arm are the same row. const markStem = " ███" -// MarkRows is the split-F, sampled from f_logo.svg — canonical, do not redraw. -var MarkRows = []string{ +// markRows is the split-F, sampled from f_logo.svg — canonical, do not redraw. +// +// An array, and unexported: markArt indexes row zero to measure the shared +// margin, so a caller that emptied a slice here would panic the whole console +// on a header render. The length is a compile-time fact instead. +var markRows = [...]string{ " ████████", " ██████████", markStem, @@ -253,17 +257,17 @@ func fold(topRow, bottomRow string) string { return strings.TrimRight(string(out), " ") } -// markArt is MarkRows with the shared left margin the SVG sample carried +// markArt is markRows with the shared left margin the SVG sample carried // measured off, so the mark starts on its own first inked column. The shape is // untouched: every row loses the same count, so the split arms keep their // overhang. Byte slicing is safe because the margin is all spaces. func markArt() []string { - indent := len(MarkRows[0]) - for _, r := range MarkRows { + indent := len(markRows[0]) + for _, r := range markRows { indent = min(indent, len(r)-len(strings.TrimLeft(r, " "))) } - out := make([]string, len(MarkRows)) - for i, r := range MarkRows { + out := make([]string, len(markRows)) + for i, r := range markRows { out[i] = r[indent:] } return out diff --git a/internal/tui/theme/theme_test.go b/internal/tui/theme/theme_test.go index d8d989a..ae1c127 100644 --- a/internal/tui/theme/theme_test.go +++ b/internal/tui/theme/theme_test.go @@ -68,7 +68,7 @@ func TestGlyphsASCII(t *testing.T) { } func TestMarkShape(t *testing.T) { - if len(MarkRows) != 7 { + if len(markRows) != 7 { t.Fatal("mark is exactly 7 rows — never redraw it") } } @@ -78,7 +78,7 @@ func TestMarkShape(t *testing.T) { // the full width, and every inked column still inked. func TestMarkFoldsToHalfHeight(t *testing.T) { rows := foldedArt() - if want := (len(MarkRows) + 1) / 2; len(rows) != want { + if want := (len(markRows) + 1) / 2; len(rows) != want { t.Fatalf("mark folded to %d rows, want %d", len(rows), want) } art := markArt() From 3dd363bae0d0429ac67532620130fa0659faee3b Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:07 +0530 Subject: [PATCH 06/28] fix(table): neutralize control characters in table cells Cell values arrive from the gateway -- a provider name, a plugin summary, an upstream error message -- and were joined into the layout raw. A tab or a newline injects a column or a row, and Rows() turns an injected newline into a separate console transcript record. ESC is worse: it hands a terminal escape sequence straight to whatever is reading stdout. Cell text is data, never layout and never terminal control, so all four collapse to a space. The guard sits in Write, which Rows delegates to, so the console and the scriptable verbs are covered by the one chokepoint. --- internal/table/table.go | 19 ++++++++++++++++++- internal/table/table_test.go | 22 ++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/internal/table/table.go b/internal/table/table.go index 0f2acb8..1681a67 100644 --- a/internal/table/table.go +++ b/internal/table/table.go @@ -16,11 +16,28 @@ import ( "text/tabwriter" ) +// tableCellReplacer neutralizes control characters a gateway-provided cell +// (a provider name, a plugin summary, an upstream error message) could carry: +// a tab or newline would inject a column or row into the layout below, and +// ESC starts a terminal escape sequence this package has no business passing +// through to whatever is reading stdout. Cell text is data, not layout or +// terminal control, so all four collapse to a single space. +var tableCellReplacer = strings.NewReplacer("\t", " ", "\r", " ", "\n", " ", "\x1b", " ") + +func normalizeCells(cells []string) []string { + out := make([]string, len(cells)) + for i, c := range cells { + out[i] = tableCellReplacer.Replace(c) + } + return out +} + // Write renders headers and rows as a plain, alignment-padded table to w: a // header line, a dashed rule the width of each heading, then one line per // row. No ANSI, no box drawing — this is the layout `ferro ` pipes to // stdout, as likely to be read by awk as by a person. func Write(w io.Writer, headers []string, rows [][]string) { + headers = normalizeCells(headers) tw := tabwriter.NewWriter(w, 0, 0, 3, ' ', 0) _, _ = fmt.Fprintln(tw, strings.Join(headers, "\t")) @@ -31,7 +48,7 @@ func Write(w io.Writer, headers []string, rows [][]string) { _, _ = fmt.Fprintln(tw, strings.Join(dashes, "\t")) for _, r := range rows { - _, _ = fmt.Fprintln(tw, strings.Join(r, "\t")) + _, _ = fmt.Fprintln(tw, strings.Join(normalizeCells(r), "\t")) } _ = tw.Flush() } diff --git a/internal/table/table_test.go b/internal/table/table_test.go index 57fdfe7..2409ff8 100644 --- a/internal/table/table_test.go +++ b/internal/table/table_test.go @@ -45,6 +45,28 @@ func TestRowsMatchesWrite(t *testing.T) { } } +// A gateway-provided cell — a provider name, a plugin summary, an upstream +// error message — is attacker-influenced data reaching a terminal. A tab or +// newline must not inject a column or row, and an ESC must not reach the +// terminal as a live escape sequence. +func TestWriteNormalizesControlCharactersInCells(t *testing.T) { + var buf bytes.Buffer + Write(&buf, []string{"NAME"}, [][]string{{"evil\tname\r\ninjected\x1b[2Jrow"}}) + + lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n") + if len(lines) != 3 { + t.Fatalf("control characters in a cell must not inject rows, got %d lines:\n%q", len(lines), buf.String()) + } + if strings.ContainsAny(lines[2], "\t\r\n\x1b") { + t.Fatalf("row line still carries a raw control character: %q", lines[2]) + } + + rows := Rows([]string{"NAME"}, [][]string{{"evil\tname\r\ninjected\x1b[2Jrow"}}) + if len(rows) != 3 { + t.Fatalf("Rows must not split an injected newline into a separate transcript record, got %d rows: %q", len(rows), rows) + } +} + func TestOrDash(t *testing.T) { for _, tc := range []struct{ in, want string }{ {"", "-"}, From d49c6cf181bfcedf533636dd5da0088024c45a43 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:09 +0530 Subject: [PATCH 07/28] fix(command): honour "missing is not zero" for latency, stop escaping HTML in JSON An unreachable gateway printed "0ms" on the same row that reported the outage, reading as an instant reply. The dash is keyed on statusErr, which is non-nil exactly when the gateway was never reached -- not on LatencyMs > 0, which would also dash a genuinely fast gateway. Printer.JSON left encoding/json's HTML escaping on, so <, > and & in audit details, provider messages and URLs reached the pipe as <. This output goes to jq or a file, never into a page. --- internal/command/output.go | 4 ++++ internal/command/output_test.go | 17 +++++++++++++++++ internal/command/status.go | 11 ++++++++++- internal/command/status_test.go | 28 ++++++++++++++++++++++++++++ 4 files changed, 59 insertions(+), 1 deletion(-) diff --git a/internal/command/output.go b/internal/command/output.go index 8f1c8c7..8a18197 100644 --- a/internal/command/output.go +++ b/internal/command/output.go @@ -137,6 +137,10 @@ func (p *Printer) Table(headers []string, rows [][]string) { func (p *Printer) JSON(v any) error { enc := json.NewEncoder(p.Out) enc.SetIndent("", " ") + // This output is piped to jq or a file, never embedded in HTML, so the + // encoder's default <, >, & escaping only mangles audit details, provider + // error messages, and URLs that legitimately contain them. + enc.SetEscapeHTML(false) return enc.Encode(v) } diff --git a/internal/command/output_test.go b/internal/command/output_test.go index e69d46b..062e1c2 100644 --- a/internal/command/output_test.go +++ b/internal/command/output_test.go @@ -57,6 +57,23 @@ func TestJSONPurityNarrativeGoesToStderr(t *testing.T) { } } +// JSON is piped to jq or a file, never embedded in HTML, so <, >, and & in an +// audit detail, a provider error message, or a URL must survive literally +// rather than becoming <-style escapes. +func TestJSONDoesNotEscapeHTMLCharacters(t *testing.T) { + p, out, _ := newTestPrinter(FormatJSON) + if err := p.JSON(map[string]string{"url": "http://x?a=1&b=2", "detail": "a was denied"}); err != nil { + t.Fatal(err) + } + got := out.String() + // Verbatim substring match is the assertion: SetEscapeHTML(false) means + // these bytes appear exactly as given rather than as <-style escapes, + // and a literal match fails on its own if any got turned into an escape. + if !strings.Contains(got, "a was denied") || !strings.Contains(got, "http://x?a=1&b=2") { + t.Fatalf("HTML characters must stay literal, not escaped, got %q", got) + } +} + func TestYAMLGoesToStdout(t *testing.T) { p, out, _ := newTestPrinter(FormatYAML) if err := p.YAML(map[string]string{"state": "connected"}); err != nil { diff --git a/internal/command/status.go b/internal/command/status.go index 0cb9c18..46d6755 100644 --- a/internal/command/status.go +++ b/internal/command/status.go @@ -40,12 +40,21 @@ func newStatusCmd() *cobra.Command { if report.Targets != nil { targets = fmt.Sprintf("%d/%d", report.Targets.Routable, report.Targets.Total) } + // statusErr is non-nil only when the gateway was never reached at + // all (Status returns early on a failed /health). The elapsed + // time up to that failure is not the gateway's RTT, so printing + // it as one would read as an instant reply on the exact row that + // reports an outage. + latency := "-" + if statusErr == nil { + latency = fmt.Sprintf("%dms", report.LatencyMs) + } d.Printer.Table( []string{colState, colURL, "LATENCY", "TARGETS", "PROVIDERS", colModels, "MCP", "AUTH"}, [][]string{{ report.State, report.URL, - fmt.Sprintf("%dms", report.LatencyMs), + latency, targets, table.CountOrDash(report.Providers), table.CountOrDash(report.Models), diff --git a/internal/command/status_test.go b/internal/command/status_test.go index 5eb7e13..9e1cd49 100644 --- a/internal/command/status_test.go +++ b/internal/command/status_test.go @@ -122,6 +122,34 @@ func TestStatusUnreachableExits1ButStillReportsState(t *testing.T) { } } +// Missing is not zero (README's "Contracts worth relying on"): an unreachable +// gateway never answered, so the elapsed time until the dial failed is not a +// latency measurement and must not print as one. +func TestStatusUnreachableRendersDashLatencyNot0ms(t *testing.T) { + stdout, _, err := execute(t, "status", "--gateway-url", "http://127.0.0.1:1") + if err == nil { + t.Fatal("unreachable must exit 1") + } + if strings.Contains(stdout, "0ms") { + t.Fatalf("an unreachable gateway must never print a latency, got %q", stdout) + } + lines := strings.Split(strings.TrimRight(stdout, "\n"), "\n") + if len(lines) != 3 { + t.Fatalf("want header + underline + 1 row, got %d lines:\n%s", len(lines), stdout) + } + headers := strings.Fields(lines[0]) + row := strings.Fields(lines[2]) + for i, h := range headers { + if h == "LATENCY" { + if row[i] != "-" { + t.Fatalf("LATENCY must render \"-\" when the gateway was never reached, got %q in %q", row[i], lines[2]) + } + return + } + } + t.Fatalf("no LATENCY column in header: %q", lines[0]) +} + // A gateway reachable without a usable credential is still reachable: the // report degrades to what /health and /readyz say rather than failing. func TestStatusWithoutCredentialDegradesNotFails(t *testing.T) { From a096c476ae189511c11e29405565192702828ba8 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:09 +0530 Subject: [PATCH 08/28] fix: attribute the stream idle timeout to ferro, not the gateway api.CodeStreamTimeout is synthesized locally when this client's idle timer fires; the gateway takes no part in it. Its doc comment said the opposite, and that error propagated into both operator-facing messages -- one claiming the gateway closed the stream, the other hard-coding "gateway bound: 2m", which would drift the moment DefaultStreamIdleTimeout moved. Both now name ferro as the closer and read the duration from the constant. playground.go's own comment promises its wording matches `ferro chat`'s; that holds again. --- internal/api/sse.go | 9 +++++---- internal/command/chat.go | 9 +++++---- internal/command/chat_test.go | 2 +- internal/tui/playground.go | 7 ++++++- 4 files changed, 17 insertions(+), 10 deletions(-) diff --git a/internal/api/sse.go b/internal/api/sse.go index fada71e..69d7d55 100644 --- a/internal/api/sse.go +++ b/internal/api/sse.go @@ -104,12 +104,13 @@ type ChatStream struct { Cancel context.CancelFunc } -// Stream error codes. The first two are the gateway's own, sent inside an -// error frame; the third is ferro's, synthesized when the connection ends with -// neither a terminator nor an explanation. +// Stream error codes. Only the first is the gateway's own, sent inside an +// error frame; the other two are ferro's, synthesized locally. Reading +// stream_timeout as the gateway's verdict is what put "the gateway closed it" +// into two operator-facing messages for a bound the gateway never saw. const ( CodeStreamError = "stream_error" // gateway: the upstream or the pipeline failed - CodeStreamTimeout = "stream_timeout" // gateway: the idle bound elapsed + CodeStreamTimeout = "stream_timeout" // client: this client's idle bound elapsed CodeStreamIncomplete = "stream_incomplete" // client: connection ended without [DONE] // DefaultStreamIdleTimeout prevents a connected-but-silent upstream from diff --git a/internal/command/chat.go b/internal/command/chat.go index 21ce690..ae8a0c0 100644 --- a/internal/command/chat.go +++ b/internal/command/chat.go @@ -229,10 +229,11 @@ func runChat(cmd *cobra.Command, model, system, prompt string) error { func streamFailure(e *api.Error) error { switch e.Code { case api.CodeStreamTimeout: - // The bound itself is the gateway's, configurable there and not - // reported on the wire, so naming a duration here would be a guess an - // operator reads during the incident it is wrong in. - return errors.New("stream idled out — the gateway closed it after its idle bound elapsed") + // The bound is ferro's own client-side idle timer (api. + // DefaultStreamIdleTimeout) — the gateway takes no part in the + // decision, so the duration is a fact this process knows, not a guess. + return fmt.Errorf("stream idled out — the gateway sent no events for %s, so ferro closed the connection", + api.DefaultStreamIdleTimeout) case api.CodeStreamIncomplete: return errors.New("stream ended mid-answer — output is truncated") default: diff --git a/internal/command/chat_test.go b/internal/command/chat_test.go index d34a6fa..def0cce 100644 --- a/internal/command/chat_test.go +++ b/internal/command/chat_test.go @@ -258,7 +258,7 @@ func TestStreamFailureWording(t *testing.T) { err api.Error want string }{ - {"timeout", api.Error{Code: api.CodeStreamTimeout}, "stream idled out — the gateway closed it after its idle bound elapsed"}, + {"timeout", api.Error{Code: api.CodeStreamTimeout}, "stream idled out — the gateway sent no events for 2m0s, so ferro closed the connection"}, {"incomplete", api.Error{Code: api.CodeStreamIncomplete}, "stream ended mid-answer — output is truncated"}, {"error", api.Error{Code: api.CodeStreamError, Message: "upstream exploded"}, "stream failed: upstream exploded"}, } diff --git a/internal/tui/playground.go b/internal/tui/playground.go index f7c2119..952ad9e 100644 --- a/internal/tui/playground.go +++ b/internal/tui/playground.go @@ -536,7 +536,12 @@ func (s *playScreen) metaCmd(a *App) tea.Cmd { func streamFailure(e *api.Error) string { switch e.Code { case api.CodeStreamTimeout: - return "gateway: stream idled out (gateway bound: 2m)" + // Neither "gateway:" nor a hand-written 2m: the idle timer is ferro's + // own (api.DefaultStreamIdleTimeout), so the gateway is not who gave + // up, and a duration typed out here drifts the moment the constant + // moves. `ferro chat` says the same thing from the same constant. + return fmt.Sprintf("stream idled out — the gateway sent no events for %s, so ferro closed the connection", + api.DefaultStreamIdleTimeout) case api.CodeStreamIncomplete: return "gateway: stream ended mid-answer with no terminator — the answer above is truncated" } From 04d70cf3c1919e76bda323a3bcc66ba5726548c3 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:10 +0530 Subject: [PATCH 09/28] fix(api): fail loudly on oversized bodies, bound error text, sync test captures io.LimitReader truncated a body over maxBody silently, so the overflow surfaced later as an opaque JSON decode error. do() now reads maxBody+1 and says what happened. The raw-body fallback error message is capped rather than echoing an unbounded response into a terminal. Three SSE tests captured request facts in the httptest handler goroutine and read them from the test goroutine with no happens-before edge -- the response body's arrival is not one. Adopted the patterns already in the repo: a mutex recorder as in chat_test.go, atomic.Pointer as in logs_test.go. --- internal/api/client.go | 20 ++++++++++++++-- internal/api/client_test.go | 14 +++++------ internal/api/sse_test.go | 46 +++++++++++++++++++++++++------------ 3 files changed, 56 insertions(+), 24 deletions(-) diff --git a/internal/api/client.go b/internal/api/client.go index 397b1b5..fb1eca6 100644 --- a/internal/api/client.go +++ b/internal/api/client.go @@ -223,10 +223,17 @@ func (c *Client) do(ctx context.Context, method, p string, q url.Values, in, out RedirectTo: resp.Header.Get("Location"), } } - raw, err := io.ReadAll(io.LimitReader(resp.Body, maxBody)) + // Read one byte past maxBody: LimitReader itself is silent about a + // truncation, and a truncated JSON body would otherwise fail inside + // json.Unmarshal as "decode response" — a report that sends an operator + // looking for a malformed payload instead of an oversized one. + raw, err := io.ReadAll(io.LimitReader(resp.Body, maxBody+1)) if err != nil { return resp.StatusCode, fmt.Errorf("read response: %w", err) } + if len(raw) > maxBody { + return resp.StatusCode, fmt.Errorf("response exceeded the %d-byte limit", maxBody) + } ok := resp.StatusCode >= 200 && resp.StatusCode < 300 if !ok && !slices.Contains(o.tolerate, resp.StatusCode) { return resp.StatusCode, decodeAPIError(resp.StatusCode, raw) @@ -244,8 +251,17 @@ func (c *Client) do(ctx context.Context, method, p string, q url.Values, in, out return resp.StatusCode, nil } +// maxErrMessage bounds the fallback error message built from a raw, +// non-envelope body. Without a cap, a proxy's HTML error page or a stack +// trace flows into terminal output and logs unbounded. +const maxErrMessage = 2048 + func decodeAPIError(status int, raw []byte) *Error { - e := &Error{Status: status, Message: strings.TrimSpace(string(raw))} + msg := strings.TrimSpace(string(raw)) + if len(msg) > maxErrMessage { + msg = msg[:maxErrMessage] + "… (truncated)" + } + e := &Error{Status: status, Message: msg} var env struct { Error struct { Message string `json:"message"` diff --git a/internal/api/client_test.go b/internal/api/client_test.go index b9a6bba..10b8dda 100644 --- a/internal/api/client_test.go +++ b/internal/api/client_test.go @@ -19,7 +19,7 @@ func TestBearerHeaderSentAndOmitted(t *testing.T) { })) defer srv.Close() - c, _ := New(srv.URL, "fgw_secret") + c := testClient(t, srv.URL, "fgw_secret") var out map[string]any if _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}); err != nil { t.Fatal(err) @@ -28,7 +28,7 @@ func TestBearerHeaderSentAndOmitted(t *testing.T) { t.Fatalf("want bearer header, got %q", got) } - c2, _ := New(srv.URL, "") + c2 := testClient(t, srv.URL, "") if _, err := c2.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}); err != nil { t.Fatal(err) } @@ -48,7 +48,7 @@ func TestRedirectRefusedNeverFollowed(t *testing.T) { })) defer srv.Close() - c, _ := New(srv.URL, "fgw_secret") + c := testClient(t, srv.URL, "fgw_secret") var out map[string]any _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) var apiErr *Error @@ -68,7 +68,7 @@ func TestEmpty2xxWithExpectedPayloadIsError(t *testing.T) { w.WriteHeader(http.StatusOK) // no body })) defer srv.Close() - c, _ := New(srv.URL, "") + c := testClient(t, srv.URL, "") var out map[string]any _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) if err == nil || !strings.Contains(err.Error(), "empty response body") { @@ -81,7 +81,7 @@ func Test204WithNilDestIsSuccess(t *testing.T) { w.WriteHeader(http.StatusNoContent) })) defer srv.Close() - c, _ := New(srv.URL, "") + c := testClient(t, srv.URL, "") if _, err := c.do(context.Background(), http.MethodDelete, "/x", nil, nil, nil, doOpts{}); err != nil { t.Fatalf("204 with nil dest must succeed: %v", err) } @@ -93,7 +93,7 @@ func TestErrorEnvelopeDecoded(t *testing.T) { `{"error":{"message":"bad key","type":"authentication_error","code":"unauthorized"}}`) })) defer srv.Close() - c, _ := New(srv.URL, "fgw_bad") + c := testClient(t, srv.URL, "fgw_bad") var out map[string]any _, err := c.do(context.Background(), http.MethodGet, "/x", nil, nil, &out, doOpts{}) var apiErr *Error @@ -108,7 +108,7 @@ func TestTolerated503DecodesBody(t *testing.T) { `{"status":"not_ready","reason":"no routable targets"}`) })) defer srv.Close() - c, _ := New(srv.URL, "") + c := testClient(t, srv.URL, "") var out struct { Status string `json:"status"` Reason string `json:"reason"` diff --git a/internal/api/sse_test.go b/internal/api/sse_test.go index ef6d917..7137643 100644 --- a/internal/api/sse_test.go +++ b/internal/api/sse_test.go @@ -7,6 +7,8 @@ import ( "net/http" "net/http/httptest" "strings" + "sync" + "sync/atomic" "testing" "time" ) @@ -69,10 +71,16 @@ func content(events []StreamEvent) string { } func TestStreamChatHappyPath(t *testing.T) { + // The handler runs in its own goroutine; the streamed response body is + // what the test goroutine synchronizes on to read the events, not these + // captured request facts, so they need their own guard. + var mu sync.Mutex var gotBody, gotAccept, gotAuth string srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { raw, _ := io.ReadAll(r.Body) + mu.Lock() gotBody, gotAccept, gotAuth = string(raw), r.Header.Get("Accept"), r.Header.Get("Authorization") + mu.Unlock() writeSSE(w, "trace-abc", frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}`), frame(`{"id":"c1","object":"chat.completion.chunk","created":100,"model":"m","choices":[{"index":0,"delta":{"content":"Hello "},"finish_reason":null}]}`), @@ -122,11 +130,14 @@ func TestStreamChatHappyPath(t *testing.T) { t.Fatalf("RequestID = %q, want the X-Request-ID header", st.RequestID) } // The request itself: stream is forced on, and the SSE surface is asked for. - if !strings.Contains(gotBody, `"stream":true`) { - t.Fatalf("StreamChat must force stream:true, body was %s", gotBody) + mu.Lock() + body, accept, auth := gotBody, gotAccept, gotAuth + mu.Unlock() + if !strings.Contains(body, `"stream":true`) { + t.Fatalf("StreamChat must force stream:true, body was %s", body) } - if gotAccept != "text/event-stream" || gotAuth != "Bearer fgw_secret" { - t.Fatalf("accept=%q auth=%q", gotAccept, gotAuth) + if accept != "text/event-stream" || auth != "Bearer fgw_secret" { + t.Fatalf("accept=%q auth=%q", accept, auth) } } @@ -443,9 +454,10 @@ func TestStreamChatURLMatchesDoResolutionForPathPrefixedBase(t *testing.T) { // (see client.go), so a path-prefixed --gateway-url cannot land the // request on a different path than every other endpoint — in particular // it cannot produce a double slash on the streaming path. - var gotPath string + var gotPath atomic.Pointer[string] srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - gotPath = r.URL.Path + p := r.URL.Path + gotPath.Store(&p) writeSSE(w, "trace-prefix", doneFrame) })) defer srv.Close() @@ -463,19 +475,23 @@ func TestStreamChatURLMatchesDoResolutionForPathPrefixedBase(t *testing.T) { st.Cancel() want := "/ferro/v1/chat/completions" - if gotPath != want { - t.Fatalf("base %q: request path = %q, want %q (no double slash)", srv.URL+suffix, gotPath, want) + var got string + if p := gotPath.Load(); p != nil { + got = *p } - if strings.Contains(gotPath, "//") { - t.Fatalf("base %q: request path %q contains a double slash", srv.URL+suffix, gotPath) + if got != want { + t.Fatalf("base %q: request path = %q, want %q (no double slash)", srv.URL+suffix, got, want) + } + if strings.Contains(got, "//") { + t.Fatalf("base %q: request path %q contains a double slash", srv.URL+suffix, got) } } } func TestTraceAttribution(t *testing.T) { - var calls int + var calls atomic.Int32 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - calls++ + calls.Add(1) if r.URL.Path != "/admin/logs" { t.Errorf("attribution must read /admin/logs, got %s", r.URL.Path) } @@ -500,9 +516,9 @@ func TestTraceAttribution(t *testing.T) { t.Fatalf("a missing row is (nil, nil) — log writes lag: got %+v, %v", row, err) } - before := calls - if row, err = c.TraceAttribution(context.Background(), "", time.Time{}); row != nil || err != nil || calls != before { - t.Fatalf("an empty trace id must answer (nil, nil) without a request: %+v %v calls=%d", row, err, calls-before) + before := calls.Load() + if row, err = c.TraceAttribution(context.Background(), "", time.Time{}); row != nil || err != nil || calls.Load() != before { + t.Fatalf("an empty trace id must answer (nil, nil) without a request: %+v %v calls=%d", row, err, calls.Load()-before) } } From db2a76fb733d6658161574ab24d702d2092d6b1e Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:11 +0530 Subject: [PATCH 10/28] refactor(table): hold the model listing's shape in one place `ferro models` and the console's models verb each carried their own copy of the same six headers and the same six accessors, so a column added to one reads as a column missing from the other -- and the console's contract is that it shows what the scriptable verb shows. Both now render through table.ModelHeaders and table.ModelRows, the shape NewPluginCatalog already established for exactly this pair of callers. --- internal/command/models.go | 15 +-------------- internal/table/models.go | 36 ++++++++++++++++++++++++++++++++++++ internal/tui/home.go | 10 ++-------- 3 files changed, 39 insertions(+), 22 deletions(-) create mode 100644 internal/table/models.go diff --git a/internal/command/models.go b/internal/command/models.go index 60f1cf3..c27a9c7 100644 --- a/internal/command/models.go +++ b/internal/command/models.go @@ -1,8 +1,6 @@ package command import ( - "fmt" - "github.com/spf13/cobra" "github.com/ferro-labs/gateway-cli/internal/table" @@ -22,18 +20,7 @@ func newModelsCmd() *cobra.Command { if d.Printer.Format != FormatTable { return d.printStructured(models) } - rows := make([][]string, 0, len(models)) - for _, m := range models { - rows = append(rows, []string{ - m.ID, - table.OrDash(m.OwnedBy), - table.OrDash(m.Mode), - table.PositiveOrDash(m.ContextWindow), - fmt.Sprintf("%d", len(m.Capabilities)), - table.OrDash(m.Status), - }) - } - d.Printer.Table([]string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", colStatus}, rows) + d.Printer.Table(table.ModelHeaders, table.ModelRows(models)) return nil }, } diff --git a/internal/table/models.go b/internal/table/models.go new file mode 100644 index 0000000..e0aa29c --- /dev/null +++ b/internal/table/models.go @@ -0,0 +1,36 @@ +package table + +import ( + "strconv" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +// ModelHeaders and ModelRows are the model listing's shape, held in one place +// because two callers render it: `ferro models` and the console's models verb. +// They were separate copies of the same six columns and the same six +// accessors, which is a drift waiting to happen — a column added to one reads +// as a column missing from the other, and the console's whole contract is that +// it shows what the scriptable verb shows. +// +// This is the shape NewPluginCatalog already established: the wire type is +// internal/api's, the presentation of it is here, and neither caller owns it. +var ModelHeaders = []string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", "STATUS"} + +// ModelRows renders models in ModelHeaders' order. Capabilities is a count, +// not a list: the names are unbounded and would push STATUS off a narrow +// terminal, and the count is what a listing is scanned for. +func ModelRows(models []api.Model) [][]string { + rows := make([][]string, 0, len(models)) + for _, m := range models { + rows = append(rows, []string{ + m.ID, + OrDash(m.OwnedBy), + OrDash(m.Mode), + PositiveOrDash(m.ContextWindow), + strconv.Itoa(len(m.Capabilities)), + OrDash(m.Status), + }) + } + return rows +} diff --git a/internal/tui/home.go b/internal/tui/home.go index 1d49504..7f7f470 100644 --- a/internal/tui/home.go +++ b/internal/tui/home.go @@ -209,14 +209,8 @@ func verbRows(ctx context.Context, c *api.Client, verb string) ([]TranscriptRow, if err != nil { return nil, err } - cells := make([][]string, 0, len(models)) - for _, m := range models { - cells = append(cells, []string{ - m.ID, table.OrDash(m.OwnedBy), table.OrDash(m.Mode), table.PositiveOrDash(m.ContextWindow), - fmt.Sprintf("%d", len(m.Capabilities)), table.OrDash(m.Status), - }) - } - return orEmpty(tableRows([]string{"ID", "OWNED BY", "MODE", "CONTEXT", "CAPABILITIES", "STATUS"}, cells), + cells := table.ModelRows(models) + return orEmpty(tableRows(table.ModelHeaders, cells), len(cells), "this gateway routes no models"), nil case verbProviders: From 49854a222b0a81d224359b67c0f79c41ea132902 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:37 +0530 Subject: [PATCH 11/28] fix(tui): keep a modal's actions when the pane is short fill truncates from the tail and Modal.lines puts the actions last, so a cramped terminal dropped the OK arm and the "type the name to confirm" gate hint -- the one control a destructive modal cannot render without -- while keeping blank separators above it. fit strips the blanks before fill sees them. Also guards a test's close(requestStarted) with sync.Once, and narrows a providers assertion that matched "0" anywhere in the row. --- internal/tui/app_test.go | 5 ++++- internal/tui/modal.go | 20 ++++++++++++++++++-- internal/tui/modal_test.go | 21 +++++++++++++++++++++ internal/tui/playground_test.go | 7 ++++++- 4 files changed, 49 insertions(+), 4 deletions(-) diff --git a/internal/tui/app_test.go b/internal/tui/app_test.go index 99db307..c1a56bf 100644 --- a/internal/tui/app_test.go +++ b/internal/tui/app_test.go @@ -266,8 +266,11 @@ func TestCompactStatusDoesNotInventZeroMeasurements(t *testing.T) { view := a.viewCompactStatus() gatewayRow := findRow(view, "Gateway") providersRow := findRow(view, "Providers") + // A bare \b0\b, not strings.Contains: the row label or padding could + // legitimately carry a "0" elsewhere, and that must not fail this check — + // only an invented zero measurement should. if !strings.Contains(gatewayRow, a.dash()) || strings.Contains(gatewayRow, "0ms") || - !strings.Contains(providersRow, a.dash()) || strings.Contains(providersRow, "0") { + !strings.Contains(providersRow, a.dash()) || regexp.MustCompile(`\b0\b`).MatchString(providersRow) { t.Fatalf("unreported latency and provider counts must render as dashes:\n%s", view) } } diff --git a/internal/tui/modal.go b/internal/tui/modal.go index a6bb9cc..4d2f50c 100644 --- a/internal/tui/modal.go +++ b/internal/tui/modal.go @@ -166,9 +166,25 @@ func (m *Modal) cycle(d int) { // degrades to its bare content rather than emitting a frame with a hole in it. func (m *Modal) view(a *App, w, rows int) string { if rows < 4 || w < 14 { - return fill(m.lines(a, w), w, rows) + return fill(m.fit(a, w, rows), w, rows) } - return a.Theme.FrameRound(fill(m.lines(a, w-4), w-4, rows-2), w) + return a.Theme.FrameRound(fill(m.fit(a, w-4, rows-2), w-4, rows-2), w) +} + +// fit drops the blank separators while the card is taller than the budget. +// fill truncates from the tail, and the tail is the OK arm and the "type the +// name to enable" gate hint — the one control a destructive modal cannot +// render without — so those blanks have to go before fill ever sees them. +func (m *Modal) fit(a *App, w, rows int) []string { + out := m.lines(a, w) + for i := 0; i < len(out) && len(out) > rows; { + if out[i] == "" { + out = append(out[:i], out[i+1:]...) + continue + } + i++ + } + return out } // lines is the card's content, in order: title, body, rows, editor, actions. diff --git a/internal/tui/modal_test.go b/internal/tui/modal_test.go index 24c78cd..157d32c 100644 --- a/internal/tui/modal_test.go +++ b/internal/tui/modal_test.go @@ -161,6 +161,27 @@ func TestModalViewKeepsThePaneContract(t *testing.T) { } } +// fill truncates from the tail, and the tail is the OK arm and the "type the +// name to enable" gate hint. Before dropping blank separators first, a short +// pane lost those before it lost anything cosmetic, leaving a gated +// destructive modal with no visible confirmation control. +func TestModalViewKeepsActionsWhenPaneIsShort(t *testing.T) { + a := composerApp() + a.Modal = &Modal{ + Title: "Revoke ci-pipeline?", + Body: "Every client holding this key fails immediately.", + Rows: []ModalKV{{K: "name", V: "ci-pipeline", Bold: true}}, + Input: true, + Confirm: "ci-pipeline", + OKLabel: "revoke", + Danger: true, + } + view := a.paneView(60, 7) + if !strings.Contains(view, "revoke") || !strings.Contains(view, "type the name to enable") { + t.Fatalf("a short pane must drop blank separators before the OK arm, got:\n%s", view) + } +} + // A modal body can carry intentional line breaks; rendering must preserve them // instead of collapsing the wording into one run-on line. func TestModalRendersEveryBodyLine(t *testing.T) { diff --git a/internal/tui/playground_test.go b/internal/tui/playground_test.go index 5148cfc..e784406 100644 --- a/internal/tui/playground_test.go +++ b/internal/tui/playground_test.go @@ -6,6 +6,7 @@ import ( "net/http" "net/http/httptest" "strings" + "sync" "sync/atomic" "testing" "time" @@ -103,8 +104,12 @@ func TestSubmitAppendsTurnsAndStreams(t *testing.T) { func TestLeavingPlaygroundCancelsStreamBeforeHeaders(t *testing.T) { requestStarted := make(chan struct{}) releaseServer := make(chan struct{}) + // sync.Once, not a bare close: a second request reaching this handler — + // a client retry, or a later test change probing the same server — must + // not panic the whole test binary on a double close. + var once sync.Once srv := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { - close(requestStarted) + once.Do(func() { close(requestStarted) }) <-releaseServer })) defer func() { From 855db28869f272bd9c98a2c7a67e518ca96d93f7 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:37 +0530 Subject: [PATCH 12/28] ci: harden the module boundary check, the release job, and the fixture bind The boundary check grepped source text, so a doc comment naming the gateway module failed CI while a single-line `require`, `replace` or `exclude` passed it. It now walks the real import graph with go list -deps and matches the module path anywhere in a go.mod directive. go list and grep are separate statements: on one pipeline, the `|| true` grep needs for "no match" would also swallow a go list failure and pass the check without scanning. depguard prefix-matches, so one entry for the module root replaces eight subpackage entries and covers subpackages that do not exist yet. The release job publishes user-facing artifacts, so it no longer restores a Go build cache that can carry entries from other refs, and a concurrency group keeps two pushes of one tag from racing. The integration matrix's "main" leg is advisory: it tracks a branch upstream of this repo, and release.yml needs ci, so an unrelated upstream commit could block a release. cmd/fakegw binds loopback by default -- --no-auth serves unauthenticated admin requests -- and both scripts now check the external tools they assume. --- .github/workflows/ci.yml | 7 +++++++ .github/workflows/release.yml | 8 ++++++++ .golangci.yml | 13 ++++--------- README.md | 2 +- cmd/fakegw/main.go | 4 +++- scripts/check-module-boundary.sh | 22 +++++++++++++++++----- scripts/smoke.sh | 1 + scripts/with-gateway.sh | 5 +++++ 8 files changed, 46 insertions(+), 16 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9d2b431..49e26ba 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,6 +24,9 @@ jobs: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false + - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 + with: + go-version-file: go.mod - run: ./scripts/check-module-boundary.sh lint: @@ -71,6 +74,10 @@ jobs: integration: name: Contract vs AI Gateway ${{ matrix.gateway_ref }} runs-on: ubuntu-latest + # The pinned v1.4.2 leg is the required signal; "main" moves upstream of + # this repo and release.yml depends on ci via `needs: ci`, so a failure + # there must not block merges or tagged releases — only report it. + continue-on-error: ${{ matrix.gateway_ref == 'main' }} strategy: fail-fast: false matrix: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 09d9642..3e5ce86 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -4,6 +4,10 @@ on: push: tags: ["v*"] +concurrency: + group: release-${{ github.ref }} + cancel-in-progress: false + permissions: {} jobs: @@ -17,6 +21,7 @@ jobs: needs: ci runs-on: ubuntu-latest permissions: + # GoReleaser publishes the GitHub release and uploads archives. contents: write steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 @@ -26,6 +31,9 @@ jobs: - uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0 with: go-version-file: go.mod + # A restored cache can carry entries from other refs; this job + # publishes release artifacts, so a poisoned cache is user-facing. + cache: false - uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7.0.0 with: distribution: goreleaser diff --git a/.golangci.yml b/.golangci.yml index 4db6c43..09c08a1 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -35,15 +35,10 @@ linters: deny: - pkg: gopkg.in/yaml.v3 desc: use go.yaml.in/yaml/v3 - - pkg: github.com/ferro-labs/ai-gateway/config - desc: &http-only gateway-cli communicates with AI Gateway over HTTP only - - { pkg: github.com/ferro-labs/ai-gateway/internal, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/mcp, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/models, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/observability, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/pkg, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/plugin, desc: *http-only } - - { pkg: github.com/ferro-labs/ai-gateway/providers, desc: *http-only } + # depguard prefix-matches, so the module root also denies every + # current and future subpackage. + - pkg: github.com/ferro-labs/ai-gateway + desc: gateway-cli communicates with AI Gateway over HTTP only dupl: threshold: 150 gocyclo: diff --git a/README.md b/README.md index 6cef23d..50ea2a4 100644 --- a/README.md +++ b/README.md @@ -196,7 +196,7 @@ the gateway module. Wire shapes are copied, never imported, and CI enforces the boundary. ```bash -make fake # fake gateway (cmd/fakegw) on :8080 +make fake # fake gateway (cmd/fakegw) on 127.0.0.1:8080 make build # go build -o ferro ./cmd/ferro make test # go test -race ./... make lint # golangci-lint run ./... diff --git a/cmd/fakegw/main.go b/cmd/fakegw/main.go index a03f511..8b5cda8 100644 --- a/cmd/fakegw/main.go +++ b/cmd/fakegw/main.go @@ -13,7 +13,9 @@ import ( ) func main() { - addr := flag.String("addr", ":8080", "listen address") + // Loopback-only: --no-auth accepts unauthenticated admin requests, so a + // wildcard bind would expose them to anything else on the network. + addr := flag.String("addr", "127.0.0.1:8080", "listen address") degraded := flag.Bool("degraded", false, "healthy gateway in trouble: 200 with a half-open circuit and one unroutable target") noProviders := flag.Bool("no-providers", false, "no credential configured: /health 503 no_providers, /readyz 503 not_ready") noAuth := flag.Bool("no-auth", false, "accept unauthenticated admin requests") diff --git a/scripts/check-module-boundary.sh b/scripts/check-module-boundary.sh index 6ab129c..2ef615b 100755 --- a/scripts/check-module-boundary.sh +++ b/scripts/check-module-boundary.sh @@ -1,15 +1,27 @@ #!/usr/bin/env bash set -euo pipefail -grep -Fxq 'module github.com/ferro-labs/gateway-cli' go.mod +if ! grep -Fxq 'module github.com/ferro-labs/gateway-cli' go.mod; then + echo 'go.mod must declare module github.com/ferro-labs/gateway-cli' >&2 + exit 1 +fi -if grep -RIn --include='*.go' --exclude-dir=.git \ - 'github.com/ferro-labs/ai-gateway' .; then +# go list walks the real import graph (covers aliased and blank imports, and +# can't be tripped by a doc comment or string literal naming the module the +# way a text grep can) instead of grepping source text. -tags integration +# pulls itest/ into the graph too. +# Two statements, not one pipeline: `|| true` is needed for grep's "no match" +# exit 1, and on a pipeline it would swallow a go list failure too — passing +# the check because the scan never ran, which is the hole this rewrite closes. +deps="$(go list -tags integration -deps ./...)" +offenders="$(printf '%s\n' "$deps" | grep '^github\.com/ferro-labs/ai-gateway' || true)" +if [ -n "$offenders" ]; then + echo "$offenders" >&2 echo 'gateway-cli must not import AI Gateway packages' >&2 exit 1 fi -if grep -qE '^[[:space:]]*github\.com/ferro-labs/ai-gateway([[:space:]]|$)' go.mod; then - echo 'gateway-cli must not require the AI Gateway module' >&2 +if grep -qE '(^|[[:space:]>])github\.com/ferro-labs/ai-gateway([[:space:]/]|$)' go.mod; then + echo 'gateway-cli must not reference the AI Gateway module in go.mod' >&2 exit 1 fi diff --git a/scripts/smoke.sh b/scripts/smoke.sh index 2ea000b..89678f4 100755 --- a/scripts/smoke.sh +++ b/scripts/smoke.sh @@ -40,6 +40,7 @@ fi if [ -n "${FERRO_SMOKE_URL:-}" ]; then FERRO_URL="$FERRO_SMOKE_URL" "$bin" status + command -v python3 >/dev/null || { echo "FAIL: python3 is required for the live JSON smoke check" >&2; exit 1; } # stdout must be exactly one JSON document — nothing else may leak into it. FERRO_URL="$FERRO_SMOKE_URL" "$bin" status --format json | python3 -m json.tool >/dev/null echo "[OK] live smoke against $FERRO_SMOKE_URL" diff --git a/scripts/with-gateway.sh b/scripts/with-gateway.sh index c44da3f..f040e51 100755 --- a/scripts/with-gateway.sh +++ b/scripts/with-gateway.sh @@ -14,6 +14,11 @@ # sessions, and audit — everything except live chat. set -euo pipefail +# Checked up front: the health probe below reads curl's exit status to decide +# the gateway is not up yet, so a missing curl looks exactly like a gateway +# that never starts — a 15-second wait ending in the wrong diagnosis. +command -v curl >/dev/null || { echo "curl is required to probe the gateway" >&2; exit 2; } + cli="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" gateway_source="${FERRO_GATEWAY_SOURCE:-}" if [ -z "$gateway_source" ]; then From e53ed41a0092ea5ac76e54118e41ee4715397715 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Fri, 14 Aug 2026 23:06:38 +0530 Subject: [PATCH 13/28] test: isolate config resolution, deflake the tail test, widen itest redaction The shared command helpers now point XDG_CONFIG_HOME at a temp dir, so a real ferro config on a developer's machine cannot resolve into a connection test. The explicit --config and FERRO_CONFIG precedence tests are untouched; those paths are read before DefaultPath is consulted. The truncation test raced a fixed budget against 32 sequential round trips. It now cancels off the 32nd response rather than off a clock. itest dumps a live gateway's response bodies on failure, straight into CI logs. Redaction gains this codebase's own credential field names and, more usefully, matches the fgw_ prefix by value -- a drifted gateway putting the secret under an unseen field name is exactly what that dump would leak. --- internal/command/logs_test.go | 37 ++++++++++++++++++++++++++++------ internal/command/root_test.go | 8 ++++++++ internal/fixture/handler.go | 34 ++++++++----------------------- itest/itest_test.go | 38 +++++++++++++++++++++++++++++++---- 4 files changed, 81 insertions(+), 36 deletions(-) diff --git a/internal/command/logs_test.go b/internal/command/logs_test.go index dfc2dda..48d37cd 100644 --- a/internal/command/logs_test.go +++ b/internal/command/logs_test.go @@ -21,7 +21,12 @@ import ( // executeCtx is execute() with a caller-owned context, which is what a tail // needs: cancelling it is how SIGINT reaches the poll loop. -func executeCtx(ctx context.Context, args ...string) (stdout, stderr string, err error) { +func executeCtx(ctx context.Context, t *testing.T, args ...string) (stdout, stderr string, err error) { + t.Helper() + // See execute's identical guard in root_test.go: without it, a real ferro + // config on the host machine could resolve into these tests' connection + // setup. + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) root := NewRoot() var out, errb bytes.Buffer root.SetOut(&out) @@ -217,7 +222,7 @@ func TestLogsTailPrintsRowsAndExitsCleanlyOnCancel(t *testing.T) { ctx, cancel := context.WithTimeout(t.Context(), 300*time.Millisecond) defer cancel() - stdout, _, err := executeCtx(ctx, "logs", "tail", "--since", "1h", + stdout, _, err := executeCtx(ctx, t, "logs", "tail", "--since", "1h", "--gateway-url", srv.URL) if err != nil { t.Fatalf("a tail the operator interrupted is not a failure: %v", err) @@ -242,7 +247,7 @@ func TestLogsTailBacksOffAndKeepsGoingOnFailure(t *testing.T) { ctx, cancel := context.WithTimeout(t.Context(), 200*time.Millisecond) defer cancel() - stdout, stderr, err := executeCtx(ctx, "logs", "tail", + stdout, stderr, err := executeCtx(ctx, t, "logs", "tail", "--gateway-url", srv.URL) if err != nil { t.Fatalf("a poll failure is a warning, not an exit: %v", err) @@ -274,17 +279,37 @@ func TestLogsTailReportsTruncationWithoutBackingOff(t *testing.T) { // every poll exhausts its page bound with rows still outstanding. body := []byte(`{"data":[` + strings.Join(rows, ",") + `],"summary":{"total_entries":1000000,"returned_entries":100}}`) + + // A fixed wall-clock budget for "one whole poll" races the page count + // against however long 32 sequential round trips take under load — land + // the deadline mid-poll and Poll returns a context error with stdout + // still empty, no product defect behind it. Cancel off the 32nd response + // instead of off a clock, so the interrupt cannot land before the poll + // that must finish first, regardless of how slow the run is. + var calls atomic.Int32 + done := make(chan struct{}) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write(body) + if calls.Add(1) == 32 { + close(done) + } })) defer srv.Close() - // Long enough for one whole poll — 32 pages of it — then the interrupt. - ctx, cancel := context.WithTimeout(t.Context(), time.Second) + ctx, cancel := context.WithCancel(t.Context()) defer cancel() + go func() { + <-done + // The 32nd response is written, not yet read: give the client time to + // receive and decode it before pulling the context out from under it. + // This only has to outlast one small JSON decode, not 32 round trips, + // so it stays well clear of the flake it replaces. + time.Sleep(50 * time.Millisecond) + cancel() + }() - stdout, stderr, err := executeCtx(ctx, "logs", "tail", "--gateway-url", srv.URL) + stdout, stderr, err := executeCtx(ctx, t, "logs", "tail", "--gateway-url", srv.URL) if err != nil { t.Fatalf("a truncated poll is not a failed command: %v", err) } diff --git a/internal/command/root_test.go b/internal/command/root_test.go index 5c786a2..d9f6f8b 100644 --- a/internal/command/root_test.go +++ b/internal/command/root_test.go @@ -13,6 +13,11 @@ import ( func execute(t *testing.T, args ...string) (stdout, stderr string, err error) { t.Helper() + // A developer's real ~/.config/ferro/config.yaml must not leak into a + // test run: point the OS default config dir at an empty one so DefaultPath + // resolves to a file that never exists, leaving --config and FERRO_CONFIG + // free to override it as they always could. + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) root := NewRoot() var out, errb bytes.Buffer root.SetOut(&out) @@ -96,6 +101,9 @@ func TestVersionSkipsConnectionSetup(t *testing.T) { // happens to exist. func withProbe(t *testing.T, args ...string) (*runtimeDeps, error) { t.Helper() + // See execute's identical guard: without it, a real ferro config on the + // host machine could resolve into these tests' connection setup. + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) root := NewRoot() var got *runtimeDeps root.AddCommand(&cobra.Command{ diff --git a/internal/fixture/handler.go b/internal/fixture/handler.go index d6fb7dd..e6cbcfb 100644 --- a/internal/fixture/handler.go +++ b/internal/fixture/handler.go @@ -481,14 +481,8 @@ func parseSince(w http.ResponseWriter, q url.Values) (time.Time, bool) { // that ignored them would answer rows the query excluded — a lie downstream // tests would then enshrine. since is pre-parsed by parseSince rather than // reparsed here, so a malformed value 400s before any row is ever filtered. -func filterLogs(rows []logRow, q map[string][]string, since time.Time) []logRow { - get := func(k string) string { - if v := q[k]; len(v) > 0 { - return v[0] - } - return "" - } - stage, model, provider, keyID := get(fieldStage), get(fieldModel), get(fieldProvider), get(fieldAPIKeyID) +func filterLogs(rows []logRow, q url.Values, since time.Time) []logRow { + stage, model, provider, keyID := q.Get(fieldStage), q.Get(fieldModel), q.Get(fieldProvider), q.Get(fieldAPIKeyID) // `since` is what a live tail advances on: Follower re-sends its cursor // every poll and expects to be given only what is newer. Echoing the @@ -523,14 +517,8 @@ func filterLogs(rows []logRow, q map[string][]string, since time.Time) []logRow // real query's WHERE clause never adds one — internal/requestlog/store.go's // SQLWriter.Stats) and no api_key_id filter (the real handler never reads // one), so this is deliberately not filterLogs with a parameter dropped. -func filterStats(rows []logRow, q map[string][]string, since time.Time) []logRow { - get := func(k string) string { - if v := q[k]; len(v) > 0 { - return v[0] - } - return "" - } - stage, model, provider := get(fieldStage), get(fieldModel), get(fieldProvider) +func filterStats(rows []logRow, q url.Values, since time.Time) []logRow { + stage, model, provider := q.Get(fieldStage), q.Get(fieldModel), q.Get(fieldProvider) out := make([]logRow, 0, len(rows)) for _, row := range rows { @@ -778,23 +766,17 @@ func auditRows() []map[string]any { } } -func filterAudit(rows []map[string]any, q map[string][]string, since time.Time) []map[string]any { - get := func(k string) string { - if v := q[k]; len(v) > 0 { - return v[0] - } - return "" - } +func filterAudit(rows []map[string]any, q url.Values, since time.Time) []map[string]any { out := make([]map[string]any, 0, len(rows)) for _, row := range rows { occurred, _ := time.Parse(time.RFC3339Nano, stringValue(row[fieldOccurredAt])) - if action := get("action"); action != "" && stringValue(row["action"]) != action { + if action := q.Get("action"); action != "" && stringValue(row["action"]) != action { continue } - if actorID := get(fieldActorID); actorID != "" && stringValue(row[fieldActorID]) != actorID { + if actorID := q.Get(fieldActorID); actorID != "" && stringValue(row[fieldActorID]) != actorID { continue } - if outcome := get(fieldOutcome); outcome != "" && stringValue(row[fieldOutcome]) != outcome { + if outcome := q.Get(fieldOutcome); outcome != "" && stringValue(row[fieldOutcome]) != outcome { continue } if !since.IsZero() && occurred.Before(since) { diff --git a/itest/itest_test.go b/itest/itest_test.go index 89df09f..3a18769 100644 --- a/itest/itest_test.go +++ b/itest/itest_test.go @@ -425,30 +425,60 @@ func TestSafeBodyRedactsCompoundCredentials(t *testing.T) { "nested":{"refresh_token":"two","client_secret":"three"}, "items":[{"private_key":"four"}], "apiKey":"five","X-API-Key":"six","sessionToken":"seven", + "credential":"eight","credentials":"nine", "note":"visible" }`)) - for _, secret := range []string{"one", "two", "three", "four", "five", "six", "seven"} { + for _, secret := range []string{"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"} { if strings.Contains(got, secret) { t.Fatalf("safeBody leaked %q: %s", secret, got) } } - if strings.Count(got, "[REDACTED]") != 7 || !strings.Contains(got, "visible") { + if strings.Count(got, "[REDACTED]") != 9 || !strings.Contains(got, "visible") { t.Fatalf("every compound credential field must be redacted: %s", got) } } +// TestSafeBodyRedactsFgwSecretUnderAnyFieldName pins the value-based catch: a +// live gateway can drift a master key onto a field name this vocabulary has +// never seen, but every key this gateway issues is fgw_-prefixed regardless +// of where it lands (newSecret, internal/fixture/keys.go). +func TestSafeBodyRedactsFgwSecretUnderAnyFieldName(t *testing.T) { + got := safeBody([]byte(`{"unexpected_field":"fgw_wildcardvalue","note":"visible"}`)) + if strings.Contains(got, "fgw_wildcardvalue") { + t.Fatalf("safeBody leaked a fgw_ secret under an unlisted field name: %s", got) + } + if strings.Count(got, "[REDACTED]") != 1 || !strings.Contains(got, "visible") { + t.Fatalf("fgw_-prefixed value must be redacted regardless of field name: %s", got) + } +} + func redact(value any) { switch value := value.(type) { case map[string]any: for key, child := range value { normalized := strings.ToLower(strings.NewReplacer("_", "", "-", "").Replace(key)) switch normalized { + // credential/credentials joins this list because it is this + // codebase's own word for the secret (AcceptKey, defaultKey in + // internal/fixture/state.go) even though the wire field is + // spelled "key". case "key", "apikey", "xapikey", "privatekey", "secret", "clientsecret", "token", "accesstoken", - "refreshtoken", "sessiontoken", "authorization": + "refreshtoken", "sessiontoken", "authorization", + "credential", "credentials": value[key] = "[REDACTED]" default: - redact(child) + if s, ok := child.(string); ok && strings.HasPrefix(s, "fgw_") { + // Every master key this gateway issues is fgw_-prefixed + // (newSecret, internal/fixture/keys.go). raw() dumps a + // live gateway's actual bytes, not internal/api's + // modeled shape, so matching the value catches a secret + // riding under a field name this vocabulary has never + // seen. + value[key] = "[REDACTED]" + } else { + redact(child) + } } } case []any: From 56b8e97e46b42dd6b4079f6796a84233f51665fb Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:11:13 +0530 Subject: [PATCH 14/28] fix(table): neutralize control characters on every surface, not one The cell normalizer added with the table layout covered exactly one of the five places that render a gateway-provided string. A provider name, a stage, an upstream error message and a model's answer all reached a terminal raw through the other four: the `logs tail` line on stdout, the two console tables, the detail strip, and the transcript. Two consequences, both reproduced. A newline in an error_message made a pane asked for twelve lines return thirteen, breaking the exact-line contract that anchors the composer to the bottom of the screen and every frame below it. An ESC from an upstream provider was forwarded verbatim to whatever was reading stdout. SanitizeCell and SanitizeText now hold that vocabulary once, and every surface collapses through them -- SanitizeText keeps LF because a streamed answer's line breaks are its own. The range is the whole of C0, DEL and C1, not the four characters that had actually caused a bug: enumerating those left BEL ringing the terminal and 0x9b opening a sequence exactly as ESC[ does, and the next gap would have been found the same way. The strip's title needed it too, which the line-count test caught: both callers pass gateway data into it ("Key "+name, "Request "+trace) and neither goes through the key/value path. Answers are sanitized where they are rendered, not where they are stored -- history() sends that text back to the gateway as the conversation, so scrubbing it at the source would corrupt every following turn's context. Also here because it shares a file: /model's near-miss suggestions compared three bytes of a typed name, which splits a multi-byte rune and silently degraded to the head of the list. Three runes. --- internal/command/logs.go | 4 +-- internal/command/logs_test.go | 23 +++++++++++++ internal/table/sanitize.go | 39 +++++++++++++++++++++ internal/table/table.go | 10 +----- internal/table/table_test.go | 30 ++++++++++++++++ internal/tui/keys.go | 7 ++-- internal/tui/keys_test.go | 22 ++++++++++++ internal/tui/playground.go | 20 ++++++++++- internal/tui/playground_test.go | 61 +++++++++++++++++++++++++++++++++ internal/tui/transcript.go | 3 +- internal/tui/transcript_test.go | 19 ++++++++++ 11 files changed, 222 insertions(+), 16 deletions(-) create mode 100644 internal/table/sanitize.go diff --git a/internal/command/logs.go b/internal/command/logs.go index 0998e18..b5a4894 100644 --- a/internal/command/logs.go +++ b/internal/command/logs.go @@ -289,7 +289,7 @@ func formatLogLine(e api.LogEntry) string { // string but disappears under an `awk`-style whitespace split, silently // shifting every column after it. func oneField(s string) string { - f := strings.Fields(s) + f := strings.Fields(table.SanitizeCell(s)) if len(f) == 0 { return "-" } @@ -302,7 +302,7 @@ func oneField(s string) string { // a script indexes into by position -- and only a literal newline or tab // inside it can break the one-line contract. func oneLine(s string) string { - return strings.Join(strings.Fields(s), " ") + return strings.Join(strings.Fields(table.SanitizeCell(s)), " ") } // fmtMillis and fmtCost keep the nullable-measurement rule in one place: the diff --git a/internal/command/logs_test.go b/internal/command/logs_test.go index 48d37cd..b058ff5 100644 --- a/internal/command/logs_test.go +++ b/internal/command/logs_test.go @@ -349,3 +349,26 @@ func TestLogsQueryFromFlagsPassesNoneSentinel(t *testing.T) { t.Fatalf("the gateway's none sentinel must pass through untouched, got %q", q.APIKeyID) } } + +// `logs tail` writes straight to stdout, and strings.Fields splits on +// whitespace only — an ESC survives it untouched. A colour or OSC sequence an +// upstream provider put in a name or an error_message is terminal control this +// tool has no business forwarding to whatever is reading the pipe. +func TestFormatLogLineStripsTerminalControl(t *testing.T) { + line := formatLogLine(api.LogEntry{ + TraceID: "tr_esc", + Provider: "op\x1b[31mai", + Model: "gpt-4o", + Stage: "on_error", + ErrorMessage: "upstream said \x1b]0;pwned\x07 and \x1b[2J", + }) + if strings.Contains(line, "\x1b") { + t.Fatalf("an escape sequence must never reach stdout: %q", line) + } + if strings.ContainsAny(line, "\n\r\t") { + t.Fatalf("tail rows must remain one line: %q", line) + } + if got := strings.Fields(line)[2]; got != "op_[31mai" { + t.Fatalf("a neutralized ESC must not widen the provider into a second column: %q (%q)", got, line) + } +} diff --git a/internal/table/sanitize.go b/internal/table/sanitize.go new file mode 100644 index 0000000..205be84 --- /dev/null +++ b/internal/table/sanitize.go @@ -0,0 +1,39 @@ +package table + +import "strings" + +// A gateway-provided string — a provider name, a plugin summary, an upstream +// error message, a model's answer — is data reaching a terminal, never layout +// and never terminal control. A tab or newline injects a column, a row, or an +// extra line into a pane that owes an exact line count; ESC starts a sequence +// this tool has no business forwarding from an upstream provider to whatever +// is reading stdout. Every surface that renders one of those strings collapses +// them here, so the vocabulary cannot drift between surfaces. +// +// The whole control range goes, not an enumerated handful. Listing the four +// characters that had actually caused a bug (tab, CR, LF, ESC) left BEL ringing +// the terminal and NUL reaching it, and the next escape hatch would have been +// found the same way — by someone hitting it. A terminal reads more than ESC as +// control: C0 and DEL, and C1 0x80–0x9f, where 0x9b is a single-byte CSI that +// opens a sequence exactly as ESC[ does. +func sanitize(s string, keepLF bool) string { + return strings.Map(func(r rune) rune { + if r == '\n' && keepLF { + return r + } + if r < 0x20 || r == 0x7f || (r >= 0x80 && r <= 0x9f) { + return ' ' + } + return r + }, s) +} + +// SanitizeCell returns s with every control character collapsed to a single +// space, LF included. For a value that occupies one cell of a table or one +// line of a pane, where a line break would break the caller's line count. +func SanitizeCell(s string) string { return sanitize(s, false) } + +// SanitizeText returns s with every control character collapsed to a single +// space except LF, which is kept: for a multi-line body whose line breaks are +// its own (a streamed answer), where the caller splits on \n itself. +func SanitizeText(s string) string { return sanitize(s, true) } diff --git a/internal/table/table.go b/internal/table/table.go index 1681a67..bb979b6 100644 --- a/internal/table/table.go +++ b/internal/table/table.go @@ -16,18 +16,10 @@ import ( "text/tabwriter" ) -// tableCellReplacer neutralizes control characters a gateway-provided cell -// (a provider name, a plugin summary, an upstream error message) could carry: -// a tab or newline would inject a column or row into the layout below, and -// ESC starts a terminal escape sequence this package has no business passing -// through to whatever is reading stdout. Cell text is data, not layout or -// terminal control, so all four collapse to a single space. -var tableCellReplacer = strings.NewReplacer("\t", " ", "\r", " ", "\n", " ", "\x1b", " ") - func normalizeCells(cells []string) []string { out := make([]string, len(cells)) for i, c := range cells { - out[i] = tableCellReplacer.Replace(c) + out[i] = SanitizeCell(c) } return out } diff --git a/internal/table/table_test.go b/internal/table/table_test.go index 2409ff8..7186f04 100644 --- a/internal/table/table_test.go +++ b/internal/table/table_test.go @@ -157,3 +157,33 @@ func TestFmtTimePtr(t *testing.T) { t.Fatalf("FmtTimePtr(&t) = %q, want %q", got, want) } } + +// SanitizeCell and SanitizeText are the one vocabulary every surface that +// renders a gateway string shares. They differ on LF alone: a line break is +// injected layout in a table cell and content in a streamed body. +func TestSanitizeCellAndText(t *testing.T) { + for _, tc := range []struct { + name, in, cell, text string + }{ + {"a clean value is untouched", "anthropic", "anthropic", "anthropic"}, + {"tab", "a\tb", "a b", "a b"}, + {"carriage return", "a\rb", "a b", "a b"}, + {"newline is layout in a cell, content in a body", "a\nb", "a b", "a\nb"}, + {"the ESC that starts a colour sequence", "a\x1b[31mb", "a [31mb", "a [31mb"}, + {"the ESC that starts an OSC title write", "a\x1b]0;pwned", "a ]0;pwned", "a ]0;pwned"}, + {"BEL, which rings the terminal on its own", "a\x07b", "a b", "a b"}, + {"NUL", "a\x00b", "a b", "a b"}, + {"DEL", "a\x7fb", "a b", "a b"}, + {"the C1 CSI, which opens a sequence without an ESC", "a\u009b31mb", "a 31mb", "a 31mb"}, + {"a multi-byte rune is not a control character", "日本語", "日本語", "日本語"}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := SanitizeCell(tc.in); got != tc.cell { + t.Errorf("SanitizeCell(%q) = %q, want %q", tc.in, got, tc.cell) + } + if got := SanitizeText(tc.in); got != tc.text { + t.Errorf("SanitizeText(%q) = %q, want %q", tc.in, got, tc.text) + } + }) + } +} diff --git a/internal/tui/keys.go b/internal/tui/keys.go index b81ff67..ae9b45d 100644 --- a/internal/tui/keys.go +++ b/internal/tui/keys.go @@ -662,7 +662,7 @@ func rowLine(cols []column, cells []cell) string { if i >= len(cells) { break } - v := cells[i].v + v := table.SanitizeCell(cells[i].v) if c.right { v = padLeft(v, c.w) } else { @@ -699,10 +699,11 @@ func detailStrip(a *App, title string, rows []ModalKV, w int) []string { th := a.Theme out := append(make([]string, 0, 2+len(rows)), th.Border.Render(a.rule(max(w, 0))), - gapPad(w, th.Bright.Bold(th.Mode.Color).Render(title), th.Dim.Render("esc close")), + gapPad(w, th.Bright.Bold(th.Mode.Color).Render(table.SanitizeCell(title)), th.Dim.Render("esc close")), ) for _, r := range rows { - out = append(out, th.Dim.Render(padRight(r.K, modalKeyCol))+kvStyle(th, r).Render(r.V)) + out = append(out, th.Dim.Render(padRight(table.SanitizeCell(r.K), modalKeyCol))+ + kvStyle(th, r).Render(table.SanitizeCell(r.V))) } return clampLines(out, w) } diff --git a/internal/tui/keys_test.go b/internal/tui/keys_test.go index 3b902dc..2b5af4d 100644 --- a/internal/tui/keys_test.go +++ b/internal/tui/keys_test.go @@ -390,3 +390,25 @@ func TestKeysScreenKeepsThePaneContract(t *testing.T) { } } } + +// The keys pane owes the same exact line count, and a key name is gateway data +// like any other: it is echoed into the table and into the detail strip. +func TestKeysPaneKeepsItsLineCountWithControlCharactersInGatewayData(t *testing.T) { + a := composerApp() + a.Screen = ScreenKeys + a.Keys.keys = []api.Key{{ + ID: "key_01", Name: "prod\ningest", Key: "fgw_abcd…9f21", + Scopes: []string{"admin\x1b[31m"}, Active: true, CreatedAt: time.Now(), + }} + a.Keys.sel, a.Keys.detail = 0, true + + for _, rows := range []int{4, 9, 20} { + out := a.Keys.view(a, 100, rows) + if got := strings.Count(out, "\n") + 1; got != rows { + t.Fatalf("view(rows=%d) returned %d lines:\n%q", rows, got, out) + } + if strings.Contains(out, "\x1b") { + t.Fatalf("view(rows=%d) forwarded an escape sequence:\n%q", rows, out) + } + } +} diff --git a/internal/tui/playground.go b/internal/tui/playground.go index 952ad9e..1233957 100644 --- a/internal/tui/playground.go +++ b/internal/tui/playground.go @@ -11,6 +11,7 @@ import ( "github.com/charmbracelet/x/ansi" "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" ) // The playground is a streamed chat with the route metadata a gateway operator @@ -248,9 +249,16 @@ func (s *playScreen) setModel(a *App, id string) { // nearest offers the models closest to what was typed: shared prefix first, // then the head of the list, so a refusal always names something runnable. func (s *playScreen) nearest(id string) []string { + // Three RUNES, not three bytes. id is whatever the operator typed, so a + // byte slice cuts a non-ASCII name at an arbitrary point: for a CJK name + // three bytes is ONE character, which matches far more than the near miss + // this reads as, and for other scripts it lands mid-rune and the comparison + // becomes a byte accident. Hoisted out of the loop while it is here. + head := []rune(id) + prefix := string(head[:min(len(head), 3)]) var out []string for _, m := range s.models { - if strings.HasPrefix(m, id[:min(len(id), 3)]) { + if strings.HasPrefix(m, prefix) { out = append(out, m) } } @@ -648,6 +656,16 @@ func (s *playScreen) wrap(text string) []string { if text == "" { return nil } + // The one chokepoint where model-supplied text becomes rendered lines: + // submit, flush and markFailed all arrive here, so this is where an answer + // stops being able to drive the terminal. wrapPlain is deliberately + // ANSI-AWARE and would carry a \x1b[2J or an OSC title change straight into + // the frame, breaking both the pane's exact-line contract and the rule that + // this tool forwards no terminal control from an upstream provider. LF + // survives — an answer's own line breaks are meaningful and the split below + // is what honours them. Text itself is left untouched: it is what history() + // sends back to the gateway as the conversation. + text = table.SanitizeText(text) w := max(s.width, 8) out := text if s.renderer != nil { diff --git a/internal/tui/playground_test.go b/internal/tui/playground_test.go index e784406..85ded65 100644 --- a/internal/tui/playground_test.go +++ b/internal/tui/playground_test.go @@ -617,3 +617,64 @@ func TestInlineChatReleasesThePromptWhenDiscoveryFails(t *testing.T) { t.Fatalf("a failed listing must not swallow the prompt, got %+v", a.Play.turns) } } + +// A streamed answer is model-supplied text, and wrapPlain is deliberately +// ANSI-AWARE: it preserved a \x1b[2J (clear screen) and an OSC window-title +// change straight into the frame. That is terminal control forwarded from an +// upstream provider into the operator's session, and a pane that no longer owes +// exactly rows lines. +func TestAnswerEscapesNeverReachTheFrame(t *testing.T) { + a := composerApp() + a.route("playground") + a.Play.renderer = wrapPlain + a.Play.submit(a, "hello") + a.update(chatDeltaMsg{gen: a.Play.gen, text: "\x1b[2Jcleared\x1b]0;pwned\x07titled\nsecond line"}) + a.update(flushTickMsg{gen: a.Play.gen}) + + turn := lastTurn(a) + // Text is the conversation history sent back to the gateway and stays as + // the model wrote it. What must be inert is the RENDERED lines. + if !strings.Contains(turn.Text, "\x1b[2J") { + t.Fatalf("the turn keeps the model's own text verbatim, got %q", turn.Text) + } + if len(turn.lines) < 2 { + t.Fatalf("the answer's own newline must still split the body: %q", turn.lines) + } + for i, line := range turn.lines { + if strings.ContainsRune(line, 0x1b) { + t.Fatalf("rendered line %d still carries an escape: %q", i, line) + } + } + + const rows = 12 + body := a.paneView(80, rows) + if strings.ContainsRune(body, 0x1b) { + t.Fatalf("an escape from the model reached the frame: %q", body) + } + if got := len(strings.Split(body, "\n")); got != rows { + t.Fatalf("the pane owes exactly %d lines, got %d", rows, got) + } + for i, line := range strings.Split(body, "\n") { + if lw := lipgloss.Width(line); lw > 80 { + t.Fatalf("line %d overflows: %d cells %q", i, lw, line) + } + } + if !strings.Contains(body, "cleared") || !strings.Contains(body, "second line") { + t.Fatalf("the answer's own words must survive sanitising:\n%s", body) + } +} + +// nearest slices what the OPERATOR typed. Three bytes is one character of a +// CJK name — and can land mid-rune — so the near miss it offered was a byte +// accident rather than the three-character prefix it reads as. +func TestNearestMatchesOnRunesNotBytes(t *testing.T) { + s := playScreen{models: []string{"日本語-alpha", "日本語-beta", "日本-gamma", "gpt-4o"}} + got := s.nearest("日本語-zeta") + if len(got) != 2 || got[0] != "日本語-alpha" || got[1] != "日本語-beta" { + t.Fatalf("want the three-character near misses, got %v", got) + } + // Shorter than three runes is still its whole self, not a panic. + if got := s.nearest("日"); len(got) != 3 { + t.Fatalf("a one-character name prefixes all three, got %v", got) + } +} diff --git a/internal/tui/transcript.go b/internal/tui/transcript.go index d8766f6..2ad4fb2 100644 --- a/internal/tui/transcript.go +++ b/internal/tui/transcript.go @@ -6,6 +6,7 @@ import ( "charm.land/lipgloss/v2" "github.com/charmbracelet/x/ansi" + "github.com/ferro-labs/gateway-cli/internal/table" "github.com/ferro-labs/gateway-cli/internal/tui/theme" ) @@ -109,7 +110,7 @@ func (r TranscriptRow) render(th theme.Theme, w, gw int) string { if r.Bold { text = text.Bold(th.Mode.Color) } - line := padRight(glyphCell(th, r.Glyph), gw) + " " + text.Render(r.Text) + line := padRight(glyphCell(th, r.Glyph), gw) + " " + text.Render(table.SanitizeCell(r.Text)) // A row wider than the pane is cut, never wrapped — wrapping would break // the pane's line count and every frame below it. The marker is what keeps // the cut from reading as the end of the row. diff --git a/internal/tui/transcript_test.go b/internal/tui/transcript_test.go index 81f8f75..2ae6d3a 100644 --- a/internal/tui/transcript_test.go +++ b/internal/tui/transcript_test.go @@ -102,3 +102,22 @@ func TestTranscriptResetClearsTheDropMarker(t *testing.T) { t.Fatalf("a cleared transcript has dropped nothing:\n%s", v) } } + +// The transcript renders the gateway's own words — an api.Error message reaches +// it whole. A newline in one must not add a line to a pane that owes exactly h, +// and an ESC in one must not reach the terminal as a live sequence. +func TestTranscriptRowWithGatewayControlCharactersKeepsTheLineCount(t *testing.T) { + th := theme.New(theme.Mode{}) + var tr Transcript + tr.Push(TranscriptRow{Glyph: kindBad, Text: "gateway: upstream\nrefused \x1b[2J"}) + + for _, h := range []int{1, 5, 12} { + out := tr.view(th, 60, h) + if got := strings.Count(out, "\n") + 1; got != h { + t.Fatalf("view(h=%d) returned %d lines: %q", h, got, out) + } + if strings.Contains(out, "\x1b") { + t.Fatalf("view(h=%d) forwarded an escape sequence: %q", h, out) + } + } +} From 61f880a59c2d02f0fa7df7e4a49c8627d59a9fa8 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:11:38 +0530 Subject: [PATCH 15/28] fix(api): charge every frame against the stream bound, free the header phase maxStreamBytes exists because a per-frame limit still allows an unending sequence of frames to exhaust the process. It was charged after the JSON decode, so the malformed-frame `continue` walked straight past it: 20MB of undecodable data: frames finished cleanly with [DONE] against a 4MB cap. The accounting moves ahead of the decode. One bad frame still never kills a live stream; it just no longer travels free. StreamChat built a dedicated client to escape the shared 15s Timeout, but borrowed the shared transport, which carries the same value as ResponseHeaderTimeout -- so the header phase was still cut at 15s, and at whatever WithTimeout set. A gateway or ingress that withholds headers until the first token is ordinary, and is what DefaultStreamIdleTimeout is sized for. The stream now gets a transport clone with that bound cleared, and the comment says what is true rather than half of it. decodeAPIError sliced its 2048-byte cap on a byte boundary, so a multi-byte rune straddling it became a replacement character. --- internal/api/client.go | 10 +++++- internal/api/client_test.go | 16 ++++++++++ internal/api/sse.go | 35 ++++++++++++++------ internal/api/sse_test.go | 64 +++++++++++++++++++++++++++++++++++++ 4 files changed, 115 insertions(+), 10 deletions(-) diff --git a/internal/api/client.go b/internal/api/client.go index fb1eca6..d737d8e 100644 --- a/internal/api/client.go +++ b/internal/api/client.go @@ -18,6 +18,7 @@ import ( "slices" "strings" "time" + "unicode/utf8" ) const ( @@ -259,7 +260,14 @@ const maxErrMessage = 2048 func decodeAPIError(status int, raw []byte) *Error { msg := strings.TrimSpace(string(raw)) if len(msg) > maxErrMessage { - msg = msg[:maxErrMessage] + "… (truncated)" + // Back up to a rune boundary before slicing: a cut through the middle + // of a multi-byte rune renders as U+FFFD, which reads as corruption in + // the gateway's reply rather than as ferro's own truncation. + cut := maxErrMessage + for cut > 0 && !utf8.RuneStart(msg[cut]) { + cut-- + } + msg = msg[:cut] + "… (truncated)" } e := &Error{Status: status, Message: msg} var env struct { diff --git a/internal/api/client_test.go b/internal/api/client_test.go index 10b8dda..a0d4eb6 100644 --- a/internal/api/client_test.go +++ b/internal/api/client_test.go @@ -9,6 +9,7 @@ import ( "sync/atomic" "testing" "time" + "unicode/utf8" ) func TestBearerHeaderSentAndOmitted(t *testing.T) { @@ -203,3 +204,18 @@ func TestWithTimeoutUpdatesClientAndHeaderBounds(t *testing.T) { t.Fatalf("timeouts diverged: client=%s header=%s", c.hc.Timeout, tr.ResponseHeaderTimeout) } } + +func TestDecodeAPIErrorTruncatesOnARuneBoundary(t *testing.T) { + // The multi-byte runes straddle the cut, so a byte slice would keep half of + // one and print U+FFFD — a corruption the operator would read as the + // gateway's, not ferro's. + raw := []byte(strings.Repeat("a", maxErrMessage-1) + strings.Repeat("é", 8)) + e := decodeAPIError(http.StatusBadGateway, raw) + if !strings.HasSuffix(e.Message, "… (truncated)") { + t.Fatalf("oversized body must be marked truncated, got %d bytes ending %q", + len(e.Message), e.Message[max(0, len(e.Message)-20):]) + } + if strings.ContainsRune(e.Message, utf8.RuneError) || !utf8.ValidString(e.Message) { + t.Fatal("truncation split a rune") + } +} diff --git a/internal/api/sse.go b/internal/api/sse.go index 69d7d55..8b74dbb 100644 --- a/internal/api/sse.go +++ b/internal/api/sse.go @@ -166,12 +166,25 @@ func (c *Client) StreamChat(ctx context.Context, req ChatRequest) (*ChatStream, httpReq.Header.Set("Authorization", "Bearer "+c.apiKey) } - // A dedicated client: the shared one carries DefaultTimeout, which would - // cut every stream off after 15s. Lifetime is ctx's job here. The redirect - // refusal is not optional — a bearer token must not replay to whatever - // host a redirect names, on this surface as much as any other. + // A dedicated client AND a dedicated transport: the shared client carries + // DefaultTimeout and its transport carries the same value as + // ResponseHeaderTimeout, so escaping only the first still cut every stream + // off at the header phase. A gateway or ingress that withholds response + // headers until the first token is ordinary, which is what + // DefaultStreamIdleTimeout is sized for; here the lifetime is ctx's and the + // idle timer's alone. The assertion falls back to the transport as-is + // because a test double is not an *http.Transport and carries no bound to + // clear. The redirect refusal is not optional — a bearer token must not + // replay to whatever host a redirect names, on this surface as much as any + // other. + streamTransport := c.hc.Transport + if tr, ok := streamTransport.(*http.Transport); ok { + clone := tr.Clone() + clone.ResponseHeaderTimeout = 0 + streamTransport = clone + } streamClient := &http.Client{ - Transport: c.hc.Transport, + Transport: streamTransport, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }, } resp, err := streamClient.Do(httpReq) @@ -277,10 +290,10 @@ func (c *Client) StreamChat(ctx context.Context, req ChatRequest) (*ChatStream, sendEvent(ctx, events, StreamEvent{Err: e}) return } - var chunk ChatChunk - if err := json.Unmarshal([]byte(payload), &chunk); err != nil { - continue // one malformed frame never kills a live stream - } + // Accounted before the decode, never after: an undecodable + // frame was still read off the wire, and charging only the ones + // that parsed let an endless run of garbage frames walk straight + // past the bound this constant exists to enforce. streamBytes += len(payload) if streamBytes > maxStreamBytes { sendEvent(ctx, events, StreamEvent{Err: &Error{ @@ -289,6 +302,10 @@ func (c *Client) StreamChat(ctx context.Context, req ChatRequest) (*ChatStream, }}) return } + var chunk ChatChunk + if err := json.Unmarshal([]byte(payload), &chunk); err != nil { + continue // one malformed frame never kills a live stream + } resetIdle() if !sendEvent(ctx, events, StreamEvent{Chunk: &chunk}) { return diff --git a/internal/api/sse_test.go b/internal/api/sse_test.go index 7137643..6d872da 100644 --- a/internal/api/sse_test.go +++ b/internal/api/sse_test.go @@ -393,6 +393,70 @@ func TestStreamChatAggregatePayloadIsBounded(t *testing.T) { } } +func TestStreamChatUndecodableFramesCountTowardAggregateBound(t *testing.T) { + // Nothing here parses, so every frame takes the malformed-frame path — the + // path that used to skip the accounting and hand a hostile or broken + // upstream an unbounded stream. + const size = 512 << 10 + payload := strings.Repeat("x", size) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + frames := make([]string, 0, maxStreamBytes/size+2) + for range maxStreamBytes/size + 1 { + frames = append(frames, frame(payload)) + } + // [DONE] last: before the fix the stream reached it and reported a + // complete answer after 4 MiB of garbage. + writeSSE(w, "trace-garbage", append(frames, doneFrame)...) + })) + defer srv.Close() + + c, _ := New(srv.URL, "") + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatal(err) + } + defer st.Cancel() + events := drain(t, st) + last := events[len(events)-1] + if last.Done { + t.Fatalf("undecodable frames must not ride past the aggregate bound to Done: %+v", events) + } + if last.Err == nil || last.Err.Code != CodeStreamIncomplete || + !strings.Contains(last.Err.Message, "aggregate") { + t.Fatalf("aggregate stream limit must terminate visibly: %+v", last) + } +} + +func TestStreamChatSurvivesSlowResponseHeaders(t *testing.T) { + // Well past the client's request timeout: a gateway that buffers until the + // upstream's first token, or an ingress in front of one, looks exactly like + // this, and the idle timer — not the header bound — is what should judge it. + const headerDelay = 300 * time.Millisecond + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + time.Sleep(headerDelay) + writeSSE(w, "trace-slow-headers", + frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"late"}}]}`), doneFrame) + })) + defer srv.Close() + + c, err := New(srv.URL, "", WithTimeout(40*time.Millisecond)) + if err != nil { + t.Fatal(err) + } + st, err := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + if err != nil { + t.Fatalf("a slow response header must not kill a stream: %v", err) + } + defer st.Cancel() + events := drain(t, st) + if got := content(events); got != "late" { + t.Fatalf("content = %q, want %q (events: %+v)", got, "late", events) + } + if last := events[len(events)-1]; !last.Done { + t.Fatalf("stream must reach Done: %+v", events) + } +} + func TestStreamChatCancelMidStreamDoesNotDeadlock(t *testing.T) { released := make(chan struct{}) tick := frame(`{"id":"c1","choices":[{"index":0,"delta":{"content":"tick"}}]}`) From 274d600eadc0128dd990a0aa903140ec93910148 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:11:41 +0530 Subject: [PATCH 16/28] fix(api): keep paging when the gateway omits total_entries Poll treated summary.total_entries as an end-of-window signal unconditionally. A gateway that does not populate it decodes as 0, which makes the comparison true for every page -- so the follower stopped after one page and returned a nil error, and ErrFollowTruncated, which exists precisely so a tail never loses rows quietly, could not fire. The total is now trusted only when the gateway supplied one. A full page without one keeps paging to the maxFollowPages bound, which reports the truncation. A stated loss beats a silent one. --- internal/api/logs.go | 10 +++++++- internal/api/logs_test.go | 53 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/internal/api/logs.go b/internal/api/logs.go index 613230a..48d62ec 100644 --- a/internal/api/logs.go +++ b/internal/api/logs.go @@ -225,7 +225,15 @@ func (f *Follower) Poll(ctx context.Context) ([]LogEntry, error) { return nil, err } rows = append(rows, page.Data...) - if len(page.Data) < q.Limit || q.Offset+len(page.Data) >= page.Summary.TotalEntries { + // A short page is the end-of-window signal every gateway gives. The + // total is only the second one when the gateway actually sent it: an + // absent summary.total_entries decodes as 0, which read as "the window + // ended here" on the first FULL page and capped the tail at one page — + // silently, because drained was set and ErrFollowTruncated never fired. + // With no usable total the drain runs to the page bound instead, and + // the stated loss that produces beats a silent one. + if total := page.Summary.TotalEntries; len(page.Data) < q.Limit || + (total > 0 && q.Offset+len(page.Data) >= total) { drained = true break } diff --git a/internal/api/logs_test.go b/internal/api/logs_test.go index 1024b11..60d62ae 100644 --- a/internal/api/logs_test.go +++ b/internal/api/logs_test.go @@ -354,6 +354,59 @@ func TestFollowerTruncatedPollKeepsRowsAndAdvances(t *testing.T) { } } +// Not every gateway populates summary.total_entries. An absent one decodes as +// 0, which used to satisfy the end-of-window test on the very first FULL page: +// the tail stopped after one page and ErrFollowTruncated — the only mechanism +// that tells the operator rows were skipped — never fired. A tail that cannot +// see the end of its window must drain to the bound and then SAY so. +func TestFollowerWithoutTotalEntriesPagesOnAndReportsTruncation(t *testing.T) { + base := time.Date(2026, 8, 8, 10, 20, 0, 0, time.UTC) + var mu sync.Mutex + requests := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + requests++ + mu.Unlock() + offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) + // Newest first, one full page every time, and no total_entries at all. + row := logRow(fmt.Sprintf("T%d", offset), "after_request", + base.Add(-time.Duration(offset)*time.Second).Format(time.RFC3339)) + writeJSON(t, w, http.StatusOK, `{"data":[`+row+`],"summary":{"returned_entries":1}}`) + })) + defer srv.Close() + + rows, err := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{Limit: 1}).Poll(context.Background()) + if !errors.Is(err, ErrFollowTruncated) { + t.Fatalf("a drain that never reached the end of its window must state the loss, got %v", err) + } + if len(rows) != maxFollowPages { + t.Fatalf("full pages must keep paging to the bound, got %d rows want %d", len(rows), maxFollowPages) + } + mu.Lock() + defer mu.Unlock() + if requests != maxFollowPages { + t.Fatalf("the tail stopped after %d pages, want %d", requests, maxFollowPages) + } +} + +// The other half of that branch: a SHORT page still ends the drain on a gateway +// that sends no total, so the fix cannot have turned every quiet poll into a +// 32-page walk. +func TestFollowerWithoutTotalEntriesStopsOnAShortPage(t *testing.T) { + row := logRow("A", "after_request", "2026-08-08T10:00:01Z") + stub := &followStub{pages: []string{`{"data":[` + row + `],"summary":{"returned_entries":1}}`}} + srv := httptest.NewServer(stub.handler(t)) + defer srv.Close() + + rows, err := NewFollower(testClient(t, srv.URL, "fgw_ok"), LogsQuery{}).Poll(context.Background()) + if err != nil { + t.Fatalf("a short page is the end of the window whatever the summary says: %v", err) + } + if len(rows) != 1 { + t.Fatalf("want the one row, got %v", traceIDs(rows)) + } +} + func TestFollowerErrorKeepsCursor(t *testing.T) { a, b, cc := "2026-08-08T10:00:01Z", "2026-08-08T10:00:02Z", "2026-08-08T10:00:03Z" stub := &followStub{ From 210e4b014c3832b70d8886beff8f6c3a81156e35 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:05 +0530 Subject: [PATCH 17/28] refactor(table): hold the provider listing's shape in one place `ferro providers` and the console's providers verb merged the same two endpoints differently. The CLI unioned them; the console iterated the authenticated listing alone and dropped any provider /health reported that /admin/health did not. Two rows against one, for the same gateway, in the same release -- while both files carried comments claiming the same merge and tableRows above them promised that a verb read in the console and through a pipe align identically. This is the drift internal/table was created to prevent, and the same shape models.go and plugins.go already follow: the wire type is internal/api's, the presentation of it lives here, and neither caller owns it. The union semantics win because they are the ones that lose no data. ProviderRow moves here with its json tags unchanged -- they are the --format json contract. Leaving it in internal/command would have meant the merge returning one type that the CLI re-copies into another just to marshal, which is a second field list to keep in sync and the same bug again. The console now dashes an absent status where it used to print an empty cell, which is the shared renderer's rule. colStatus goes with it: the provider table was its only caller. --- internal/command/output.go | 5 +- internal/command/providers.go | 67 ++------------------- internal/command/services_test.go | 11 ++-- internal/table/providers.go | 94 ++++++++++++++++++++++++++++++ internal/table/providers_test.go | 96 +++++++++++++++++++++++++++++++ internal/tui/home.go | 31 ++-------- internal/tui/home_test.go | 51 ++++++++++++++++ 7 files changed, 262 insertions(+), 93 deletions(-) create mode 100644 internal/table/providers.go create mode 100644 internal/table/providers_test.go diff --git a/internal/command/output.go b/internal/command/output.go index 8a18197..ec836cc 100644 --- a/internal/command/output.go +++ b/internal/command/output.go @@ -113,11 +113,14 @@ func (p *Printer) Fail(format string, a ...any) { // the condition ferro derived, STATUS the one the gateway reported — so a // reader who has learnt one table can read the next, and a script locating a // column by name finds it under that name everywhere. +// +// STATUS is not here: the provider listing was its only caller and that table's +// shape now lives in internal/table alongside the merge that builds it, so both +// this package and the console spell it from there. const ( colTime = "TIME" colName = "NAME" colState = "STATE" - colStatus = "STATUS" colScopes = "SCOPES" colExpires = "EXPIRES" colProvider = "PROVIDER" diff --git a/internal/command/providers.go b/internal/command/providers.go index 8b9c69c..6a4875c 100644 --- a/internal/command/providers.go +++ b/internal/command/providers.go @@ -1,61 +1,16 @@ package command import ( - "fmt" - "github.com/spf13/cobra" "github.com/ferro-labs/gateway-cli/internal/api" "github.com/ferro-labs/gateway-cli/internal/table" ) -// providerRow is the merged view: no single endpoint serves all five columns. -// /health is unauthenticated and carries the circuit; /admin/health needs a -// credential and carries the status, the model count and the failure message. -type providerRow struct { - Name string `json:"name"` - Status string `json:"status"` - Circuit string `json:"circuit"` - Models int `json:"models"` - Message string `json:"message,omitempty"` -} - -func mergeProviders(h *api.HealthReport, ah *api.AdminHealth) []providerRow { - circuits := map[string]string{} - for _, p := range h.Providers { - circuits[p.Name] = p.Circuit - } - if ah == nil { - // Unauthenticated is a smaller answer, not an error. - rows := make([]providerRow, 0, len(h.Providers)) - for _, p := range h.Providers { - rows = append(rows, providerRow{ - Name: p.Name, Status: p.Status, Circuit: p.Circuit, - Models: p.Models, - }) - } - return rows - } - rows := make([]providerRow, 0, max(len(ah.Providers), len(h.Providers))) - seen := make(map[string]struct{}, len(ah.Providers)) - for _, p := range ah.Providers { - seen[p.Name] = struct{}{} - rows = append(rows, providerRow{ - Name: p.Name, Status: p.Status, Circuit: circuits[p.Name], - Models: p.Models, Message: p.Message, - }) - } - for _, p := range h.Providers { - if _, ok := seen[p.Name]; ok { - continue - } - rows = append(rows, providerRow{ - Name: p.Name, Status: p.Status, Circuit: p.Circuit, Models: p.Models, - }) - } - return rows -} - +// The merged row, its five columns and the dash-for-absent rendering live in +// internal/table (providers.go) because the console renders the same listing +// and cannot import this package. table.ProviderRow's json tags are this +// command's --format json|yaml contract, unchanged by the move. func newProvidersCmd() *cobra.Command { return &cobra.Command{ Use: "providers", @@ -82,21 +37,11 @@ func newProvidersCmd() *cobra.Command { d.Printer.Warn("%s — status and message come from /health only (%v)", why, adminErr) } - rows := mergeProviders(health, admin) + rows := table.MergeProviders(health, admin) if d.Printer.Format != FormatTable { return d.printStructured(rows) } - cells := make([][]string, 0, len(rows)) - for _, r := range rows { - // Every cell that can be absent renders "-": an empty one would - // collapse the column for anything splitting this table on - // whitespace, and read as a status rather than as its absence. - cells = append(cells, []string{ - r.Name, table.OrDash(r.Status), table.OrDash(r.Circuit), - fmt.Sprintf("%d", r.Models), table.OrDash(r.Message), - }) - } - d.Printer.Table([]string{colProvider, colStatus, "CIRCUIT", colModels, "MESSAGE"}, cells) + d.Printer.Table(table.ProviderHeaders, table.ProviderRows(rows)) return nil }, } diff --git a/internal/command/services_test.go b/internal/command/services_test.go index 78d4704..1d13c4d 100644 --- a/internal/command/services_test.go +++ b/internal/command/services_test.go @@ -9,6 +9,7 @@ import ( "github.com/ferro-labs/gateway-cli/internal/api" "github.com/ferro-labs/gateway-cli/internal/fixture" + "github.com/ferro-labs/gateway-cli/internal/table" ) func TestModelsTable(t *testing.T) { @@ -72,7 +73,7 @@ func TestMergeProvidersFallsBackToHealthAlone(t *testing.T) { h := &api.HealthReport{Providers: []api.ProviderHealth{ {Name: "anthropic", Status: "available", Circuit: "open", Models: 412}, }} - rows := mergeProviders(h, nil) + rows := table.MergeProviders(h, nil) if len(rows) != 1 || rows[0].Circuit != "open" || rows[0].Models != 412 { t.Fatalf("health-only fallback lost data: %+v", rows) } @@ -87,7 +88,7 @@ func TestMergeProvidersKeepsHealthOnlyRowsAndNumericCounts(t *testing.T) { {Name: "fallback", Status: "available", Circuit: "open", Models: 2}, }} ah := &api.AdminHealth{Providers: []api.AdminProviderHealth{{Name: "openai", Status: "healthy", Models: 10}}} - rows := mergeProviders(h, ah) + rows := table.MergeProviders(h, ah) if len(rows) != 2 || rows[1].Name != "fallback" || rows[1].Models != 2 { t.Fatalf("admin health omissions must not hide /health providers: %+v", rows) } @@ -291,15 +292,15 @@ func TestAuditRejectsBadOutcomeClientSide(t *testing.T) { } // A dash is a rendering of absence, not a value the gateway sent. Every field -// of providerRow must therefore stay literal in --format json, and be dashed -// only where the table is drawn. circuit briefly broke that rule on its own, +// of table.ProviderRow must therefore stay literal in --format json, and be +// dashed only where the table is drawn. circuit briefly broke that rule on its own, // so one document carried "-" for an absent circuit beside an empty string // for an absent status — two conventions in one object. func TestProvidersJSONKeepsAbsenceLiteral(t *testing.T) { h := &api.HealthReport{Providers: []api.ProviderHealth{ {Name: "anthropic", Status: "available", Models: 412}, // no circuit reported }} - rows := mergeProviders(h, nil) + rows := table.MergeProviders(h, nil) if len(rows) != 1 { t.Fatalf("want one row, got %d", len(rows)) } diff --git a/internal/table/providers.go b/internal/table/providers.go new file mode 100644 index 0000000..8998ed6 --- /dev/null +++ b/internal/table/providers.go @@ -0,0 +1,94 @@ +package table + +import ( + "strconv" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +// ProviderHeaders and ProviderRows are the provider listing's shape, and +// MergeProviders is the reading they render, held in one place because two +// callers print it: `ferro providers` and the console's providers verb. They +// each carried their own copy of the merge, under near-identical comments +// claiming they did the same thing, and they did not: the console iterated +// /admin/health's list alone, so a provider /health reported and /admin/health +// did not was a row in the pipe and no row on screen — two answers for one +// gateway at one instant. The union here loses nothing, and is now the only one. +// +// This is the shape models.go and plugins.go already established: the wire +// types are internal/api's, the presentation of them is here, and neither +// caller owns it. +var ProviderHeaders = []string{"PROVIDER", "STATUS", "CIRCUIT", "MODELS", "MESSAGE"} + +// ProviderRow is the merged view: no single endpoint serves all five columns. +// /health is unauthenticated and carries the circuit; /admin/health needs a +// credential and carries the status, the model count and the failure message. +// +// The json tags are `ferro providers --format json|yaml`'s output contract and +// are frozen — which is why the whole type moved here rather than the console +// growing a second one beside it. A dash is a rendering of absence, so it is +// applied in ProviderRows and never stored: these fields stay literally what +// the gateway said, empty string included. +type ProviderRow struct { + Name string `json:"name"` + Status string `json:"status"` + Circuit string `json:"circuit"` + Models int `json:"models"` + Message string `json:"message,omitempty"` +} + +// MergeProviders unions the two listings, ah being nil when no credential +// worked — unauthenticated is a smaller answer, not an error. +// +// /admin/health's reading wins where both endpoints name a provider: it is the +// only one carrying a message, and its status vocabulary is the richer one. +// /health's circuit is grafted on because /admin/health does not report it. +// Providers only /health knows are appended rather than dropped: /admin/health +// listing fewer of them is an omission by that endpoint, not a provider that +// stopped existing. +func MergeProviders(h *api.HealthReport, ah *api.AdminHealth) []ProviderRow { + circuits := make(map[string]string, len(h.Providers)) + for _, p := range h.Providers { + circuits[p.Name] = p.Circuit + } + + // No credential is just an empty authenticated listing, so both loops run + // either way and the union has one implementation rather than two. + var admin []api.AdminProviderHealth + if ah != nil { + admin = ah.Providers + } + rows := make([]ProviderRow, 0, max(len(admin), len(h.Providers))) + seen := make(map[string]struct{}, len(admin)) + for _, p := range admin { + seen[p.Name] = struct{}{} + rows = append(rows, ProviderRow{ + Name: p.Name, Status: p.Status, Circuit: circuits[p.Name], + Models: p.Models, Message: p.Message, + }) + } + for _, p := range h.Providers { + if _, ok := seen[p.Name]; ok { + continue + } + rows = append(rows, ProviderRow{ + Name: p.Name, Status: p.Status, Circuit: p.Circuit, Models: p.Models, + }) + } + return rows +} + +// ProviderRows renders merged rows in ProviderHeaders' order. Every cell that +// can be absent goes through OrDash: an empty one collapses the column for +// anything splitting this table on whitespace, and reads as a blank status +// rather than as its absence. MODELS is the exception — a provider routing +// zero models is a reading the gateway gave, so it prints 0. +func ProviderRows(rows []ProviderRow) [][]string { + cells := make([][]string, 0, len(rows)) + for _, r := range rows { + cells = append(cells, []string{ + r.Name, OrDash(r.Status), OrDash(r.Circuit), strconv.Itoa(r.Models), OrDash(r.Message), + }) + } + return cells +} diff --git a/internal/table/providers_test.go b/internal/table/providers_test.go new file mode 100644 index 0000000..072851a --- /dev/null +++ b/internal/table/providers_test.go @@ -0,0 +1,96 @@ +package table + +import ( + "slices" + "testing" + + "github.com/ferro-labs/gateway-cli/internal/api" +) + +// The listing the merge exists for: /health names two providers, /admin/health +// knows about fewer of them, and neither endpoint alone fills the five columns. +var providerHealth = &api.HealthReport{Providers: []api.ProviderHealth{ + {Name: "openai", Status: "available", Circuit: "closed", Models: 1104}, + {Name: "anthropic", Status: "available", Circuit: "half_open", Models: 412}, +}} + +// The console used to iterate /admin/health's list alone, so a provider that +// endpoint omitted disappeared from the screen while the pipe still printed +// it. Every case below asserts the whole row set, not a count: the bug was a +// missing row, and a length check would have missed which one. +func TestMergeProvidersUnionsBothListings(t *testing.T) { + for _, tc := range []struct { + name string + admin *api.AdminHealth + want []ProviderRow + }{ + { + // Unauthenticated is a smaller answer, not an error: /health alone + // still names every provider and its circuit, and no row carries a + // message because only /admin/health serves one. + name: "no credential leaves /health answering alone", + admin: nil, + want: []ProviderRow{ + {Name: "openai", Status: "available", Circuit: "closed", Models: 1104}, + {Name: "anthropic", Status: "available", Circuit: "half_open", Models: 412}, + }, + }, + { + // Where both endpoints know a provider the authenticated reading + // wins — it is the one with a message — and /health's circuit is + // grafted on because /admin/health does not report it. + name: "admin's status, message and count win, /health's circuit is grafted on", + admin: &api.AdminHealth{Providers: []api.AdminProviderHealth{ + {Name: "openai", Status: "healthy", Models: 1104}, + {Name: "anthropic", Status: "degraded", Models: 3, Message: "rate limited upstream"}, + }}, + want: []ProviderRow{ + {Name: "openai", Status: "healthy", Circuit: "closed", Models: 1104}, + {Name: "anthropic", Status: "degraded", Circuit: "half_open", Models: 3, + Message: "rate limited upstream"}, + }, + }, + { + // The divergence itself: one row from /admin/health, one that only + // /health knows. Dropping the second is what the console did. + name: "a provider only /health reports still gets a row", + admin: &api.AdminHealth{Providers: []api.AdminProviderHealth{ + {Name: "openai", Status: "healthy", Models: 1104}, + }}, + want: []ProviderRow{ + {Name: "openai", Status: "healthy", Circuit: "closed", Models: 1104}, + {Name: "anthropic", Status: "available", Circuit: "half_open", Models: 412}, + }, + }, + } { + t.Run(tc.name, func(t *testing.T) { + if got := MergeProviders(providerHealth, tc.admin); !slices.Equal(got, tc.want) { + t.Fatalf("merge lost or reshaped a row:\n got %+v\nwant %+v", got, tc.want) + } + }) + } +} + +// A dash is how absence renders: an empty cell collapses the column for +// anything splitting this table on whitespace, and reads as a blank status +// rather than as no status at all. MODELS is deliberately not dashed — zero +// models is a reading the gateway gave, not a value it withheld. +func TestProviderRowsDashEveryAbsentCell(t *testing.T) { + got := ProviderRows([]ProviderRow{{Name: "openai"}, {Name: "anthropic", Status: "healthy", + Circuit: "closed", Models: 412, Message: "recovering"}}) + want := [][]string{ + {"openai", "-", "-", "0", "-"}, + {"anthropic", "healthy", "closed", "412", "recovering"}, + } + if len(got) != len(want) { + t.Fatalf("want %d rows, got %d (%v)", len(want), len(got), got) + } + for i := range want { + if !slices.Equal(got[i], want[i]) { + t.Fatalf("row %d: got %q, want %q", i, got[i], want[i]) + } + } + if len(want[0]) != len(ProviderHeaders) { + t.Fatalf("a row must have one cell per header: %d cells, %d headers", len(want[0]), len(ProviderHeaders)) + } +} diff --git a/internal/tui/home.go b/internal/tui/home.go index 7f7f470..982ca90 100644 --- a/internal/tui/home.go +++ b/internal/tui/home.go @@ -223,8 +223,11 @@ func verbRows(ctx context.Context, c *api.Client, verb string) ([]TranscriptRow, if adminErr != nil { admin = nil } - cells := providerCells(health, admin) - rows := tableRows([]string{colProvider, "STATUS", "CIRCUIT", "MODELS", "MESSAGE"}, cells) + // The merge, the five columns and the dash-for-absent rendering are + // internal/table's: `ferro providers` renders this same listing and the + // two used to disagree about a provider /admin/health omits. + cells := table.ProviderRows(table.MergeProviders(health, admin)) + rows := tableRows(table.ProviderHeaders, cells) if adminErr != nil { // Name what actually happened. A refused credential and a timed-out // or broken /admin/health cost the same two columns, but only one of @@ -313,30 +316,6 @@ func mcpServers(ctx context.Context, c *api.Client) ([]api.MCPServer, error) { return ready.MCPServers, nil } -// providerCells merges the two listings: /health is unauthenticated and carries -// the circuit; /admin/health needs a credential and carries the status, the -// model count and the failure message. -func providerCells(h *api.HealthReport, ah *api.AdminHealth) [][]string { - circuits := make(map[string]string, len(h.Providers)) - for _, p := range h.Providers { - circuits[p.Name] = p.Circuit - } - if ah == nil { - cells := make([][]string, 0, len(h.Providers)) - for _, p := range h.Providers { - cells = append(cells, []string{p.Name, p.Status, table.OrDash(p.Circuit), fmt.Sprintf("%d", p.Models), "-"}) - } - return cells - } - cells := make([][]string, 0, len(ah.Providers)) - for _, p := range ah.Providers { - cells = append(cells, []string{ - p.Name, p.Status, table.OrDash(circuits[p.Name]), fmt.Sprintf("%d", p.Models), table.OrDash(p.Message), - }) - } - return cells -} - // The two failure policies a catalog entry reports. Which one a plugin has is // the single most consequential thing on the plugins table — it is the // difference between a broken guardrail stopping traffic and waving it through diff --git a/internal/tui/home_test.go b/internal/tui/home_test.go index 67e9b20..21d8b65 100644 --- a/internal/tui/home_test.go +++ b/internal/tui/home_test.go @@ -1,9 +1,11 @@ package tui import ( + "encoding/json" "io" "net/http" "net/http/httptest" + "slices" "strings" "testing" "time" @@ -11,6 +13,7 @@ import ( "charm.land/lipgloss/v2" "github.com/ferro-labs/gateway-cli/internal/api" + "github.com/ferro-labs/gateway-cli/internal/table" "github.com/ferro-labs/gateway-cli/internal/tui/theme" ) @@ -367,6 +370,54 @@ func TestVerbRowsRenderEveryTranscriptVerb(t *testing.T) { } } +// The console and `ferro providers` read the same two endpoints, and they used +// to merge them differently: the console iterated /admin/health's list alone, +// so /health naming openai and anthropic while /admin/health named only openai +// printed two rows through a pipe and one on screen. That is the fixture below. +// +// The expectation is table.ProviderRows' own output rather than a table typed +// out here, because a hand-written one drifts the moment either side changes a +// column — and then the guard against divergence is itself divergent. +func TestProviderRowsAreTheScriptableVerbsRows(t *testing.T) { + h := &api.HealthReport{Status: "ok", Providers: []api.ProviderHealth{ + {Name: "openai", Status: "available", Circuit: "closed", Models: 3}, + {Name: "anthropic", Status: "available", Circuit: "open", Models: 412}, + }} + ah := &api.AdminHealth{Status: "degraded", Providers: []api.AdminProviderHealth{ + {Name: "openai", Status: "degraded", Models: 3, Message: "rate limited upstream"}, + }} + + mux := http.NewServeMux() + serve := func(path string, v any) { + mux.HandleFunc(path, func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(v) + }) + } + serve("/health", h) + serve("/admin/health", ah) + srv := httptest.NewServer(mux) + t.Cleanup(srv.Close) + c, err := api.New(srv.URL, "test-key") + if err != nil { + t.Fatalf("client: %v", err) + } + + rows, err := verbRows(t.Context(), c, verbProviders) + if err != nil { + t.Fatalf("providers: %v", err) + } + want := tableRows(table.ProviderHeaders, table.ProviderRows(table.MergeProviders(h, ah))) + if !slices.Equal(rows, want) { + t.Fatalf("the console must render the rows `ferro providers` renders:\n got %#v\nwant %#v", rows, want) + } + // The union is the point: anthropic is in /health only, and three rows + // (header, rule, one provider) would be the console dropping it again. + if len(rows) != 4 { + t.Fatalf("want header, rule and both providers, got %d rows: %#v", len(rows), rows) + } +} + // A gateway that does not serve an endpoint must surface its own words, not a // paraphrase and not an empty table. func TestVerbRowsSurfaceGatewayErrors(t *testing.T) { From 806c3307214f5e4d144798a8b7251f0bc44701b4 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:06 +0530 Subject: [PATCH 18/28] fix(config): confine the MASTER_KEY fallback to a loopback gateway Unlike FERRO_API_KEY and a profile's api_key_env, nobody names MASTER_KEY for ferro. It is the gateway server's own variable, so it is simply present in the shell on a gateway host -- which is the point of the fallback and also the problem. Nothing bound it to a host, so `ferro --gateway-url https://elsewhere status`, typed in that shell, handed the gateway's root credential to a stranger with no prompt and no indication of which credential was sent. It now applies only when the resolved URL is loopback. A remote URL falls through to no credential rather than erroring: the gateway answers 401 and status prints auth: unauthorized, the same story an expired key tells. KeySource carries the refusal, because APIKey is empty by then and that field is the only place a doctor-style display would look. isLoopbackHost is duplicated rather than exported from internal/api -- config sits below the client, and one caller does not justify widening that package's surface. The test pins the two spellings against each other. --- internal/config/config.go | 54 ++++++++++++++++++++++++++++++++-- internal/config/config_test.go | 41 ++++++++++++++++++++++++++ 2 files changed, 92 insertions(+), 3 deletions(-) diff --git a/internal/config/config.go b/internal/config/config.go index 8b5f248..bfa8d59 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -2,13 +2,21 @@ // Precedence — path: --config > FERRO_CONFIG > DefaultPath() // // URL: --gateway-url > FERRO_URL > profile.url > http://localhost:8080 -// key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY > "" +// key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY (loopback URL only) > "" +// +// The MASTER_KEY step is restricted because, unlike the two above it, nobody +// named it for ferro: it is the gateway server's own variable and is simply +// present in the shell on a gateway host. Honouring it for any URL would let +// `ferro --gateway-url https://elsewhere status`, typed in that shell, hand the +// gateway's root credential to a stranger. // // ferro stores no gateway data; this file holds connection profiles only. package config import ( "fmt" + "net" + "net/url" "os" "path/filepath" "sort" @@ -32,6 +40,12 @@ const ( keySourceFerroEnv = "env:" + envFerroKey keySourceMasterEnv = "env:" + envMasterKey keySourceProfile = "profile:" + + // keySourceMasterSkipped is reported instead of a credential when + // MASTER_KEY is set but the gateway is remote. It rides on KeySource + // rather than a new field so any display that already shows where the + // credential came from also explains why there is none. + keySourceMasterSkipped = keySourceMasterEnv + " skipped (gateway is not loopback)" ) // Profile is one named connection. It holds no credential: api_key_env names @@ -49,7 +63,9 @@ type File struct { } // Resolved is what the rest of ferro consumes. KeySource is for doctor-style -// display ("env:FERRO_API_KEY", "profile:PROD_KEY", "env:MASTER_KEY"). +// display ("env:FERRO_API_KEY", "profile:PROD_KEY", "env:MASTER_KEY"), and is +// the only place a refused MASTER_KEY is visible -- APIKey is then empty and +// the gateway's 401 is all ferro would otherwise have to go on. type Resolved struct { ProfileName string URL string @@ -144,7 +160,39 @@ func Resolve(f File, flagURL, flagProfile string, getenv func(string) string) (R case prof != nil && prof.APIKeyEnv != "" && getenv(prof.APIKeyEnv) != "": r.APIKey, r.KeySource = getenv(prof.APIKeyEnv), keySourceProfile+prof.APIKeyEnv case getenv(envMasterKey) != "": - r.APIKey, r.KeySource = getenv(envMasterKey), keySourceMasterEnv + // Loopback only -- see the package comment. Falling through to no + // credential rather than erroring keeps the failure the gateway's to + // report: it answers 401 and `ferro status` prints auth: unauthorized, + // which is the same story an expired key tells. + if isLoopbackURL(r.URL) { + r.APIKey, r.KeySource = getenv(envMasterKey), keySourceMasterEnv + } else { + r.KeySource = keySourceMasterSkipped + } } return r, nil } + +// isLoopbackURL reports whether raw names a host on this machine. +// +// internal/api holds the other copy of this test (isLoopbackHost, which gates +// plaintext HTTP). They are duplicated rather than shared because config sits +// below the client and must not import it to answer a question about a string, +// and exporting one of them would put an internal predicate in a package API +// for a single caller. Keep the two in step: if they disagree about what +// loopback means, ferro would ship MASTER_KEY to a host it also refuses to +// speak plaintext to, or withhold it from one it will. +func isLoopbackURL(raw string) bool { + u, err := url.Parse(raw) + if err != nil { + return false + } + // A trailing dot is the same name in DNS ("localhost." resolves like + // "localhost"), so it must not be a way past this check. + host := strings.TrimSuffix(strings.ToLower(u.Hostname()), ".") + if host == "localhost" || strings.HasSuffix(host, ".localhost") { + return true + } + ip := net.ParseIP(host) + return ip != nil && ip.IsLoopback() +} diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 32669ac..349ff3f 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -39,6 +39,17 @@ func TestResolvePrecedence(t *testing.T) { {name: "MASTER_KEY is the last key fallback", flagProfile: "local", envv: map[string]string{"MASTER_KEY": "fgw_master"}, wantURL: "http://localhost:9999", wantKey: "fgw_master", wantSource: "env:MASTER_KEY"}, + // The whole point of the restriction: MASTER_KEY is in the shell on a + // gateway host, and this invocation is aimed at somebody else's host. + {name: "MASTER_KEY is withheld from a remote gateway", flagURL: "https://someone-else.example.com", + flagProfile: "local", envv: map[string]string{"MASTER_KEY": "fgw_master"}, + wantURL: "https://someone-else.example.com", wantKey: "", + wantSource: "env:MASTER_KEY skipped (gateway is not loopback)"}, + // A named credential is named for this tool, so the restriction must + // not spread to it: the two upper steps still reach any host. + {name: "a named credential still reaches a remote gateway", flagURL: "https://someone-else.example.com", + envv: map[string]string{"FERRO_API_KEY": "fgw_env", "MASTER_KEY": "fgw_master"}, + wantURL: "https://someone-else.example.com", wantKey: "fgw_env", wantSource: "env:FERRO_API_KEY"}, {name: "defaults", flagProfile: "none-selected", envv: map[string]string{}, flagURL: "", wantURL: "http://localhost:8080", wantKey: "", wantSource: ""}, } @@ -95,3 +106,33 @@ func TestLoadMalformedYAMLNamesTheFile(t *testing.T) { t.Fatalf("malformed YAML must fail and name its file: %v", err) } } + +// TestIsLoopbackURL pins the semantics against internal/api's isLoopbackHost, +// the other copy of this test. A case that changes here without changing there +// means MASTER_KEY and the plaintext-HTTP gate have started disagreeing about +// what counts as this machine. +func TestIsLoopbackURL(t *testing.T) { + loopback := []string{ + "http://localhost:8080", "http://LOCALHOST", "http://localhost.:8080", + "http://app.localhost:3000", "http://127.0.0.1:8080", "http://127.9.9.9", + "http://[::1]:8080", "https://localhost", + } + remote := []string{ + "https://gw.example.com", "http://localhost.evil.com", "http://notlocalhost", + "http://0.0.0.0:8080", "http://10.0.0.1", "http://[fe80::1]", "", + // A scheme-less string parses as scheme "localhost" with an empty + // host, so it must not be read as the loopback name it resembles. + "localhost:8080", + "://not a url", + } + for _, u := range loopback { + if !isLoopbackURL(u) { + t.Errorf("%q is this machine; MASTER_KEY must be usable", u) + } + } + for _, u := range remote { + if isLoopbackURL(u) { + t.Errorf("%q is not this machine; MASTER_KEY must not be sent there", u) + } + } +} From 57beeafd725ef15dcd3ab40dc11624e1901e4ef0 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:33 +0530 Subject: [PATCH 19/28] feat(command): gate keys rotate and revoke behind a typed confirmation The console will not revoke until the operator types the key's exact name, and prints the blast radius while they do. The CLI did it on one keystroke. The two surfaces are meant to be the same tool. Both verbs now ask at a terminal, and ask for the key id rather than "y" -- the id is what the command line already carries, so it is the one answer that also catches a typo in the argument. The prompt goes to stderr; stdout stays the payload channel even here, where there is no payload. --yes skips it, and is required when stdin is not a terminal. A pipe, a CI job or a cron line has nobody to answer: blocking on a read that never returns is the worst behaviour available and proceeding unasked is the second worst. rotate is gated too. From outside it is as destructive as revocation -- every client holding the current secret stops authenticating the moment it lands, and no flag brings the old one back. --- internal/command/keys.go | 60 +++++++++++++++++- internal/command/keys_test.go | 111 +++++++++++++++++++++++++++++++++- 2 files changed, 167 insertions(+), 4 deletions(-) diff --git a/internal/command/keys.go b/internal/command/keys.go index 0965db4..9c5badd 100644 --- a/internal/command/keys.go +++ b/internal/command/keys.go @@ -1,8 +1,11 @@ package command import ( + "bufio" "errors" "fmt" + "io" + "os" "strings" "time" @@ -153,12 +156,18 @@ func keyCreateRequest(name, scope string, expiresIn time.Duration) (api.KeyCreat } func newKeysRotateCmd() *cobra.Command { - return &cobra.Command{ + // Rotation is as destructive as revocation from the outside: every client + // still holding the current secret stops authenticating the moment it + // lands, and no flag brings the old one back. + rotate := &cobra.Command{ Use: "rotate ", Short: "Rotate a key (the previous secret dies immediately)", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { d := deps(cmd) + if err := confirmDestructive(cmd, "rotate", args[0]); err != nil { + return err + } k, err := d.Client.RotateKey(cmd.Context(), args[0]) if err != nil { return err @@ -167,6 +176,8 @@ func newKeysRotateCmd() *cobra.Command { "previous secret stopped authenticating; the new one is shown once") }, } + addYesFlag(rotate) + return rotate } // printSecretOnce is the one deliberate credential display: the secret goes to @@ -182,12 +193,15 @@ func printSecretOnce(d *runtimeDeps, k *api.Key, warning string) error { } func newKeysRevokeCmd() *cobra.Command { - return &cobra.Command{ + revoke := &cobra.Command{ Use: "revoke ", Short: "Revoke a key (immediate and irreversible)", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { d := deps(cmd) + if err := confirmDestructive(cmd, "revoke", args[0]); err != nil { + return err + } if err := d.Client.RevokeKey(cmd.Context(), args[0]); err != nil { return err } @@ -195,4 +209,46 @@ func newKeysRevokeCmd() *cobra.Command { return nil }, } + addYesFlag(revoke) + return revoke +} + +// flagYes is the one spelling of "I have read the blast radius", shared by both +// destructive key verbs so a script that learnt it on one keeps it on the other. +const flagYes = "yes" + +func addYesFlag(cmd *cobra.Command) { + cmd.Flags().Bool(flagYes, false, "skip the confirmation prompt (required when there is no terminal)") +} + +// confirmDestructive gates rotate and revoke on the operator typing the key id +// back. Typing the id rather than "y" is the console's discipline -- its modal +// demands the key's exact name before it will revoke (internal/tui's +// openRevoke) -- and the id is what the CLI has on the command line, so it is +// the thing that can actually be checked against a typo in the argument. +// +// The prompt goes to stderr and the answer comes from cmd's stdin: stdout stays +// the payload channel even here, where there is no payload. +func confirmDestructive(cmd *cobra.Command, verb, id string) error { + if yes, _ := cmd.Flags().GetBool(flagYes); yes { + return nil + } + // A pipe, a CI job, or a cron line has nobody to answer. Blocking on a read + // that will never return is the worst of the three possible behaviours, and + // proceeding unasked is the second worst. + if !stdinIsTTY() || !isTTY(os.Stderr) { + return fmt.Errorf( + "%s %s is irreversible and there is no terminal to confirm on: pass --yes to run it non-interactively", + verb, id) + } + deps(cmd).Printer.Warn("%s %s is irreversible — type the key id to confirm:", verb, id) + answer, err := bufio.NewReader(cmd.InOrStdin()).ReadString('\n') + // EOF (a closed terminal) is a valid end to the answer, not a read failure. + if err != nil && !errors.Is(err, io.EOF) { + return fmt.Errorf("read confirmation: %w", err) + } + if strings.TrimSpace(answer) != id { + return fmt.Errorf("aborted: the id typed did not match %q, so nothing was %sd", id, verb) + } + return nil } diff --git a/internal/command/keys_test.go b/internal/command/keys_test.go index b7712b1..a6cf8a0 100644 --- a/internal/command/keys_test.go +++ b/internal/command/keys_test.go @@ -1,6 +1,9 @@ package command import ( + "bytes" + "net/http/httptest" + "os" "strings" "testing" "time" @@ -9,6 +12,44 @@ import ( "github.com/ferro-labs/gateway-cli/internal/fixture" ) +// runInteractive is run() with the terminal faked and an answer already waiting +// on stdin. Faking is the only way in: isTTY asks real descriptors, and a test +// binary's stdin is never one of them. +func runInteractive(t *testing.T, srv *httptest.Server, answer string, args ...string) (stdout, stderr string, err error) { + t.Helper() + t.Setenv("FERRO_API_KEY", "fgw_test") + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + oldTTY, oldStdin := isTTY, stdinIsTTY + isTTY = func(*os.File) bool { return true } + stdinIsTTY = func() bool { return true } + t.Cleanup(func() { isTTY, stdinIsTTY = oldTTY, oldStdin }) + + root := NewRoot() + var out, errb bytes.Buffer + root.SetOut(&out) + root.SetErr(&errb) + root.SetIn(strings.NewReader(answer)) + root.SetArgs(append(args, "--gateway-url", srv.URL)) + err = root.Execute() + return out.String(), errb.String(), err +} + +// keyIsLive reports whether the fixture still serves id as an active key. The +// fixture's key store is stateful, so this is what tells an aborted revoke +// apart from one that ran and printed an error afterwards. +func keyIsLive(t *testing.T, srv *httptest.Server, id string) bool { + t.Helper() + stdout, _, err := run(t, srv, "keys", "get", id) + if err != nil { + t.Fatalf("keys get %s: %v", id, err) + } + var got map[string]any + if err := decodeOne(stdout, &got); err != nil { + t.Fatalf("keys get %s: %v (%q)", id, err, stdout) + } + return got["revoked_at"] == nil +} + func TestKeysListDerivesStateAndNeverPrintsASecret(t *testing.T) { srv := gateway(t, fixture.Default()) stdout, _, err := run(t, srv, "keys", "list") @@ -106,7 +147,7 @@ func TestKeysCreateRejectsNegativeExpiry(t *testing.T) { func TestKeysRotateShowsNewSecretOnce(t *testing.T) { srv := gateway(t, fixture.Default()) - stdout, stderr, err := run(t, srv, "keys", "rotate", "key_02") + stdout, stderr, err := run(t, srv, "keys", "rotate", "key_02", "--yes") if err != nil { t.Fatal(err) } @@ -120,7 +161,7 @@ func TestKeysRotateShowsNewSecretOnce(t *testing.T) { func TestKeysRevokeConfirmsOnStderrAndPrintsNothingToStdout(t *testing.T) { srv := gateway(t, fixture.Default()) - stdout, stderr, err := run(t, srv, "keys", "revoke", "key_01") + stdout, stderr, err := run(t, srv, "keys", "revoke", "key_01", "--yes") if err != nil { t.Fatal(err) } @@ -180,3 +221,69 @@ func TestKeysListReportsAnExpiredKeyAsExpired(t *testing.T) { t.Fatalf("an expired key was never revoked: %q", row) } } + +// The pipeline case: no terminal to prompt on, so the only two acceptable +// outcomes are --yes or a refusal. Hanging on a read nobody will answer would +// wedge a CI job, and revoking unasked is what this gate exists to stop. +func TestKeysDestructiveVerbsRefuseWithoutTerminalOrYes(t *testing.T) { + for _, verb := range []string{"rotate", "revoke"} { + t.Run(verb, func(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := run(t, srv, "keys", verb, "key_01") + if err == nil { + t.Fatal("a non-interactive destructive verb must refuse, not proceed") + } + if !strings.Contains(err.Error(), "--yes") { + t.Fatalf("the refusal must name the way through it: %v", err) + } + if strings.TrimSpace(stdout) != "" { + t.Fatalf("nothing ran, so stdout must be empty: %q", stdout) + } + if !keyIsLive(t, srv, "key_01") { + t.Fatal("the refused verb reached the gateway anyway") + } + }) + } +} + +func TestKeysRevokeProceedsWhenTheIDIsTypedBack(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, stderr, err := runInteractive(t, srv, "key_01\n", "keys", "revoke", "key_01") + if err != nil { + t.Fatal(err) + } + if !strings.Contains(stderr, "type the key id") { + t.Fatalf("the prompt belongs on stderr: %q", stderr) + } + if strings.TrimSpace(stdout) != "" { + t.Fatalf("neither prompt nor result is a payload: %q", stdout) + } + if keyIsLive(t, srv, "key_01") { + t.Fatal("a confirmed revoke must actually revoke") + } +} + +// "y" is exactly the answer this prompt refuses to accept: the console makes +// the operator type the key's name for the same reason. +func TestKeysRevokeAbortsOnAnythingButTheID(t *testing.T) { + srv := gateway(t, fixture.Default()) + _, _, err := runInteractive(t, srv, "y\n", "keys", "revoke", "key_01") + if err == nil || !strings.Contains(err.Error(), "aborted") { + t.Fatalf("a wrong answer must abort: %v", err) + } + if !keyIsLive(t, srv, "key_01") { + t.Fatal("an aborted revoke revoked the key anyway") + } +} + +// Ctrl-D at the prompt: an empty answer is a wrong answer, not a default yes. +func TestKeysRotateAbortsOnEOFAndMintsNoSecret(t *testing.T) { + srv := gateway(t, fixture.Default()) + stdout, _, err := runInteractive(t, srv, "", "keys", "rotate", "key_02") + if err == nil || !strings.Contains(err.Error(), "aborted") { + t.Fatalf("EOF at the prompt must abort: %v", err) + } + if strings.Contains(stdout, "fgw_") { + t.Fatalf("an aborted rotate must mint nothing: %q", stdout) + } +} From fda8a7e5834c7528cce185f1635a1d23a4b17809 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:34 +0530 Subject: [PATCH 20/28] fix(version): fall back to the embedded build info Version, Commit and Date are injected by the release build's ldflags, which is right for goreleaser and wrong for the install path the README leads with: `go install` applies no ldflags, so those users read "ferro dev (commit none, built unknown)". The defaults now fill from debug.ReadBuildInfo when the linker did not stamp them -- the module version for a `go install pkg@version` build, and the vcs revision and time for a build from a checkout, with -dirty when the worktree was modified. Only fields still at their default are touched, so an ldflags build keeps reporting exactly what was stamped. --- internal/version/version.go | 78 ++++++++++++++++++++++++--- internal/version/version_test.go | 93 ++++++++++++++++++++++++++++++++ 2 files changed, 164 insertions(+), 7 deletions(-) create mode 100644 internal/version/version_test.go diff --git a/internal/version/version.go b/internal/version/version.go index c80e6f4..7a037b5 100644 --- a/internal/version/version.go +++ b/internal/version/version.go @@ -1,18 +1,82 @@ // Package version holds build metadata injected via -ldflags, mirroring the // gateway's internal/version so release tooling stays uniform across the two -// projects. +// projects. What the linker did not stamp is recovered from the build info the +// toolchain embeds anyway — see fillFromBuildInfo. package version -import "fmt" +import ( + "fmt" + "runtime/debug" +) -// Version, Commit, and Date are overwritten at link time by the release -// build. The defaults below are what a plain `go build` or `go run` reports. +// Version, Commit, and Date are overwritten at link time by the release build. var ( - Version = "dev" - Commit = "none" - Date = "unknown" + Version = devVersion + Commit = noCommit + Date = noDate +) + +// The values a build with no -ldflags starts from. They double as the marker +// that the linker stamped nothing, which is what lets fillFromBuildInfo tell +// "not set" from "set to something that happens to look unhelpful". +const ( + devVersion = "dev" + noCommit = "none" + noDate = "unknown" ) +func init() { fillFromBuildInfo(debug.ReadBuildInfo) } + +// fillFromBuildInfo recovers what the linker did not set. +// +// `go install github.com/ferro-labs/gateway-cli/cmd/ferro@v0.1.0` is the +// install path the README documents first, and go install applies no ldflags — +// so without this, everyone who followed the README reports +// "dev (commit none, built unknown)" and cannot tell a bug report apart from +// any other. The module version is in the build info for that build, and a +// build from a checkout carries the revision and time as vcs settings. +// +// A stamped field is never overwritten: what the release build says is what +// ferro reports, so a goreleaser binary and this fallback can never disagree. +// read is a parameter so a test can supply build info a test binary cannot have. +func fillFromBuildInfo(read func() (*debug.BuildInfo, bool)) { + bi, ok := read() + if !ok { + return + } + // "(devel)" is what a local build reports for its own module; it says less + // than "dev" already does and would only obscure that nothing stamped this. + if Version == devVersion && bi.Main.Version != "" && bi.Main.Version != "(devel)" { + Version = bi.Main.Version + } + // Read all three before deciding: the settings arrive in no promised order, + // and vcs.modified changes what vcs.revision is allowed to claim. + var revision, when string + var dirty bool + for _, s := range bi.Settings { + switch s.Key { + case "vcs.revision": + revision = s.Value + case "vcs.time": + when = s.Value + case "vcs.modified": + dirty = s.Value == "true" + } + } + if Commit == noCommit && revision != "" { + if dirty { + // The worktree had uncommitted changes, so this commit does not + // describe the binary. Say so rather than name a tree nobody can + // check out to reproduce it. + revision += "-dirty" + } + Commit = revision + } + if Date == noDate && when != "" { + Date = when + } +} + // String renders the full build stamp for `ferro version`. func String() string { return fmt.Sprintf("%s (commit %s, built %s)", Version, Commit, Date) diff --git a/internal/version/version_test.go b/internal/version/version_test.go new file mode 100644 index 0000000..62e634f --- /dev/null +++ b/internal/version/version_test.go @@ -0,0 +1,93 @@ +package version + +import ( + "runtime/debug" + "strings" + "testing" +) + +// reset returns the package vars to their unstamped defaults for the duration +// of one test. They are package state written by init(), and this test binary's +// own build info has already run through it. +func reset(t *testing.T) { + t.Helper() + old := [3]string{Version, Commit, Date} + t.Cleanup(func() { Version, Commit, Date = old[0], old[1], old[2] }) + Version, Commit, Date = devVersion, noCommit, noDate +} + +func buildInfo(mainVersion string, settings ...debug.BuildSetting) func() (*debug.BuildInfo, bool) { + return func() (*debug.BuildInfo, bool) { + return &debug.BuildInfo{Main: debug.Module{Version: mainVersion}, Settings: settings}, true + } +} + +// The release build is the one that must never be second-guessed: goreleaser +// stamps a tag and a commit, and a binary built from a checkout also carries +// vcs settings that disagree with them. +func TestLdflagsValuesWin(t *testing.T) { + reset(t) + Version, Commit, Date = "1.2.3", "abc1234", "2026-08-16T00:00:00Z" + fillFromBuildInfo(buildInfo("v9.9.9", + debug.BuildSetting{Key: "vcs.revision", Value: "deadbeef"}, + debug.BuildSetting{Key: "vcs.time", Value: "1999-01-01T00:00:00Z"})) + if got := String(); got != "1.2.3 (commit abc1234, built 2026-08-16T00:00:00Z)" { + t.Fatalf("the linker's values must survive the fallback, got %q", got) + } +} + +// The README's primary install path: go install applies no ldflags, but the +// module version it resolved is in the build info. +func TestGoInstallVersionFillsTheDevDefault(t *testing.T) { + reset(t) + fillFromBuildInfo(buildInfo("v0.1.0")) + if Version != "v0.1.0" { + t.Fatalf("go install must not report %q", Version) + } + // go install builds from the module cache, which has no VCS to read. + if Commit != noCommit || Date != noDate { + t.Fatalf("nothing supplied a commit or date: %q %q", Commit, Date) + } +} + +func TestVCSSettingsFillCommitAndDate(t *testing.T) { + reset(t) + fillFromBuildInfo(buildInfo("(devel)", + debug.BuildSetting{Key: "vcs.revision", Value: "deadbeef"}, + debug.BuildSetting{Key: "vcs.time", Value: "2026-08-16T12:00:00Z"})) + // "(devel)" carries no more information than the default it would replace. + if Version != devVersion { + t.Fatalf("(devel) must not become the reported version: %q", Version) + } + if Commit != "deadbeef" || Date != "2026-08-16T12:00:00Z" { + t.Fatalf("vcs settings ignored: %q %q", Commit, Date) + } +} + +// A commit from a dirty worktree does not describe the binary, and a bug report +// quoting it would send somebody to the wrong tree. +func TestDirtyWorktreeIsMarked(t *testing.T) { + reset(t) + fillFromBuildInfo(buildInfo("", + debug.BuildSetting{Key: "vcs.modified", Value: "true"}, + debug.BuildSetting{Key: "vcs.revision", Value: "deadbeef"})) + if Commit != "deadbeef-dirty" { + t.Fatalf("an uncommitted build must say so: %q", Commit) + } +} + +// `go run .` in a sandbox with no VCS and no ldflags. The stamp is useless but +// it still has to be a line, not three gaps in a sentence. +func TestNoLdflagsAndNoBuildInfoStillRenders(t *testing.T) { + reset(t) + fillFromBuildInfo(func() (*debug.BuildInfo, bool) { return nil, false }) + got := String() + if got != "dev (commit none, built unknown)" { + t.Fatalf("unstamped builds have a fixed rendering, got %q", got) + } + for _, part := range strings.Fields(got) { + if part == "" || part == "()" { + t.Fatalf("no field may render empty: %q", got) + } + } +} From ffc40b0ecad02b6e3bc04e743d928835019cdaa0 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:35 +0530 Subject: [PATCH 21/28] fix(tui): follow a selected log row by its identity, not its trace id A trace has one row per pipeline stage -- api.dedupeKey identifies a row as trace, stage and created_at together. prepend re-found the selection on the trace id alone, so a poll arriving under the cursor could re-point the detail strip at a different stage of the same request: exactly the silent re-pointing the function's own comment says it prevents. Two comments corrected while here. pollGen is documented as bumped when the connection changes and never is: v0.1 has no reconnect or profile switch, the screens carry the live generation counters, and the field is reserved. It stays rather than being deleted -- removing it would push a literal 0 into the three fetches in msgs.go, which is worse than the named zero. RailData.Providers said "nil when unauthorized". That stopped being true when fetchRail began carrying the previous snapshot forward, deliberately, so a 401 now leaves the last good list on screen and AuthError reports the round. --- internal/tui/app.go | 18 ++++++++---- internal/tui/logs.go | 18 +++++++----- internal/tui/logs_test.go | 58 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 82 insertions(+), 12 deletions(-) diff --git a/internal/tui/app.go b/internal/tui/app.go index 97436a1..675f681 100644 --- a/internal/tui/app.go +++ b/internal/tui/app.go @@ -91,7 +91,12 @@ const ( // RailData is the left rail's four sources, already reduced to what it draws. // A count of unknownCount means "not served", which is not the same as zero. type RailData struct { - Providers []api.AdminProviderHealth // nil when unauthorized + // Providers is the last GOOD list, not this round's. fetchRail carries the + // previous snapshot forward, so a 401 or a failed admin-health round leaves + // what was already on screen there rather than blanking the rail; AuthError + // is what says this round could not confirm it. It is nil only before the + // first successful fetch, or on a gateway that reported none. + Providers []api.AdminProviderHealth MCPReady, MCPTotal int PluginsActive int Sessions int @@ -117,7 +122,7 @@ type App struct { // The three screens below Home. Each is a value the App owns outright and // each carries its own generation counter, so a message from a screen the // operator has left is dropped rather than applied — the same contract - // pollGen gives the shell's own polls. + // pollGen is reserved to give the shell's own polls. Logs logsScreen Keys keysScreen Play playScreen @@ -139,9 +144,12 @@ type App struct { Rail RailData RailErr error - // pollGen is bumped when the connection changes; a message carrying an - // older generation is dropped, so a slow in-flight response cannot - // overwrite state fetched against the newer profile. + // pollGen is the generation every shell poll is issued under and matched + // against on arrival, so a slow in-flight response cannot overwrite state + // fetched against a newer connection. It is RESERVED: nothing bumps it and + // it is always zero, because v0.1 has neither a reconnect nor a profile + // switch to bump it for. The guards below are the seam either would land + // on; the screens' own gen counters are the live ones. pollGen int statusEvery, trafficEvery time.Duration diff --git a/internal/tui/logs.go b/internal/tui/logs.go index 99591dd..df2d1d0 100644 --- a/internal/tui/logs.go +++ b/internal/tui/logs.go @@ -190,12 +190,7 @@ func (s *logsScreen) prepend(rows []api.LogEntry) { if len(rows) == 0 { return } - var selected string - hadSelection := false - if k, ok := s.row(); ok { - selected = k.TraceID - hadSelection = true - } + selected, hadSelection := s.row() next := make([]api.LogEntry, 0, min(len(rows)+len(s.rows), logsRing)) for i := len(rows) - 1; i >= 0; i-- { @@ -211,7 +206,7 @@ func (s *logsScreen) prepend(rows []api.LogEntry) { return } for i, r := range s.rows { - if r.TraceID == selected { + if sameRow(r, selected) { s.sel = i return } @@ -219,6 +214,15 @@ func (s *logsScreen) prepend(rows []api.LogEntry) { s.sel, s.detail = -1, false } +// sameRow is api.dedupeKey's identity, spelled locally because the wire's +// notion of one row belongs to the API layer. A trace has one row per pipeline +// stage, so the trace id alone matches several rows: following it would land +// the cursor on a different stage of the same request, which is the exact +// silent re-pointing prepend exists to prevent. +func sameRow(a, b api.LogEntry) bool { + return a.TraceID == b.TraceID && a.Stage == b.Stage && a.CreatedAt.Equal(b.CreatedAt) +} + func (s *logsScreen) row() (api.LogEntry, bool) { if s.sel < 0 || s.sel >= len(s.rows) { return api.LogEntry{}, false diff --git a/internal/tui/logs_test.go b/internal/tui/logs_test.go index 55f1e7c..ceb2aca 100644 --- a/internal/tui/logs_test.go +++ b/internal/tui/logs_test.go @@ -438,3 +438,61 @@ func TestLogsTruncatedWindowKeepsRowsAndSaysSo(t *testing.T) { t.Fatal("a clean poll clears the truncation notice") } } + +// Every pane owes exactly `rows` lines — that contract is what anchors the +// composer to the bottom of the screen. Gateway data reaches both the table +// (provider, model, stage) and the detail strip (error_message), so a newline +// in either would add a line to the frame and shift everything below it. +func TestLogsPaneKeepsItsLineCountWithControlCharactersInGatewayData(t *testing.T) { + a := composerApp() + a.route("logs") + r := logRow("tr_control0", time.Now()) + r.Provider = "anth\nropic" + r.ErrorMessage = "upstream\nrefused \x1b[31mhard\x1b[0m" + a.update(logsBatchMsg{gen: a.Logs.gen, rows: []api.LogEntry{r}}) + a.Logs.sel, a.Logs.detail = 0, true + + for _, rows := range []int{4, 9, 20} { + out := a.Logs.view(a, 100, rows) + if got := strings.Count(out, "\n") + 1; got != rows { + t.Fatalf("view(rows=%d) returned %d lines:\n%q", rows, got, out) + } + if strings.Contains(out, "\x1b") { + t.Fatalf("view(rows=%d) forwarded an escape sequence:\n%q", rows, out) + } + } +} + +// api.dedupeKey identifies a log row as trace + stage + created_at, because one +// trace has one row per pipeline stage. Following the trace id alone lands the +// cursor on whichever row of that trace arrives first, which is the silent +// re-pointing of the detail strip prepend exists to prevent. +func TestLogsSelectionFollowsItsRowNotItsTrace(t *testing.T) { + now := time.Now() + for _, tc := range []struct { + name string + mutate func(*api.LogEntry) + }{ + {"another stage of the same trace", func(e *api.LogEntry) { e.Stage = "on_error" }}, + {"the same trace and stage seen again later", func(e *api.LogEntry) { e.CreatedAt = now.Add(time.Second) }}, + } { + t.Run(tc.name, func(t *testing.T) { + var s logsScreen + selected := logRow("tr_onetrace", now) + s.rows = []api.LogEntry{selected} + s.sel, s.detail = 0, true + + arriving := logRow("tr_onetrace", now) + tc.mutate(&arriving) + s.prepend([]api.LogEntry{arriving}) + + if s.sel != 1 { + t.Fatalf("the selection must follow its own row to index 1, got %d", s.sel) + } + got, ok := s.row() + if !ok || got.Stage != selected.Stage || !got.CreatedAt.Equal(selected.CreatedAt) { + t.Fatalf("the strip is describing a different row now: %+v", got) + } + }) + } +} From 18b5bc75aa04c51668d375e18e98007a0ed98517 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:53 +0530 Subject: [PATCH 22/28] ci: unalias the concurrency group, make release builds reproducible Inside a called workflow github.workflow resolves to the caller's name, so ci.yml's group became "Release-" when release.yml invoked it, against a caller holding "release-". GitHub matches group names case-insensitively, which makes those one group -- and the called half sets cancel-in-progress true against a caller that set it false. A literal prefix cannot alias under any casing, and cannot change meaning depending on who called it. mod_timestamp alone would not have made the archives reproducible. goreleaser passes no -trimpath, so the binary carried absolute source paths, and version.Date was linked from {{.Date}}, the build wall clock, so it changed every run. With -trimpath and {{.CommitDate}} two snapshot runs of one commit now produce byte-identical checksums across all six targets. Syft is not on GitHub runners and goreleaser hard-fails a release when the sboms cmd is missing -- after the binaries are built, on the first real tag. The pinned download-syft step is what makes the sboms block safe to ship. --- .github/workflows/ci.yml | 12 +++++++++++- .github/workflows/release.yml | 4 ++++ .goreleaser.yaml | 19 ++++++++++++++++++- 3 files changed, 33 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 49e26ba..83ffb02 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -10,7 +10,17 @@ on: - cron: "0 4 * * 1" concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + # Literal "ci-", never ${{ github.workflow }}: inside a reusable workflow that + # expression resolves to the *caller's* name, so the `uses: ./.github/workflows/ci.yml` + # leg of release.yml would compute "Release-refs/tags/vX" while release.yml's own + # group is "release-refs/tags/vX" -- the same group, because GitHub matches + # concurrency names case-insensitively, but with the two halves disagreeing about + # cancel-in-progress (true here, false there). A literal keeps this group's meaning + # fixed no matter who calls the workflow. Do not "restore" the expression. + group: ci-${{ github.ref }} + # Pull requests and pushes to main only care about the newest commit; superseded + # runs are wasted minutes. Tagged releases are serialised by release.yml's own + # group instead, which is where cancel-in-progress: false belongs. cancel-in-progress: true permissions: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 3e5ce86..db266e3 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -34,6 +34,10 @@ jobs: # A restored cache can carry entries from other refs; this job # publishes release artifacts, so a poisoned cache is user-facing. cache: false + # .goreleaser.yaml's sboms block shells out to syft, which is not present on + # GitHub-hosted runners; without this step the first real tag fails at the + # SBOM stage, after the binaries are already built. + - uses: anchore/sbom-action/download-syft@e22c389904149dbc22b58101806040fa8d37a610 # v0.24.0 - uses: goreleaser/goreleaser-action@ec59f474b9834571250b370d4735c50f8e2d1e29 # v7.0.0 with: distribution: goreleaser diff --git a/.goreleaser.yaml b/.goreleaser.yaml index 60f8e1e..51a4301 100644 --- a/.goreleaser.yaml +++ b/.goreleaser.yaml @@ -10,11 +10,21 @@ builds: env: [CGO_ENABLED=0] goos: [linux, darwin, windows] goarch: [amd64, arm64] + # Reproducibility: rebuilding a tag must yield the same bytes, or a user has + # no way to check that a published binary was built from the source it names. + # mod_timestamp pins the file mtimes goreleaser stamps into archives, and + # .CommitDate replaces the build wall clock below -- both are needed, since + # either one alone still leaves the build time baked in. + mod_timestamp: "{{ .CommitTimestamp }}" + # -trimpath is the third leg: without it the binary embeds the absolute build + # directory, so a rebuild anywhere but the CI runner's own path differs even + # with the timestamps pinned -- and the published binary leaks that path. + flags: [-trimpath] ldflags: - -s -w - -X github.com/ferro-labs/gateway-cli/internal/version.Version={{.Version}} - -X github.com/ferro-labs/gateway-cli/internal/version.Commit={{.ShortCommit}} - - -X github.com/ferro-labs/gateway-cli/internal/version.Date={{.Date}} + - -X github.com/ferro-labs/gateway-cli/internal/version.Date={{.CommitDate}} # cmd/fakegw is a development tool (a fake gateway for testing the CLI without # a server). It is excluded by omission — builds are listed explicitly above. @@ -37,6 +47,13 @@ archives: checksum: name_template: checksums.txt +# One SBOM per archive (syft's default, SPDX JSON), so a consumer can answer +# "is this build affected by CVE-x" without unpacking and re-scanning it. +# Requires syft on the runner -- release.yml installs it, and goreleaser fails +# the release rather than skipping the SBOM if it is missing. +sboms: + - artifacts: archive + release: name_template: "Ferro CLI v{{ .Version }}" From 0e2d3bc37128c638828575ed0ad287be5047ae3b Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:54 +0530 Subject: [PATCH 23/28] test: isolate the chat tests from a developer's ferro config runChatWith builds its own root and runs PersistentPreRunE, so config resolution reached a real ~/.config/ferro/config.yaml. Measured rather than assumed: with a malformed config planted in XDG_CONFIG_HOME, exactly eight tests failed and all eight were this helper's. status_test.go was never exposed -- every test there reaches the CLI through execute, which already isolates. It gets a comment recording where that comes from and warning that a test building its own root must repeat it, which is the trap this helper fell into, rather than a second redundant Setenv. --- internal/command/chat_test.go | 5 +++++ internal/command/status_test.go | 4 +++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/internal/command/chat_test.go b/internal/command/chat_test.go index def0cce..cee848f 100644 --- a/internal/command/chat_test.go +++ b/internal/command/chat_test.go @@ -73,6 +73,11 @@ func recordingGateway(t *testing.T, s fixture.State) (*httptest.Server, *recorde // the context that an interrupt cancels. func runChatWith(ctx context.Context, t *testing.T, srv *httptest.Server, stdin io.Reader, stdout io.Writer, args ...string) (stderr string, err error) { t.Helper() + // This builds its own root instead of going through execute(), so it does not + // inherit execute's config isolation -- see root_test.go. Without this line a + // developer's real ~/.config/ferro/config.yaml resolves into PersistentPreRunE + // and steers every test below it. + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) t.Setenv("FERRO_API_KEY", "fgw_test") root := NewRoot() var errb bytes.Buffer diff --git a/internal/command/status_test.go b/internal/command/status_test.go index 9e1cd49..0a88f36 100644 --- a/internal/command/status_test.go +++ b/internal/command/status_test.go @@ -21,7 +21,9 @@ func gateway(t *testing.T, s fixture.State) *httptest.Server { return srv } -// run executes a verb against srv with the fixture's credential. +// run executes a verb against srv with the fixture's credential. Config +// isolation is execute's (root_test.go) and reaches every test through here -- +// a test that builds its own root instead has to repeat it, as chat_test.go does. func run(t *testing.T, srv *httptest.Server, args ...string) (stdout, stderr string, err error) { t.Helper() t.Setenv("FERRO_API_KEY", "fgw_test") From 03b9fa360e530c8370e66a33c75aefb1823bcfae Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:12:54 +0530 Subject: [PATCH 24/28] docs: record the behaviour changes and declare the copyright The credential fallback, the destructive-verb prompt and the release packaging all changed in ways an operator can observe, and shipping those undocumented would be worse than the bugs they fix. v0.1.0 is unreleased, so the entry is amended rather than superseded. Nothing in the repository said who owns the code: LICENSE is the stock Apache text whose appendix is a template by design, and there was no NOTICE and no copyright line anywhere. Adding a NOTICE is the conventional answer; per-file headers are a far larger diff than this warrants. --- CHANGELOG.md | 26 +++++++++++++++++++++++--- NOTICE | 8 ++++++++ README.md | 11 ++++++----- 3 files changed, 37 insertions(+), 8 deletions(-) create mode 100644 NOTICE diff --git a/CHANGELOG.md b/CHANGELOG.md index 290039d..8bb6e0c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -25,13 +25,20 @@ Requires AI Gateway v1.4.2 or later. filters for time, model, provider, stage, and credential. - **Key management** — list, create, rotate, and revoke API keys, with derived `active` / `expired` / `revoked` state. New secrets are printed once, to - stdout, and never enter the console transcript or history. + stdout, and never enter the console transcript or history. `rotate` and + `revoke` are irreversible, so at a terminal each asks for the key id typed + back before it runs; `--yes` skips the prompt, and is required when stdin is + not a terminal rather than the verb blocking or proceeding unasked. - **Playground** — streaming chat against the gateway with `/model` and `/clear`, showing token usage plus route and cost when available. - **Connection profiles** at `os.UserConfigDir()/ferro/config.yaml`. URL resolution: `--gateway-url` > `FERRO_URL` > profile > `http://localhost:8080`. - Key resolution: `FERRO_API_KEY` > profile `api_key_env` > `MASTER_KEY`. Keys - are never passed as flags, so they stay out of shell history. + Key resolution: `FERRO_API_KEY` > profile `api_key_env` > `MASTER_KEY`, the + last of which applies only when the gateway URL is loopback. `MASTER_KEY` is + the gateway server's own variable and is not chosen for ferro by anyone, so + it is the one source that could otherwise be forwarded to a remote host the + operator named on the command line. Keys are never passed as flags, so they + stay out of shell history. - **Global flags** `--gateway-url`, `--profile`, `--format`, `--ascii`, plus `NO_COLOR`, TTY, and `TERM=dumb` detection. @@ -43,6 +50,19 @@ Requires AI Gateway v1.4.2 or later. degraded gateway exits 0 and reports its degraded state. - Missing measurements render `-`, never `0`. Endpoints the gateway does not serve disable that panel with a hint instead of failing the command. +- Gateway-supplied text is data, never layout or terminal control. Control + characters in a provider name, an upstream error message, or a model's answer + are neutralized on every surface, so a table keeps its columns, a pane keeps + its line count, and nothing upstream can drive the terminal. + +### Distribution + +- Release binaries are reproducible: `-trimpath`, and both the build stamp and + the archive timestamps come from the tagged commit rather than the build + clock, so two builds of one tag are byte-identical. +- An SPDX SBOM ships beside each archive. +- `go install` builds, which carry no linker stamp, now report their module + version and commit from the embedded build info instead of `dev`/`none`. ### Known limitations diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..783c26f --- /dev/null +++ b/NOTICE @@ -0,0 +1,8 @@ +Ferro Operator Console (ferro-cli) +Copyright 2026 Ferro Labs + +This product includes software developed at Ferro Labs +(https://github.com/ferro-labs). + +Licensed under the Apache License, Version 2.0; see the LICENSE file for the +full terms. diff --git a/README.md b/README.md index 50ea2a4..047922b 100644 --- a/README.md +++ b/README.md @@ -71,8 +71,8 @@ Every list and get honours `--format json|yaml`. | `ferro keys list` | Keys — name, masked secret, scopes, expiry, last used, uses, state. | | `ferro keys get ` | One key, as structured output. | | `ferro keys create` | `--name` (required), `--scope admin\|read_only`, `--expires-in`. | -| `ferro keys rotate ` | Mint a new secret; the previous one stops authenticating at once. | -| `ferro keys revoke ` | Immediate and irreversible. | +| `ferro keys rotate ` | Mint a new secret; the previous one stops authenticating at once. Confirms first; `--yes` to skip. | +| `ferro keys revoke ` | Immediate and irreversible. Confirms first; `--yes` to skip. | | `ferro logs list` | Request log — time, trace, provider, model, stage, duration, cost, tokens. | | `ferro logs stats` | Totals, errors, tokens, cost, and latency percentiles over a window. | | `ferro logs tail` | Follow the log. Poll-based, deduped, plain lines; Ctrl-C exits clean. | @@ -89,12 +89,12 @@ Every list and get honours `--format json|yaml`. |---|---| | `FERRO_URL` | Gateway base URL. Default `http://localhost:8080`. | | `FERRO_API_KEY` | Bearer credential sent to the gateway. | -| `MASTER_KEY` | Last-resort credential fallback. | +| `MASTER_KEY` | Last-resort credential fallback, **only when the gateway URL is loopback**. It is the gateway server's own variable, so it is sent to `localhost` and `127.0.0.1` alone — never to a remote host that merely happens to be on the command line. | | `NO_COLOR` | Any value suppresses ANSI. (Also off under `TERM=dumb` or a non-TTY stdout.) | ```text URL: --gateway-url > FERRO_URL > profile.url > http://localhost:8080 -key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY +key: FERRO_API_KEY > profile.api_key_env deref > MASTER_KEY (loopback only) ``` **There is deliberately no credential flag.** Command-line arguments show up in @@ -222,4 +222,5 @@ proves the CLI is internally correct; only this proves the contract is real. ## License -Apache 2.0 — see [`LICENSE`](LICENSE). +Copyright 2026 Ferro Labs. Apache 2.0 — see [`LICENSE`](LICENSE) and +[`NOTICE`](NOTICE). From b42f56e9e6f09b00434fffb30e0538c8930ee211 Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:19:29 +0530 Subject: [PATCH 25/28] docs: give the README the gateway's header and its own badges The two repositories are one product and read as two: the gateway leads with the F mark, a titled table and a badge row, and this one led with a bare h1. Same header shape here, so a reader arriving from either recognises the other. The mark is the gateway's canonical logo.png resampled to 192px and 28KB rather than copied at its full 929px and 650KB. It is rendered at 64 cells; the original would have been a second console.gif, and this repository already carries one asset it cannot take back out of its history. Badges are the four that can be checked: the Go version from go.mod, the pkg.go.dev reference (which fills in once v0.1.0 is tagged), Apache 2.0, and the CI workflow. The gateway's codecov, stars, Discord, DeepWiki and Artifact Hub badges are not carried over -- none of them describes this repository. The docs link says "gateway documentation" and says what it is: the only CLI reference on docs.ferrolabs.ai is ferrogw's, a different binary with different verbs, so pointing an operator there for `ferro` would be a wrong turn. This README is the reference for this tool until that changes. --- README.md | 29 +++++++++++++++++++++-------- docs/logo.png | Bin 0 -> 28651 bytes 2 files changed, 21 insertions(+), 8 deletions(-) create mode 100644 docs/logo.png diff --git a/README.md b/README.md index 047922b..9fefd1c 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,26 @@ -# Ferro Operator Console +

-**A scriptable CLI and interactive TUI for the [Ferro Labs AI Gateway](https://github.com/ferro-labs/ai-gateway).** -One static binary that is both a scriptable CLI and a full-screen terminal -console — health, request logs, API keys, and a live playground, without -opening a browser. + + + + + +
Ferro Labs Gateway CLI

Ferro Labs Gateway CLI

Operator Console for the Ferro Labs AI Gateway
-![ferro-cli console demo](docs/console.gif) +**A scriptable CLI and interactive TUI for the [Ferro Labs AI Gateway](https://github.com/ferro-labs/ai-gateway). One static binary — health, request logs, API keys, and a live playground, without opening a browser.** + +[![Go](https://img.shields.io/badge/go-1.25+-00ADD8.svg)](https://go.dev) +[![Go Reference](https://pkg.go.dev/badge/github.com/ferro-labs/gateway-cli.svg)](https://pkg.go.dev/github.com/ferro-labs/gateway-cli) +[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE) +[![CI](https://github.com/ferro-labs/gateway-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/ferro-labs/gateway-cli/actions/workflows/ci.yml) + +📖 **Gateway documentation:** [docs.ferrolabs.ai](https://docs.ferrolabs.ai) · this README is the reference for `ferro` itself + +ferro-cli console demo + +
+ +--- `ferro-cli` ships a single binary named **`ferro`**. Run it with a verb and it behaves like any other Unix tool — `ferro status`, `ferro keys list`, @@ -15,8 +30,6 @@ terminal and it opens the console above. Every console view has a scriptable twin. The console is a lens, never the only door. ---- - ## Install ```bash diff --git a/docs/logo.png b/docs/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..166e73a011abc85daaa66c994b1f57d6a8b5ad0a GIT binary patch literal 28651 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 O0000 Date: Sun, 16 Aug 2026 12:23:07 +0530 Subject: [PATCH 26/28] docs: carry the gateway's logo.png verbatim The mark shipped resampled to 192px to keep the asset small. Use the same file the gateway does instead, byte for byte, so the two repositories cannot drift to different renderings of one logo and a future update to it is a copy rather than a copy plus a resample. Supersedes the resampling described in the previous commit. --- docs/logo.png | Bin 28651 -> 650496 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/logo.png b/docs/logo.png index 166e73a011abc85daaa66c994b1f57d6a8b5ad0a..f3ca42d29aa876ffb0a08b872fe66a5b5c5eec84 100644 GIT binary patch literal 650496 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

*IHkO3 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%0D~YsH<_b%X4Rzzq#i-fbWitE&j)vk&&!a4<}hR$ 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

=n-s+kLmPo9vrDj*hrU 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%0Aq*@<#5zAheJ{wk0i?)f8^`W=3r1B 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 Uc|p?oGltGU&*V;-j{Tee0Ni@G$N&HU literal 28651 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 O0000 Date: Sun, 16 Aug 2026 12:27:57 +0530 Subject: [PATCH 27/28] fix(api): bound the envelope error message and the stream's header wait Two findings from review, both on code this branch had just touched. decodeAPIError capped the raw body and then overwrote that message with the envelope's, uncapped -- so maxErrMessage held only for a gateway that answered with something other than its own error shape. A well-formed {"error":{"message":...}} put unbounded text into terminal output and logs while the constant read as enforced. Both sources go through boundMessage now. The rune-boundary walk moves with it rather than being written twice. Freeing the stream from the shared 15s ResponseHeaderTimeout went too far and cleared it. Do runs before the idle timer is armed and the stream client carries no Timeout, so the only remaining bound was the caller's context -- which has no deadline in the CLI's signal context or the console's Background(). A peer that accepted the connection and then said nothing held StreamChat open forever. The bound is now the idle timeout: widened from 15s to the two minutes a buffering gateway actually needs, not removed. Disabling the idle bound still disables both. The boundary check scanned the non-test import graph only, leaving the ~30 packages reachable just from _test.go files unchecked -- and a test importing the gateway module puts it in go.mod exactly as any other import would. -test closes that. Both fixes carry a test verified to fail without them: 8192 bytes past a 2048 bound, and a stream that never returns. --- internal/api/client.go | 33 +++++++++++++++++------------ internal/api/client_test.go | 28 +++++++++++++++++++++++++ internal/api/sse.go | 17 ++++++++++----- internal/api/sse_test.go | 36 ++++++++++++++++++++++++++++++++ scripts/check-module-boundary.sh | 7 +++++-- 5 files changed, 101 insertions(+), 20 deletions(-) diff --git a/internal/api/client.go b/internal/api/client.go index d737d8e..8fbe7d9 100644 --- a/internal/api/client.go +++ b/internal/api/client.go @@ -257,19 +257,26 @@ func (c *Client) do(ctx context.Context, method, p string, q url.Values, in, out // trace flows into terminal output and logs unbounded. const maxErrMessage = 2048 -func decodeAPIError(status int, raw []byte) *Error { - msg := strings.TrimSpace(string(raw)) - if len(msg) > maxErrMessage { - // Back up to a rune boundary before slicing: a cut through the middle - // of a multi-byte rune renders as U+FFFD, which reads as corruption in - // the gateway's reply rather than as ferro's own truncation. - cut := maxErrMessage - for cut > 0 && !utf8.RuneStart(msg[cut]) { - cut-- - } - msg = msg[:cut] + "… (truncated)" +// boundMessage caps an operator-facing message at maxErrMessage. Both of +// decodeAPIError's sources go through it: capping only the raw body left the +// bound trivially bypassable, because a gateway answering with a well-formed +// envelope replaces that message with an unbounded one. +func boundMessage(s string) string { + if len(s) <= maxErrMessage { + return s + } + // Back up to a rune boundary before slicing: a cut through the middle of a + // multi-byte rune renders as U+FFFD, which reads as corruption in the + // gateway's reply rather than as ferro's own truncation. + cut := maxErrMessage + for cut > 0 && !utf8.RuneStart(s[cut]) { + cut-- } - e := &Error{Status: status, Message: msg} + return s[:cut] + "… (truncated)" +} + +func decodeAPIError(status int, raw []byte) *Error { + e := &Error{Status: status, Message: boundMessage(strings.TrimSpace(string(raw)))} var env struct { Error struct { Message string `json:"message"` @@ -278,7 +285,7 @@ func decodeAPIError(status int, raw []byte) *Error { } `json:"error"` } if json.Unmarshal(raw, &env) == nil && env.Error.Message != "" { - e.Message, e.Type, e.Code = env.Error.Message, env.Error.Type, env.Error.Code + e.Message, e.Type, e.Code = boundMessage(env.Error.Message), env.Error.Type, env.Error.Code } if e.Message == "" { e.Message = http.StatusText(status) diff --git a/internal/api/client_test.go b/internal/api/client_test.go index a0d4eb6..abc7ecf 100644 --- a/internal/api/client_test.go +++ b/internal/api/client_test.go @@ -219,3 +219,31 @@ func TestDecodeAPIErrorTruncatesOnARuneBoundary(t *testing.T) { t.Fatal("truncation split a rune") } } + +// The envelope path replaces the message the raw-body cap just bounded, so it +// needs the same cap. Without one, a gateway answering with a well-formed +// {"error":{"message":...}} sends unbounded text into terminal output and logs +// while the constant that exists to prevent that reads as enforced. +func TestDecodeAPIErrorBoundsTheEnvelopeMessageToo(t *testing.T) { + body := `{"error":{"message":"` + strings.Repeat("z", maxErrMessage*4) + `","code":"upstream"}}` + e := decodeAPIError(http.StatusBadGateway, []byte(body)) + + if e.Code != "upstream" { + t.Fatalf("envelope must still be decoded, got code %q", e.Code) + } + if len(e.Message) > maxErrMessage+len("… (truncated)") { + t.Errorf("envelope message escaped the %d-byte bound: got %d bytes", maxErrMessage, len(e.Message)) + } + if !strings.HasSuffix(e.Message, "… (truncated)") { + t.Error("an oversized envelope message must be marked truncated") + } +} + +// A short envelope message is not truncated, so the bound cannot be read as +// "every structured error loses its tail". +func TestDecodeAPIErrorLeavesAShortEnvelopeMessageWhole(t *testing.T) { + e := decodeAPIError(http.StatusNotFound, []byte(`{"error":{"message":"no such model"}}`)) + if e.Message != "no such model" { + t.Fatalf("got %q", e.Message) + } +} diff --git a/internal/api/sse.go b/internal/api/sse.go index 8b74dbb..3c25458 100644 --- a/internal/api/sse.go +++ b/internal/api/sse.go @@ -171,16 +171,23 @@ func (c *Client) StreamChat(ctx context.Context, req ChatRequest) (*ChatStream, // ResponseHeaderTimeout, so escaping only the first still cut every stream // off at the header phase. A gateway or ingress that withholds response // headers until the first token is ordinary, which is what - // DefaultStreamIdleTimeout is sized for; here the lifetime is ctx's and the - // idle timer's alone. The assertion falls back to the transport as-is - // because a test double is not an *http.Transport and carries no bound to - // clear. The redirect refusal is not optional — a bearer token must not + // DefaultStreamIdleTimeout is sized for. The assertion falls back to the + // transport as-is because a test double is not an *http.Transport and + // carries no bound to set. The redirect refusal is not optional — a bearer token must not // replay to whatever host a redirect names, on this surface as much as any // other. streamTransport := c.hc.Transport if tr, ok := streamTransport.(*http.Transport); ok { clone := tr.Clone() - clone.ResponseHeaderTimeout = 0 + // Widened to the idle bound, not removed. Do runs before the idle timer + // below exists and this client carries no Timeout, so zeroing it left a + // peer that accepts the connection and then withholds headers blocking + // StreamChat for as long as the caller's context allows — which for the + // CLI's signal context and the console's is forever. The idle timeout is + // already the answer to "how long may this stream say nothing"; the + // header phase is the first stretch of exactly that silence. A caller + // who disables the idle bound disables this one with it. + clone.ResponseHeaderTimeout = c.streamIdleTimeout streamTransport = clone } streamClient := &http.Client{ diff --git a/internal/api/sse_test.go b/internal/api/sse_test.go index 6d872da..fff8027 100644 --- a/internal/api/sse_test.go +++ b/internal/api/sse_test.go @@ -599,3 +599,39 @@ func TestTraceAttributionNoLogStoreIsNotAnError(t *testing.T) { t.Fatalf("a 501 log store must degrade to (nil, nil), got %+v, %v", row, err) } } + +// A peer that accepts the connection and then withholds response headers must +// not hold StreamChat open indefinitely. Do runs before the idle timer exists +// and the stream client carries no Timeout, so the transport's header bound is +// the only thing standing between a silent peer and a CLI that never returns — +// the caller's context has no deadline in either the CLI or the console. +func TestStreamChatBoundsAPeerThatWithholdsHeaders(t *testing.T) { + release := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { + <-release // never sends headers until the test is done with it + })) + t.Cleanup(func() { close(release); srv.Close() }) + + const idle = 150 * time.Millisecond + c, err := New(srv.URL, "", WithStreamIdleTimeout(idle)) + if err != nil { + t.Fatal(err) + } + + done := make(chan error, 1) + go func() { + // context.Background(): exactly what the console passes, and what the + // CLI's signal context amounts to when nobody presses ctrl+c. + _, streamErr := c.StreamChat(context.Background(), ChatRequest{Model: "m"}) + done <- streamErr + }() + + select { + case streamErr := <-done: + if streamErr == nil { + t.Fatal("a peer that sent no headers must not yield a usable stream") + } + case <-time.After(10 * idle): + t.Fatalf("StreamChat did not return within %s of a %s idle bound: the header phase is unbounded", 10*idle, idle) + } +} diff --git a/scripts/check-module-boundary.sh b/scripts/check-module-boundary.sh index 2ef615b..6308745 100755 --- a/scripts/check-module-boundary.sh +++ b/scripts/check-module-boundary.sh @@ -9,11 +9,14 @@ fi # go list walks the real import graph (covers aliased and blank imports, and # can't be tripped by a doc comment or string literal naming the module the # way a text grep can) instead of grepping source text. -tags integration -# pulls itest/ into the graph too. +# pulls itest/ into the graph too, and -test the imports that only _test.go +# files have: a test reaching into the gateway module puts it in go.mod the +# same as any other import, so leaving those 30-odd packages unscanned left +# the one file type most likely to "just import it for a fixture" unchecked. # Two statements, not one pipeline: `|| true` is needed for grep's "no match" # exit 1, and on a pipeline it would swallow a go list failure too — passing # the check because the scan never ran, which is the hole this rewrite closes. -deps="$(go list -tags integration -deps ./...)" +deps="$(go list -tags integration -deps -test ./...)" offenders="$(printf '%s\n' "$deps" | grep '^github\.com/ferro-labs/ai-gateway' || true)" if [ -n "$offenders" ]; then echo "$offenders" >&2 From 6dc82b689f96f97d922de32b073daf38c202205a Mon Sep 17 00:00:00 2001 From: Mitul Shah Date: Sun, 16 Aug 2026 12:47:51 +0530 Subject: [PATCH 28/28] refactor: write the 501 rule once, and start one fixture server per test Two maintainability findings from review, both flagged trivial and both true. `ferro services` repeated one shape four times: probe, mark the row unsupported on a 501, return any other error, else derive a state string. Only the string differed. The rule that a 501 means "this gateway does not serve the feature" -- as opposed to serves it and has nothing -- was therefore written four times, and widening it (tolerating a 404 as well, say) was four edits with nothing to catch the one that got missed. serviceProbe.summarize holds it once. The reading is a closure rather than a value because Go evaluates arguments eagerly and audit's row reads through a pointer the gateway leaves nil when it refuses the call: passing the sentence in would panic before the error that explains it could be checked. The four probes also answer with four different types, and only the sentence they reduce to is common. The fixture tests started a listener per request, so a create-then-read flow against one stateful handler opened and closed four of them. serve() starts one per test and t.Cleanup closes it; the handler was always shared, so this only changes setup cost, not behaviour. The servers inside the five path loops and decodeStats are hoisted out, which is where most of the churn was. 27 listeners for 27 tests now, one each, and the same 27 tests pass. --- internal/command/services.go | 125 ++++++++++++++++++------------ internal/fixture/handler_test.go | 129 +++++++++++++++++-------------- 2 files changed, 147 insertions(+), 107 deletions(-) diff --git a/internal/command/services.go b/internal/command/services.go index b36f6b9..5811e62 100644 --- a/internal/command/services.go +++ b/internal/command/services.go @@ -35,6 +35,34 @@ type serviceSummary struct { State string `json:"state"` } +// serviceProbe is one row's name and the reading behind it. read is a closure +// rather than a value because the four services answer with four different +// types and only the sentence they reduce to is shared -- and because the +// reading must not be evaluated before its error is checked: audit's row reads +// through a pointer the gateway leaves nil when it refuses the call. +type serviceProbe struct { + name string + read func() (string, error) +} + +// summarize applies the rule every service row obeys: a gateway that does not +// serve the endpoint at all answers 501, which reports the feature absent +// rather than present-and-empty, and is not a failure. Anything else is. +// +// It exists so that rule is written once. Four copies of it meant a change to +// what counts as "absent" -- tolerating a 404 as well, say -- was four edits +// with nothing to catch the one that got missed. +func (p serviceProbe) summarize() (serviceSummary, error) { + state, err := p.read() + switch { + case api.IsNotSupported(err): + return serviceSummary{Name: p.name, State: stateUnsupported}, nil + case err != nil: + return serviceSummary{}, err + } + return serviceSummary{Name: p.name, State: state}, nil +} + func newServicesCmd() *cobra.Command { return &cobra.Command{ Use: "services", @@ -42,61 +70,56 @@ func newServicesCmd() *cobra.Command { Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, _ []string) error { d := deps(cmd) - rows := make([]serviceSummary, 0, 4) - - servers, err := mcpServers(cmd) - switch { - case api.IsNotSupported(err): - rows = append(rows, serviceSummary{Name: svcMCP, State: stateUnsupported}) - case err != nil: - return err - default: - ready := 0 - for _, s := range servers { - if s.Ready { - ready++ + probes := []serviceProbe{ + {svcMCP, func() (string, error) { + servers, err := mcpServers(cmd) + if err != nil { + return "", err } - } - rows = append(rows, serviceSummary{ - Name: svcMCP, - State: fmt.Sprintf("%d/%d ready", ready, len(servers)), - }) - } - - plugins, err := d.Client.Plugins(cmd.Context()) - switch { - case api.IsNotSupported(err): - rows = append(rows, serviceSummary{Name: svcPlugins, State: stateUnsupported}) - case err != nil: - return err - default: - active := 0 - for _, p := range plugins { - if p.Enabled { - active++ + ready := 0 + for _, s := range servers { + if s.Ready { + ready++ + } } - } - rows = append(rows, serviceSummary{Name: svcPlugins, State: fmt.Sprintf("%d active", active)}) - } - - sessions, err := d.Client.Sessions(cmd.Context()) - switch { - case api.IsNotSupported(err): - rows = append(rows, serviceSummary{Name: svcSessions, State: stateUnsupported}) - case err != nil: - return err - default: - rows = append(rows, serviceSummary{Name: svcSessions, State: fmt.Sprintf("%d operators", len(sessions))}) + return fmt.Sprintf("%d/%d ready", ready, len(servers)), nil + }}, + {svcPlugins, func() (string, error) { + plugins, err := d.Client.Plugins(cmd.Context()) + if err != nil { + return "", err + } + active := 0 + for _, p := range plugins { + if p.Enabled { + active++ + } + } + return fmt.Sprintf("%d active", active), nil + }}, + {svcSessions, func() (string, error) { + sessions, err := d.Client.Sessions(cmd.Context()) + if err != nil { + return "", err + } + return fmt.Sprintf("%d operators", len(sessions)), nil + }}, + {svcAudit, func() (string, error) { + audit, err := d.Client.Audit(cmd.Context(), api.AuditQuery{Limit: 1}) + if err != nil { + return "", err + } + return fmt.Sprintf("%d events", audit.Summary.TotalEntries), nil + }}, } - audit, err := d.Client.Audit(cmd.Context(), api.AuditQuery{Limit: 1}) - switch { - case api.IsNotSupported(err): - rows = append(rows, serviceSummary{Name: svcAudit, State: stateUnsupported}) - case err != nil: - return err - default: - rows = append(rows, serviceSummary{Name: svcAudit, State: fmt.Sprintf("%d events", audit.Summary.TotalEntries)}) + rows := make([]serviceSummary, 0, len(probes)) + for _, p := range probes { + row, err := p.summarize() + if err != nil { + return err + } + rows = append(rows, row) } if d.Printer.Format != FormatTable { diff --git a/internal/fixture/handler_test.go b/internal/fixture/handler_test.go index 65e8a95..21323e5 100644 --- a/internal/fixture/handler_test.go +++ b/internal/fixture/handler_test.go @@ -19,13 +19,22 @@ type reply struct { body []byte } -// do runs one request against a fresh server wrapping h. Every test goes -// through it, so the request context, the body read and the close are done in -// one place rather than re-hand-rolled per test. -func do(t *testing.T, h http.Handler, method, path, bearer, body string) reply { +// serve starts one server for state's handler. It is the unit a test shares: +// the fixture's key store lives in the handler, so a create followed by a read +// is one flow against one gateway, and opening a listener per request modelled +// it as four unrelated ones. +func serve(t *testing.T, state State) *httptest.Server { t.Helper() - srv := httptest.NewServer(h) + srv := httptest.NewServer(Handler(state)) t.Cleanup(srv.Close) + return srv +} + +// do runs one request against srv. Every test goes through it, so the request +// context, the body read and the close are done in one place rather than +// re-hand-rolled per test. +func do(t *testing.T, srv *httptest.Server, method, path, bearer, body string) reply { + t.Helper() var payload io.Reader if body != "" { payload = strings.NewReader(body) @@ -54,13 +63,13 @@ func do(t *testing.T, h http.Handler, method, path, bearer, body string) reply { } // get is do for the read surface, which is most of it. -func get(t *testing.T, h http.Handler, method, path, bearer string) reply { +func get(t *testing.T, srv *httptest.Server, method, path, bearer string) reply { t.Helper() - return do(t, h, method, path, bearer, "") + return do(t, srv, method, path, bearer, "") } func TestHealthShapeMatchesContract(t *testing.T) { - res := get(t, Handler(Default()), "GET", "/health", "") + res := get(t, serve(t, Default()), "GET", "/health", "") if res.status != 200 { t.Fatalf("healthy /health must be 200, got %d", res.status) } @@ -85,7 +94,7 @@ func TestHealthShapeMatchesContract(t *testing.T) { // a half-open circuit with live providers still answers 200 "ok"; only an // empty provider set makes /health non-200. func TestDegradedIsA200WithAHalfOpenCircuit(t *testing.T) { - res := get(t, Handler(State{Degraded: true}), "GET", "/health", "") + res := get(t, serve(t, State{Degraded: true}), "GET", "/health", "") if res.status != 200 { t.Fatalf("a circuit does not make /health non-200, got %d", res.status) } @@ -96,7 +105,7 @@ func TestDegradedIsA200WithAHalfOpenCircuit(t *testing.T) { } func TestNoProvidersIs503WithAnEmptyProviderSet(t *testing.T) { - res := get(t, Handler(State{NoProviders: true}), "GET", "/health", "") + res := get(t, serve(t, State{NoProviders: true}), "GET", "/health", "") if res.status != 503 { t.Fatalf("an empty provider set is the one 503 /health has, got %d", res.status) } @@ -110,7 +119,7 @@ func TestNoProvidersIs503WithAnEmptyProviderSet(t *testing.T) { // taught ferro status to read target counts that are not there, and report // "0/0 targets" for a gateway whose targets were merely dead. func TestNotReadyCarriesOnlyStatusAndReason(t *testing.T) { - res := get(t, Handler(State{NoProviders: true}), "GET", "/readyz", "") + res := get(t, serve(t, State{NoProviders: true}), "GET", "/readyz", "") if res.status != 503 { t.Fatalf("want 503, got %d", res.status) } @@ -135,26 +144,26 @@ func TestNotReadyCarriesOnlyStatusAndReason(t *testing.T) { } func TestAdminRoutesRequireBearer(t *testing.T) { - h := Handler(Default()) - res := get(t, h, "GET", "/admin/keys", "") + srv := serve(t, Default()) + res := get(t, srv, "GET", "/admin/keys", "") if res.status != 401 || !strings.Contains(string(res.body), "authentication_error") { t.Fatalf("want the documented 401 envelope, got %d %s", res.status, res.body) } - if res = get(t, h, "GET", "/admin/keys", "fgw_test"); res.status != 200 { + if res = get(t, srv, "GET", "/admin/keys", "fgw_test"); res.status != 200 { t.Fatalf("valid bearer must be accepted, got %d", res.status) } } func TestFeatureAbsenceIs501(t *testing.T) { - res := get(t, Handler(State{NoLogStore: true}), "GET", "/admin/logs", "") + res := get(t, serve(t, State{NoLogStore: true}), "GET", "/admin/logs", "") if res.status != 501 { t.Fatalf("absent log store must 501 so the CLI can feature-detect, got %d", res.status) } } func TestKeysAreStatefulAcrossRequests(t *testing.T) { - h := Handler(Default()) // one handler, two requests: the store must persist - res := do(t, h, "POST", "/admin/keys", "fgw_test", + srv := serve(t, Default()) // one server, two requests: the store must persist + res := do(t, srv, "POST", "/admin/keys", "fgw_test", `{"name":"itest","scopes":["read_only"]}`) if res.status != 201 { t.Fatalf("create must be 201: %d %s", res.status, res.body) @@ -169,7 +178,7 @@ func TestKeysAreStatefulAcrossRequests(t *testing.T) { if !strings.HasPrefix(created.Key, "fgw_") || len(created.Key) < 20 { t.Fatalf("create must return the full secret once, got %q", created.Key) } - list := get(t, h, "GET", "/admin/keys", "fgw_test") + list := get(t, srv, "GET", "/admin/keys", "fgw_test") if !strings.Contains(string(list.body), "itest") { t.Fatal("created key must appear in the list — the fake is stateful by design") } @@ -184,9 +193,9 @@ func TestKeysAreStatefulAcrossRequests(t *testing.T) { // could pass CI. This covers the mutating half of the key surface the way // TestKeysAreStatefulAcrossRequests covers create/list. func TestKeyLifecycleMutatesTheStore(t *testing.T) { - h := Handler(Default()) + srv := serve(t, Default()) - rotated := do(t, h, http.MethodPost, "/admin/keys/key_01/rotate", "fgw_test", "") + rotated := do(t, srv, http.MethodPost, "/admin/keys/key_01/rotate", "fgw_test", "") if rotated.status != http.StatusOK { t.Fatalf("rotate must be 200: %d %s", rotated.status, rotated.body) } @@ -200,17 +209,17 @@ func TestKeyLifecycleMutatesTheStore(t *testing.T) { if !strings.HasPrefix(row.Key, "fgw_") || row.RotatedAt == nil { t.Fatalf("rotate must serve the new secret once and stamp rotated_at: %s", rotated.body) } - if listed := get(t, h, http.MethodGet, "/admin/keys/key_01", "fgw_test"); strings.Contains(string(listed.body), row.Key) { + if listed := get(t, srv, http.MethodGet, "/admin/keys/key_01", "fgw_test"); strings.Contains(string(listed.body), row.Key) { t.Fatal("a later read must mask the rotated secret") } - if res := do(t, h, http.MethodPost, "/admin/keys/key_02/revoke", "fgw_test", ""); res.status != http.StatusOK { + if res := do(t, srv, http.MethodPost, "/admin/keys/key_02/revoke", "fgw_test", ""); res.status != http.StatusOK { t.Fatalf("revoke must be 200: %d %s", res.status, res.body) } - if res := do(t, h, http.MethodDelete, "/admin/keys/key_02", "fgw_test", ""); res.status != http.StatusNoContent { + if res := do(t, srv, http.MethodDelete, "/admin/keys/key_02", "fgw_test", ""); res.status != http.StatusNoContent { t.Fatalf("delete must be 204: %d %s", res.status, res.body) } - res := get(t, h, http.MethodGet, "/admin/keys/key_02", "fgw_test") + res := get(t, srv, http.MethodGet, "/admin/keys/key_02", "fgw_test") if res.status != http.StatusNotFound || !strings.Contains(string(res.body), "not_found_error") { t.Fatalf("a deleted key must 404 in the documented envelope: %d %s", res.status, res.body) } @@ -220,12 +229,13 @@ func TestKeyLifecycleMutatesTheStore(t *testing.T) { // store both its backends share. A fake that stored the empty list instead // would hand every fixture-backed test a scopeless key the gateway never mints. func TestCreateWithoutScopesDefaultsToReadOnly(t *testing.T) { + srv := serve(t, Default()) for _, body := range []string{ `{"name":"absent"}`, `{"name":"null","scopes":null}`, `{"name":"empty","scopes":[]}`, } { - res := do(t, Handler(Default()), "POST", "/admin/keys", "fgw_test", body) + res := do(t, srv, "POST", "/admin/keys", "fgw_test", body) if res.status != 201 { t.Fatalf("create must be 201: %d %s", res.status, res.body) } @@ -245,7 +255,7 @@ func TestCreateWithoutScopesDefaultsToReadOnly(t *testing.T) { // order. A seeded row out of order would validate paging against an order the // gateway cannot produce. func TestSeededLogIsNewestFirst(t *testing.T) { - res := get(t, Handler(Default()), "GET", "/admin/logs?stage=all", "fgw_test") + res := get(t, serve(t, Default()), "GET", "/admin/logs?stage=all", "fgw_test") var page struct { Data []struct { Stage string `json:"stage"` @@ -273,7 +283,7 @@ func TestSeededLogIsNewestFirst(t *testing.T) { } func TestChatStreamFraming(t *testing.T) { - res := do(t, Handler(Default()), "POST", "/v1/chat/completions", "fgw_test", + res := do(t, serve(t, Default()), "POST", "/v1/chat/completions", "fgw_test", `{"model":"claude-sonnet-4-6","messages":[{"role":"user","content":"hi"}],"stream":true}`) if ct := res.header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") { t.Fatalf("want SSE content type, got %q", ct) @@ -295,7 +305,7 @@ func TestChatErrorFrameHasNoDone(t *testing.T) { // The WHOLE stream is read, not its first frame: "there is no [DONE]" is a // claim about the end of the stream, and a partial read can only fail to // find one that was in fact sent. - res := do(t, Handler(State{ChatFails: true}), "POST", "/v1/chat/completions", "", + res := do(t, serve(t, State{ChatFails: true}), "POST", "/v1/chat/completions", "", `{"model":"m","messages":[],"stream":true}`) got := string(res.body) if !strings.Contains(got, "stream_error") || strings.Contains(got, "[DONE]") { @@ -307,7 +317,7 @@ func TestChatErrorFrameHasNoDone(t *testing.T) { // fake did not, the CLI's model discovery and playground could be built without // sending a credential and would 401 on first contact with a real gateway. func TestV1RoutesRequireBearerToo(t *testing.T) { - h := Handler(Default()) + srv := serve(t, Default()) // Each route is probed with the METHOD the CLI reaches it by. A handler // that authenticated GET /v1/chat/completions but not the POST the // playground sends would pass a GET-only loop and 401 in production. @@ -315,7 +325,7 @@ func TestV1RoutesRequireBearerToo(t *testing.T) { {http.MethodGet, "/v1/models", ""}, {http.MethodPost, "/v1/chat/completions", `{"model":"m","messages":[],"stream":true}`}, } { - res := do(t, h, tc.method, tc.path, "", tc.body) + res := do(t, srv, tc.method, tc.path, "", tc.body) if res.status != 401 { t.Fatalf("%s %s without a bearer must be 401, got %d", tc.method, tc.path, res.status) } @@ -323,34 +333,34 @@ func TestV1RoutesRequireBearerToo(t *testing.T) { t.Fatalf("%s %s must use the documented error envelope: %s", tc.method, tc.path, res.body) } } - if res := get(t, h, "GET", "/v1/models", "fgw_test"); res.status != 200 { + if res := get(t, srv, "GET", "/v1/models", "fgw_test"); res.status != 200 { t.Fatalf("valid bearer must be accepted on /v1/models, got %d", res.status) } } // ...while the liveness surface stays open, as it is on the real router. func TestHealthSurfaceStaysUnauthenticated(t *testing.T) { - h := Handler(Default()) + srv := serve(t, Default()) for _, path := range []string{"/health", "/readyz"} { - if res := get(t, h, "GET", path, ""); res.status == 401 { + if res := get(t, srv, "GET", path, ""); res.status == 401 { t.Fatalf("%s must not require a credential", path) } } - res := get(t, h, "GET", "/livez", "") + res := get(t, srv, "GET", "/livez", "") if res.status != http.StatusOK || strings.TrimSpace(string(res.body)) != `{"status":"ok"}` { t.Fatalf("/livez must be an open 200 status payload, got %d %s", res.status, res.body) } } func TestChatRequiresStreaming(t *testing.T) { - h := Handler(Default()) + srv := serve(t, Default()) for _, body := range []string{ `{"model":"m"}`, `{"model":"m","stream":false}`, `{"model":"m","stream":true}{"stream":true}`, `{"stream":false,"stream":true}`, } { - res := do(t, h, http.MethodPost, "/v1/chat/completions", "fgw_test", body) + res := do(t, srv, http.MethodPost, "/v1/chat/completions", "fgw_test", body) if res.status != http.StatusBadRequest { t.Fatalf("non-streaming request must be rejected, got %d", res.status) } @@ -358,8 +368,8 @@ func TestChatRequiresStreaming(t *testing.T) { } func TestAuditFiltersAndPagesRows(t *testing.T) { - h := Handler(Default()) - res := get(t, h, "GET", "/admin/audit?outcome=ok&limit=1&offset=1", "fgw_test") + srv := serve(t, Default()) + res := get(t, srv, "GET", "/admin/audit?outcome=ok&limit=1&offset=1", "fgw_test") if res.status != http.StatusOK { t.Fatalf("audit query failed: %d %s", res.status, res.body) } @@ -379,7 +389,7 @@ func TestAuditFiltersAndPagesRows(t *testing.T) { } func TestAuditRejectsInvalidSince(t *testing.T) { - res := get(t, Handler(Default()), "GET", "/admin/audit?since=not-a-time", "fgw_test") + res := get(t, serve(t, Default()), "GET", "/admin/audit?since=not-a-time", "fgw_test") if res.status != http.StatusBadRequest || !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { t.Fatalf("invalid since must use the invalid-request envelope: %d %s", res.status, res.body) @@ -391,6 +401,7 @@ func TestAuditRejectsInvalidSince(t *testing.T) { // silently fell back to its default and served an empty page instead. Both // endpoints share the page[T] helper, so one table covers both. func TestNonPositiveLimitIs400OnLogsAndAudit(t *testing.T) { + srv := serve(t, Default()) for _, path := range []string{ "/admin/logs?limit=0", "/admin/logs?limit=-1", @@ -399,7 +410,7 @@ func TestNonPositiveLimitIs400OnLogsAndAudit(t *testing.T) { "/admin/audit?limit=-1", "/admin/audit?limit=abc", } { - res := get(t, Handler(Default()), "GET", path, "fgw_test") + res := get(t, srv, "GET", path, "fgw_test") if res.status != http.StatusBadRequest || !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { t.Fatalf("%s: want the documented 400 envelope for a non-positive limit, got %d %s", path, res.status, res.body) @@ -409,13 +420,14 @@ func TestNonPositiveLimitIs400OnLogsAndAudit(t *testing.T) { // parseOffset rejects the same two shapes parseLimit does, one bound over. func TestNegativeOffsetIs400OnLogsAndAudit(t *testing.T) { + srv := serve(t, Default()) for _, path := range []string{ "/admin/logs?offset=-1", "/admin/logs?offset=abc", "/admin/audit?offset=-1", "/admin/audit?offset=abc", } { - res := get(t, Handler(Default()), "GET", path, "fgw_test") + res := get(t, srv, "GET", path, "fgw_test") if res.status != http.StatusBadRequest || !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { t.Fatalf("%s: want the documented 400 envelope for a bad offset, got %d %s", path, res.status, res.body) @@ -428,6 +440,7 @@ func TestNegativeOffsetIs400OnLogsAndAudit(t *testing.T) { // so `?limit=` is the same request as no limit at all. A fixture that rejected // it would send someone hunting a CLI bug that does not exist. func TestEmptyBoundIsReadAsAbsentNotRejected(t *testing.T) { + srv := serve(t, Default()) for _, path := range []string{ "/admin/logs?limit=", "/admin/logs?offset=", @@ -435,7 +448,7 @@ func TestEmptyBoundIsReadAsAbsentNotRejected(t *testing.T) { "/admin/audit?limit=", "/admin/audit?offset=", } { - res := get(t, Handler(Default()), "GET", path, "fgw_test") + res := get(t, srv, "GET", path, "fgw_test") if res.status != http.StatusOK { t.Fatalf("%s: an empty bound means absent, want 200, got %d %s", path, res.status, res.body) } @@ -447,11 +460,12 @@ func TestEmptyBoundIsReadAsAbsentNotRejected(t *testing.T) { // shared by all three) — this fixture used to accept anything on // /admin/logs/stats because it never looked at the query at all. func TestMalformedSinceIs400OnLogsAndStats(t *testing.T) { + srv := serve(t, Default()) for _, path := range []string{ "/admin/logs?since=not-a-time", "/admin/logs/stats?since=not-a-time", } { - res := get(t, Handler(Default()), "GET", path, "fgw_test") + res := get(t, srv, "GET", path, "fgw_test") if res.status != http.StatusBadRequest || !strings.Contains(string(res.body), `"type":"invalid_request_error"`) { t.Fatalf("%s: want the documented 400 envelope for a malformed since, got %d %s", path, res.status, res.body) @@ -466,9 +480,9 @@ type statsSummary struct { ByProvider map[string]json.RawMessage `json:"by_provider"` } -func decodeStats(t *testing.T, path string) statsSummary { +func decodeStats(t *testing.T, srv *httptest.Server, path string) statsSummary { t.Helper() - res := get(t, Handler(Default()), "GET", path, "fgw_test") + res := get(t, srv, "GET", path, "fgw_test") if res.status != http.StatusOK { t.Fatalf("%s: want 200, got %d %s", path, res.status, res.body) } @@ -485,7 +499,8 @@ func decodeStats(t *testing.T, path string) statsSummary { // narrows a five-row seed a different way, and the unfiltered count (5) proves // the baseline itself is real data, not a coincidence of one filter. func TestStatsFiltersNarrowTheAggregate(t *testing.T) { - base := decodeStats(t, "/admin/logs/stats") + srv := serve(t, Default()) + base := decodeStats(t, srv, "/admin/logs/stats") if base.Summary.TotalEntries != 5 { t.Fatalf("unfiltered stats: want all 5 seeded rows, got %d", base.Summary.TotalEntries) } @@ -504,7 +519,7 @@ func TestStatsFiltersNarrowTheAggregate(t *testing.T) { {"/admin/logs/stats?stage=before_request", 1}, {"/admin/logs/stats?model=does-not-exist", 0}, } { - got := decodeStats(t, tc.path) + got := decodeStats(t, srv, tc.path) if got.Summary.TotalEntries != tc.want { t.Fatalf("%s: want %d entries, got %d (a fixture that dropped this filter would still report %d)", tc.path, tc.want, got.Summary.TotalEntries, base.Summary.TotalEntries) @@ -513,7 +528,7 @@ func TestStatsFiltersNarrowTheAggregate(t *testing.T) { // provider=openai must also drop anthropic out of the by_provider // breakdown, not just shrink the total. - openaiOnly := decodeStats(t, "/admin/logs/stats?provider=openai") + openaiOnly := decodeStats(t, srv, "/admin/logs/stats?provider=openai") if _, ok := openaiOnly.ByProvider["anthropic"]; ok { t.Fatalf("provider=openai must drop anthropic from by_provider: %+v", openaiOnly.ByProvider) } @@ -524,13 +539,14 @@ func TestStatsFiltersNarrowTheAggregate(t *testing.T) { // not 400, and — because /admin/logs/stats used to ignore every parameter — // it must not silently narrow the aggregate either. func TestStatsEmptyFilterValueIsAbsentNotRejected(t *testing.T) { + srv := serve(t, Default()) for _, path := range []string{ "/admin/logs/stats?model=", "/admin/logs/stats?provider=", "/admin/logs/stats?stage=", "/admin/logs/stats?since=", } { - got := decodeStats(t, path) + got := decodeStats(t, srv, path) if got.Summary.TotalEntries != 5 { t.Fatalf("%s: an empty value means absent, want all 5 seeded rows, got %d", path, got.Summary.TotalEntries) } @@ -541,8 +557,9 @@ func TestStatsEmptyFilterValueIsAbsentNotRejected(t *testing.T) { // SQLWriter.Stats: "created_at >= ?"), so a cursor five minutes back must drop // exactly the row seeded nine minutes back and keep the other four. func TestStatsSinceKeepsOnlyRowsAtOrAfterTheCursor(t *testing.T) { + srv := serve(t, Default()) since := time.Now().Add(-5 * time.Minute).UTC().Format(time.RFC3339) - got := decodeStats(t, "/admin/logs/stats?since="+since) + got := decodeStats(t, srv, "/admin/logs/stats?since="+since) if got.Summary.TotalEntries != 4 { t.Fatalf("since=-5m must drop the row seeded 9 minutes ago, want 4 entries, got %d", got.Summary.TotalEntries) } @@ -552,8 +569,8 @@ func TestStatsSinceKeepsOnlyRowsAtOrAfterTheCursor(t *testing.T) { // the fixture must too — a fake that accepts "readonly" lets a CLI that sends // the wrong spelling pass every test here and fail against a real gateway. func TestCreateRejectsAnUnknownScope(t *testing.T) { - h := Handler(Default()) - res := do(t, h, http.MethodPost, "/admin/keys", "fgw_test", + srv := serve(t, Default()) + res := do(t, srv, http.MethodPost, "/admin/keys", "fgw_test", `{"name":"typo","scopes":["readonly"]}`) if res.status != http.StatusBadRequest { t.Fatalf("an unknown scope must be 400, got %d %s", res.status, res.body) @@ -564,7 +581,7 @@ func TestCreateRejectsAnUnknownScope(t *testing.T) { } } // The refusal must not have created anything. - if list := get(t, h, http.MethodGet, "/admin/keys", "fgw_test"); strings.Contains(string(list.body), "typo") { + if list := get(t, srv, http.MethodGet, "/admin/keys", "fgw_test"); strings.Contains(string(list.body), "typo") { t.Fatalf("a refused create must not reach the store: %s", list.body) } } @@ -572,9 +589,9 @@ func TestCreateRejectsAnUnknownScope(t *testing.T) { // Both members of the closed set are accepted, so the guard above cannot pass // by rejecting everything. func TestCreateAcceptsBothValidScopes(t *testing.T) { - h := Handler(Default()) + srv := serve(t, Default()) for _, scope := range []string{scopeAdmin, scopeReadOnly} { - res := do(t, h, http.MethodPost, "/admin/keys", "fgw_test", + res := do(t, srv, http.MethodPost, "/admin/keys", "fgw_test", `{"name":"ok-`+scope+`","scopes":["`+scope+`"]}`) if res.status != http.StatusCreated { t.Fatalf("%s must be accepted, got %d %s", scope, res.status, res.body) @@ -586,7 +603,7 @@ func TestCreateAcceptsBothValidScopes(t *testing.T) { // revoked_at:null, expires_at in the past. Seeding active:false here was // fixture-only fiction that hid a real CLI bug. func TestExpiredKeyKeepsActiveTrueOnTheWire(t *testing.T) { - res := get(t, Handler(Default()), http.MethodGet, "/admin/keys", "fgw_test") + res := get(t, serve(t, Default()), http.MethodGet, "/admin/keys", "fgw_test") var rows []struct { Name string `json:"name"` RevokedAt *string `json:"revoked_at"`

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