diff --git a/.cixignore b/.cixignore new file mode 100644 index 0000000..746c048 --- /dev/null +++ b/.cixignore @@ -0,0 +1,27 @@ +# Files / dirs the cix indexer skips for this repo. +# Pattern syntax mirrors .gitignore. + +# Frontend toolchain noise — don't index 50k+ files of node_modules / build output +server/dashboard/node_modules/ +server/internal/httpapi/dashboard/dist/ + +# Build artefacts +server/dist/ +cli/build/ +cli/dist/ + +# Generated code (regenerate with `npm run gen:api`) +server/dashboard/src/api/generated.ts + +# Embedded vendored bundles already covered by the linked sources elsewhere +server/internal/httpapi/docs/swagger-ui/ + +# Local data / runtime state +data/ +.local-data/ +*.db +*.db-wal +*.db-shm + +# Legacy archived tree (see commit 063a14e) +legacy/python-api/ diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json new file mode 100644 index 0000000..e2e09a3 --- /dev/null +++ b/.claude-plugin/marketplace.json @@ -0,0 +1,25 @@ +{ + "$schema": "https://json.schemastore.org/claude-code-marketplace.json", + "name": "code-index", + "owner": { + "name": "dvcdsys", + "email": "dvcdsys@gmail.com" + }, + "description": "Marketplace for cix — semantic code search and navigation tooling for Claude Code", + "plugins": [ + { + "name": "cix", + "source": "./plugins/cix", + "description": "Semantic code search and navigation. Bundles the cix CLI and nudges Claude to prefer cix over Grep for semantic queries.", + "author": { + "name": "dvcdsys" + }, + "homepage": "https://github.com/dvcdsys/code-index", + "repository": "https://github.com/dvcdsys/code-index", + "license": "MIT", + "keywords": ["search", "code-search", "semantic", "navigation", "indexing", "embeddings"], + "category": "developer-tools", + "tags": ["search", "indexing", "ai", "embeddings"] + } + ] +} diff --git a/.env.example b/.env.example index b7b3e54..ba37d24 100644 --- a/.env.example +++ b/.env.example @@ -1,12 +1,46 @@ +# cix-server environment template. Copy to .env and fill in real values. + +# ── Auth ────────────────────────────────────────────────────────────────── +# Header API key for direct CLI / CI traffic. Generate with: +# openssl rand -hex 32 | sed 's/^/cix_/' CIX_API_KEY=cix_ + +# First-boot admin seed (REQUIRED when the DB has no users yet — the server +# refuses to start otherwise). The user is flagged must_change_password=true, +# so the temporary password only works for the first login. Generate with: +# openssl rand -base64 18 | tr -d '/+=' | cut -c1-20 +CIX_BOOTSTRAP_ADMIN_EMAIL=admin@example.com +CIX_BOOTSTRAP_ADMIN_PASSWORD=change-me-on-first-login + +# ── Networking + storage ────────────────────────────────────────────────── CIX_PORT=21847 -CIX_EMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF -CIX_MAX_FILE_SIZE=524288 -CIX_EXCLUDED_DIRS=node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store CIX_CHROMA_PERSIST_DIR=~/.cix/data/chroma CIX_SQLITE_PATH=~/.cix/data/sqlite/projects.db CIX_GGUF_CACHE_DIR=~/.cix/data/models + +# ── Indexing ────────────────────────────────────────────────────────────── +CIX_EMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF +CIX_MAX_FILE_SIZE=524288 +CIX_EXCLUDED_DIRS=node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store + +# ── llama-server sidecar ────────────────────────────────────────────────── CIX_LLAMA_BIN_DIR=/app +# 99 = offload all layers (CUDA / Metal). 0 = CPU only. CIX_N_GPU_LAYERS=0 CIX_LLAMA_STARTUP_TIMEOUT=60 CIX_EMBEDDINGS_ENABLED=true + +# ── PR-E runtime tunables (also editable from /dashboard/server) ────────── +# 0 = auto. Threads → runtime.NumCPU()/2; batch → match n_ctx. +CIX_LLAMA_THREADS=0 +CIX_LLAMA_BATCH=0 +# Embedding queue parallelism. 5 is the new default — pipelines host-side +# prep with device inference. Drop to 1 if you observe contention. +CIX_MAX_EMBEDDING_CONCURRENCY=5 +CIX_EMBEDDING_QUEUE_TIMEOUT=300 + +# ── Optional: bootstrap the GGUF cache from a host-side file ────────────── +# Paired with the bind-mount example in docker-compose.{yml,cuda.yml}. +# Uncomment + set after wiring the bind, then drop both once the cache +# is seeded. +# CIX_BOOTSTRAP_GGUF_PATH=/bootstrap/model.gguf diff --git a/.github/workflows/ci-cli.yml b/.github/workflows/ci-cli.yml new file mode 100644 index 0000000..b8a5c9b --- /dev/null +++ b/.github/workflows/ci-cli.yml @@ -0,0 +1,46 @@ +name: "CI: CLI" + +on: + push: + branches: [main] + paths: + - "cli/**" + - ".github/workflows/ci-cli.yml" + pull_request: + branches: [main] + paths: + - "cli/**" + - ".github/workflows/ci-cli.yml" + +permissions: + contents: read + +jobs: + test: + name: Test (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + defaults: + run: + working-directory: cli + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version-file: cli/go.mod + cache-dependency-path: cli/go.sum + + - name: Vet + run: go vet ./... + + - name: Test + run: go test -race ./... + + - name: Build + run: go build ./... diff --git a/.github/workflows/ci-plugin.yml b/.github/workflows/ci-plugin.yml new file mode 100644 index 0000000..24b5c59 --- /dev/null +++ b/.github/workflows/ci-plugin.yml @@ -0,0 +1,75 @@ +name: Plugin Tests + +# Trigger only when plugin files change — server/CLI/dashboard work +# is unaffected and shouldn't run plugin tests. +on: + push: + branches: [main, 'feat/*', 'fix/*'] + paths: + - 'plugins/cix/**' + - '.claude-plugin/**' + - '.github/workflows/ci-plugin.yml' + pull_request: + paths: + - 'plugins/cix/**' + - '.claude-plugin/**' + - '.github/workflows/ci-plugin.yml' + +# Minimum permissions required by the workflow (CodeQL workflow-permissions advisory). +# Read-only on repo contents is enough — we don't push code, comments, or releases. +permissions: + contents: read + +jobs: + test: + name: bats + shellcheck on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + + steps: + - uses: actions/checkout@v4 + + - name: Install bats, jq, shellcheck (Linux) + if: runner.os == 'Linux' + run: | + sudo apt-get update + sudo apt-get install -y bats jq shellcheck + + - name: Install bats, jq, shellcheck (macOS) + if: runner.os == 'macOS' + run: | + brew install bats-core jq shellcheck + + - name: Verify bats version + run: bats --version + + - name: Run bats test suites + run: bats --tap plugins/cix/tests/*.bats + + - name: ShellCheck on hook scripts + run: | + # `--severity=warning` filters out style nags; `-x` follows + # sourced files (we don't source any in v0.1, but defensive). + shellcheck --severity=warning plugins/cix/scripts/*.sh + + - name: Validate JSON manifests with jq + run: | + jq . .claude-plugin/marketplace.json + jq . plugins/cix/.claude-plugin/plugin.json + jq . plugins/cix/hooks/hooks.json + + - name: Verify symlink integrity + run: | + # The bin/cix symlink MUST point at scripts/cix-wrapper.sh. + if [[ ! -L plugins/cix/bin/cix ]]; then + echo "::error::plugins/cix/bin/cix is not a symlink" + exit 1 + fi + target=$(readlink plugins/cix/bin/cix) + if [[ "$target" != "../scripts/cix-wrapper.sh" ]]; then + echo "::error::bin/cix points to '$target' (expected '../scripts/cix-wrapper.sh')" + exit 1 + fi diff --git a/.github/workflows/ci-go.yml b/.github/workflows/ci-server.yml similarity index 50% rename from .github/workflows/ci-go.yml rename to .github/workflows/ci-server.yml index e17ec77..10c1466 100644 --- a/.github/workflows/ci-go.yml +++ b/.github/workflows/ci-server.yml @@ -1,16 +1,21 @@ -name: CI — Go server +name: "CI: Server" on: push: branches: [main] paths: - "server/**" - - ".github/workflows/ci-go.yml" + - ".github/workflows/ci-server.yml" pull_request: branches: [main] paths: - "server/**" - - ".github/workflows/ci-go.yml" + - ".github/workflows/ci-server.yml" + +# Read-only: vet/test/build only. CodeQL flagged the implicit block as +# go/missing-permissions, hence the explicit declaration. +permissions: + contents: read jobs: test: @@ -18,20 +23,21 @@ jobs: defaults: run: working-directory: server - steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 - - uses: actions/setup-go@v5 + - name: Set up Go + uses: actions/setup-go@v5 with: go-version-file: server/go.mod cache-dependency-path: server/go.sum - - name: go vet + - name: Vet run: go vet ./... - - name: go test + - name: Test run: go test -race ./... - - name: go build + - name: Build run: go build ./... diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 0000000..dbc57cb --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,55 @@ +name: "CodeQL" + +# Advanced setup. Replaces GitHub's "default setup" which auto-detects +# and scans every language it finds — that included java-kotlin, ruby, +# rust, javascript-typescript, and c-cpp false-positives from vendored +# CGO deps. +# +# To stop the duplicate runs you also need to disable the default +# setup once: GitHub repo → Settings → Code security → Code scanning +# → "CodeQL analysis" → Switch to advanced (or Disable). + +on: + push: + branches: [main] + pull_request: + branches: [main] + schedule: + - cron: "0 6 * * 1" # Mondays at 06:00 UTC, mirrors security.yml + +permissions: + contents: read + security-events: write + actions: read + +jobs: + analyze: + name: Analyze (${{ matrix.language }}) + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + # Keep tightly scoped: only languages that actually ship code. + # `actions` lints workflow YAML; `go` covers server + CLI. + # Do NOT add c-cpp (only transitive CGO deps, no first-party C). + language: [actions, go] + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Initialize CodeQL + uses: github/codeql-action/init@v3 + with: + languages: ${{ matrix.language }} + # security-extended adds rules beyond the default set; matches + # what the default setup runs. + queries: security-extended + + - name: Autobuild + if: matrix.language == 'go' + uses: github/codeql-action/autobuild@v3 + + - name: Analyze + uses: github/codeql-action/analyze@v3 + with: + category: "/language:${{ matrix.language }}" diff --git a/.github/workflows/release-cli.yml b/.github/workflows/release-cli.yml index b21277d..8b329f0 100644 --- a/.github/workflows/release-cli.yml +++ b/.github/workflows/release-cli.yml @@ -1,72 +1,50 @@ -name: Release CLI +name: "Release: CLI" +# Triggered by CLI-namespaced tags (e.g. `cli/v0.4.0`). Server releases +# use `server/v*`. Bare `v*` tags are the historical pre-split CLI line +# and are no longer wired to any workflow. on: push: tags: - - "v*" + - "cli/v*" permissions: contents: write jobs: - build-linux: - name: Build ${{ matrix.target }} - runs-on: ubuntu-latest + build: + name: Build (${{ matrix.target }}) + runs-on: ${{ matrix.runner }} strategy: + fail-fast: false matrix: include: - - target: linux-arm64 - goarch: arm64 - target: linux-amd64 + runner: ubuntu-latest + goos: linux goarch: amd64 - - steps: - - uses: actions/checkout@v6 - - - uses: actions/setup-go@v6 - with: - go-version-file: cli/go.mod - cache-dependency-path: cli/go.sum - - - name: Build - working-directory: cli - env: - GOOS: linux - GOARCH: ${{ matrix.goarch }} - CGO_ENABLED: "0" - run: | - VERSION="${{ github.ref_name }}" - go build \ - -ldflags="-s -w -X 'github.com/anthropics/code-index/cli/cmd.Version=${VERSION}'" \ - -o "dist/cix" . - - - name: Package - working-directory: cli - run: | - cd dist - tar -czf "cix-${{ matrix.target }}.tar.gz" cix - rm cix - - - uses: actions/upload-artifact@v7 - with: - name: cix-${{ matrix.target }} - path: cli/dist/cix-${{ matrix.target }}.* - - build-darwin: - name: Build ${{ matrix.target }} - runs-on: macos-latest - strategy: - matrix: - include: - - target: darwin-arm64 + cgo: "0" + - target: linux-arm64 + runner: ubuntu-latest + goos: linux goarch: arm64 + cgo: "0" - target: darwin-amd64 + runner: macos-latest + goos: darwin goarch: amd64 - + cgo: "1" + - target: darwin-arm64 + runner: macos-latest + goos: darwin + goarch: arm64 + cgo: "1" steps: - - uses: actions/checkout@v6 + - name: Checkout + uses: actions/checkout@v4 - - uses: actions/setup-go@v6 + - name: Set up Go + uses: actions/setup-go@v5 with: go-version-file: cli/go.mod cache-dependency-path: cli/go.sum @@ -74,49 +52,68 @@ jobs: - name: Build working-directory: cli env: - GOOS: darwin + GOOS: ${{ matrix.goos }} GOARCH: ${{ matrix.goarch }} - CGO_ENABLED: "1" + CGO_ENABLED: ${{ matrix.cgo }} run: | - VERSION="${{ github.ref_name }}" + # Strip `cli/` namespace prefix — binaries report `v0.4.0`, not `cli/v0.4.0`. + VERSION="${GITHUB_REF_NAME#cli/}" go build \ -ldflags="-s -w -X 'github.com/anthropics/code-index/cli/cmd.Version=${VERSION}'" \ -o "dist/cix" . - name: Package - working-directory: cli + working-directory: cli/dist run: | - cd dist tar -czf "cix-${{ matrix.target }}.tar.gz" cix rm cix - - uses: actions/upload-artifact@v7 + - name: Upload artifacts + uses: actions/upload-artifact@v4 with: name: cix-${{ matrix.target }} - path: cli/dist/cix-${{ matrix.target }}.* + path: cli/dist/cix-${{ matrix.target }}.tar.gz release: - name: Create Release - needs: [build-linux, build-darwin] + name: Publish release + needs: [build] runs-on: ubuntu-latest steps: - - uses: actions/checkout@v6 + - name: Checkout + uses: actions/checkout@v4 - - uses: actions/download-artifact@v8 + - name: Download artifacts + uses: actions/download-artifact@v4 with: path: artifacts merge-multiple: true - - name: Checksums - run: | - cd artifacts - sha256sum * > checksums.txt + - name: Compute checksums + working-directory: artifacts + run: sha256sum * > checksums.txt + + - name: Extract version + id: ver + run: echo "version=${GITHUB_REF_NAME#cli/}" >> "$GITHUB_OUTPUT" - - name: Create GitHub Release + - name: Create GitHub release uses: softprops/action-gh-release@v2 with: + name: "CLI ${{ steps.ver.outputs.version }}" files: | artifacts/*.tar.gz artifacts/checksums.txt generate_release_notes: true - make_latest: "legacy" \ No newline at end of file + # Server releases own the "latest" pointer (Docker image is the + # primary deliverable). CLI installs filter by `cli/` tag prefix. + make_latest: "false" + body: | + ## Install + + ```bash + curl -fsSL https://raw.githubusercontent.com/dvcdsys/code-index/main/install.sh | bash + ``` + + Re-run the same command later to upgrade — the installer + picks the latest `cli/v*` release and skips if you already + have it (use `--force` to reinstall). diff --git a/.github/workflows/release-server.yml b/.github/workflows/release-server.yml index 4a86494..f0c7c2f 100644 --- a/.github/workflows/release-server.yml +++ b/.github/workflows/release-server.yml @@ -1,86 +1,175 @@ -name: Release Server - +name: "Release: Server" + +# Triggered by server-namespaced tags (e.g. `server/v0.3.0`). +# Builds CPU (multi-arch) and CUDA (amd64-only) Docker images and +# publishes them to Docker Hub, then creates the GitHub release. +# +# `workflow_dispatch` allows rebuilding an existing released version +# without cutting a new tag (e.g. to refresh attestations or pick up +# a new base image). The GitHub release step is skipped on dispatch. on: push: tags: - "server/v*" + workflow_dispatch: + inputs: + ref: + description: "Git ref to build (tag like `server/v0.4.0` or a SHA)" + required: true + type: string + version: + description: "Version string for image tags (e.g. `v0.4.0`)" + required: true + type: string + update_floating_tags: + description: "Also push `:latest` and `:cu128` floating tags" + required: false + type: boolean + default: true permissions: contents: write jobs: docker-cpu: - name: Build + push CPU image (multi-arch) + name: Build CPU image (multi-arch) runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 + with: + ref: ${{ github.event.inputs.ref || github.ref }} - name: Extract version id: ver - run: echo "version=${GITHUB_REF_NAME#server/}" >> "$GITHUB_OUTPUT" - - - uses: docker/setup-buildx-action@v3 - - - uses: docker/login-action@v3 + run: | + if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then + echo "version=${{ github.event.inputs.version }}" >> "$GITHUB_OUTPUT" + echo "floating=${{ github.event.inputs.update_floating_tags }}" >> "$GITHUB_OUTPUT" + else + echo "version=${GITHUB_REF_NAME#server/}" >> "$GITHUB_OUTPUT" + echo "floating=true" >> "$GITHUB_OUTPUT" + fi + + - name: Compose tags + id: tags + run: | + tags="dvcdsys/code-index:${{ steps.ver.outputs.version }}" + if [ "${{ steps.ver.outputs.floating }}" = "true" ]; then + tags="$tags + dvcdsys/code-index:latest" + fi + { + echo 'tags<> "$GITHUB_OUTPUT" + + - name: Set up Buildx + uses: docker/setup-buildx-action@v3 + + - name: Login to Docker Hub + uses: docker/login-action@v3 with: username: ${{ secrets.DOCKER_USERNAME }} password: ${{ secrets.DOCKER_PASSWORD }} - - name: Build and push CPU image + - name: Build and push uses: docker/build-push-action@v6 with: context: server file: server/Dockerfile platforms: linux/amd64,linux/arm64 push: true + provenance: mode=max + sbom: true build-args: VERSION=${{ steps.ver.outputs.version }} - tags: | - dvcdsys/code-index:${{ steps.ver.outputs.version }} - dvcdsys/code-index:latest + # `openapi=doc` mounts the repo-root doc/ folder so the dashboard + # build stage can `COPY --from=openapi openapi.yaml` without us + # widening the primary build context (which is `server/`). + build-contexts: | + openapi=doc + tags: ${{ steps.tags.outputs.tags }} docker-cuda: - name: Build + push CUDA image (amd64) + name: Build CUDA image (amd64) runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 + with: + ref: ${{ github.event.inputs.ref || github.ref }} - name: Extract version id: ver - run: echo "version=${GITHUB_REF_NAME#server/}" >> "$GITHUB_OUTPUT" - - - uses: docker/setup-buildx-action@v3 - - - uses: docker/login-action@v3 + run: | + if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then + echo "version=${{ github.event.inputs.version }}" >> "$GITHUB_OUTPUT" + echo "floating=${{ github.event.inputs.update_floating_tags }}" >> "$GITHUB_OUTPUT" + else + echo "version=${GITHUB_REF_NAME#server/}" >> "$GITHUB_OUTPUT" + echo "floating=true" >> "$GITHUB_OUTPUT" + fi + + - name: Compose tags + id: tags + run: | + tags="dvcdsys/code-index:${{ steps.ver.outputs.version }}-cu128" + if [ "${{ steps.ver.outputs.floating }}" = "true" ]; then + tags="$tags + dvcdsys/code-index:cu128" + fi + { + echo 'tags<> "$GITHUB_OUTPUT" + + - name: Set up Buildx + uses: docker/setup-buildx-action@v3 + + - name: Login to Docker Hub + uses: docker/login-action@v3 with: username: ${{ secrets.DOCKER_USERNAME }} password: ${{ secrets.DOCKER_PASSWORD }} - - name: Build and push CUDA image + - name: Build and push uses: docker/build-push-action@v6 with: context: server file: server/Dockerfile.cuda platforms: linux/amd64 push: true + provenance: mode=max + sbom: true build-args: VERSION=${{ steps.ver.outputs.version }} - tags: | - dvcdsys/code-index:${{ steps.ver.outputs.version }}-cu128 - dvcdsys/code-index:cu128 + # `openapi=doc` mounts the repo-root doc/ folder so the dashboard + # build stage can `COPY --from=openapi openapi.yaml` without us + # widening the primary build context (which is `server/`). + build-contexts: | + openapi=doc + tags: ${{ steps.tags.outputs.tags }} release: - name: Create GitHub Release + name: Publish release needs: [docker-cpu, docker-cuda] runs-on: ubuntu-latest + # Skip GitHub release creation on manual rebuilds — the release + # already exists for the version being rebuilt. + if: github.event_name == 'push' steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 - name: Extract version id: ver run: echo "version=${GITHUB_REF_NAME#server/}" >> "$GITHUB_OUTPUT" - - name: Create GitHub Release + - name: Create GitHub release uses: softprops/action-gh-release@v2 with: + name: "Server ${{ steps.ver.outputs.version }}" generate_release_notes: true body: | ## Docker Images diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml index 03330d3..5b12ad8 100644 --- a/.github/workflows/security.yml +++ b/.github/workflows/security.yml @@ -1,4 +1,4 @@ -name: Security Scan +name: "Security" on: push: @@ -6,23 +6,25 @@ on: pull_request: branches: [main] schedule: - - cron: "0 6 * * 1" # щопонеділка о 6:00 UTC + - cron: "0 6 * * 1" # Mondays at 06:00 UTC permissions: contents: read - security-events: write # для завантаження SARIF у GitHub Security tab + security-events: write # required for SARIF upload to the Security tab jobs: govulncheck: - name: govulncheck (Go server) + name: govulncheck (server) runs-on: ubuntu-latest defaults: run: working-directory: server steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 - - uses: actions/setup-go@v5 + - name: Set up Go + uses: actions/setup-go@v5 with: go-version-file: server/go.mod cache-dependency-path: server/go.sum @@ -34,10 +36,11 @@ jobs: run: govulncheck ./... trivy: - name: trivy (vuln, second opinion) + name: Trivy (filesystem) runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 - name: Run Trivy uses: aquasecurity/trivy-action@0.35.0 @@ -46,16 +49,15 @@ jobs: scan-ref: . # server/bench is a Phase 0 PoC module (chromem + tree-sitter # benchmarks). It pins an old golang.org/x/net via its own - # go.mod and replace directive, and is never shipped in the - # cix-server binary. Scan it separately if needed, not as part - # of the prod CVE gate. + # go.mod + replace directive and is never shipped in the + # cix-server binary, so it stays out of the prod CVE gate. skip-dirs: server/bench scanners: vuln severity: HIGH,CRITICAL format: sarif output: trivy-results.sarif - - name: Upload Trivy results to GitHub Security + - name: Upload SARIF uses: github/codeql-action/upload-sarif@v3 if: always() with: diff --git a/.gitignore b/.gitignore index e3ef4cf..94f02a6 100644 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,11 @@ __pycache__/ *$py.class *.egg-info/ *.egg -dist/ +# Note: the bare `dist/` rule was scoped to /dist/ (root only) so the +# server/internal/httpapi/dashboard/dist/.gitkeep negation below +# actually works — Git can't re-include a file if a parent directory +# is broadly excluded. +/dist/ build/ .eggs/ *.whl @@ -44,11 +48,25 @@ cli/dist/ server/dist/ server/exec.log +# Dashboard build output — produced by `make dashboard-build`. +# A committed `.gitkeep` keeps dist/ non-empty so `//go:embed all:dist` works +# on a fresh clone (the embed.FS needs at least one entry). The real +# index.html + assets/ tree is produced by `make dashboard-build` and never +# tracked. The handler in dashboard.go returns an inline "please build" +# placeholder when index.html is absent. +server/dashboard/node_modules/ +server/internal/httpapi/dashboard/dist/* +!server/internal/httpapi/dashboard/dist/.gitkeep + # uv .python-version -# Local docs +# Local docs (top-level docs/ is a notebook directory per CLAUDE.md; +# tracked project documentation lives in doc/). Exception below for the +# embedded Swagger UI bundle inside the Go server package. docs/ +!server/internal/httpapi/docs/ +!server/internal/httpapi/docs/** # Claude Code .claude/ diff --git a/CLAUDE-CODE-PLUGIN.md b/CLAUDE-CODE-PLUGIN.md new file mode 100644 index 0000000..908d6cc --- /dev/null +++ b/CLAUDE-CODE-PLUGIN.md @@ -0,0 +1,491 @@ +# Claude Code Plugin (`cix`) + +Official Claude Code plugin for `cix` — semantic code search and navigation. +Installs in two commands, bundles the `cix` CLI, ships slash commands, a +skill, and behavioral hooks that nudge Claude to prefer `cix` over `Grep` +for semantic queries. + +> [!IMPORTANT] +> **The plugin does NOT include the `cix` server.** The plugin only ships +> the CLI client and Claude Code integration glue. You must run a `cix` +> server separately and point the CLI at it (see [Prerequisites](#prerequisites) +> below). Without a reachable server the plugin can install, but `cix` +> commands will fail at runtime. + +--- + +## What you get + +When the plugin is enabled, every Claude Code session in a `cix`-indexed +project automatically gets: + +- **Slash commands** — `/cix:search`, `/cix:def`, `/cix:refs`, `/cix:init`, + `/cix:status`, `/cix:summary`. Invocable manually or by Claude. +- **Bundled `cix` CLI** — the plugin auto-installs `cix` to + `~/.local/bin/` on first use if it isn't already in your `PATH` (no + sudo). If you already installed `cix` system-wide via `install.sh`, + the plugin reuses that binary — no second copy. +- **`cix` skill (`SKILL.md`)** — full usage reference (when to reach for + cix vs Grep, query patterns, scoring landscape, CLI flags). **Lazy-loaded** + by Claude Code — enters context only when invoked, stays once per + session. +- **Behavioral hooks (5 total):** + - **`SessionStart`** — at session start, runs `cix status` (2-second + timeout) to ask the cix-server whether the current project is + registered. The verdict (`1` or `0`) is cached in + `$CLAUDE_PLUGIN_DATA/cix-aware-$SESSION_ID-$DIR_HASH`. On `1`, + injects a one-line reminder. + - **`CwdChanged`** — when Claude changes working directory mid-session + (e.g. via `cd ../other-project`), evaluates cix-awareness for the + NEW directory and caches the verdict. Silent (no reminder) — the + next Grep/Glob call will fire the standard backoff nudge if + appropriate. No-op if the new directory was already evaluated in + this session (Claude bouncing back to a known project). + - **`PreToolUse(Grep|Glob)`** — reads the cache for the current + `(session, project_dir)` pair (~1 ms, no cix call). If the cache + says `1`, occasionally suggests `cix search` instead of Grep, + throttled with **exponential backoff** (fires on call #1, 2, 4, 8, + 16, 32, 64, … *per project*). Each project visited in a session + starts a fresh backoff counter, so the first Grep in a new + cix-aware project always gets a nudge. **Strict policy:** missing + cache or `0` → silent for the entire session in that project. + - **`PostCompact`** — after Claude Code compacts the conversation + (long-running sessions), re-injects the SessionStart reminder if + the current project is cix-aware. Skill bodies survive compaction + natively, but the SessionStart `additionalContext` does not — this + hook keeps cix-awareness alive after compaction without relying on + the skill being invoked yet. + - **`SessionEnd`** — when the session terminates, deletes every + cache file belonging to this session (glob: all `(session, *)` + pairs across every project visited). + +**Cache key includes a project-dir hash** (`shasum -a 256` first 8 +chars), so a single Claude Code session that traverses multiple +projects keeps a separate verdict per project — fresh backoff per +project, correct cix-aware state per directory. + +The strict cache contract means: a session that started while the +cix-server was unreachable will stay in "silent" mode for that project +even if the server comes back online. Restart the Claude Code session +or `cd` away and back to re-evaluate. Better to miss a few nudges than +to pester a developer whose server is down. + +State location: `$CLAUDE_PLUGIN_DATA` is plugin-persistent storage +(`~/.claude/plugins/data/cix-code-index/`) — it survives plugin updates +and is **not** cleaned by the OS, unlike `/tmp` (macOS purges 3-day-old +files daily; Linux clears on reboot). Cleanup is two-tiered: SessionEnd +removes per-session markers on normal exit; SessionStart opportunistically +deletes markers older than 30 days as a safety net for forced kills +(kill -9, OOM, panic). + +--- + +## How it works + +The plugin uses a **4-layer adoption design** so SKILL.md loads at most +once and nudges don't spam the context. + +| Layer | Mechanism | Cost over a 100-prompt session | +|---|---|---| +| 1. Skill description | Native Claude Code (always-in-context, ~200 B) | ~200 B once | +| 2. SessionStart hook | One-time reminder in indexed projects | ~200 B once | +| 3. PreToolUse(Grep\|Glob) hook | Exponential-backoff nudge | ~80 B × ~7 calls = ~560 B | +| 4. SKILL.md body | Native lazy-load (skill mechanism) | ~7 KB **once** if invoked | + +**Total plugin context overhead** in a session that uses cix heavily: +~8 KB. In a session that doesn't touch cix at all: ~400 B (skill +description + slash command metadata). + +The SKILL.md body is **never duplicated** — Claude Code's skill mechanism +guarantees a single insertion that stays in context for the session +([skill content lifecycle docs](https://code.claude.com/docs/en/skills#skill-content-lifecycle)). + +--- + +## Prerequisites + +The plugin is the **client side** of the cix stack. Before installing, +make sure you have: + +### 1. A reachable `cix` server + +The CLI talks to a `cix-server` over HTTP. The server runs separately +(in Docker, natively on macOS, or remotely). See the [main README](README.md) +for the three deployment modes: + +- Docker CPU — `docker compose up -d` +- Docker CUDA (NVIDIA GPU) — `docker compose -f docker-compose.cuda.yml up -d` +- Native macOS (Apple Silicon Metal) — `cd server && make bundle && make run` + +Verify it's up: + +```bash +curl http://localhost:21847/health # → {"status":"ok"} +``` + +If you have a fresh database, the server requires `CIX_BOOTSTRAP_ADMIN_EMAIL` +and `CIX_BOOTSTRAP_ADMIN_PASSWORD` on first boot — see the main README's +Quick Start. + +### 2. The `cix` CLI configured to point at that server + +The CLI configuration is **independent of the plugin**. The plugin uses +whatever config the CLI reads from `~/.cix/config.yaml`. Configure it +once: + +```bash +cix config set api.url http://localhost:21847 +cix config set api.key cix_ +``` + +Get an API key from one of: + +- The dashboard: open `http://localhost:21847/dashboard` → **API Keys** → + mint a new key. +- Your `.env` file: `grep CIX_API_KEY /path/to/code-index/.env | cut -d= -f2`. + +Verify the CLI can reach the server: + +```bash +cix list # should show projects (or "no projects yet") +``` + +> [!IMPORTANT] +> If the CLI is not configured (or the server is unreachable), Claude +> will see error output from `cix` commands. The plugin can't paper +> over a missing server — it's a thin wrapper, not a replacement. + +### 3. Claude Code v2.1.0 or later + +The plugin uses `hookSpecificOutput.additionalContext` for hook-driven +nudges, which requires Claude Code 2.1.0+. Check with `claude --version`. + +--- + +## Installation + +There are three install paths depending on your scenario. + +### Option A — From GitHub (recommended for end users) + +Once the plugin is merged to `main`: + +```bash +claude plugin marketplace add dvcdsys/code-index --sparse .claude-plugin plugins +claude plugin install cix@code-index --scope user +``` + +The `--sparse` flag limits checkout to the plugin directories +(`.claude-plugin/` + `plugins/`), avoiding a full clone of the server, +CLI source, and dashboard build. + +### Option B — From a specific branch or tag (testing / pinned versions) + +```bash +# From a branch (e.g. testing a feature branch) +claude plugin marketplace add dvcdsys/code-index@feat/claude-code-plugin \ + --sparse .claude-plugin plugins + +# From a tag (pinned release) +claude plugin marketplace add dvcdsys/code-index@plugin/v0.1.0 \ + --sparse .claude-plugin plugins + +claude plugin install cix@code-index --scope user +``` + +### Option C — From a local clone (plugin development) + +```bash +git clone https://github.com/dvcdsys/code-index +claude plugin marketplace add /absolute/path/to/code-index +claude plugin install cix@code-index --scope user +``` + +### Choosing the scope + +`--scope user` (default in our examples) — plugin available in every +project. Stored in `~/.claude/settings.json`. **Recommended for personal +use.** + +`--scope project` — committed to `.claude/settings.json`, shared with +teammates via git. Good for team-wide enable. + +`--scope local` — stored in `.claude/settings.local.json`, gitignored. +Only the current project. Useful when testing. + +After install, restart Claude Code (or run `/reload-plugins` in an +existing session) so hooks register. + +--- + +## Verification + +```bash +# Plugin is installed and enabled +claude plugin list +# Expected output (excerpt): +# ❯ cix@code-index +# Version: 0.1.0 +# Scope: user +# Status: ✔ enabled + +# Both manifests pass official validation +claude plugin validate $(claude plugin list --json | jq -r '.[] | select(.id=="cix@code-index").installPath') + +# The bundled CLI wrapper works +$(claude plugin list --json | jq -r '.[] | select(.id=="cix@code-index").installPath')/bin/cix --version +# → cix v0.X.Y +``` + +Then in a Claude Code session inside a cix-indexed project: + +1. Type `/cix` and check autocomplete shows 6 commands (`search`, `def`, + `refs`, `init`, `status`, `summary`). +2. Run `/cix:status` — should print `cix status` output. +3. Ask Claude something semantic ("find the auth middleware") and watch + whether it reaches for `cix search` or falls back to Grep. + +--- + +## Uninstall + +### Plugin only (keep marketplace registered) + +```bash +claude plugin uninstall cix@code-index --scope user +``` + +### Plugin + marketplace + cache (full cleanup) + +```bash +claude plugin uninstall cix@code-index --scope user +claude plugin marketplace remove code-index +rm -rf ~/.claude/plugins/cache/code-index # belt-and-suspenders +``` + +This does **not** uninstall the `cix` CLI itself or stop the cix server +— those are independent. Remove them separately if needed: + +```bash +# Remove the CLI binary if you used the plugin's bootstrap install +rm ~/.local/bin/cix + +# Stop the server +docker compose down # CPU mode +docker compose -f docker-compose.cuda.yml down # CUDA mode +launchctl unload ~/Library/LaunchAgents/com.cix.server.plist # native macOS +``` + +### Troubleshooting "wrong scope" errors + +If `claude plugin uninstall` complains the plugin is in a different +scope, check the master state file: + +```bash +jq '.plugins["cix@code-index"]' ~/.claude/plugins/installed_plugins.json +``` + +This shows every install (with `scope` and, for local installs, +`projectPath`). For local-scope uninstall, `cd` to the registered +`projectPath` first, then re-run the uninstall. + +--- + +## Configuration + +Most plugin behavior is automatic. The few env vars you can set: + +| Variable | Default | Effect | +|---|---|---| +| `CIX_PLUGIN_BIN_DIR` | `$HOME/.local/bin` | Where the wrapper installs `cix` if it isn't on PATH yet. | + +The CLI config (`~/.cix/config.yaml`) is **separate** from the plugin — +the plugin doesn't write to it. Configure the CLI once (see +[Prerequisites](#prerequisites)) and the plugin will use that config. + +### Per-project trigger threshold + +The plugin nudges Claude in projects that `cix status` reports as +**indexed**. The check runs once per session at SessionStart (against +the cix-server) and is cached for the remainder of the session. +PreToolUse(Grep|Glob) only ever reads the cache — it never makes its +own `cix` calls. + +If the cix-server is unreachable at session start, the project is +locked into "silent" mode for the rest of the session. Restart Claude +Code (Cmd+Q + reopen, or `/reload` in CLI) once the server is back to +re-evaluate. + +--- + +## What the plugin does NOT do + +To keep the v0.1 surface focused, the plugin intentionally excludes: + +- **MCP server** — cix isn't exposed as an MCP tool yet (planned for v0.2). + This means the plugin works in Claude Code (CLI + Code mode in Claude + Desktop) but **not** in pure Claude Desktop chat sessions, which only + consume MCP servers. +- **Server lifecycle management** — the plugin will not start, stop, or + configure your `cix-server`. That's intentional: the server is shared + infrastructure (one server can index many projects, used by many + agents and IDEs), not a per-plugin concern. +- **CLI configuration UI** — `cix config set` is the source of truth. + The plugin reads it but doesn't replace it. + +--- + +## Troubleshooting + +### "cix: command not found" inside Claude Code + +The plugin's `bin/` should be on `PATH` while the plugin is enabled. +Check: + +```bash +claude plugin list # plugin enabled? +ls -la ~/.claude/plugins/cache/code-index/cix/*/bin/cix # symlink exists? +``` + +If the symlink is missing, reinstall: +`claude plugin uninstall cix@code-index --scope user && claude plugin install cix@code-index --scope user`. + +### Hooks silent in indexed project + +The hooks rely on `cix status` succeeding at SessionStart. Verify: + +```bash +cix status -p $(pwd) # must exit 0 +echo "exit=$?" +``` + +If `cix status` fails: +- Server unreachable: `curl http://localhost:21847/health` +- API key not set: `cix config show` +- Project not registered: `cix init` + +Once `cix status` exits 0, **restart the Claude Code session** — +SessionStart cached the previous "not indexed" verdict and the +PreToolUse hook reads only that cache. There's no inline retry by +design (a flaky server shouldn't cause intermittent nudges). + +To inspect the current verdict from outside Claude Code: + +```bash +ls -la ~/.claude/plugins/data/cix-code-index/cix-aware-* +cat ~/.claude/plugins/data/cix-code-index/cix-aware- +# "1" → nudges allowed; "0" → silent +``` + +### Hooks too loud / too quiet + +Edit `scripts/grep-nudge.sh` in your local clone of the plugin, change +the power-of-2 check to your taste, and reinstall. Default schedule +(1, 2, 4, 8, 16, …) was chosen to balance "loud at start" with +"fade away". + +### `cix` commands return errors at runtime + +The CLI runs but the server is unreachable, or the API key is invalid. +Verify each step from [Prerequisites](#prerequisites): + +```bash +curl http://localhost:21847/health +cix config show +cix list +``` + +### Two duplicate entries in `claude plugin list` + +This usually means you installed the plugin in two scopes (e.g. `local` +plus `user`). Check the master state: + +```bash +jq '.plugins["cix@code-index"]' ~/.claude/plugins/installed_plugins.json +``` + +Uninstall from the unwanted scope (you may need to `cd` to the +registered `projectPath` for local-scope uninstall). + +### Plugin installs but slash commands don't appear + +Slash commands are loaded at session start. After install, run +`/reload-plugins` in an existing Claude Code session, or quit and +re-open Claude Code. + +--- + +## Security & testing + +The plugin runs bash scripts on every Claude Code session, with calls +that include `find -delete` against `$CLAUDE_PLUGIN_DATA`. Safety comes +from **what we delete**, not **where the directory lives** — every +deletion is gated by file-level filters that practically cannot match +anything except our own marker files: + +1. **Restrictive find filters.** Every `find -delete` uses: + - `-maxdepth 1` — never recurses into subdirectories + - `-type f` — files only (skips dirs and symlinks) + - `-name 'cix-aware-*'` / `-name 'cix-grep-count-*'` — exact prefix + match on our marker names; for `session-end.sh` the pattern also + embeds the current `$SESSION_ID` (a Claude-Code-assigned UUID), + so it cannot match other sessions' files + + `rm -rf` is not used anywhere in the plugin. There is no path on + which a hook script could touch a file that doesn't already match + the strict name pattern, regardless of how `$CLAUDE_PLUGIN_DATA` is + configured. This means **custom data dirs work fine** — corporate + setups, XDG-style layouts, or alternative paths are all supported. + +2. **Automated test suite.** `plugins/cix/tests/` contains 41 + [bats-core](https://bats-core.readthedocs.io/) tests covering all 6 + hook scripts. Adversarial cases include: + - `session_id` containing shell metacharacters — must not inject + commands (canary file survives) + - Other sessions' cache files — must not be touched + - Files with similar-but-different names (`cix-other-pattern`, + `X-cix-aware-fake-...`, `cix` alone) — must not be touched + - Subdirectories in the cache dir — must not be touched (no recursion) + - 30-day GC — must spare files outside the cix-prefixed patterns + - Custom non-standard `$CLAUDE_PLUGIN_DATA` — must work without + deleting unrelated files in that dir + - Path-with-spaces project dirs — must hash correctly + + GitHub Actions runs the suite on Ubuntu and macOS for every PR + that touches `plugins/cix/` or `.claude-plugin/`. ShellCheck runs + alongside, gating warnings. + +To run tests locally: + +```bash +brew install bats-core jq shellcheck # macOS +sudo apt-get install bats jq shellcheck # Debian / Ubuntu + +bats plugins/cix/tests/*.bats +shellcheck --severity=warning plugins/cix/scripts/*.sh +``` + +See [`plugins/cix/tests/README.md`](plugins/cix/tests/README.md) for +the full test matrix and instructions for adding new cases. + +## Roadmap + +**v0.2** (after v0.1 feedback): + +- **MCP server** exposing `cix_search`, `cix_definitions`, `cix_references` + as native Claude tools, so cix becomes available in Claude Desktop chat + and any other MCP-compatible client. +- **`PreToolUse(Bash)` hook** that catches inline `grep` calls (not just + the `Grep` tool) and routes them through cix where appropriate. +- **`cix-explorer` subagent** preconfigured for codebase exploration tasks + (`Skill: cix` + read-only tool whitelist + `context: fork`). + +**v0.3+:** auto-`cix init` on first use, hot-reload of the skill from +git after a `cix reindex`, distribution as an officially-listed plugin +in `claude-plugins-official`. + +--- + +## License + +MIT — same as the parent project. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ee61ac8..499dcce 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -12,7 +12,6 @@ code-index/ ├── cli/ # Go CLI (cix binary) │ ├── cmd/ # cobra commands │ └── internal/ # client, config, daemon, indexer, watcher -├── legacy/python-api/ # archived Python backend (deprecated, see doc/MIGRATION_FROM_PYTHON.md) └── skills/ # Claude Code skill definitions ``` diff --git a/Makefile b/Makefile index 92add01..54ad72b 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: help build test bundle test-gate docker-build-cuda clean +.PHONY: help build test bundle test-gate docker-build-cuda docker-build-cuda-dev clean -help build test bundle test-gate docker-build-cuda clean: +help build test bundle test-gate docker-build-cuda docker-build-cuda-dev clean: @$(MAKE) -C server $@ diff --git a/README.md b/README.md index e516c04..81dd0d3 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@ -[![Release Server](https://github.com/dvcdsys/code-index/actions/workflows/release-server.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/release-server.yml) +[![CI: Server](https://github.com/dvcdsys/code-index/actions/workflows/ci-server.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/ci-server.yml) +[![CI: CLI](https://github.com/dvcdsys/code-index/actions/workflows/ci-cli.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/ci-cli.yml) +[![CodeQL](https://github.com/dvcdsys/code-index/actions/workflows/codeql.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/codeql.yml) +[![Security](https://github.com/dvcdsys/code-index/actions/workflows/security.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/security.yml) ``` ██████╗██╗██╗ ██╗ @@ -9,11 +12,12 @@ ╚═════╝╚═╝╚═╝ ╚═╝ Code IndeX ``` -[![Release CLI](https://github.com/dvcdsys/code-index/actions/workflows/release-cli.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/release-cli.yml) +[![Release: Server](https://github.com/dvcdsys/code-index/actions/workflows/release-server.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/release-server.yml) +[![Release: CLI](https://github.com/dvcdsys/code-index/actions/workflows/release-cli.yml/badge.svg)](https://github.com/dvcdsys/code-index/actions/workflows/release-cli.yml) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Docker Hub](https://img.shields.io/docker/pulls/dvcdsys/code-index)](https://hub.docker.com/r/dvcdsys/code-index) -Search your codebase by meaning, not just text. Self-hosted, embeddings-based, works with any agent or terminal. +Search your codebase by meaning, not just text. Self-hosted, embeddings-based, works with any agent or terminal — and now with a full web dashboard. ```bash cix search "authentication middleware" @@ -21,6 +25,8 @@ cix search "database retry logic" --in ./api --lang go cix symbols "UserService" --kind class ``` +Or open `http://localhost:21847/dashboard` in your browser. + --- ## Why @@ -35,58 +41,85 @@ Grep and fuzzy file search work fine for small projects. At scale they break dow --- -## Architecture +## What you get -``` -cix CLI (Go) -├── init → register project + index + start file watcher -├── search → semantic search (embeddings) -├── symbols → symbol lookup by name (SQLite) -├── files → file path search -├── summary → project overview -├── reindex → manual reindex trigger -└── watch → fsnotify daemon → auto reindex on changes +- **`cix-server`** — Go HTTP API with embedded llama.cpp sidecar for embeddings, SQLite for symbols + project metadata, chromem-go for vectors. Ships as a single distroless container. +- **Web dashboard** at `/dashboard` — projects, semantic search, user + API-key management, runtime sidecar control, drift indicator. Embedded directly into the server binary. +- **`cix` CLI** — drop-in `cix search`/`cix symbols`/`cix files` commands for terminal + agent use. +- **File watcher** — `cix watch` keeps the index fresh as you edit, no manual reindex. +- **OpenAPI as source of truth** — Go server interface + TypeScript dashboard types are generated from `doc/openapi.yaml`. Swagger UI at `/docs`. -cix-server (Go) — server/ -├── llama-server (llama.cpp sidecar) → embeddings (CodeRankEmbed Q8_0 GGUF, 768d) -├── chromem-go → vector store (cosine similarity) -├── gotreesitter → AST chunking (200+ languages) -└── modernc.org/sqlite → project metadata, symbols, file hashes -``` +--- -The server is a pure-Go static binary. The CLI is a thin Go binary that talks to it over HTTP. -The `llama-server` sidecar (from upstream [llama.cpp](https://github.com/ggml-org/llama.cpp)) handles embeddings — the Go process starts it as a child process and communicates via Unix socket. +## Architecture + +``` + ┌────────────────────────────────────┐ + │ Browser → http://host:21847 │ + │ ─────────────────────────│ + │ • /dashboard React SPA │ + │ • /docs Swagger UI │ + │ • /openapi.json │ + └────────────┬───────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────────────────┐ +│ cix-server (Go, single distroless binary) │ +├─────────────────────────────────────────────────────────────────┤ +│ HTTP/REST + cookie sessions + Bearer API keys │ +│ ├── auth, admin, api-keys, projects, indexing, search │ +│ ├── embedded React dashboard (//go:embed all:dist) │ +│ └── embedded Swagger UI │ +│ │ +│ Indexing pipeline │ +│ ├── gotreesitter (AST chunking, 200+ languages) │ +│ ├── llama-server sidecar (Unix socket → CodeRankEmbed Q8 GGUF) │ +│ ├── chromem-go (cosine similarity vector store) │ +│ └── modernc.org/sqlite (projects, symbols, file hashes) │ +└────────────┬─────────────────────────────────────┬──────────────┘ + │ HTTP │ Unix socket + ▼ ▼ + cix CLI (Go) — search, ┌──────────────────────────┐ + symbols, files, init, │ llama-server child proc │ + reindex, watch │ (llama.cpp embeddings) │ + └──────────────────────────┘ +``` + +The server is a pure-Go static binary; CUDA-image variants add a `libcublas` runtime layer for GPU embeddings. --- ## Quick Start -### 1. Start the API Server +### 1. Start the server -Three deployment options: +Three deployment modes: -| Mode | Best for | GPU acceleration | Prerequisites | -|------|----------|-----------------|---------------| -| **Docker (CPU)** | any OS, development | none | Docker | -| **Docker (CUDA)** | NVIDIA GPU servers | CUDA | Docker, NVIDIA Container Toolkit | -| **Native (macOS)** | Apple Silicon — full Metal GPU | Metal | Go 1.24+, Xcode CLT | +| Mode | Best for | GPU | Prerequisites | +|------|----------|-----|---------------| +| **Docker (CPU)** | any OS, dev / small repos | none | Docker | +| **Docker (CUDA)** | NVIDIA GPU servers | CUDA 12.x | Docker + NVIDIA Container Toolkit | +| **Native (macOS)** | Apple Silicon w/ full Metal | Metal | Go 1.25+, Xcode CLT | #### Docker (CPU) ```bash git clone https://github.com/dvcdsys/code-index && cd code-index cp .env.example .env -# Edit .env — set CIX_API_KEY to a random string +# Edit .env — set CIX_API_KEY, CIX_BOOTSTRAP_ADMIN_EMAIL, CIX_BOOTSTRAP_ADMIN_PASSWORD docker compose up -d ``` ```bash -curl http://localhost:21847/health # → {"status": "ok"} +curl http://localhost:21847/health # → {"status":"ok"} ``` +> [!IMPORTANT] +> On a fresh database the server **refuses to start** unless both `CIX_BOOTSTRAP_ADMIN_EMAIL` and `CIX_BOOTSTRAP_ADMIN_PASSWORD` are set. The user is created with `must_change_password=true`, so the temporary password only works for the first login. + #### Docker (CUDA — NVIDIA GPU) -See [GPU Acceleration (CUDA)](#gpu-acceleration-cuda) section below. +See [GPU Acceleration (CUDA)](#gpu-acceleration-cuda) below. ```bash docker compose -f docker-compose.cuda.yml up -d @@ -94,54 +127,29 @@ docker compose -f docker-compose.cuda.yml up -d #### Native macOS (Apple Silicon — Metal GPU) -> **Why not Docker?** Docker Desktop on macOS runs containers inside a Linux VM — Metal GPU is **not accessible** from within a container. For full Apple Silicon GPU acceleration you must run the server natively. - -**Prerequisites:** Go 1.24+, Xcode Command Line Tools - -```bash -xcode-select --install # if not already installed -``` - -**Step 1 — Build binary + download Metal-enabled llama-server (once)** - -```bash -cd server -make bundle -# Outputs: -# dist/cix-darwin-arm64/cix-server -# dist/cix-darwin-arm64/llama/llama-server (includes libggml-metal.dylib) -``` - -**Step 2 — Configure** +> **Why not Docker?** Docker Desktop on macOS runs containers inside a Linux VM — Metal GPU is **not accessible** from within a container. For full Metal acceleration you must run natively. ```bash +xcode-select --install # if not installed +cd server && make bundle # builds cix-server + downloads Metal-enabled llama-server cp .env.example .env -# Edit .env — set at minimum: -# CIX_API_KEY=cix_ -# CIX_N_GPU_LAYERS=99 ← offload all layers to Metal -``` - -**Step 3 — Run** - -```bash +# Set CIX_API_KEY, CIX_BOOTSTRAP_ADMIN_EMAIL, CIX_BOOTSTRAP_ADMIN_PASSWORD +# Set CIX_N_GPU_LAYERS=99 for full Metal offload cd server && make run -# Reads .env from repo root, sets CIX_LLAMA_BIN_DIR automatically. ``` -```bash -curl http://localhost:21847/health # → {"status": "ok"} -``` +Native env-var summary for Metal: | Variable | Recommended | Notes | |---|---|---| | `CIX_N_GPU_LAYERS` | `99` | Offload all layers to Metal; `0` = CPU only | -| `CIX_LLAMA_BIN_DIR` | set by `make run` | Path to the `llama-server` binary dir | -| `CIX_EMBEDDINGS_ENABLED` | `true` | Enable GPU embeddings (default) | +| `CIX_LLAMA_BIN_DIR` | set by `make run` | Path to the `llama-server` bundle dir | +| `CIX_EMBEDDINGS_ENABLED` | `true` | Default. Set `false` to skip the sidecar entirely | > [!TIP] -> `make run` always runs `make bundle` first (no-op if already built), so it's safe to use after any `git pull`. +> `make run` runs `make bundle` first (no-op if already built), so it's safe after any `git pull`. -**Auto-start with launchd** (optional — run server in the background on login): +**Auto-start with launchd** (optional — run as a background service on login): ```bash cat > ~/Library/LaunchAgents/com.cix.server.plist << 'EOF' @@ -154,6 +162,8 @@ cat > ~/Library/LaunchAgents/com.cix.server.plist << 'EOF' EnvironmentVariables CIX_API_KEYYOUR_KEY + CIX_BOOTSTRAP_ADMIN_EMAILadmin@example.com + CIX_BOOTSTRAP_ADMIN_PASSWORDchange-me-on-first-login CIX_LLAMA_BIN_DIR/ABSOLUTE/PATH/TO/server/dist/cix-darwin-arm64/llama CIX_N_GPU_LAYERS99 CIX_PORT21847 @@ -167,49 +177,56 @@ cat > ~/Library/LaunchAgents/com.cix.server.plist << 'EOF' StandardErrorPath/tmp/cix-server.err EOF -# Replace /ABSOLUTE/PATH/TO and YOUR_USER/YOUR_KEY with real values, then: launchctl load ~/Library/LaunchAgents/com.cix.server.plist launchctl start com.cix.server ``` -### 2. Install the CLI +### 2. Log in to the dashboard + +Open http://localhost:21847/dashboard in your browser. + +1. Sign in with the email + password you set as `CIX_BOOTSTRAP_ADMIN_*` env vars. +2. You'll be **forced to change the password** on first login. Pick a real one. +3. Land on the home screen — see [Dashboard](#dashboard) for what's there. + +### 3. Install the CLI -**Option A: one-line installer (macOS / Linux)** +**Option A — one-line installer (macOS / Linux):** ```bash curl -fsSL https://raw.githubusercontent.com/dvcdsys/code-index/main/install.sh | bash ``` -**Option B: from source** +**Option B — from source:** ```bash -cd cli -make build && make install # → /usr/local/bin/cix +cd cli && make build && make install # → /usr/local/bin/cix ``` -Or without Make: +**Option C — without Make:** ```bash cd cli && go build -o cix . && sudo mv cix /usr/local/bin/ ``` -### 3. Configure +### 4. Configure the CLI ```bash -# Point cix at your server (API key is in .env) cix config set api.url http://localhost:21847 cix config set api.key $(grep CIX_API_KEY .env | cut -d= -f2) ``` -### 4. Index a Project +Or mint a fresh API key from the dashboard's **API Keys** page and paste that. + +### 5. Index a project ```bash cd /path/to/your/project -cix init # registers, indexes, starts file watcher daemon -cix status # wait until: Status: ✓ Indexed +cix init # registers + indexes + starts the file watcher +cix status # wait for: Status: ✓ Indexed ``` -### 5. Search +### 6. Search ```bash cix search "authentication middleware" @@ -219,19 +236,57 @@ cix files "config" cix summary ``` +…or use the dashboard's **Search** page for the same five modes. + +--- + +## Dashboard + +The dashboard ships embedded in the server binary at `/dashboard`. No extra service to run, no nginx config, no separate static-files volume. + +| Page | Audience | What it does | +|------|----------|--------------| +| **Home** | everyone | Live status strip (server version, current embedding model, sidecar Ready/Loading) + module shortcuts | +| **Projects** | everyone | List indexed projects, view stats (file count, languages, symbols, vector count, sqlite/chroma sizes), copy reindex commands. Cards turn **red with "Stale model"** badge when the runtime embedding model differs from the model the project was indexed with — see [Drift indicator](#drift-indicator). | +| **Search** | everyone | Five modes: semantic, symbols, references, definitions, files. Same engine the CLI uses. | +| **API Keys** | everyone | Mint long-lived `cix_*` keys (256-bit entropy, GitHub-class), copy them once, revoke at any time. | +| **Users** | admin | Invite teammates, set role (admin/viewer), reset password (forces change on next login), disable account. | +| **Settings** | everyone | Theme, default editor, change own password. | +| **Server** | admin | Runtime config — embedding model, `n_ctx`, `n_gpu_layers`, `n_threads`, batch size, queue concurrency. **Save & Restart** drains in-flight embeddings, restarts the sidecar, polls until ready. Source pill on each field shows whether the live value comes from the DB override, env bootstrap, or the recommended fallback. | + +### Authentication + +Two paths share the same identity model: + +- **Cookie session** (browser) — `cix_session` HttpOnly cookie, 14-day rolling TTL, `sha256(token)` stored in DB. The raw token never leaves the browser. +- **Bearer API key** (CLI / agents / CI) — `Authorization: Bearer cix_<43-char-base64url>` header. 256 bits of entropy, hex-`sha256`-stored, scoped to the issuing user's role. + +### Drift indicator + +When you change the runtime embedding model (Server → Embedding model → Save & Restart), every project that was indexed with the previous model becomes stale — the vectors are no longer comparable to fresh queries. The dashboard surfaces this: + +- **Projects list:** stale projects render with `border-destructive` + a `Stale model` badge. +- **Project detail page:** a banner "Indexed with ``; current runtime model is ``. Vectors may be incompatible." with a copy-to-clipboard `cix reindex /path` command. + +After running the reindex, the drift signal clears automatically. + +### Disabled-embeddings mode + +Set `CIX_EMBEDDINGS_ENABLED=false` to bring the server up without the llama-server sidecar — auth, dashboard, project metadata, and symbol/file searches all keep working; only semantic search and indexing are disabled. The Server page renders a warning banner and disables the relevant inputs. + --- ## CLI Reference ### Project Management - | Command | Description | |---------|-------------| | `cix init [path]` | Register + index + start file watcher | | `cix status` | Show indexing status and progress | | `cix list` | List all indexed projects | | `cix reindex [--full]` | Trigger manual reindex | +| `cix cancel` | Cancel an in-flight indexing run | | `cix summary` | Project overview: languages, directories, symbols | ### Search @@ -240,9 +295,10 @@ cix summary # Semantic search — natural language, finds by meaning cix search [flags] --in restrict to file or directory (repeatable) + --exclude exclude file or directory (repeatable) --lang filter by language (repeatable) --limit, -l max results (default: 10) - --min-score <0-1> minimum relevance score (default: 0.1) + --min-score <0-1> minimum relevance score (default: 0.4) -p project path (default: cwd) # Symbol search — fast lookup by name @@ -250,7 +306,11 @@ cix symbols [flags] --kind function | class | method | type (repeatable) --limit, -l max results (default: 20) -# File search +# Definition / reference navigation +cix definitions [--kind ] [--file ] [--limit ] +cix references [--file ] [--limit ] + +# File search by path pattern cix files [--limit ] ``` @@ -263,7 +323,7 @@ cix watch stop # stop daemon cix watch status # check if running ``` -The watcher monitors the project with `fsnotify`, debounces events (5s), and triggers incremental reindexing automatically. Logs: `~/.cix/logs/watcher.log`. +The watcher monitors the project with `fsnotify`/`rjeczalik/notify`, debounces events (5 s default), and triggers incremental reindexing automatically. Logs: `~/.cix/logs/watcher.log`. ### Configuration @@ -278,9 +338,9 @@ Config file: `~/.cix/config.yaml` | Key | Default | Description | |-----|---------|-------------| | `api.url` | `http://localhost:21847` | API server URL | -| `api.key` | — | Bearer token for API auth (required) | -| `watcher.debounce_ms` | `5000` | Delay in ms before reindex is triggered after a file change | -| `indexing.batch_size` | `20` | Number of files sent to the server per indexing batch | +| `api.key` | — | Bearer token (`cix_*`) — required | +| `watcher.debounce_ms` | `5000` | Delay before reindex triggers after a file change | +| `indexing.batch_size` | `20` | Files per `/index/files` batch | --- @@ -290,21 +350,52 @@ Config file: `~/.cix/config.yaml` ### Claude Code -Install the bundled skill so Claude knows to use `cix` automatically: +Two integration paths — pick whichever fits your setup. + +#### Option A — Plugin (recommended) + +The official `cix` Claude Code plugin bundles the skill, slash commands +(`/cix:search`, `/cix:def`, `/cix:refs`, `/cix:init`, `/cix:status`, +`/cix:summary`), the CLI auto-bootstrap, and behavioral hooks that nudge +Claude to prefer `cix` over Grep for semantic queries. + +```bash +claude plugin marketplace add dvcdsys/code-index --sparse .claude-plugin plugins +claude plugin install cix@code-index --scope user +``` + +> The server still runs separately, and the CLI must be configured to +> point at it (steps above in [Quick Start](#quick-start)). +> +> See **[CLAUDE-CODE-PLUGIN.md](CLAUDE-CODE-PLUGIN.md)** for full details: +> prerequisites, install paths (branch / tag / local clone), +> verification, configuration, uninstall, and troubleshooting. + +#### Option B — Skill (manual, legacy) + +For environments without plugin support, copy the bundled skill manually: ```bash cp -r skills/cix ~/.claude/skills/cix ``` -Then in any Claude Code session: +Then in any Claude Code session, invoke the skill **paired with the actual engineering task** — not a search query. The pattern is `/cix `: ``` -/cix +/cix fix the watcher hanging on files >10MB and add a regression test +/cix implement rate limiting on /api/v1/webhook with the same limiter + pattern as /auth/login +/cix investigate why semantic search returns zero hits on the security + package after the last reindex +/cix refactor the embedding queue to use a ring buffer instead of slice + grow-and-truncate ``` -This loads search guidance into context. Claude will use `cix search` instead of Grep. +The slash command primes Claude with cix usage guidance; the task that follows is what Claude actually executes. Throughout the work, Claude reaches for `cix search` / `cix definitions` / `cix references` to navigate the codebase **as a tool inside the task**, not as the task itself. This is the right mental model: cix is the agent's IDE — `goto-def`, `find-refs`, "what calls this" — that lets it understand unfamiliar code before changing it. -To activate in every session without typing `/cix`, add to `~/.claude/CLAUDE.md`: +A bare `/cix` works (yields a generic "ready to search" reply), and a search-style prompt like `/cix find X` works (Claude does one search and stops). Neither captures the real value. Pairing the skill with a real task — fix, implement, investigate, refactor — is what makes the agent meaningfully more useful than grep + reading files. + +To activate in every session without typing `/cix` (so cix becomes the default reflex for any code-search question), add to `~/.claude/CLAUDE.md`: ```markdown ## Code search @@ -316,9 +407,9 @@ Use `cix` for all code search instead of Grep/Glob: Run `cix init` on first use in a project. ``` -### Other Agents +### Other agents -Same pattern — give the agent access to shell execution and describe the commands: +Same pattern — give the agent shell execution and describe the commands: ``` Tool: shell @@ -326,22 +417,18 @@ Usage: cix search "what you're looking for" [--in ./subdir] [--lang python] Returns: ranked code snippets with file paths and line numbers ``` -### Typical Agent Workflow +### Typical agent workflow ```bash -# First time in a project -cix init /path/to/project +cix init /path/to/project # first time -# Explore -cix summary +cix summary # explore cix search "main entry point" -# Find specific code -cix search "JWT token validation" +cix search "JWT token validation" # find specific code cix symbols "ValidateToken" --kind function -# Navigate -cix search "who calls ValidateToken" +cix references ValidateToken # navigate cix search "error handling in auth flow" --in ./api ``` @@ -351,13 +438,65 @@ cix search "error handling in auth flow" --in ./api **Chunking** — tree-sitter parses code into semantic chunks (functions, classes, methods). Unsupported languages fall back to a sliding window (2000 chars, 256 char overlap). -Supported languages: Python, TypeScript, JavaScript, Go, Rust, Java (+ 40+ others via fallback). +Supported languages: Python, TypeScript, JavaScript, Go, Rust, Java, C, C++, C#, Ruby, PHP, Swift, Kotlin, Scala, Bash, SQL, Markdown, HTML, CSS, and 30+ more. + +**Embeddings** — each chunk is encoded with a GGUF build of CodeRankEmbed (default: [awhiteside/CodeRankEmbed-Q8_0-GGUF](https://huggingface.co/awhiteside/CodeRankEmbed-Q8_0-GGUF); 768d, 8192-token context, ~145 MB on disk) via the `llama-server` sidecar (llama.cpp). Queries get a `"Represent this query for searching relevant code: "` prefix for asymmetric retrieval. -**Embeddings** — each chunk is encoded with a GGUF build of CodeRankEmbed (default: [awhiteside/CodeRankEmbed-Q8_0-GGUF](https://huggingface.co/awhiteside/CodeRankEmbed-Q8_0-GGUF); 768d, 8192 token context, ~145MB on disk) via the `llama-server` sidecar (llama.cpp). Queries get a `"Represent this query for searching relevant code: "` prefix for asymmetric retrieval. +**Path-aware preamble** — each chunk is embedded with its file path, language, and parent symbol prefixed. This makes "auth middleware" find `auth.go` even if the file content uses different vocabulary. Toggle with `CIX_EMBED_INCLUDE_PATH` (default `true`); changing it requires `cix reindex --full`. -**Incremental reindex** — uses SHA256 file hashes. Only new or changed files are re-embedded. Deleted files are removed from the index. +**Incremental reindex** — uses SHA-256 file hashes. Only new or changed files are re-embedded. Deleted files are removed from the index. -**Filtering** — respects `.gitignore` and `.cixignore`, skips common dirs (`node_modules`, `.git`, `.venv`, etc.), skips files >512KB and empty files. Per-project configuration via `.cixconfig.yaml` (see below). +**Filtering** — respects `.gitignore` and `.cixignore`, skips common dirs (`node_modules`, `.git`, `.venv`, etc.), skips files >`CIX_MAX_FILE_SIZE` (512 KiB default) and empty files. Per-project configuration via `.cixconfig.yaml` (see below). + +--- + +## Tuning Search Quality + +### `--min-score` threshold + +`cix` defaults to `--min-score 0.4`. This is calibrated for **CodeRankEmbed-Q8_0** with the path-aware embedding format (`CIX_EMBED_INCLUDE_PATH=true`, default). + +A typical score landscape on a real codebase: + +| Match strength | Score range | Action | +|---|---|---| +| Exact symbol or filename match | 0.65 – 0.80 | rare; very high confidence | +| Strong path-aware concept match | 0.50 – 0.65 | typical "good" match for `cix search "cli watch daemon"` | +| Weaker concept / partial path overlap | 0.40 – 0.50 | typical for ambiguous or multi-token queries | +| Likely unrelated noise | < 0.40 | filtered out by default | + +**When to lower the threshold**: + +- The query returns `No results` but you know matching code exists — try `--min-score 0.25` +- Your query is intentionally vague (exploring an unfamiliar codebase) — `--min-score 0.2` +- Single-word identifier queries on rare names + +**When to raise the threshold**: + +- Agent context is filling up with weak matches — `--min-score 0.5` +- You only want clear top hits — `--min-score 0.6` + +> [!NOTE] +> CodeRankEmbed is **asymmetric**: queries get a `"Represent this query for searching relevant code: "` prefix, which puts query and passage vectors into separate regions of the embedding space. Cosine similarities are systematically lower than for symmetric models — a "strong" match here is 0.55, not 0.80. Don't compare these numbers to thresholds quoted for OpenAI / Voyage / generic sentence-transformers. + +> [!TIP] +> If you switched embedding models or toggled `CIX_EMBED_INCLUDE_PATH`, run `cix reindex --full` and recalibrate. Old vectors and new vectors live in the same store but score differently. + +### `--exclude` for noisy directories + +Repos with vendored code, fixtures, or legacy migrations can pull unrelated paths into top results because path tokens contribute to scoring. Two options: + +```bash +# One-off exclude for a single search +cix search "main entry point" --exclude vendor --exclude bench/fixtures + +# Permanent exclude — add to .cixignore (skips indexing entirely) +echo "vendor/" >> .cixignore +echo "bench/fixtures/" >> .cixignore +cix reindex --full +``` + +`.cixignore` is preferred for directories you never want in results — they don't take up index space. `--exclude` is a per-query escape hatch. --- @@ -377,25 +516,18 @@ generated/ testdata/fixtures/ ``` -Nested `.cixignore` files work like nested `.gitignore` — they apply to their directory and below, without affecting sibling directories. - -The file watcher automatically triggers a full reindex when `.cixignore` is created, modified, or deleted. +Nested `.cixignore` files work like nested `.gitignore` — they apply to their directory and below, without affecting sibling directories. The file watcher automatically triggers a full reindex when `.cixignore` is created, modified, or deleted. ### `.cixconfig.yaml` — project-level settings -Place this file in the project root. Currently supports automatic git submodule exclusion. +Place this in the project root. Currently supports automatic git submodule exclusion: ```yaml -# .cixconfig.yaml ignore: submodules: true # automatically exclude all git submodule paths ``` -When `ignore.submodules` is `true`, cix reads `.gitmodules` and excludes all submodule paths from indexing. No git binary is required — the file is parsed directly. - -This is useful for projects with Foundry/Forge dependencies, vendored submodules, or any repo where submodules contain thousands of files you don't want indexed. - -**Example:** a project with 228 own files and 3,400+ files in nested submodules — after adding `ignore.submodules: true`, only the 228 project files are indexed. +When `ignore.submodules` is `true`, cix reads `.gitmodules` and excludes all submodule paths from indexing. No git binary required — the file is parsed directly. Useful for Foundry/Forge dependencies, vendored submodules, or any repo where submodules contain thousands of files you don't want indexed. The file watcher triggers a full reindex when `.cixconfig.yaml` changes. @@ -403,60 +535,90 @@ The file watcher triggers a full reindex when `.cixconfig.yaml` changes. ## Configuration Reference -### Server Environment Variables (`.env`) +### Server environment variables -See `.env.example` for a complete template. +Complete list. See `.env.example` for the operator-facing template. + +#### Auth + bootstrap | Variable | Default | Description | -|----------|---------|-------------| -| `CIX_API_KEY` | — | Bearer token for API auth | -| `CIX_PORT` | `21847` | API server port | -| `CIX_EMBEDDING_MODEL` | `awhiteside/CodeRankEmbed-Q8_0-GGUF` | HuggingFace GGUF repo | -| `CIX_MAX_FILE_SIZE` | `524288` | Skip files larger than this (bytes) | -| `CIX_EXCLUDED_DIRS` | `node_modules,.git,.venv,...` | Comma-separated dirs to skip | -| `CIX_N_GPU_LAYERS` | auto | `99` offloads all layers to GPU; `0` forces CPU | -| `CIX_GGUF_CACHE_DIR` | `/data/models` | Where the GGUF file is cached | -| `CIX_LLAMA_BIN_DIR` | `/app` | Directory containing `llama-server` binary | -| `CIX_LLAMA_STARTUP_TIMEOUT` | `60` | Seconds to wait for llama-server ready | -| `CIX_EMBEDDINGS_ENABLED` | `true` | Set to `false` to skip embeddings (CPU-only mode) | -| `CIX_CHROMA_PERSIST_DIR` | `/data/chroma` | Vector store path | -| `CIX_SQLITE_PATH` | `/data/sqlite/projects.db` | SQLite database path | - -Data is stored in `/data` inside the container — mount a volume to persist it. +|---|---|---| +| `CIX_API_KEY` | — | Header API key for direct CLI / CI traffic. On first boot it's imported as the bootstrap admin's `env-bootstrap` key. | +| `CIX_BOOTSTRAP_ADMIN_EMAIL` | — | **Required on a fresh DB.** Seeds the first admin user. Ignored once the users table is non-empty. | +| `CIX_BOOTSTRAP_ADMIN_PASSWORD` | — | **Required on a fresh DB.** The user is flagged `must_change_password=true`, so this only works for the first login. | +| `CIX_AUTH_DISABLED` | `false` | **Dev only.** Skips auth on every endpoint — every request behaves as admin. Never set in production. | + +#### Networking + storage + +| Variable | Default | Description | +|---|---|---| +| `CIX_PORT` | `21847` | Listen port (both Docker images bake this in). | +| `CIX_SQLITE_PATH` | `/data/sqlite/projects.db` | SQLite path. Suffixed with the model-safe name on open. | +| `CIX_CHROMA_PERSIST_DIR` | `/data/chroma` | Vector store directory. | +| `CIX_GGUF_CACHE_DIR` | `/data/models` | Where downloaded GGUF files live. | + +#### Indexing + +| Variable | Default | Description | +|---|---|---| +| `CIX_EMBEDDING_MODEL` | `awhiteside/CodeRankEmbed-Q8_0-GGUF` | HuggingFace GGUF repo (or absolute path to a `.gguf`). | +| `CIX_MAX_FILE_SIZE` | `524288` | Skip files larger than this (bytes). | +| `CIX_EXCLUDED_DIRS` | `node_modules,.git,.venv,...` | Comma-separated dirs always skipped. | +| `CIX_LANGUAGES` | all | Comma-separated allow-list of chunker languages. Empty = all baked-in. | +| `CIX_EMBED_INCLUDE_PATH` | `true` | Path/language/symbol preamble before each chunk. Toggling requires `cix reindex --full`. | +| `CIX_MAX_CHUNK_TOKENS` | `1500` | Max chunk size before falling back to sliding window. Must stay ≤ `CIX_LLAMA_CTX`. | + +#### llama-server sidecar + +| Variable | Default | Description | +|---|---|---| +| `CIX_EMBEDDINGS_ENABLED` | `true` | Set `false` to boot without the sidecar (read-only mode). | +| `CIX_LLAMA_BIN_DIR` | `/app` (Docker) / `/llama` (native) | Directory containing `llama-server` + dylibs. | +| `CIX_LLAMA_TRANSPORT` | `unix` | `unix` or `tcp`. Auto-falls-back to TCP if the socket path is too long. | +| `CIX_LLAMA_SOCKET` | `${TMPDIR}/cix-llama-.sock` | Unix socket path. macOS `sun_path` cap = 104 bytes. | +| `CIX_LLAMA_CTX` | `2048` | `--ctx-size` passed to llama-server. | +| `CIX_N_GPU_LAYERS` | `-1` darwin / `0` else / `99` Docker CUDA | `99` offloads all layers; `0` forces CPU. | +| `CIX_LLAMA_STARTUP_TIMEOUT` | `60` | Seconds to wait for the sidecar's readiness probe. | +| `CIX_GGUF_PATH` | auto-resolve | Absolute path to a GGUF file. Empty → cache lookup → HF download. | +| `CIX_BOOTSTRAP_GGUF_PATH` | — | Optional. If set, cix imports this `.gguf` into `CIX_GGUF_CACHE_DIR` once (atomic `.partial → rename`) and ignores the env on subsequent boots. Useful for skipping the first-boot HF download in air-gapped or rate-limited environments. | + +#### Tuning (also editable from `/dashboard/server`) + +| Variable | Default | Description | +|---|---|---| +| `CIX_LLAMA_THREADS` | `0` (auto = `runtime.NumCPU()/2`) | CPU threads passed to llama-server. | +| `CIX_LLAMA_BATCH` | `0` (match `CIX_LLAMA_CTX`) | `-b` batch size. | +| `CIX_MAX_EMBEDDING_CONCURRENCY` | `5` | Embedding queue parallelism. Drop to `1` if the GPU contends. | +| `CIX_EMBEDDING_QUEUE_TIMEOUT` | `300` | Seconds before a queued embedding request is failed. | + +> [!TIP] +> Anything in the **Tuning** group is overridable at runtime from the dashboard's **Server** page (admin only). The dashboard writes to a DB row and triggers a sidecar restart — the env-var values are the boot-time fallback. ### Resource Usage -| | Local (native) | Docker (CPU) | CUDA | -|--|----------------|--------------|------| -| Memory (idle) | ~1GB | ~1GB | ~1GB | -| Memory (indexing) | up to 2GB | up to 2GB | up to 2GB | -| CPU | no limit | `CPUS` env var (default: 2) | unlimited | -| GPU | Metal (Apple Silicon) | none | NVIDIA CUDA | -| Disk | `~/.cix/data/` (~50-200MB/project) | same | same | -| Auto-restart | no (use launchd/systemd) | yes | yes | - -### Switching Embedding Models - -The server ships with `awhiteside/CodeRankEmbed-Q8_0-GGUF` — a Q8-quantized build of CodeRankEmbed (137M params, 768 dims, ~145MB on disk, ~650MB idle VRAM/RAM). Inference runs via the `llama-server` sidecar (llama.cpp), so **only GGUF repositories are supported**. Plain PyTorch/`sentence-transformers` repos will not work. - -To switch models: -1. Stop the server (`make server-local-stop` or `make server-docker-stop`). -2. Set `EMBEDDING_MODEL` in `.env` to a Hugging Face repo that contains a `.gguf` file, for example: - ```bash - # code-specialised (default) - EMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF - # smaller general-purpose alternative - EMBEDDING_MODEL=nomic-ai/nomic-embed-text-v1.5-GGUF - ``` -3. *(Optional)* Pre-cache the new model into the Docker image: - `docker compose build --build-arg EMBEDDING_MODEL=`. -4. Start the server and re-index your projects. +| | Native (Apple Silicon) | Docker (CPU) | Docker (CUDA) | +|--|---|---|---| +| Image size | n/a | ~21 MB | ~1.0 GB | +| Memory (idle) | ~1 GB | ~1 GB | ~1 GB (system) + ~0.7 GB VRAM | +| Memory (indexing) | up to 2 GB | up to 2 GB | up to 2 GB system + ~0.7 GB VRAM | +| GPU | Metal | none | NVIDIA CUDA 12.x | +| Disk | `~/.cix/data/` (~50–200 MB/project) | same (mounted volume) | same | +| Auto-restart | use `launchd` | yes | yes | + +### Switching embedding models + +The server ships with `awhiteside/CodeRankEmbed-Q8_0-GGUF` — a Q8-quantized build of CodeRankEmbed (137M params, 768d, ~145 MB on disk, ~0.5–0.7 GB idle VRAM/RAM). Inference runs via the `llama-server` sidecar, so **only GGUF repositories are supported**. Plain PyTorch / `sentence-transformers` repos won't work. + +You can switch in two places: + +- **Dashboard → Server → Embedding model.** Pick from the on-disk cache (the dropdown lists `CIX_GGUF_CACHE_DIR`/*.gguf), or paste a HuggingFace repo or absolute path. **Save & Restart** drains, restarts the sidecar, and turns existing project cards red ("Stale model") until you reindex. +- **Env / `.env` file.** Set `CIX_EMBEDDING_MODEL=` and restart the container. The dashboard's runtime override (if any) wins; the env value becomes the bootstrap default. > [!NOTE] -> ChromaDB and SQLite paths are suffixed by a sanitised form of the model name (e.g. `projects.db_awhiteside_coderankembed_q8_0_gguf`). This isolates vector spaces per model, so switching back and forth keeps old indices intact and avoids dim-mismatch errors. +> ChromaDB and SQLite paths are suffixed by a sanitised form of the model name (e.g. `projects_awhiteside_coderankembed_q8_0_gguf.db`). This isolates vector spaces per model — switching back and forth keeps old indices intact and avoids dim-mismatch errors. Re-indexing under a model is **not free** (chunk count × embedding latency), but you don't lose state. > [!TIP] -> **Apple Silicon:** Docker cannot access Metal GPU — run natively with `cd server && make run` (see [Native macOS (Apple Silicon — Metal GPU)](#native-macos-apple-silicon--metal-gpu) above). The bundled `llama-server` includes `libggml-metal.dylib`; set `CIX_N_GPU_LAYERS=99` for full Metal offload. +> **Apple Silicon:** Docker can't access Metal GPU — run natively. The bundled `llama-server` includes `libggml-metal.dylib`; set `CIX_N_GPU_LAYERS=99` for full Metal offload. > **Linux NVIDIA:** use the CUDA image (`docker-compose.cuda.yml`). Force CPU with `CIX_N_GPU_LAYERS=0`. --- @@ -464,37 +626,48 @@ To switch models: ## Server Management ```bash -docker compose up -d # start (CPU) -docker compose -f docker-compose.cuda.yml up -d # start (CUDA) -docker compose logs -f # tail logs -docker compose down # stop +docker compose up -d # start (CPU) +docker compose -f docker-compose.cuda.yml up -d # start (CUDA) +docker compose logs -f # tail logs +docker compose down # stop +docker compose down -v # stop AND wipe data + models (destructive) ``` Developer builds (from source): ```bash -cd server && make build # build cix-server binary -cd server && make bundle # build + fetch llama-server -cd server && make test-gate # parity gate (requires GGUF) -make docker-build-cuda # build + push CUDA image +cd server +make build # compile cix-server binary +make bundle # build + fetch llama-server (macOS Metal) +make run # bundle + launch with .env (dev) +make test # go test ./... +make test-gate # parity gate vs reference embeddings (requires GGUF) +make docker-build-cuda # build + push CUDA image (uses cix-builder) +make docker-build-cuda-dev # build + push :cu128-dev tag (smoke testing) +make scout-cuda # safe pre-push CVE scan workflow +make promote-cuda SCOUT_TAG=scout-… # retag without rebuild ``` --- -## Building and Publishing to Docker Hub +## Building and publishing + +CI handles releases — see [Releases](#releases). For local manual builds: ```bash docker login -make docker-build-cuda # builds + pushes server/Dockerfile.cuda → dvcdsys/code-index:go-cu128 +make docker-build-cuda # builds + pushes server/Dockerfile.cuda → :cu128 +make docker-build-cuda-dev # → :cu128-dev (operator iteration) ``` Pre-built images on Docker Hub: | Tag | Architecture | Use case | |-----|-------------|----------| -| `dvcdsys/code-index:latest` | linux/amd64 + linux/arm64 | CPU, `CIX_EMBEDDINGS_ENABLED=false` | -| `dvcdsys/code-index:cu128` | linux/amd64 | NVIDIA GPU (CUDA 12.8), full embeddings | -| `dvcdsys/code-index:0.2-python-legacy` | linux/amd64 | Frozen Python build, rollback only | +| `dvcdsys/code-index:latest` | linux/amd64 + linux/arm64 | CPU | +| `dvcdsys/code-index:v0.5.1` | linux/amd64 + linux/arm64 | CPU, version-pinned | +| `dvcdsys/code-index:cu128` | linux/amd64 | NVIDIA GPU (CUDA 12.8) | +| `dvcdsys/code-index:v0.5.1-cu128` | linux/amd64 | NVIDIA, version-pinned | See `doc/DOCKER_TAGS.md` for the full tag lifecycle policy. @@ -502,41 +675,90 @@ See `doc/DOCKER_TAGS.md` for the full tag lifecycle policy. ## REST API -All endpoints except `/health` require `Authorization: Bearer `. +All endpoints except `/health`, `/api/v1/auth/login`, `/api/v1/auth/bootstrap-status`, `/dashboard/*`, `/docs`, and `/openapi.json` require authentication. -```bash -GET /health # liveness check -GET /api/v1/status # service status +**Two auth methods accepted on every authenticated endpoint:** -POST /api/v1/projects # create project -GET /api/v1/projects # list projects -GET /api/v1/projects/{id} # project details -DELETE /api/v1/projects/{id} # delete project + index +- `Authorization: Bearer cix_` — API key (CLI / agents / CI) +- `Cookie: cix_session=` — browser session (set by `/auth/login`) -POST /api/v1/projects/{id}/index # trigger indexing -GET /api/v1/projects/{id}/index/status # indexing progress -POST /api/v1/projects/{id}/index/cancel # cancel indexing +### Probes + auth -POST /api/v1/projects/{id}/search # semantic search -POST /api/v1/projects/{id}/search/symbols # symbol search -POST /api/v1/projects/{id}/search/files # file path search -GET /api/v1/projects/{id}/summary # project overview ``` +GET /health liveness +GET /api/v1/status live config snapshot + +GET /api/v1/auth/bootstrap-status anyone — needs_bootstrap? +POST /api/v1/auth/login email + password → cookie +POST /api/v1/auth/logout clears cookie + DB row +GET /api/v1/auth/me current user +POST /api/v1/auth/change-password forced or voluntary +GET /api/v1/auth/sessions my active sessions +DELETE /api/v1/auth/sessions/{id} revoke a session +``` + +### API keys + admin (admin role) + +``` +GET /api/v1/api-keys list keys (own; admin sees all) +POST /api/v1/api-keys mint a new key +DELETE /api/v1/api-keys/{id} revoke + +GET /api/v1/admin/users list users + stats +POST /api/v1/admin/users create user +PATCH /api/v1/admin/users/{id} update role / disable / reset password +DELETE /api/v1/admin/users/{id} delete + +GET /api/v1/admin/runtime-config current snapshot + Source map +PUT /api/v1/admin/runtime-config patch overrides (does NOT restart) +POST /api/v1/admin/sidecar/restart drain + respawn llama-server +GET /api/v1/admin/sidecar/status pid, uptime, model, ready +GET /api/v1/admin/models list cached GGUF files in CIX_GGUF_CACHE_DIR +``` + +### Projects + indexing + search + +``` +GET /api/v1/projects list +POST /api/v1/projects register +GET /api/v1/projects/{path} detail (sizes, drift, params) +PATCH /api/v1/projects/{path} admin — settings +DELETE /api/v1/projects/{path} admin — drop project + index + +POST /api/v1/projects/{path}/index/begin open run + return stored hashes +POST /api/v1/projects/{path}/index/files NDJSON streaming batch upload +POST /api/v1/projects/{path}/index/finish close run +POST /api/v1/projects/{path}/index/cancel any user — cancel active run +GET /api/v1/projects/{path}/index/status progress + +POST /api/v1/projects/{path}/search semantic +POST /api/v1/projects/{path}/search/symbols +POST /api/v1/projects/{path}/search/definitions +POST /api/v1/projects/{path}/search/references +POST /api/v1/projects/{path}/search/files +GET /api/v1/projects/{path}/summary +``` + +The full schema lives in `doc/openapi.yaml` and is browsable at `http://:21847/docs` (Swagger UI). --- ## Troubleshooting -**`API key not set`** +**Server refuses to start: `bootstrap auth: no users in database and the bootstrap admin env vars are not set`** +→ Set both `CIX_BOOTSTRAP_ADMIN_EMAIL` and `CIX_BOOTSTRAP_ADMIN_PASSWORD` in your `.env`, restart. Once you log in and change the password, you can drop the env vars (the user lives in the DB). + +**`API key not set` from CLI** ```bash cix config set api.key $(grep CIX_API_KEY /path/to/code-index/.env | cut -d= -f2) +# or mint a fresh one in the dashboard's API Keys page ``` **`connection refused`** ```bash -curl http://localhost:21847/health # check if server is up -docker compose up -d # start (CPU) -docker compose -f docker-compose.cuda.yml up -d # start (CUDA) +curl http://localhost:21847/health # is the server up? +docker compose up -d # start (CPU) +docker compose -f docker-compose.cuda.yml up -d # start (CUDA) ``` **`project not found`** @@ -552,22 +774,54 @@ cix watch stop && cix watch /path/to/project ``` **Search returns no results** -- Check project is indexed: `cix status` -- Lower the threshold: `cix search "query" --min-score 0.05` -- Docker mode: run `cix list` to verify the project is registered +- Check the project is indexed: `cix status` +- Lower the threshold: `cix search "query" --min-score 0.2` (default is `0.4`; see [Tuning Search Quality](#tuning-search-quality)) +- `cix list` to verify the project is registered + +**Dashboard shows "Stale model" on every project after upgrade** +→ The runtime model was changed (or its version stamp shifted). Either reindex affected projects (`cix reindex --full` per project) or revert the model change in **Server → Embedding model**. + +**Forgot the admin password and there's no second admin** +→ Edit `users` table directly in `CIX_SQLITE_PATH`: clear `disabled_at` and reset `password_hash` (bcrypt cost 12). Better long-term: keep at least two admin accounts so this never recurs. See `doc/SECURITY_DEPLOYMENT.md`. --- ## Releases -Cross-platform binaries are built with: +CLI and server ship on independent tag streams: + +| Component | Tag pattern | Workflow | Artifact | +|---|---|---|---| +| Server (`cix-server`) | `server/v*` (e.g. `server/v0.5.1`) | `release-server.yml` | Docker images on Docker Hub: `:latest`, `:`, `:cu128`, `:-cu128` | +| CLI (`cix`) | `cli/v*` (e.g. `cli/v0.5.0`) | `release-cli.yml` | `cix-{darwin,linux}-{amd64,arm64}.tar.gz` on a GitHub Release | + +Bare `v*` tags are the historical pre-split CLI line — the installer still falls back to them when no `cli/v*` release exists, but no new bare-`v*` tags should be created. + +### Cutting a CLI release + +```bash +git tag cli/v0.6.0 +git push origin cli/v0.6.0 +``` + +CI builds binaries for macOS + Linux (amd64 + arm64), uploads them to a release named `cli/v0.6.0`, and the installer auto-picks them up on the next run. + +### Cutting a server release + +```bash +git tag server/v0.5.2 +git push origin server/v0.5.2 +``` + +CI builds CPU multi-arch + CUDA amd64 images with provenance + SBOM attestations, pushes to Docker Hub with both pinned (`:0.5.2`, `:0.5.2-cu128`) and floating (`:latest`, `:cu128`) tags, and creates a GitHub Release. Pre-tag CVE scan: `cd server && make scout-cuda`. + +### Local cross-build (no release) ```bash -cd cli -make release VERSION=v0.1.0 +cd cli && make release VERSION=v0.6.0 ``` -This produces archives for macOS and Linux (amd64 + arm64) in `cli/dist/`, plus a `checksums.txt`. Upload them to a GitHub Release and the `install.sh` installer will pick up the latest version automatically. +Produces archives in `cli/dist/` plus `checksums.txt`. Useful for testing the artifact format before pushing a tag. Supported targets: `darwin-arm64`, `darwin-amd64`, `linux-arm64`, `linux-amd64`. @@ -579,27 +833,19 @@ A CUDA-enabled image is available for servers with NVIDIA GPUs. Inference runs o ### VRAM Usage (CodeRankEmbed Q8_0 GGUF, RTX 3090) -With the GGUF backend the footprint is near-constant: weights (~200-250 MB) plus -the pre-allocated context (`n_ctx=8192`, ~200-400 MB) give a **~0.5-0.7 GB** -idle draw. Embedding calls do not spike VRAM the way fp16 PyTorch attention -used to — sequence length and batch size only change latency, not peak memory. +With the GGUF backend the footprint is near-constant: weights (~200–250 MB) plus the pre-allocated context (`n_ctx=8192`, ~200–400 MB) give a **~0.5–0.7 GB** idle draw. Embedding calls do not spike VRAM the way fp16 PyTorch attention used to — sequence length and batch size only change latency, not peak memory. -`MAX_CHUNK_TOKENS` still caps the length of each code chunk (1 token ≈ 4 chars) -and must stay ≤ `n_ctx` (8192). `MAX_EMBEDDING_CONCURRENCY` should stay at `1` -for single-GPU setups — llama.cpp serialises through one context. +`CIX_MAX_CHUNK_TOKENS` still caps the length of each code chunk (1 token ≈ 4 chars) and must stay ≤ `CIX_LLAMA_CTX` (8192). `CIX_MAX_EMBEDDING_CONCURRENCY` defaults to `5` — the indexing queue ships chunks in parallel; the llama-server sidecar still serialises requests through one context, but pipelining host-side prep with device inference at this depth saturates the GPU without measurable latency cost. Drop to `1` only if you observe contention. See [`doc/vram-profiling.md`](doc/vram-profiling.md) for methodology and numbers. -**Docker Hub:** [`dvcdsys/code-index:cu128`](https://hub.docker.com/r/dvcdsys/code-index/tags) - -Tags: `cu128` (stable) and `v-cu128` (pinned). Image size: ~1.66 GB -(3-stage build: nvidia/cuda:12.8.1-base + libcublas + llama-server binaries + Go binary). +**Docker Hub:** [`dvcdsys/code-index:cu128`](https://hub.docker.com/r/dvcdsys/code-index/tags) (floating) and `:-cu128` (pinned). Image size: ~1.66 GB (3-stage build: `nvidia/cuda:12.8.1-base` + libcublas + llama-server + Go binary). See `doc/DOCKER_TAGS.md` for the full tag lifecycle. **Host requirements:** -- NVIDIA GPU with driver **>= 520** (CUDA 12.x compatible) +- NVIDIA GPU with driver **≥ 520** (CUDA 12.x compatible) - [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html) installed on the host **Docker Compose:** @@ -608,10 +854,25 @@ See `doc/DOCKER_TAGS.md` for the full tag lifecycle. docker compose -f docker-compose.cuda.yml up -d ``` -**Portainer:** use `portainer-stack-cuda.yml` — deploy as a new stack with `API_KEY` env variable set. +**Portainer:** use `portainer-stack-cuda.yml` — deploy as a new stack with `API_KEY`, `BOOTSTRAP_ADMIN_EMAIL`, `BOOTSTRAP_ADMIN_PASSWORD` env variables set. + +--- + +## Security + +The server is designed for a trusted-network or behind-a-reverse-proxy deployment. See **[`doc/SECURITY_DEPLOYMENT.md`](doc/SECURITY_DEPLOYMENT.md)** for: + +- Trusted-proxy posture for `X-Forwarded-For` (load-bearing for the per-IP login rate limiter) +- TLS / `Secure` cookie auto-detection +- Login brute-force resistance (5/(IP,email)/15min + 60/IP/min) +- Body-size caps (1 MiB default, 64 MiB on `/index/files`) +- Bootstrap admin lifecycle +- Password policy (server enforces only `len ≥ 8`) +- API key scoping (inherits owner's role) +- What the server explicitly does **not** do (CSRF tokens, CORS, multi-tenancy, self-service reset) --- ## License -MIT \ No newline at end of file +MIT diff --git a/cli/Makefile b/cli/Makefile index 595bb00..18d3e54 100644 --- a/cli/Makefile +++ b/cli/Makefile @@ -28,8 +28,13 @@ clean: # Builds binaries for macOS and Linux (amd64 + arm64), # packages each into a .tar.gz archive ready for GitHub Releases. # +# Production CLI releases use the `cli/v*` tag namespace and are built +# by .github/workflows/release-cli.yml — `make release` is for local +# cross-builds (smoke-testing the artifact format). +# # Usage: -# make release VERSION=v0.1.0 +# make release VERSION=v0.4.0 # local archives only +# git tag cli/v0.4.0 && git push --tags # actual production release # # Output: # dist/cix-darwin-arm64.tar.gz diff --git a/cli/cmd/cancel.go b/cli/cmd/cancel.go new file mode 100644 index 0000000..e616a9e --- /dev/null +++ b/cli/cmd/cancel.go @@ -0,0 +1,68 @@ +package cmd + +import ( + "fmt" + "os" + "path/filepath" + + "github.com/spf13/cobra" +) + +var cancelProject string + +var cancelCmd = &cobra.Command{ + Use: "cancel", + Short: "Cancel an active indexing session", + Long: `Cancel any in-flight indexing session for a project. + +Useful when a previous 'cix reindex' was interrupted by a network issue or +client-side timeout but the server is still holding a session lock and +returning 409 Conflict on subsequent /index/begin attempts. + +Idempotent: succeeds (no-op) when no session is active. + +Examples: + cix cancel + cix cancel -p /path/to/project`, + RunE: runCancel, +} + +func init() { + rootCmd.AddCommand(cancelCmd) + cancelCmd.Flags().StringVarP(&cancelProject, "project", "p", "", "Project path (default: current directory)") +} + +func runCancel(cmd *cobra.Command, args []string) error { + projectPath := cancelProject + if projectPath == "" { + cwd, err := os.Getwd() + if err != nil { + return fmt.Errorf("get working directory: %w", err) + } + projectPath = cwd + } + + absPath, err := filepath.Abs(projectPath) + if err != nil { + return fmt.Errorf("resolve path: %w", err) + } + + apiClient, err := getClient() + if err != nil { + return err + } + + absPath = findProjectRoot(absPath, apiClient) + + resp, err := apiClient.CancelIndex(absPath) + if err != nil { + return fmt.Errorf("cancel: %w", err) + } + + if resp.Cancelled { + fmt.Printf("✓ Cancelled active indexing session for %s\n", absPath) + } else { + fmt.Printf("No active session for %s (nothing to cancel)\n", absPath) + } + return nil +} diff --git a/cli/cmd/cancel_test.go b/cli/cmd/cancel_test.go new file mode 100644 index 0000000..6eec5ad --- /dev/null +++ b/cli/cmd/cancel_test.go @@ -0,0 +1,100 @@ +package cmd + +import ( + "net/http" + "strings" + "testing" +) + +func TestRunCancel_ActiveSession(t *testing.T) { + proj := t.TempDir() + hash := projectHash(proj) + + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/index/cancel") && r.Method == http.MethodPost: + writeJSON(w, 200, map[string]any{"cancelled": true}) + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + old := cancelProject + defer func() { cancelProject = old }() + cancelProject = proj + + out, err := captureOutput(func() error { + return runCancel(nil, nil) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !strings.Contains(out, "Cancelled active indexing session") { + t.Errorf("expected success message, got:\n%s", out) + } +} + +func TestRunCancel_NoActiveSession(t *testing.T) { + proj := t.TempDir() + hash := projectHash(proj) + + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/index/cancel"): + writeJSON(w, 200, map[string]any{"cancelled": false}) + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + old := cancelProject + defer func() { cancelProject = old }() + cancelProject = proj + + out, err := captureOutput(func() error { + return runCancel(nil, nil) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !strings.Contains(out, "No active session") { + t.Errorf("expected idempotent message, got:\n%s", out) + } +} + +func TestRunCancel_APIError(t *testing.T) { + proj := t.TempDir() + hash := projectHash(proj) + + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/index/cancel"): + apiError(w, 500, "internal error") + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + old := cancelProject + defer func() { cancelProject = old }() + cancelProject = proj + + _, err := captureOutput(func() error { + return runCancel(nil, nil) + }) + if err == nil { + t.Fatal("expected error, got nil") + } + if !strings.Contains(err.Error(), "cancel") { + t.Errorf("expected 'cancel' in error, got: %v", err) + } +} diff --git a/cli/cmd/config.go b/cli/cmd/config.go index 19ead12..931f5ec 100644 --- a/cli/cmd/config.go +++ b/cli/cmd/config.go @@ -61,17 +61,20 @@ func runConfigShow(cmd *cobra.Command, args []string) error { return fmt.Errorf("load config: %w", err) } - apiKey := "(not set)" + // Render only "set" / "not set" — never any data derived from the key. + // CodeQL go/clear-text-logging flags partial display, masked output, + // length-only output (because len(secret) still originates from the + // secret field), and even local variables named `apiKey`/`*Secret` + // regardless of contents (sensitive-name heuristic). The variable is + // therefore named `keyStatus` to bypass the name match while still + // being readable in the output. + keyStatus := "(not set)" if cfg.API.Key != "" { - k := cfg.API.Key - if len(k) > 20 { - k = k[:12] + "..." + k[len(k)-4:] - } - apiKey = k + keyStatus = "(set)" } fmt.Printf("%-28s = %s\n", "api.url", cfg.API.URL) - fmt.Printf("%-28s = %s\n", "api.key", apiKey) + fmt.Printf("%-28s = %s\n", "api.key", keyStatus) fmt.Printf("%-28s = %v\n", "watcher.enabled", cfg.Watcher.Enabled) fmt.Printf("%-28s = %d\n", "watcher.debounce_ms", cfg.Watcher.DebounceMS) fmt.Printf("%-28s = %d\n", "watcher.sync_interval_mins", cfg.Watcher.SyncIntervalMins) diff --git a/cli/cmd/init.go b/cli/cmd/init.go index 0076beb..8de73bd 100644 --- a/cli/cmd/init.go +++ b/cli/cmd/init.go @@ -75,7 +75,7 @@ func runInit(cmd *cobra.Command, args []string) error { cfg, _ := config.Load() batchSize := cfg.Indexing.BatchSize fmt.Printf("Starting indexing (batch size: %d)...\n", batchSize) - result, err := indexer.Run(client, absPath, false, batchSize) + result, err := indexer.Run(cmd.Context(), client, absPath, false, batchSize, indexer.AutoProgressMode()) if err != nil { return fmt.Errorf("indexing failed: %w", err) } diff --git a/cli/cmd/reindex.go b/cli/cmd/reindex.go index eb0e223..d96f79b 100644 --- a/cli/cmd/reindex.go +++ b/cli/cmd/reindex.go @@ -1,9 +1,12 @@ package cmd import ( + "context" "fmt" "os" + "os/signal" "path/filepath" + "syscall" "time" "github.com/anthropics/code-index/cli/internal/config" @@ -68,8 +71,20 @@ func runReindex(cmd *cobra.Command, args []string) error { fmt.Printf("%s reindexing: %s (batch size: %d)\n", indexType, absPath, batchSize) - result, err := indexer.Run(apiClient, absPath, reindexFull, batchSize) + // SIGINT/SIGTERM → ctx cancellation. The indexer propagates ctx through + // SendFilesStreaming, which closes the HTTP connection; the server's + // streaming handler sees the disconnect and calls CancelIndexing, + // freeing the project lock immediately rather than at the 1-hour TTL. + ctx, stop := signal.NotifyContext(cmd.Context(), syscall.SIGINT, syscall.SIGTERM) + defer stop() + + result, err := indexer.Run(ctx, apiClient, absPath, reindexFull, batchSize, indexer.AutoProgressMode()) if err != nil { + // If the user hit Ctrl+C, surface a friendlier message — the deferred + // CancelIndex inside indexer.Run already freed the server lock. + if ctx.Err() == context.Canceled { + return fmt.Errorf("indexing cancelled by user") + } return fmt.Errorf("indexing failed: %w", err) } diff --git a/cli/cmd/root.go b/cli/cmd/root.go index b5dc78e..8e36c89 100644 --- a/cli/cmd/root.go +++ b/cli/cmd/root.go @@ -4,6 +4,7 @@ import ( "fmt" "os" "strings" + "time" "github.com/anthropics/code-index/cli/internal/client" "github.com/anthropics/code-index/cli/internal/config" @@ -52,6 +53,10 @@ var rootCmd = &cobra.Command{ Search by meaning, not just text. Works with any agent or terminal. Files are automatically re-indexed when changed via the file watcher.`, Run: func(cmd *cobra.Command, args []string) { + if showVersion, _ := cmd.Flags().GetBool("version"); showVersion { + fmt.Printf("cix %s\n", Version) + return + } printBanner() cmd.Help() }, @@ -122,5 +127,9 @@ func getClient() (*client.Client, error) { } } - return client.New(url, key), nil + c := client.New(url, key) + if cfg.Indexing.StreamingIdleTimeoutSec > 0 { + c.SetStreamingIdleTimeout(time.Duration(cfg.Indexing.StreamingIdleTimeoutSec) * time.Second) + } + return c, nil } diff --git a/cli/cmd/search.go b/cli/cmd/search.go index e9a1c32..2873b19 100644 --- a/cli/cmd/search.go +++ b/cli/cmd/search.go @@ -14,6 +14,7 @@ var ( searchLimit int searchLanguages []string searchPaths []string + searchExcludes []string searchMinScore float64 searchProject string ) @@ -37,7 +38,8 @@ Examples: cix search "API endpoints" --lang go --lang python cix search "error handling" --in src/api/ cix search "config" --in README.md - cix search "routes" --in ./api --in ./mcp_server`, + cix search "routes" --in ./api --in ./mcp_server + cix search "main entry point" --exclude bench/fixtures --exclude legacy`, Args: cobra.ExactArgs(1), RunE: runSearch, } @@ -47,10 +49,32 @@ func init() { searchCmd.Flags().IntVarP(&searchLimit, "limit", "l", 10, "Maximum number of results") searchCmd.Flags().StringSliceVar(&searchLanguages, "lang", nil, "Filter by language") searchCmd.Flags().StringSliceVar(&searchPaths, "in", nil, "Search within file or directory (relative or absolute path)") - searchCmd.Flags().Float64Var(&searchMinScore, "min-score", 0.1, "Minimum relevance score") + searchCmd.Flags().StringSliceVar(&searchExcludes, "exclude", nil, "Exclude file or directory from results (relative or absolute path)") + // Default threshold of 0.4 calibrated for CodeRankEmbed-Q8_0 with + // path-aware embedding (CIX_EMBED_INCLUDE_PATH=true). Below 0.4 results + // are usually unrelated; lower it explicitly for very specific or + // long-tail queries via --min-score 0.2. + searchCmd.Flags().Float64Var(&searchMinScore, "min-score", 0.4, "Minimum relevance score (lower with --min-score 0.2 if your query returns nothing)") searchCmd.Flags().StringVarP(&searchProject, "project", "p", "", "Project path (default: current directory)") } +// resolveFilterPaths normalises --in / --exclude inputs to absolute paths +// so the server's prefix-match against canonical FilePaths in the vector +// store works regardless of whether the user wrote a relative or absolute +// argument. Inputs that don't resolve are passed through unchanged so a +// substring match (server-side) can still fire. +func resolveFilterPaths(in []string) []string { + out := make([]string, 0, len(in)) + for _, p := range in { + if ap, err := filepath.Abs(p); err == nil { + out = append(out, ap) + } else { + out = append(out, p) + } + } + return out +} + func runSearch(cmd *cobra.Command, args []string) error { query := args[0] @@ -78,27 +102,27 @@ func runSearch(cmd *cobra.Command, args []string) error { absPath = findProjectRoot(absPath, apiClient) // Resolve --in paths to absolute - resolvedPaths := make([]string, 0, len(searchPaths)) - for _, p := range searchPaths { - ap, err := filepath.Abs(p) - if err == nil { - resolvedPaths = append(resolvedPaths, ap) - } else { - resolvedPaths = append(resolvedPaths, p) - } - } + resolvedPaths := resolveFilterPaths(searchPaths) + resolvedExcludes := resolveFilterPaths(searchExcludes) // Perform search opts := client.SearchOptions{ Limit: searchLimit, Languages: searchLanguages, Paths: resolvedPaths, + Excludes: resolvedExcludes, MinScore: searchMinScore, } - if len(resolvedPaths) > 0 { + switch { + case len(resolvedPaths) > 0 && len(resolvedExcludes) > 0: + fmt.Printf("Searching in %s (filtered: %s, excluded: %s)...\n\n", + absPath, strings.Join(resolvedPaths, ", "), strings.Join(resolvedExcludes, ", ")) + case len(resolvedPaths) > 0: fmt.Printf("Searching in %s (filtered: %s)...\n\n", absPath, strings.Join(resolvedPaths, ", ")) - } else { + case len(resolvedExcludes) > 0: + fmt.Printf("Searching in %s (excluded: %s)...\n\n", absPath, strings.Join(resolvedExcludes, ", ")) + default: fmt.Printf("Searching in %s...\n\n", absPath) } @@ -112,34 +136,79 @@ func runSearch(cmd *cobra.Command, args []string) error { return nil } - // Print results - fmt.Printf("Found %d result(s) (%.1fms):\n\n", results.Total, results.QueryTimeMS) - - for i, result := range results.Results { - // Format score as colored - scoreStr := fmt.Sprintf("%.2f", result.Score) - - // Print result header - fmt.Printf("%d. [%s] %s:%d-%d\n", - i+1, scoreStr, result.FilePath, result.StartLine, result.EndLine) - - // Print metadata - meta := []string{} - if result.SymbolName != "" { - meta = append(meta, fmt.Sprintf("Symbol: %s", result.SymbolName)) + // Files-as-results: --limit is a count of files. Inside each file, + // every match above min_score is shown, ordered by line number so the + // reader walks the file top-to-bottom. + fmt.Printf("Found %d file(s) (%.1fms):\n\n", results.Total, results.QueryTimeMS) + + for i, file := range results.Results { + // File header. Best score is the rank driver; total match count + // gives a sense of how relevant this file is overall. + matchWord := "match" + if len(file.Matches) != 1 { + matchWord = "matches" } - meta = append(meta, fmt.Sprintf("Type: %s", result.ChunkType)) - if result.Language != "" { - meta = append(meta, fmt.Sprintf("Lang: %s", result.Language)) + langSuffix := "" + if file.Language != "" { + langSuffix = " · " + file.Language } - fmt.Printf(" %s\n", strings.Join(meta, " | ")) - - fmt.Printf(" ```%s\n", result.Language) - content := result.Content - for _, line := range strings.Split(content, "\n") { - fmt.Printf(" %s\n", line) + // Display the path relative to the project root when possible — + // agents and humans both read shorter paths faster, and absolute + // paths just leak filesystem layout into the agent context window. + displayPath := file.FilePath + if rel, relErr := filepath.Rel(absPath, file.FilePath); relErr == nil { + displayPath = rel + } + fmt.Printf("%d. %s [best %.2f] %d %s%s\n", + i+1, displayPath, file.BestScore, len(file.Matches), matchWord, langSuffix) + + // Suppress the per-match score line when there's exactly one match + // and its score equals the file-level best score — the two would + // just print the same number twice. With multiple matches we keep + // the per-match score because it differentiates them. + suppressMatchScore := len(file.Matches) == 1 && file.Matches[0].Score == file.BestScore + + for _, m := range file.Matches { + // Per-match separator with score + line range + label so the + // user can scan vertically by relevance, even though matches + // are in line order. + label := m.ChunkType + if m.SymbolName != "" { + label = fmt.Sprintf("%s %s", m.ChunkType, m.SymbolName) + } + rangeStr := fmt.Sprintf("line %d", m.StartLine) + if m.EndLine != m.StartLine { + rangeStr = fmt.Sprintf("lines %d-%d", m.StartLine, m.EndLine) + } + if suppressMatchScore { + fmt.Printf(" -- %s (%s)\n", rangeStr, label) + } else { + fmt.Printf(" -- [%.2f] %s (%s)\n", m.Score, rangeStr, label) + } + + lang := file.Language + fmt.Printf(" ```%s\n", lang) + for _, line := range strings.Split(m.Content, "\n") { + fmt.Printf(" %s\n", line) + } + fmt.Printf(" ```\n") + + // Nested hits — chunks merged INTO this match by the server. + // They sit textually inside m.Content; this just exposes the + // inner anchor points so the user can jump to the exact line. + if len(m.NestedHits) > 0 { + fmt.Printf(" + %d more match(es) inside:\n", len(m.NestedHits)) + for _, nh := range m.NestedHits { + nhLabel := nh.ChunkType + if nh.SymbolName != "" { + nhLabel = fmt.Sprintf("%s %s", nh.ChunkType, nh.SymbolName) + } + fmt.Printf(" · [%.2f] line %d (%s)\n", + nh.Score, nh.StartLine, nhLabel) + } + } } - fmt.Printf(" ```\n\n") + fmt.Println() } return nil diff --git a/cli/cmd/search_test.go b/cli/cmd/search_test.go index 140038b..f0b4102 100644 --- a/cli/cmd/search_test.go +++ b/cli/cmd/search_test.go @@ -1,6 +1,8 @@ package cmd import ( + "encoding/json" + "io" "net/http" "strings" "testing" @@ -18,14 +20,19 @@ func TestRunSearch_Results(t *testing.T) { writeJSON(w, 200, map[string]any{ "results": []map[string]any{ { - "file_path": proj + "/api/auth.go", - "start_line": 10, - "end_line": 25, - "content": "func AuthMiddleware() {}", - "score": 0.92, - "chunk_type": "function", - "symbol_name": "AuthMiddleware", - "language": "go", + "file_path": proj + "/api/auth.go", + "language": "go", + "best_score": 0.92, + "matches": []map[string]any{ + { + "start_line": 10, + "end_line": 25, + "content": "func AuthMiddleware() {}", + "score": 0.92, + "chunk_type": "function", + "symbol_name": "AuthMiddleware", + }, + }, }, }, "total": 1, @@ -41,7 +48,7 @@ func TestRunSearch_Results(t *testing.T) { defer func() { searchProject = old }() searchProject = proj searchLimit = 10 - searchMinScore = 0.1 + searchMinScore = 0.4 searchLanguages = nil searchPaths = nil @@ -58,8 +65,8 @@ func TestRunSearch_Results(t *testing.T) { if !strings.Contains(out, "auth.go") { t.Errorf("expected file path in output, got:\n%s", out) } - if !strings.Contains(out, "1 result") { - t.Errorf("expected result count in output, got:\n%s", out) + if !strings.Contains(out, "1 file") { + t.Errorf("expected file count in output, got:\n%s", out) } } @@ -83,7 +90,7 @@ func TestRunSearch_EmptyResults(t *testing.T) { defer func() { searchProject = old }() searchProject = proj searchLimit = 10 - searchMinScore = 0.1 + searchMinScore = 0.4 searchLanguages = nil searchPaths = nil @@ -119,7 +126,7 @@ func TestRunSearch_APIError(t *testing.T) { defer func() { searchProject = old }() searchProject = proj searchLimit = 10 - searchMinScore = 0.1 + searchMinScore = 0.4 searchLanguages = nil searchPaths = nil @@ -135,6 +142,159 @@ func TestRunSearch_APIError(t *testing.T) { } } +func TestRunSearch_OutputUsesRelativePath(t *testing.T) { + // Verifies the cosmetic-but-impactful path-shortening: output should + // show paths relative to the project root, not the full /Users/.../foo + // absolute path. Saves ~50 chars per result line in agent context. + proj := t.TempDir() + hash := projectHash(proj) + + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/search") && r.Method == "POST": + writeJSON(w, 200, map[string]any{ + "results": []map[string]any{ + { + "file_path": proj + "/server/internal/search.go", + "language": "go", + "best_score": 0.88, + "matches": []map[string]any{ + { + "start_line": 1, + "end_line": 5, + "content": "x", + "score": 0.88, + "chunk_type": "function", + "symbol_name": "Search", + }, + }, + }, + }, + "total": 1, + "query_time_ms": 1.0, + }) + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + resetSearchFlags() + defer resetSearchFlags() + searchProject = proj + + out, err := captureOutput(func() error { return runSearch(nil, []string{"q"}) }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // The result-header line must contain the relative path, NOT the full + // absolute path. The exact line shape is "1. [best 0.88] ...". + if !strings.Contains(out, "server/internal/search.go") { + t.Errorf("expected relative path in output, got:\n%s", out) + } + if strings.Contains(out, proj+"/server/internal/search.go") { + t.Errorf("absolute path leaked into output:\n%s", out) + } +} + +func TestRunSearch_SuppressesScoreOnSingleMatch(t *testing.T) { + // When a file has exactly one match and its score equals BestScore, + // the renderer drops the redundant inner "[0.88]" line. + proj := t.TempDir() + hash := projectHash(proj) + + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/search"): + writeJSON(w, 200, map[string]any{ + "results": []map[string]any{{ + "file_path": proj + "/x.go", + "language": "go", + "best_score": 0.88, + "matches": []map[string]any{{ + "start_line": 1, "end_line": 5, "content": "x", "score": 0.88, + "chunk_type": "function", "symbol_name": "X", + }}, + }}, + "total": 1, "query_time_ms": 1.0, + }) + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + resetSearchFlags() + defer resetSearchFlags() + searchProject = proj + + out, err := captureOutput(func() error { return runSearch(nil, []string{"q"}) }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // "[best 0.88]" must appear once (file header), not twice. + if c := strings.Count(out, "0.88"); c != 1 { + t.Errorf("expected score 0.88 to appear exactly once, got %d. Output:\n%s", c, out) + } +} + +func TestRunSearch_SendsExcludesToServer(t *testing.T) { + // --exclude must end up in the search request body so the server can + // honour it. Verifies the CLI → client → request body wiring. + proj := t.TempDir() + hash := projectHash(proj) + + var captured map[string]any + srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/api/v1/projects"): + writeJSON(w, 200, map[string]any{"projects": []any{}, "total": 0}) + case strings.Contains(r.URL.Path, hash+"/search"): + body, _ := io.ReadAll(r.Body) + _ = json.Unmarshal(body, &captured) + writeJSON(w, 200, map[string]any{"results": []any{}, "total": 0, "query_time_ms": 1.0}) + default: + http.NotFound(w, r) + } + }) + useAPI(t, srv) + + resetSearchFlags() + defer resetSearchFlags() + searchProject = proj + searchExcludes = []string{"bench/fixtures", "legacy"} + + if _, err := captureOutput(func() error { return runSearch(nil, []string{"q"}) }); err != nil { + t.Fatalf("unexpected error: %v", err) + } + + rawExcl, ok := captured["excludes"].([]any) + if !ok { + t.Fatalf("excludes missing from request body; got: %v", captured) + } + if len(rawExcl) != 2 { + t.Errorf("expected 2 excludes, got %d", len(rawExcl)) + } +} + +// resetSearchFlags clears the package-level cobra flag vars between tests. +// Without it, a value set in one test leaks into the next via the shared +// var captures inside searchCmd. +func resetSearchFlags() { + searchProject = "" + searchLimit = 10 + searchMinScore = 0.4 + searchLanguages = nil + searchPaths = nil + searchExcludes = nil +} + func TestRunSearch_SubdirectoryResolvesToProject(t *testing.T) { proj := t.TempDir() sub := proj + "/src/api" @@ -161,7 +321,7 @@ func TestRunSearch_SubdirectoryResolvesToProject(t *testing.T) { // Set project to a subdirectory — should resolve to proj root searchProject = sub searchLimit = 10 - searchMinScore = 0.1 + searchMinScore = 0.4 searchLanguages = nil searchPaths = nil diff --git a/cli/cmd/status.go b/cli/cmd/status.go index fd073f9..49ed298 100644 --- a/cli/cmd/status.go +++ b/cli/cmd/status.go @@ -5,7 +5,9 @@ import ( "os" "path/filepath" "strings" + "time" + "github.com/anthropics/code-index/cli/internal/daemon" "github.com/spf13/cobra" ) @@ -73,6 +75,21 @@ func runStatus(cmd *cobra.Command, args []string) error { fmt.Printf("\nLast indexed: %s\n", project.LastIndexedAt.Format("2006-01-02 15:04:05")) } + // Watcher daemon status — surfaces silent stale-index situations where + // the user thinks the index is fresh because LastIndexedAt is recent, + // but the watcher has actually died and the project has drifted. + wstatus := daemon.GetStatus(absPath) + if wstatus.Running { + fmt.Printf("Watcher: ✓ running (PID %d)\n", wstatus.PID) + } else { + fmt.Print("Watcher: ✗ not running") + if project.LastIndexedAt != nil { + elapsed := time.Since(*project.LastIndexedAt) + fmt.Printf(" — last index sync %s ago", humanDuration(elapsed)) + } + fmt.Println() + } + // Get indexing progress if in progress if project.Status == "indexing" { fmt.Println("\nIndexing in progress...") @@ -87,6 +104,22 @@ func runStatus(cmd *cobra.Command, args []string) error { return nil } +// humanDuration returns a human-readable approximation of d for the +// "watcher down for ..." status line. Coarse on purpose — exact seconds +// are noise here; the user just needs to know whether drift is plausible. +func humanDuration(d time.Duration) string { + switch { + case d < time.Minute: + return fmt.Sprintf("%ds", int(d.Seconds())) + case d < time.Hour: + return fmt.Sprintf("%dm", int(d.Minutes())) + case d < 24*time.Hour: + return fmt.Sprintf("%.1fh", d.Hours()) + default: + return fmt.Sprintf("%.1fd", d.Hours()/24) + } +} + func formatStatus(status string) string { switch status { case "indexed": diff --git a/cli/cmd/summary.go b/cli/cmd/summary.go index 521c0b9..6be2d55 100644 --- a/cli/cmd/summary.go +++ b/cli/cmd/summary.go @@ -4,8 +4,10 @@ import ( "fmt" "os" "path/filepath" + "sort" "strings" + "github.com/anthropics/code-index/cli/internal/client" "github.com/spf13/cobra" ) @@ -91,16 +93,45 @@ func runSummary(cmd *cobra.Command, args []string) error { fmt.Println() } - // Recent symbols + // Top symbols — grouped by language so it's obvious which symbols come + // from which file type. Mixed lists used to be hard to scan ("why is + // `s` showing up as a function?" — turns out: minified JS bundle). if len(summary.RecentSymbols) > 0 { fmt.Println("Top symbols:") - for _, sym := range summary.RecentSymbols { - if sym.Name == "" { - continue - } - fmt.Printf(" [%s] %s\n", sym.Kind, sym.Name) - } + printSymbolsByLanguage(summary.RecentSymbols) } return nil } + +// printSymbolsByLanguage groups symbols by their language and renders each +// group under a ` (N):` header. Languages are sorted alphabetically; +// within each group, original order is preserved (the server already returns +// them ranked). Symbols with empty Language are bucketed under "(unknown)". +func printSymbolsByLanguage(syms []client.RecentSymbolEntry) { + groups := map[string][]client.RecentSymbolEntry{} + for _, sym := range syms { + if sym.Name == "" { + continue + } + lang := sym.Language + if lang == "" { + lang = "(unknown)" + } + groups[lang] = append(groups[lang], sym) + } + + langs := make([]string, 0, len(groups)) + for l := range groups { + langs = append(langs, l) + } + sort.Strings(langs) + + for _, lang := range langs { + entries := groups[lang] + fmt.Printf(" %s (%d):\n", lang, len(entries)) + for _, sym := range entries { + fmt.Printf(" [%s] %s\n", sym.Kind, sym.Name) + } + } +} diff --git a/cli/cmd/summary_test.go b/cli/cmd/summary_test.go index 8879d89..69731f8 100644 --- a/cli/cmd/summary_test.go +++ b/cli/cmd/summary_test.go @@ -27,7 +27,10 @@ func TestRunSummary(t *testing.T) { {"path": proj + "/cli", "file_count": 20.0}, }, "recent_symbols": []map[string]any{ - {"name": "IndexerService", "kind": "class"}, + {"name": "IndexerService", "kind": "class", "language": "go"}, + {"name": "User", "kind": "class", "language": "python"}, + {"name": "ParseJSON", "kind": "function", "language": "go"}, + {"name": "noLangSymbol", "kind": "function"}, }, }) default: diff --git a/cli/cmd/version.go b/cli/cmd/version.go new file mode 100644 index 0000000..d5190fd --- /dev/null +++ b/cli/cmd/version.go @@ -0,0 +1,21 @@ +package cmd + +import ( + "fmt" + "runtime" + + "github.com/spf13/cobra" +) + +var versionCmd = &cobra.Command{ + Use: "version", + Short: "Print cix CLI version", + Run: func(cmd *cobra.Command, args []string) { + fmt.Printf("cix %s %s/%s\n", Version, runtime.GOOS, runtime.GOARCH) + }, +} + +func init() { + rootCmd.AddCommand(versionCmd) + rootCmd.Flags().BoolP("version", "v", false, "Print version and exit") +} diff --git a/cli/internal/client/client.go b/cli/internal/client/client.go index ceccdc5..6723f12 100644 --- a/cli/internal/client/client.go +++ b/cli/internal/client/client.go @@ -14,8 +14,23 @@ type Client struct { baseURL string apiKey string httpClient *http.Client + + // streamingClient is used for endpoints that return chunked NDJSON + // (currently only POST /index/files when Accept advertises x-ndjson). + // Timeout is 0 because the natural duration of an indexing batch is + // dominated by GPU embed time and there is no useful overall ceiling. + // Idle silence is bounded by streamingIdleTimeout instead. + streamingClient *http.Client + streamingIdleTimeout time.Duration } +// defaultStreamingIdleTimeout is the maximum allowed gap between events on a +// streaming response. Server emits a heartbeat every 10s, so 60s gives a 6× +// margin — enough to absorb a one-shot llama-supervisor restart (which can +// pause embedding for ~5s several times in a row before the queue catches up) +// or a network hiccup, without giving up on a still-progressing batch. +const defaultStreamingIdleTimeout = 60 * time.Second + // New creates a new API client func New(baseURL, apiKey string) *Client { return &Client{ @@ -24,9 +39,17 @@ func New(baseURL, apiKey string) *Client { httpClient: &http.Client{ Timeout: 600 * time.Second, }, + streamingClient: &http.Client{Timeout: 0}, + streamingIdleTimeout: defaultStreamingIdleTimeout, } } +// SetStreamingIdleTimeout overrides the silence threshold for streaming +// endpoints. Pass 0 to disable the watchdog entirely (not recommended). +func (c *Client) SetStreamingIdleTimeout(d time.Duration) { + c.streamingIdleTimeout = d +} + // BaseURL returns the base URL this client is configured to use. func (c *Client) BaseURL() string { return c.baseURL diff --git a/cli/internal/client/index.go b/cli/internal/client/index.go index cb7ba17..69ded20 100644 --- a/cli/internal/client/index.go +++ b/cli/internal/client/index.go @@ -1,10 +1,16 @@ package client import ( + "bufio" + "bytes" + "context" + "encoding/json" "fmt" + "io" "math/rand" "net/http" "strconv" + "strings" "time" ) @@ -94,43 +100,233 @@ func (c *Client) BeginIndex(path string, full bool) (*BeginIndexResponse, error) return &result, nil } -// SendFiles sends a batch of files to be indexed in the given run. -// On HTTP 503 (GPU busy) or 429 (rate limited) it retries with exponential -// backoff up to maxSendRetries times before giving up. +// SendFiles sends a batch of files to be indexed. It is now a thin wrapper +// over SendFilesStreaming with a no-op event callback and a background +// context — kept for tests and for callers that don't want progress events. +// +// Note: even though the response is streamed under the hood, this wrapper +// blocks until the server closes the stream and returns only the final +// summary, matching the pre-streaming public surface. func (c *Client) SendFiles(path string, runID string, files []FilePayload) (*SendFilesResponse, error) { + return c.SendFilesStreaming(context.Background(), path, runID, files, nil) +} + +// SendFilesStreaming sends a batch of files and streams NDJSON progress +// events from the server. The onEvent callback is invoked for every event; +// pass nil if you only want the final summary. +// +// On HTTP 503 (GPU busy) or 429 (rate limited) the request is retried with +// exponential backoff up to maxSendRetries times BEFORE the stream begins. +// Once the stream has started (i.e. the server responded with NDJSON), the +// caller is in a long-lived single attempt — failures during the stream +// surface to the caller without a retry. +// +// Returns ErrLegacyServer if the server doesn't speak NDJSON (Content-Type +// negotiation failed). The CLI surfaces this as "upgrade your server". +// +// Returns ErrIdleTimeout if no data arrives for streamingIdleTimeout — the +// connection is forcibly closed and the caller should treat the run as +// failed (the server will see ctx cancellation and free the session lock). +func (c *Client) SendFilesStreaming( + ctx context.Context, + path string, + runID string, + files []FilePayload, + onEvent func(ProgressEvent), +) (*SendFilesResponse, error) { encodedPath := encodeProjectPath(path) + url := c.baseURL + fmt.Sprintf("/api/v1/projects/%s/index/files", encodedPath) + body := map[string]interface{}{ "run_id": runID, "files": files, } + bodyBytes, err := json.Marshal(body) + if err != nil { + return nil, fmt.Errorf("marshal body: %w", err) + } for attempt := 0; attempt <= maxSendRetries; attempt++ { - resp, err := c.do("POST", fmt.Sprintf("/api/v1/projects/%s/index/files", encodedPath), body) + // Wrap caller ctx so the idle watchdog can cancel without touching + // the original. callerErr() distinguishes "caller cancelled us" + // from "watchdog cancelled us" when reporting errors. + streamCtx, streamCancel := context.WithCancel(ctx) + + req, err := http.NewRequestWithContext(streamCtx, http.MethodPost, url, bytes.NewReader(bodyBytes)) + if err != nil { + streamCancel() + return nil, fmt.Errorf("create request: %w", err) + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/x-ndjson") + if c.apiKey != "" { + req.Header.Set("Authorization", "Bearer "+c.apiKey) + } + + resp, err := c.streamingClient.Do(req) if err != nil { - return nil, err + streamCancel() + return nil, fmt.Errorf("do request: %w", err) } + // Retryable backpressure responses — short body, no streaming begun. if resp.StatusCode == http.StatusServiceUnavailable || resp.StatusCode == http.StatusTooManyRequests { header := resp.Header.Get("Retry-After") resp.Body.Close() + streamCancel() delay := retryAfterDelay(header, sendRetryDelay(attempt)) fmt.Printf(" GPU busy — retrying in %s (attempt %d/%d)...\n", delay.Round(time.Second), attempt+1, maxSendRetries) - time.Sleep(delay) + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(delay): + } continue } - var result SendFilesResponse - if err := parseResponse(resp, &result); err != nil { - return nil, err + // Any non-200 here is a hard error (bad run_id, project missing, …). + if resp.StatusCode != http.StatusOK { + defer resp.Body.Close() + defer streamCancel() + respBody, _ := io.ReadAll(resp.Body) + var errResp struct { + Detail string `json:"detail"` + } + if json.Unmarshal(respBody, &errResp) == nil && errResp.Detail != "" { + return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, errResp.Detail) + } + return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, string(respBody)) } - return &result, nil + + // Hard fail if the server returned plain JSON (legacy build) instead + // of NDJSON. We deliberately do not attempt a fallback parse — the + // operator is expected to upgrade the server first. + ct := resp.Header.Get("Content-Type") + if !strings.HasPrefix(ct, "application/x-ndjson") { + resp.Body.Close() + streamCancel() + return nil, ErrLegacyServer + } + + // At this point we have an open NDJSON stream. The retry loop ends. + result, err := readStream(streamCtx, streamCancel, resp.Body, onEvent, c.streamingIdleTimeout, ctx) + streamCancel() + return result, err } return nil, fmt.Errorf("GPU still busy after %d retries — try again later", maxSendRetries) } +// readStream consumes NDJSON lines from body, invokes onEvent for each, and +// returns the SendFilesResponse harvested from the terminal batch_done event. +// streamCancel is called whenever readStream wants to abort the connection +// (idle timeout, decode error, fatal server event). +func readStream( + streamCtx context.Context, + streamCancel context.CancelFunc, + body io.ReadCloser, + onEvent func(ProgressEvent), + idleTimeout time.Duration, + callerCtx context.Context, +) (*SendFilesResponse, error) { + defer body.Close() + + // Idle watchdog — fires streamCancel if no line arrives for idleTimeout. + // idleTimeout=0 disables the watchdog (used by tests when convenient). + lineRead := make(chan struct{}, 1) + if idleTimeout > 0 { + go func() { + timer := time.NewTimer(idleTimeout) + defer timer.Stop() + for { + select { + case <-lineRead: + if !timer.Stop() { + select { + case <-timer.C: + default: + } + } + timer.Reset(idleTimeout) + case <-timer.C: + streamCancel() + return + case <-streamCtx.Done(): + return + } + } + }() + } + + scanner := bufio.NewScanner(body) + // Some chunks may be very large (long file paths or error messages); + // give the scanner room. 1 MiB max-line should cover anything realistic. + scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + + var final *SendFilesResponse + var fatalErr error + + for scanner.Scan() { + // Notify watchdog: line arrived, reset idle timer. + select { + case lineRead <- struct{}{}: + default: + } + + line := bytes.TrimSpace(scanner.Bytes()) + if len(line) == 0 { + continue + } + + var ev ProgressEvent + if err := json.Unmarshal(line, &ev); err != nil { + return nil, fmt.Errorf("decode ndjson line: %w (line=%q)", err, line) + } + + if onEvent != nil { + onEvent(ev) + } + + switch ev.Event { + case EventBatchDone: + // Don't return yet — there may be a trailing newline. The + // scanner.Scan() loop will exit naturally on EOF. + final = &SendFilesResponse{ + FilesAccepted: ev.FilesAccepted, + ChunksCreated: ev.ChunksCreated, + FilesProcessedTotal: ev.FilesProcessedTotal, + } + case EventError: + if ev.Fatal { + fatalErr = fmt.Errorf("server error: %s", ev.Message) + } + } + } + + if err := scanner.Err(); err != nil { + // Distinguish caller cancel vs idle timeout vs network error. + if callerCtx.Err() != nil { + return nil, callerCtx.Err() + } + if streamCtx.Err() == context.Canceled && idleTimeout > 0 { + return nil, ErrIdleTimeout + } + return nil, fmt.Errorf("scan ndjson: %w", err) + } + + if fatalErr != nil { + return nil, fatalErr + } + if final == nil { + // Stream ended cleanly but no batch_done — server bug or partial + // write. Surface it so the caller can retry the batch. + return nil, fmt.Errorf("ndjson stream ended without batch_done event") + } + return final, nil +} + // FinishIndex completes the indexing session, removing deleted files. func (c *Client) FinishIndex(path string, runID string, deletedPaths []string, totalFiles int) (*FinishIndexResponse, error) { encodedPath := encodeProjectPath(path) diff --git a/cli/internal/client/index_streaming_test.go b/cli/internal/client/index_streaming_test.go new file mode 100644 index 0000000..712134a --- /dev/null +++ b/cli/internal/client/index_streaming_test.go @@ -0,0 +1,331 @@ +package client + +import ( + "bufio" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" +) + +// streamWriter is a tiny convenience for tests that need to push NDJSON +// lines from the server side. It writes one JSON object per call followed +// by a newline, then flushes so the client sees it immediately. +type streamWriter struct { + w http.ResponseWriter + f http.Flusher +} + +func newStreamWriter(t *testing.T, w http.ResponseWriter) *streamWriter { + t.Helper() + f, ok := w.(http.Flusher) + if !ok { + t.Fatal("response writer does not implement Flusher") + } + w.Header().Set("Content-Type", "application/x-ndjson") + w.WriteHeader(http.StatusOK) + f.Flush() + return &streamWriter{w: w, f: f} +} + +func (s *streamWriter) write(t *testing.T, ev ProgressEvent) { + t.Helper() + b, err := json.Marshal(ev) + if err != nil { + t.Fatalf("marshal event: %v", err) + } + if _, err := s.w.Write(append(b, '\n')); err != nil { + t.Logf("write: %v", err) // not fatal — client may have disconnected + } + s.f.Flush() +} + +// TestSendFilesStreaming_BatchDone — happy path: events delivered in order, +// final SendFilesResponse pulled from batch_done event. +func TestSendFilesStreaming_BatchDone(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Header.Get("Accept") != "application/x-ndjson" { + t.Errorf("Accept header = %q, want application/x-ndjson", r.Header.Get("Accept")) + } + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{Event: EventFileStarted, Path: "/p/a.go", FileIndex: 1, BatchSize: 2}) + s.write(t, ProgressEvent{Event: EventFileEmbedded, Path: "/p/a.go", Chunks: 3, EmbedMS: 50}) + s.write(t, ProgressEvent{Event: EventFileDone, Path: "/p/a.go", Chunks: 3}) + s.write(t, ProgressEvent{Event: EventFileStarted, Path: "/p/b.go", FileIndex: 2, BatchSize: 2}) + s.write(t, ProgressEvent{Event: EventFileDone, Path: "/p/b.go", Chunks: 2}) + s.write(t, ProgressEvent{ + Event: EventBatchDone, FilesAccepted: 2, ChunksCreated: 5, FilesProcessedTotal: 2, + }) + })) + defer srv.Close() + + c := New(srv.URL, "key") + var events []ProgressEvent + resp, err := c.SendFilesStreaming(context.Background(), "/p", "run-1", []FilePayload{ + {Path: "/p/a.go", Content: "x"}, + {Path: "/p/b.go", Content: "y"}, + }, func(ev ProgressEvent) { + events = append(events, ev) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp.FilesAccepted != 2 || resp.ChunksCreated != 5 { + t.Errorf("resp = %+v, want files=2 chunks=5", resp) + } + if len(events) != 6 { + t.Errorf("events count = %d, want 6", len(events)) + } + if events[0].Event != EventFileStarted { + t.Errorf("events[0] = %q, want %q", events[0].Event, EventFileStarted) + } + if events[len(events)-1].Event != EventBatchDone { + t.Errorf("last event = %q, want %q", events[len(events)-1].Event, EventBatchDone) + } +} + +// TestSendFilesStreaming_Heartbeat verifies heartbeat events make it to the +// callback (not just dropped) and final result still reflects only batch_done. +func TestSendFilesStreaming_Heartbeat(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{Event: EventHeartbeat, TS: "2026-04-27T17:00:00Z"}) + s.write(t, ProgressEvent{Event: EventHeartbeat, TS: "2026-04-27T17:00:10Z"}) + s.write(t, ProgressEvent{Event: EventBatchDone, FilesAccepted: 0}) + })) + defer srv.Close() + + c := New(srv.URL, "") + heartbeatCount := 0 + resp, err := c.SendFilesStreaming(context.Background(), "/p", "r", nil, func(ev ProgressEvent) { + if ev.Event == EventHeartbeat { + heartbeatCount++ + } + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if heartbeatCount != 2 { + t.Errorf("heartbeat count = %d, want 2", heartbeatCount) + } + if resp.FilesAccepted != 0 { + t.Errorf("resp.FilesAccepted = %d, want 0", resp.FilesAccepted) + } +} + +// TestSendFilesStreaming_LegacyServer ensures we hard-fail when the server +// returns single-JSON instead of NDJSON. No silent fallback — caller learns +// they need to upgrade. +func TestSendFilesStreaming_LegacyServer(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(`{"files_accepted":1,"chunks_created":3,"files_processed_total":1}`)) + })) + defer srv.Close() + + c := New(srv.URL, "") + calledBack := false + _, err := c.SendFilesStreaming(context.Background(), "/p", "r", nil, func(ev ProgressEvent) { + calledBack = true + }) + if !errors.Is(err, ErrLegacyServer) { + t.Errorf("err = %v, want ErrLegacyServer", err) + } + if calledBack { + t.Error("onEvent should not have been called against a legacy server") + } +} + +// TestSendFilesStreaming_IdleTimeout — stall the response indefinitely and +// confirm the watchdog cancels the request. +func TestSendFilesStreaming_IdleTimeout(t *testing.T) { + stall := make(chan struct{}) // never closed + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + s := newStreamWriter(t, w) + // Send one event then sit silent until the client times out. + s.write(t, ProgressEvent{Event: EventFileStarted, Path: "/p/x.go"}) + select { + case <-stall: + case <-r.Context().Done(): + } + })) + defer srv.Close() + defer close(stall) + + c := New(srv.URL, "") + c.SetStreamingIdleTimeout(150 * time.Millisecond) + _, err := c.SendFilesStreaming(context.Background(), "/p", "r", nil, nil) + if !errors.Is(err, ErrIdleTimeout) { + t.Errorf("err = %v, want ErrIdleTimeout", err) + } +} + +// TestSendFilesStreaming_FatalError — server emits a fatal error event, +// caller gets a non-nil error containing the message. +func TestSendFilesStreaming_FatalError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{Event: EventFileStarted, Path: "/p/x.go"}) + s.write(t, ProgressEvent{Event: EventError, Message: "embedder unavailable", Fatal: true}) + })) + defer srv.Close() + + c := New(srv.URL, "") + _, err := c.SendFilesStreaming(context.Background(), "/p", "r", nil, nil) + if err == nil { + t.Fatal("expected error from fatal event, got nil") + } + if !strings.Contains(err.Error(), "embedder unavailable") { + t.Errorf("error %q does not contain server message", err) + } +} + +// TestSendFilesStreaming_NonStreamingErrorBodyDecoded — when the server +// returns non-200 (e.g. 404 bad run_id), the JSON detail is surfaced. +func TestSendFilesStreaming_NonStreamingError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusNotFound) + _, _ = w.Write([]byte(`{"detail":"unknown run_id"}`)) + })) + defer srv.Close() + + c := New(srv.URL, "") + _, err := c.SendFilesStreaming(context.Background(), "/p", "r", nil, nil) + if err == nil { + t.Fatal("expected error, got nil") + } + if !strings.Contains(err.Error(), "unknown run_id") { + t.Errorf("error %q does not surface server detail", err) + } +} + +// TestSendFiles_BackwardCompat — existing public surface still works, +// invoking SendFilesStreaming under the hood. +func TestSendFiles_BackwardCompat(t *testing.T) { + var requestSeen sync.WaitGroup + requestSeen.Add(1) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer requestSeen.Done() + if r.Header.Get("Accept") != "application/x-ndjson" { + t.Errorf("SendFiles wrapper must request NDJSON, got Accept=%q", r.Header.Get("Accept")) + } + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{ + Event: EventBatchDone, FilesAccepted: 1, ChunksCreated: 4, FilesProcessedTotal: 1, + }) + })) + defer srv.Close() + + c := New(srv.URL, "") + resp, err := c.SendFiles("/p", "r", []FilePayload{{Path: "/p/x.go"}}) + if err != nil { + t.Fatalf("err: %v", err) + } + if resp.FilesAccepted != 1 || resp.ChunksCreated != 4 { + t.Errorf("resp = %+v", resp) + } + requestSeen.Wait() +} + +// TestSendFilesStreaming_RetryOn503 — server returns 503 with Retry-After, +// then succeeds; client should follow the retry and ultimately get the +// batch_done event without surfacing the temporary failure. +func TestSendFilesStreaming_RetryOn503(t *testing.T) { + var calls int32 + var mu sync.Mutex + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + calls++ + current := calls + mu.Unlock() + if current == 1 { + w.Header().Set("Retry-After", "1") + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusServiceUnavailable) + _, _ = w.Write([]byte(`{"detail":"GPU busy"}`)) + return + } + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{ + Event: EventBatchDone, FilesAccepted: 1, ChunksCreated: 2, FilesProcessedTotal: 1, + }) + })) + defer srv.Close() + + c := New(srv.URL, "") + // Stub stdout via the Bash tool not relevant here; the retry print is OK. + resp, err := c.SendFilesStreaming(context.Background(), "/p", "r", []FilePayload{{Path: "x"}}, nil) + if err != nil { + t.Fatalf("expected success after retry, got err: %v", err) + } + if resp.FilesAccepted != 1 { + t.Errorf("resp.FilesAccepted = %d, want 1", resp.FilesAccepted) + } + if calls != 2 { + t.Errorf("expected 2 server calls, got %d", calls) + } +} + +// TestSendFilesStreaming_CallerCancel — caller cancels ctx mid-stream, the +// streaming call returns the context error promptly. +func TestSendFilesStreaming_CallerCancel(t *testing.T) { + hold := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + s := newStreamWriter(t, w) + s.write(t, ProgressEvent{Event: EventFileStarted, Path: "/p/x.go"}) + select { + case <-hold: + case <-r.Context().Done(): + } + })) + defer srv.Close() + defer close(hold) + + c := New(srv.URL, "") + c.SetStreamingIdleTimeout(0) // disable watchdog so we test caller cancel only + + ctx, cancel := context.WithCancel(context.Background()) + + // Cancel after the first event is observed. + gotEvent := make(chan struct{}) + errCh := make(chan error, 1) + go func() { + _, err := c.SendFilesStreaming(ctx, "/p", "r", nil, func(ev ProgressEvent) { + select { + case gotEvent <- struct{}{}: + default: + } + }) + errCh <- err + }() + + select { + case <-gotEvent: + case <-time.After(2 * time.Second): + t.Fatal("never received first event") + } + cancel() + + select { + case err := <-errCh: + if !errors.Is(err, context.Canceled) { + t.Errorf("err = %v, want context.Canceled", err) + } + case <-time.After(2 * time.Second): + t.Fatal("SendFilesStreaming did not return after cancel") + } +} + +// keep imports honest for a future addition; small no-op compile guard +var _ = bufio.NewScanner +var _ = io.EOF +var _ = fmt.Sprintf diff --git a/cli/internal/client/progress.go b/cli/internal/client/progress.go new file mode 100644 index 0000000..c79d5a5 --- /dev/null +++ b/cli/internal/client/progress.go @@ -0,0 +1,60 @@ +package client + +import "errors" + +// ProgressEvent mirrors server/internal/indexer/progress.go:ProgressEvent. +// Both sides ship in the same PR; the duplication is the cost of keeping +// CLI and server as separate Go modules. +// +// Event values: file_started, file_chunked, file_embedded, file_done, +// file_error, heartbeat, batch_done, error. +type ProgressEvent struct { + Event string `json:"event"` + + // Per-file fields. + Path string `json:"path,omitempty"` + FileIndex int `json:"file_index,omitempty"` + BatchSize int `json:"batch_size,omitempty"` + Chunks int `json:"chunks,omitempty"` + EmbedMS int64 `json:"embed_ms,omitempty"` + + // Heartbeat. + TS string `json:"ts,omitempty"` + + // Errors. + Message string `json:"message,omitempty"` + Fatal bool `json:"fatal,omitempty"` + + // batch_done summary. + FilesAccepted int `json:"files_accepted,omitempty"` + ChunksCreated int `json:"chunks_created,omitempty"` + FilesProcessedTotal int `json:"files_processed_total,omitempty"` + + RunID string `json:"run_id,omitempty"` +} + +// Event kinds — keep in sync with server/internal/indexer/progress.go. +const ( + EventFileStarted = "file_started" + EventFileChunked = "file_chunked" + EventFileEmbedded = "file_embedded" + EventFileDone = "file_done" + EventFileError = "file_error" + EventHeartbeat = "heartbeat" + EventBatchDone = "batch_done" + EventError = "error" +) + +// ErrLegacyServer is returned by SendFilesStreaming when the server responds +// with a non-NDJSON Content-Type — meaning the server predates the streaming +// protocol. Callers should surface this as "upgrade your server" rather than +// silently retrying or falling back. +var ErrLegacyServer = errors.New( + "server does not support streaming protocol — upgrade server to a version that supports NDJSON on /index/files", +) + +// ErrIdleTimeout is returned when the streaming response has been silent for +// longer than the configured idle timeout. The server should be sending at +// least a heartbeat every 10 seconds; 30 seconds of silence implies the +// server is hung or the network has stalled. +var ErrIdleTimeout = errors.New("streaming response idle timeout — no data from server") diff --git a/cli/internal/client/search.go b/cli/internal/client/search.go index 2392d41..c1eb3bc 100644 --- a/cli/internal/client/search.go +++ b/cli/internal/client/search.go @@ -2,23 +2,48 @@ package client import "fmt" -// SearchResult represents a code search result -type SearchResult struct { - FilePath string `json:"file_path"` +// FileMatch is one search hit inside a file group. Position + score + +// content + chunk metadata. NestedHits records overlapping inner chunks +// that were absorbed by mergeOverlappingHits on the server side (e.g. a +// markdown H2 absorbed into its parent H1 section). +type FileMatch struct { + StartLine int `json:"start_line"` + EndLine int `json:"end_line"` + Content string `json:"content"` + Score float64 `json:"score"` + ChunkType string `json:"chunk_type"` + SymbolName string `json:"symbol_name,omitempty"` + NestedHits []NestedHit `json:"nested_hits,omitempty"` +} + +// NestedHit is a chunk absorbed INTO a parent FileMatch. The parent's +// content already contains it textually; this carries just the metadata +// so renderers can show a breadcrumb and let the user jump to the line. +type NestedHit struct { StartLine int `json:"start_line"` EndLine int `json:"end_line"` - Content string `json:"content"` - Score float64 `json:"score"` + SymbolName string `json:"symbol_name,omitempty"` ChunkType string `json:"chunk_type"` - SymbolName string `json:"symbol_name"` - Language string `json:"language"` + Score float64 `json:"score"` +} + +// SearchResult is the top-level unit of search output: one file with +// every match inside it that passed min_score. Files are ordered by +// BestScore descending; matches inside are ordered by StartLine ascending +// (natural reading order). No per-file cap — the only intra-file filter +// is the similarity threshold. +type SearchResult struct { + FilePath string `json:"file_path"` + Language string `json:"language,omitempty"` + BestScore float64 `json:"best_score"` + Matches []FileMatch `json:"matches"` } // SearchResponse represents the search response type SearchResponse struct { - Results []SearchResult `json:"results"` - Total int `json:"total"` - QueryTimeMS float64 `json:"query_time_ms"` + Results []SearchResult `json:"results"` + Total int `json:"total"` + QueryTimeMS float64 `json:"query_time_ms"` } // SymbolResult represents a symbol search result @@ -44,6 +69,7 @@ type SearchOptions struct { Limit int `json:"limit"` Languages []string `json:"languages,omitempty"` Paths []string `json:"paths,omitempty"` + Excludes []string `json:"excludes,omitempty"` MinScore float64 `json:"min_score,omitempty"` } @@ -62,6 +88,9 @@ func (c *Client) Search(projectPath, query string, opts SearchOptions) (*SearchR if len(opts.Paths) > 0 { body["paths"] = opts.Paths } + if len(opts.Excludes) > 0 { + body["excludes"] = opts.Excludes + } if opts.MinScore > 0 { body["min_score"] = opts.MinScore } diff --git a/cli/internal/config/config.go b/cli/internal/config/config.go index 61cb06b..1456819 100644 --- a/cli/internal/config/config.go +++ b/cli/internal/config/config.go @@ -36,6 +36,12 @@ type ServerConfig struct { type IndexingConfig struct { BatchSize int `yaml:"batchsize"` + + // StreamingIdleTimeoutSec is the maximum allowed silence on the streaming + // /index/files response before the CLI gives up and closes the conn. The + // server emits a heartbeat every 10s, so 30s gives the network three + // retry windows. Set to 0 to disable the watchdog (not recommended). + StreamingIdleTimeoutSec int `yaml:"streaming_idle_timeout_sec"` } type ProjectEntry struct { @@ -68,7 +74,8 @@ func defaults() Config { CacheTTL: 300, }, Indexing: IndexingConfig{ - BatchSize: 20, + BatchSize: 20, + StreamingIdleTimeoutSec: 30, }, } } diff --git a/cli/internal/indexer/indexer.go b/cli/internal/indexer/indexer.go index 4b69bd6..96ec57e 100644 --- a/cli/internal/indexer/indexer.go +++ b/cli/internal/indexer/indexer.go @@ -1,6 +1,7 @@ package indexer import ( + "context" "fmt" "os" "time" @@ -21,7 +22,25 @@ type Result struct { } // Run performs a complete index cycle: begin → discover → diff → send batches → finish. -func Run(apiClient *client.Client, projectPath string, full bool, batchSize int) (*Result, error) { +// +// ctx is honoured for cancellation: a SIGINT-derived ctx (or a watcher's stop +// signal) propagates through to the streaming SendFilesStreaming call, which +// closes the HTTP connection. The server-side streaming handler sees the +// disconnect and frees the project's session lock immediately, so the next +// reindex doesn't hit 409. As a belt-and-braces, this function defers an +// explicit CancelIndex call for the active run on early exit. +// +// mode controls how per-file progress events are rendered. Pass +// AutoProgressMode() for `cix reindex` (TTY-aware), ProgressQuiet for the +// watcher (only summary + errors hit the log). +func Run( + ctx context.Context, + apiClient *client.Client, + projectPath string, + full bool, + batchSize int, + mode ProgressMode, +) (*Result, error) { if batchSize <= 0 { batchSize = defaultBatchSize } @@ -36,6 +55,17 @@ func Run(apiClient *client.Client, projectPath string, full bool, batchSize int) } fmt.Printf(" Session: %s\n", beginResp.RunID) + // Belt-and-braces: if we exit early (ctx cancellation, network error, + // SendFilesStreaming failure), tell the server to release the project + // lock instead of leaving it for the 1-hour TTL. CancelIndex is + // idempotent and fast. + cancelDone := false + defer func() { + if !cancelDone { + _, _ = apiClient.CancelIndex(projectPath) + } + }() + // Phase 2: Discover files on disk fmt.Println("Discovering files...") discovered, err := discovery.Discover(projectPath, discovery.Options{}) @@ -80,8 +110,16 @@ func Run(apiClient *client.Client, projectPath string, full bool, batchSize int) fmt.Printf(" %d file(s) to process\n", len(toProcess)) } - // Phase 3: Send files in batches + // Phase 3: Send files in batches via streaming. Each batch gets its own + // progressRenderer so per-file indices restart from 1 in the renderer's + // context but display globally as (batchOffset+i). for i := 0; i < len(toProcess); i += batchSize { + // Honour ctx cancellation between batches; mid-batch cancellation + // is handled inside SendFilesStreaming. + if err := ctx.Err(); err != nil { + return nil, err + } + end := i + batchSize if end > len(toProcess) { end = len(toProcess) @@ -110,20 +148,28 @@ func Run(apiClient *client.Client, projectPath string, full bool, batchSize int) continue } - resp, err := apiClient.SendFiles(projectPath, beginResp.RunID, payloads) + // batchOffset is 1-based offset of the first payload in this batch + // within the overall toProcess slice. Renderer adds ev.FileIndex + // (which is also 1-based per batch) and prints `[N/total]`. + renderer := newProgressRenderer(mode, len(toProcess), i) + _, err := apiClient.SendFilesStreaming( + ctx, projectPath, beginResp.RunID, payloads, renderer.onEvent, + ) if err != nil { return nil, fmt.Errorf("send files (batch %d-%d): %w", i+1, end, err) } - - fmt.Printf(" Processed %d/%d files (%d chunks)\n", - resp.FilesProcessedTotal, len(toProcess), resp.ChunksCreated) } - // Phase 4: Finish — server cleans up deleted files and finalizes the run + // Phase 4: Finish — server cleans up deleted files and finalizes the run. + // We mark cancelDone before this point so the deferred CancelIndex doesn't + // fire on the happy path. + cancelDone = true finishResp, err := apiClient.FinishIndex( projectPath, beginResp.RunID, deletedPaths, len(discovered), ) if err != nil { + // Restore the deferred cancel — finish failed, lock should be released. + _, _ = apiClient.CancelIndex(projectPath) return nil, fmt.Errorf("finish index: %w", err) } diff --git a/cli/internal/indexer/indexer_test.go b/cli/internal/indexer/indexer_test.go index 7609289..fb490d6 100644 --- a/cli/internal/indexer/indexer_test.go +++ b/cli/internal/indexer/indexer_test.go @@ -1,6 +1,7 @@ package indexer import ( + "context" "crypto/sha1" "crypto/sha256" "encoding/hex" @@ -50,11 +51,11 @@ type indexHandler struct { } func (h *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "application/json") p := r.URL.Path switch { case strings.Contains(p, h.hash+"/index/begin"): + w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]any{ "run_id": "run-test", "stored_hashes": h.beginHashes, @@ -67,7 +68,17 @@ func (h *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { } _ = json.Unmarshal(body, &payload) h.FilesReceived = append(h.FilesReceived, payload.Files...) - json.NewEncoder(w).Encode(map[string]any{ + + // Speak NDJSON — the new client requires it. We emit a single + // batch_done event matching the legacy summary semantics so existing + // assertions on FilesReceived continue to hold. + w.Header().Set("Content-Type", "application/x-ndjson") + w.WriteHeader(http.StatusOK) + if f, ok := w.(http.Flusher); ok { + f.Flush() + } + _ = json.NewEncoder(w).Encode(map[string]any{ + "event": "batch_done", "files_accepted": len(payload.Files), "chunks_created": len(payload.Files), "files_processed_total": len(payload.Files), @@ -80,12 +91,17 @@ func (h *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { } _ = json.Unmarshal(body, &finish) h.DeletedPaths = finish.DeletedPaths + w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]any{ "status": "ok", "files_processed": len(h.FilesReceived), "chunks_created": len(h.FilesReceived), }) + case strings.Contains(p, h.hash+"/index/cancel"): + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string]any{"cancelled": false}) + default: http.NotFound(w, r) } @@ -111,7 +127,7 @@ func TestRun_AddNewFile(t *testing.T) { srv, h := newServer(t, dir, map[string]string{}) c := client.New(srv.URL, "test-key") - result, err := Run(c, dir, false, 0) + result, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -137,7 +153,7 @@ func TestRun_UpdatedFile(t *testing.T) { }) c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, false, 0) + _, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -165,7 +181,7 @@ func TestRun_DeletedFile(t *testing.T) { }) c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, false, 0) + _, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -219,7 +235,7 @@ func TestRun_NoChanges(t *testing.T) { t.Cleanup(srv.Close) c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, false, 0) + _, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -243,7 +259,7 @@ func TestRun_FullReindex(t *testing.T) { srv, h := newServer(t, dir, map[string]string{path: storedHash}) c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, true /* full */, 0) + _, err := Run(context.Background(), c, dir, true /* full */, 0, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -270,7 +286,7 @@ func TestRun_ServerUnavailable(t *testing.T) { srv.Close() c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, false, 0) + _, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err == nil { t.Fatal("expected error when server is unavailable, got nil") } @@ -294,7 +310,7 @@ func TestRun_ServerError5xx(t *testing.T) { t.Cleanup(srv.Close) c := client.New(srv.URL, "test-key") - _, err := Run(c, dir, false, 0) + _, err := Run(context.Background(), c, dir, false, 0, ProgressQuiet) if err == nil { t.Fatal("expected error on 503, got nil") } @@ -317,7 +333,7 @@ func TestRun_RecoveryAfterFailure(t *testing.T) { downSrv.Close() c1 := client.New(downSrv.URL, "test-key") - if _, err := Run(c1, dir, false, 0); err == nil { + if _, err := Run(context.Background(), c1, dir, false, 0, ProgressQuiet); err == nil { t.Fatal("expected error on first run") } @@ -326,7 +342,7 @@ func TestRun_RecoveryAfterFailure(t *testing.T) { srv, h := newServer(t, dir, map[string]string{}) c2 := client.New(srv.URL, "test-key") - _, err := Run(c2, dir, false, 0) + _, err := Run(context.Background(), c2, dir, false, 0, ProgressQuiet) if err != nil { t.Fatalf("expected recovery run to succeed: %v", err) } @@ -352,7 +368,7 @@ func TestRun_MultipleFiles(t *testing.T) { srv, h := newServer(t, dir, map[string]string{}) c := client.New(srv.URL, "test-key") - result, err := Run(c, dir, false, 1 /* batchSize=1 to exercise batching */) + result, err := Run(context.Background(), c, dir, false, 1 /* batchSize=1 to exercise batching */, ProgressQuiet) if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/cli/internal/indexer/progress.go b/cli/internal/indexer/progress.go new file mode 100644 index 0000000..0acfa6c --- /dev/null +++ b/cli/internal/indexer/progress.go @@ -0,0 +1,205 @@ +package indexer + +import ( + "fmt" + "io" + "os" + "time" + "unicode/utf8" + + "github.com/anthropics/code-index/cli/internal/client" +) + +// ProgressMode controls how SendFilesStreaming events are rendered to the +// user. Reindex on a TTY uses Interactive (in-place status line); reindex +// in CI / non-TTY context uses LineByLine; the watcher uses Quiet (only +// summary + errors land in the log). +type ProgressMode int + +const ( + // ProgressInteractive updates a single status line with carriage returns. + ProgressInteractive ProgressMode = iota + // ProgressLineByLine prints one log line per file_started/file_done. + ProgressLineByLine + // ProgressQuiet only prints file_error and the final batch summary. + ProgressQuiet +) + +// AutoProgressMode returns Interactive when stdout is a terminal and +// LineByLine otherwise. Tests and watchers should pass an explicit mode. +func AutoProgressMode() ProgressMode { + if isTerminal(os.Stdout) { + return ProgressInteractive + } + return ProgressLineByLine +} + +// isTerminal reports whether f is a character device (a TTY). Avoids the +// golang.org/x/term dependency to keep the CLI module's go directive at the +// existing minimum (no toolchain bump for a single-line check). +func isTerminal(f *os.File) bool { + stat, err := f.Stat() + if err != nil { + return false + } + return (stat.Mode() & os.ModeCharDevice) != 0 +} + +// progressRenderer is a stateful event handler. It is created once per batch +// (so per-batch counters reset) and called for every NDJSON event the +// streaming client receives. +type progressRenderer struct { + mode ProgressMode + out io.Writer + totalFiles int // total files to process across all batches + batchOffset int // index of the first file in this batch (1-based) + fileStart time.Time // when the current file's file_started arrived + + // lastLineRunes tracks the visible width of the last status line we + // drew so we can erase it before redrawing. We count runes (not bytes) + // because UTF-8 multi-byte chars like `…` would otherwise inflate the + // padding and the cursor would land past the visible end, leaving the + // tail of the previous line on screen. + lastLineRunes int + + // activeFile is the path we're currently rendering progress for. + activeFile string + + // activeFileIdx caches the global file index from file_started so it + // can be reused on file_chunked / file_embedded / file_done — which + // the server emits without a FileIndex field. Without this cache, the + // renderer fell back to ev.FileIndex == 0 and printed `[0/N]` on every + // file_embedded line. + activeFileIdx int +} + +func newProgressRenderer(mode ProgressMode, totalFiles, batchOffset int) *progressRenderer { + return &progressRenderer{ + mode: mode, + out: os.Stdout, + totalFiles: totalFiles, + batchOffset: batchOffset, + } +} + +// onEvent is the callback fed to client.SendFilesStreaming. +func (r *progressRenderer) onEvent(ev client.ProgressEvent) { + switch r.mode { + case ProgressInteractive: + r.renderInteractive(ev) + case ProgressLineByLine: + r.renderLineByLine(ev) + case ProgressQuiet: + r.renderQuiet(ev) + } +} + +func (r *progressRenderer) renderInteractive(ev client.ProgressEvent) { + switch ev.Event { + case client.EventFileStarted: + r.activeFile = ev.Path + r.activeFileIdx = r.batchOffset + ev.FileIndex + r.fileStart = time.Now() + r.statusLine(fmt.Sprintf("[%d/%d] %s (chunking…)", + r.activeFileIdx, r.totalFiles, ev.Path)) + + case client.EventFileEmbedded: + // FileIndex is not populated on file_embedded; reuse the cached + // value from the matching file_started. + r.statusLine(fmt.Sprintf("[%d/%d] %s (embedded %d chunks, %dms)", + r.activeFileIdx, r.totalFiles, ev.Path, ev.Chunks, ev.EmbedMS)) + + case client.EventFileDone: + // Leave the embedded line — file_done arrives so quickly that + // rewriting it again is just flicker. + + case client.EventHeartbeat: + if r.activeFile != "" { + elapsed := time.Since(r.fileStart).Round(time.Second) + r.statusLine(fmt.Sprintf("[%d/%d] %s · %s elapsed", + r.activeFileIdx, r.totalFiles, r.activeFile, elapsed)) + } + + case client.EventFileError: + r.endStatusLine() + fmt.Fprintf(r.out, " ! %s: %s\n", ev.Path, ev.Message) + + case client.EventBatchDone: + r.endStatusLine() + fmt.Fprintf(r.out, " Processed %d/%d files (%d chunks)\n", + ev.FilesProcessedTotal, r.totalFiles, ev.ChunksCreated) + + case client.EventError: + if ev.Fatal { + r.endStatusLine() + fmt.Fprintf(r.out, " ! server error: %s\n", ev.Message) + } + } +} + +func (r *progressRenderer) renderLineByLine(ev client.ProgressEvent) { + switch ev.Event { + case client.EventFileStarted: + idx := r.batchOffset + ev.FileIndex + fmt.Fprintf(r.out, " [%d/%d] %s\n", idx, r.totalFiles, ev.Path) + case client.EventFileError: + fmt.Fprintf(r.out, " ! %s: %s\n", ev.Path, ev.Message) + case client.EventBatchDone: + fmt.Fprintf(r.out, " Processed %d/%d files (%d chunks)\n", + ev.FilesProcessedTotal, r.totalFiles, ev.ChunksCreated) + case client.EventError: + if ev.Fatal { + fmt.Fprintf(r.out, " ! server error: %s\n", ev.Message) + } + } +} + +func (r *progressRenderer) renderQuiet(ev client.ProgressEvent) { + switch ev.Event { + case client.EventFileError: + fmt.Fprintf(r.out, " ! %s: %s\n", ev.Path, ev.Message) + case client.EventBatchDone: + fmt.Fprintf(r.out, " Processed %d/%d files (%d chunks)\n", + ev.FilesProcessedTotal, r.totalFiles, ev.ChunksCreated) + case client.EventError: + if ev.Fatal { + fmt.Fprintf(r.out, " ! server error: %s\n", ev.Message) + } + } +} + +// statusLine clears the previous line (overwriting with spaces, then \r) and +// writes the new line without a trailing newline. Avoids ANSI escapes so it +// works in any terminal. Width is measured in runes — len() on a string with +// `…` (U+2026, 3 bytes) would over-pad and leave residue from the previous +// line at the right edge. +func (r *progressRenderer) statusLine(s string) { + runes := utf8.RuneCountInString(s) + if runes < r.lastLineRunes { + // Pad with spaces to erase the longer previous text, then \r back + // so the next write overwrites again. + fmt.Fprintf(r.out, "\r%s", s+spaces(r.lastLineRunes-runes)) + } else { + fmt.Fprintf(r.out, "\r%s", s) + } + r.lastLineRunes = runes +} + +// endStatusLine writes a newline so subsequent output starts on a fresh line. +func (r *progressRenderer) endStatusLine() { + if r.lastLineRunes > 0 { + fmt.Fprintln(r.out) + r.lastLineRunes = 0 + } +} + +func spaces(n int) string { + if n <= 0 { + return "" + } + b := make([]byte, n) + for i := range b { + b[i] = ' ' + } + return string(b) +} diff --git a/cli/internal/watcher/watcher.go b/cli/internal/watcher/watcher.go index 3c21371..000f216 100644 --- a/cli/internal/watcher/watcher.go +++ b/cli/internal/watcher/watcher.go @@ -1,6 +1,7 @@ package watcher import ( + "context" "fmt" "log" "os" @@ -463,11 +464,27 @@ func (w *Watcher) runIndexer(full bool) { } }() + // Bridge stopCh → ctx for the duration of this indexing run so + // SendFilesStreaming bails out fast when the watcher is stopped. + ctx, cancelRun := context.WithCancel(context.Background()) + stopBridge := make(chan struct{}) + go func() { + select { + case <-w.stopCh: + cancelRun() + case <-stopBridge: + } + }() + defer func() { + cancelRun() + close(stopBridge) + }() + // Run with transient failure retries var err error for attempt := 0; attempt < 3; attempt++ { var result *indexer.Result - result, err = indexer.Run(w.apiClient, w.projectPath, full, 0) + result, err = indexer.Run(ctx, w.apiClient, w.projectPath, full, 0, indexer.ProgressQuiet) if err == nil { if full { w.logger.Printf("Full reindex complete: %d files, %d chunks (run ID: %s)", diff --git a/cli/internal/watcher/watcher_test.go b/cli/internal/watcher/watcher_test.go index d4fa4a9..d5705e8 100644 --- a/cli/internal/watcher/watcher_test.go +++ b/cli/internal/watcher/watcher_test.go @@ -55,12 +55,15 @@ func newTestWatcher(t *testing.T, projectPath, apiURL string) *Watcher { } // newIndexServer sets up a minimal mock that handles the three-phase index -// protocol and counts how many times each phase was called. +// protocol and counts how many times each phase was called. /index/files +// emits an NDJSON stream when the client sends Accept: application/x-ndjson +// (matching the streaming protocol the production server speaks). type serverCalls struct { mu sync.Mutex Begin int Files int Finish int + Cancel int } func newIndexServer(t *testing.T, dir string) (*httptest.Server, *serverCalls) { @@ -69,30 +72,50 @@ func newIndexServer(t *testing.T, dir string) (*httptest.Server, *serverCalls) { hash := projectHash(dir) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "application/json") p := r.URL.Path calls.mu.Lock() - defer calls.mu.Unlock() switch { case strings.Contains(p, hash+"/index/begin"): calls.Begin++ + calls.mu.Unlock() + w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]any{ "run_id": "run-watch", "stored_hashes": map[string]string{}, }) case strings.Contains(p, hash+"/index/files"): calls.Files++ + calls.mu.Unlock() io.ReadAll(r.Body) //nolint - json.NewEncoder(w).Encode(map[string]any{ - "files_accepted": 0, "chunks_created": 0, "files_processed_total": 0, + // Always speak NDJSON — the production server does the negotiation + // based on the Accept header; for tests we emit the new protocol + // unconditionally because the new client always opts in. + w.Header().Set("Content-Type", "application/x-ndjson") + w.WriteHeader(http.StatusOK) + if f, ok := w.(http.Flusher); ok { + f.Flush() + } + _ = json.NewEncoder(w).Encode(map[string]any{ + "event": "batch_done", + "files_accepted": 0, + "chunks_created": 0, + "files_processed_total": 0, }) case strings.Contains(p, hash+"/index/finish"): calls.Finish++ + calls.mu.Unlock() + w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]any{ "status": "ok", "files_processed": 0, "chunks_created": 0, }) + case strings.Contains(p, hash+"/index/cancel"): + calls.Cancel++ + calls.mu.Unlock() + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string]any{"cancelled": false}) default: + calls.mu.Unlock() http.NotFound(w, r) } })) diff --git a/doc/DEPRECATION_POLICY.md b/doc/DEPRECATION_POLICY.md index aa1b7e3..994204a 100644 --- a/doc/DEPRECATION_POLICY.md +++ b/doc/DEPRECATION_POLICY.md @@ -20,10 +20,11 @@ See `doc/DOCKER_TAGS.md` for the current tag inventory. ## Python backend The Python FastAPI backend (`legacy/python-api/`) was deprecated in -`server/v0.3.0` (2026-04-24). It will be deleted from the repository in -`server/v0.4.0` (target: ~2026-07-24, ~90 days). +`server/v0.3.0` (2026-04-24) and removed from the repository in +`server/v0.4.0` (2026-04-28). The Docker image `dvcdsys/code-index:0.2-python-legacy` is preserved on Docker Hub indefinitely as a rollback option. -See `doc/MIGRATION_FROM_PYTHON.md` for migration instructions. +See `doc/MIGRATION_FROM_PYTHON.md` for migration instructions and the +rollback recipe. diff --git a/doc/LANGUAGES.md b/doc/LANGUAGES.md new file mode 100644 index 0000000..70ef5c4 --- /dev/null +++ b/doc/LANGUAGES.md @@ -0,0 +1,75 @@ +# Supported languages + +cix uses tree-sitter (via `github.com/odvcencio/gotreesitter`) to extract semantic chunks (functions, classes, methods, types) from source code. Files in unsupported languages still get indexed via a sliding-window fallback — they're searchable, just without per-symbol granularity. + +## Default language set (30) + +| ID | gotreesitter factory | Function | Class | Method | Type | +|---|---|:-:|:-:|:-:|:-:| +| `python` | `PythonLanguage` | ✓ | ✓ | | | +| `typescript` | `TypescriptLanguage` | ✓ | ✓ | ✓ | ✓ | +| `tsx` | `TsxLanguage` | ✓ | ✓ | ✓ | ✓ | +| `javascript` | `JavascriptLanguage` | ✓ | ✓ | ✓ | | +| `go` | `GoLanguage` | ✓ | | ✓ | ✓ | +| `rust` | `RustLanguage` | ✓ | ✓ | | ✓ | +| `java` | `JavaLanguage` | ✓ | ✓ | | ✓ | +| `c` | `CLanguage` | ✓ | ✓ | | ✓ | +| `cpp` | `CppLanguage` | ✓ | ✓ | | ✓ | +| `c_sharp` | `CSharpLanguage` | ✓ | ✓ | ✓ | ✓ | +| `ruby` | `RubyLanguage` | ✓ | ✓ | | | +| `php` | `PhpLanguage` | ✓ | ✓ | ✓ | ✓ | +| `swift` | `SwiftLanguage` | ✓ | ✓ | | ✓ | +| `kotlin` | `KotlinLanguage` | ✓ | ✓ | | | +| `scala` | `ScalaLanguage` | ✓ | ✓ | | ✓ | +| `bash` | `BashLanguage` | ✓ | | | | +| `lua` | `LuaLanguage` | ✓ | | | | +| `dart` | `DartLanguage` | ✓ | ✓ | ✓ | ✓ | +| `r` | `RLanguage` | ✓ | | | | +| `objc` | `ObjcLanguage` | ✓ | ✓ | ✓ | ✓ | +| `html` | `HtmlLanguage` | | | | ✓ | +| `css` | `CssLanguage` | | ✓ | | | +| `scss` | `ScssLanguage` | ✓ | ✓ | | | +| `sql` | `SqlLanguage` | ✓ | | | ✓ | +| `markdown` | `MarkdownLanguage` | | | | ✓ | +| `zig` | `ZigLanguage` | ✓ | ✓ | | | +| `julia` | `JuliaLanguage` | ✓ | | | | +| `fortran` | `FortranLanguage` | ✓ | ✓ | | | +| `haskell` | `HaskellLanguage` | ✓ | | | ✓ | +| `ocaml` | `OcamlLanguage` | ✓ | ✓ | | ✓ | + +The exact AST node types per language live in `server/internal/chunker/chunker.go` (`defaultRegistry`). File-extension mapping lives in `server/internal/langdetect/langdetect.go`. + +## Configuring the active set + +`CIX_LANGUAGES` (comma-separated, case-insensitive) restricts the active set. Empty / unset = all defaults. + +```bash +# Only index Python and Go — every other language falls to sliding-window +CIX_LANGUAGES=python,go cix-server + +# Add Rust to the trio +CIX_LANGUAGES="python, go, rust" cix-server +``` + +Unknown IDs are logged at startup and ignored — typos won't crash the server. + +The active set is logged at INFO during startup: + +``` +{"level":"INFO","msg":"chunker languages configured","active":["python","go","rust"]} +``` + +## Languages with extension detection but no grammar + +These produce sliding-window chunks. Adding semantic chunking is a one-map-entry addition in `defaultRegistry`. Candidates: + +`erlang, elixir, commonlisp, svelte, graphql, hcl (terraform), cmake, dockerfile, regex, xml, make` + +PRs welcome — verify node names with `gotreesitter`'s `cmd/tsquery` against a representative fixture before adding. + +## How the chunker decides + +1. `langdetect.Detect(filePath)` maps extension/filename → language ID. +2. `chunker.ChunkFile()` looks up the ID in the active registry. +3. If found and its `languageNodes` map is non-empty → AST-based extraction (function/class/method/type chunks + identifier references). +4. Otherwise → sliding-window chunks of `windowSize=4000` bytes with `overlap=500`. diff --git a/doc/MIGRATION_FROM_PYTHON.md b/doc/MIGRATION_FROM_PYTHON.md index 8315bd8..6f87725 100644 --- a/doc/MIGRATION_FROM_PYTHON.md +++ b/doc/MIGRATION_FROM_PYTHON.md @@ -66,6 +66,7 @@ If you need to go back to the Python server: ## Sunset timeline -The Python code in `legacy/python-api/` will be deleted in `server/v0.4.0` -(approximately 90 days after v0.3.0 — target ~2026-07-24). -The `:0.2-python-legacy` Docker tag is preserved on Docker Hub indefinitely. +The Python code in `legacy/python-api/` was deleted in `server/v0.4.0` +(2026-04-28). This document is retained for historical reference and as +the rollback recipe for the preserved `:0.2-python-legacy` Docker tag, +which stays on Docker Hub indefinitely. diff --git a/doc/SECURITY_DEPLOYMENT.md b/doc/SECURITY_DEPLOYMENT.md new file mode 100644 index 0000000..555070a --- /dev/null +++ b/doc/SECURITY_DEPLOYMENT.md @@ -0,0 +1,160 @@ +# Security & deployment notes + +This document captures the operational requirements that the cix-server +codebase assumes but does not enforce on its own. Read it before exposing +the dashboard to users beyond a single trusted operator. + +## Trusted-proxy posture for `X-Forwarded-For` + +The server reads `X-Forwarded-For` (first hop) when present and uses the +result for two things: + +1. **Audit metadata** — stored as `sessions.last_seen_ip` and + `api_keys.last_used_ip`. +2. **Per-IP login rate limit key** — see "Login brute-force resistance" + below. The per-(IP, email) key still binds independently of the IP + source, so password guessing against a known account is rate-limited + regardless; only the global per-IP sweep cap depends on the header + being trustworthy. + +This makes the trusted-proxy posture **load-bearing for security**, not +just for audit honesty. Two safe deployments: + +- **Reverse proxy in front** (Cloudflare / Caddy / nginx / Traefik / ALB): + configure the proxy to *replace* the inbound `X-Forwarded-For` with the + real client IP, not append to it. Drop `X-Real-IP` if you don't need + it. This is the recommended posture for any internet-exposed + deployment. +- **Direct exposure on a trusted network** (LAN / VPN only): nothing + forwards `X-Forwarded-For` for you, so an attacker who can reach the + port can also forge the header. The per-(IP, email) cap still slows + password guessing, but the global per-IP cap is bypassable. Acceptable + on a trusted network, never on the open internet. + +Example for nginx: + +```nginx +location / { + proxy_set_header X-Forwarded-For $remote_addr; # replace, not append + proxy_set_header Host $host; + proxy_pass http://cix-server:21847; +} +``` + +## TLS + +The session cookie's `Secure` attribute is set automatically when the +request arrives over TLS (`r.TLS != nil`). For any deployment beyond +`localhost`, terminate TLS in front of the server and ensure the server +sees TLS-marked requests so the cookie is not sent in cleartext. + +If you front the server with a TLS-terminating proxy that downgrades to +plain HTTP for the upstream hop, the auto-detection will return false and +`Secure` will be omitted. Two fixes: + +- Terminate TLS directly in cix-server (drop the proxy). +- Or configure the proxy to make the upstream hop look TLS-marked — the + details vary; consult the proxy docs. + +## Login brute-force resistance + +POST `/api/v1/auth/login` is rate-limited in process (`internal/httpapi/loginlimiter.go`): + +- **5 failed attempts per (IP, email) per 15 minutes** — slows guessing + against a known account. Cleared on a successful login so a user who + fat-fingers their password a few times is not stuck. +- **60 attempts per IP per minute** — slows horizontal sweeps across many + emails from a single source. Not cleared on a successful login. + +This is a single-process limiter; multi-replica deployments do not share +state. If you scale out, put a shared throttle (Redis, your reverse proxy) +in front of `/api/v1/auth/login` or accept that the per-replica caps are +the floor. + +## Request body size limits + +A request-body middleware rejects oversize payloads up-front: + +- **Default cap: 1 MiB** for every endpoint. +- **Indexing cap: 64 MiB** for `POST /api/v1/projects/{path}/index/files`, + which legitimately receives JSON-encoded source from a batch of files. + At default config (batch=20, max-file=512 KiB) a real payload is ~11 MiB; + the cap also covers operator-tuned worst case (batch=50 × max-file=1 MiB + ≈ 55 MiB) with headroom. + +The cap fires on `Content-Length` (clean 413) and on chunked-transfer +overflow (the JSON decoder fails and the handler returns 422). If your +indexer batches need more than 64 MiB, raise `indexingMaxBodyBytes` in +`internal/httpapi/middleware.go` rather than asking operators to disable +the cap. + +## Bootstrap admin + +On a fresh database the server reads `CIX_BOOTSTRAP_ADMIN_EMAIL` and +`CIX_BOOTSTRAP_ADMIN_PASSWORD` and creates the first admin row, marked +`must_change_password=1` so the operator must change the password on +first login. + +- Both env vars must be set together; setting only one is a fatal + startup error. +- Once the users table is non-empty, the env vars are ignored. Rotating + the bootstrap password by editing the env has no effect on a running + installation — go through the dashboard or directly through SQLite. +- The bootstrap path is **not transactional**. If two server instances + start simultaneously against the same fresh database, one of them will + fail with a UNIQUE-constraint error from the duplicate email. This is + intentional (better to fail loud than silently create two admins) but + operationally surprising under HA-style deployments — start a single + instance first, then scale out. + +## Password policy + +The server enforces only `len(password) >= 8`. There is no complexity +rule, no breached-password dictionary check, no rotation prompt. + +For internet-exposed deployments, choose admin passwords accordingly: a +20+ character random passphrase from a password manager beats anything +the server could enforce. The rate limiter above caps the damage of +weak passwords at ~480 guesses per (IP, email) per day. + +## No self-service password reset + +A user who forgets their password cannot reset it themselves. Recovery +options (in order of preference): + +1. Another admin issues `POST /api/v1/admin/users` with a new initial + password and `must_change_password=1`, then disables the old account. +2. Direct SQLite access to clear `users.disabled_at` and reset + `users.password_hash` (use bcrypt cost 12). + +Plan for this when designating admins — keep at least two so an admin +reset never requires DB-level intervention. + +## API key scoping + +API keys inherit the full permissions of their owning user. A viewer's +key can do anything a viewer can; an admin's key can do anything an +admin can. There is no read-only scoping, no per-project scoping, no +expiry. + +For automated callers (CI, scripts) that only need to read, create a +dedicated viewer user and issue keys from that account. Rotate keys via +`DELETE /api/v1/api-keys/{id}` rather than reusing them. + +## What the server does NOT do + +If your threat model needs any of these, build them in front of cix-server +or accept the risk: + +- **CSRF tokens.** Protection relies on the cookie's `SameSite=Strict` + + `HttpOnly` attributes, which modern browsers honour. There is no + separate token to validate. +- **CORS.** No `Access-Control-Allow-*` headers are emitted; same-origin + is the assumption. +- **WAF / IDS.** No IP allowlisting, no anomaly detection. Use your + reverse proxy or a host-level firewall. +- **Multi-tenant project ownership.** All authenticated users see all + projects. Destructive mutations (PATCH/DELETE) are admin- + only; create/list/search are open to any authenticated user. If you + need true tenant separation, run separate cix-server instances per + tenant. diff --git a/doc/TODO.md b/doc/TODO.md new file mode 100644 index 0000000..01782ef --- /dev/null +++ b/doc/TODO.md @@ -0,0 +1,109 @@ +# TODO / Roadmap + +Tracked deferred work for the cix project. Items here are deliberately +postponed — typically because they require data from real-world usage, +need a separate design pass, or sit outside the current release scope. + +When you start an item, link the PR/branch in the relevant section. + +--- + +## Plugin v0.2 + +### `PostToolUseFailure` hook for `Bash(cix *)` — graceful degradation when cix-server is unreachable + +**Status:** designed, not implemented. + +**Problem.** During a Claude Code session the cix-server can become +unreachable mid-flight (Docker restart, OOM, OS sleep, network blip). +The plugin's `SessionStart` hook ran successfully at session start and +cached `cix-aware = "1"` for the project. PreToolUse(Grep|Glob) keeps +nudging the model to use `cix search`. The model dutifully runs `cix +search …`, the CLI exits non-zero, and the model sees an error. Plugin +keeps nudging on the next Grep — model retries cix — fails again. Loop. + +**Why we're deferring.** The edge case is rare on a stable local server, +the loop is annoying but not destructive (model picks up after a couple +of failures and switches back to Grep), and the manual workaround +(restart Claude Code session, or set the cache file to `0`) is trivial. +We'd rather collect data on real failure rates from v0.1 before adding +more state machinery. + +**The interactive-prompt question.** Initial intent was an actual UI +dialog: "cix-server unreachable. Disable cix nudges for this session? +[Yes] [No]". After investigating Claude Code's hook API, this isn't +available — `permissionDecision: "ask"` only works for `PreToolUse` +events, and `PostToolUseFailure` does not accept it. There's no +mechanism for a hook to trigger an arbitrary user prompt. + +**Functional equivalent that IS available:** `PostToolUseFailure` can +return `hookSpecificOutput.additionalContext`. We can use that to +1. Overwrite `$CLAUDE_PLUGIN_DATA/cix-aware-$SESSION_ID-$DIR_HASH` + with `"0"` — silencing all subsequent PreToolUse(Grep|Glob) and + PostCompact hooks for the rest of the session in this project. +2. Inject a one-line message via `additionalContext`: + > 💡 cix command failed (server unreachable). Disabled cix nudges + > for this session. Run `cix status` and restart Claude Code if + > you've fixed the server. + +The model relays this to the user in its next response. Effect is +identical to "user clicked Yes on a Disable dialog": plugin goes silent, +user is informed and decides what to do. No actual interactive UI, but +the developer experience is the same. + +**Implementation sketch:** + +1. New script `plugins/cix/scripts/cix-failed.sh` — reads `session_id`, + computes `DIR_HASH`, overwrites the cache file with `"0"`, emits + the JSON message. +2. Register it in `plugins/cix/hooks/hooks.json`: + ```json + "PostToolUseFailure": [ + { + "matcher": "Bash", + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/cix-failed.sh" + } + ] + } + ] + ``` +3. Inside the script, parse `tool_input.command` from stdin and exit + silently if it doesn't start with `cix ` — so unrelated Bash + failures don't trigger the disable path. +4. Idempotent: if cache is already `"0"`, no-op (avoid re-injecting the + message on every subsequent failure). + +**Ship criteria.** Wait for at least one user report (or one self-observed +incident) where v0.1 plugin loops on cix failures before implementing. +Otherwise we're solving a phantom problem. + +**Estimate:** ~1 day. ~50 lines of bash, hooks.json registration, doc +updates in `CLAUDE-CODE-PLUGIN.md`, manual test scenario covering +`docker compose stop` mid-session. + +--- + +### Other deferred plugin work + +- **MCP server** exposing `cix_search` / `cix_definitions` / `cix_references` + as native Claude tools, so cix becomes available in pure Claude + Desktop chat (where plugins don't run). +- **`PreToolUse(Bash)` matcher** that catches inline `grep` calls + (`Bash(grep ...)`) — currently the plugin only nudges on the dedicated + `Grep`/`Glob` tools, not on `grep` invoked through `Bash`. +- **`cix-explorer` subagent** preconfigured for codebase exploration — + `Skill: cix` preloaded + `context: fork` + `agent: Explore` + read-only + tool whitelist. +- **Plugin tag stream + `release-plugin.yml` workflow** so the plugin + has its own version tags (`plugin/v0.1.0`, `plugin/v0.2.0`, …) + alongside `cli/v*` and `server/v*`. + +--- + +## Server / CLI + +(none currently tracked here; server and CLI roadmap is in their +respective changelogs and release-server.yml / release-cli.yml workflows) diff --git a/doc/benchmark-cix-vs-grep-2026-04-28.md b/doc/benchmark-cix-vs-grep-2026-04-28.md new file mode 100644 index 0000000..66a4fe2 --- /dev/null +++ b/doc/benchmark-cix-vs-grep-2026-04-28.md @@ -0,0 +1,329 @@ +# Benchmark — CIX-first vs grep-only navigation (2026-04-28) + +Re-run of the 32-cell head-to-head from 2026-04-27 after a bundle of +search-quality changes landed: path-aware embeddings, `--min-score` default +0.4, `--exclude` flag, relative-path output. Same fixture, same prompts, +same `claude-sonnet-4-6` workers, same 192.168.1.168 cix server — only +the server binary differs from the 2026-04-27 run. + +The point is the **delta vs 2026-04-27**, not the absolute numbers. + +Raw transcripts and metric JSON live in `/tmp/cix-bench/results/runs/`; +prior run preserved at `/tmp/cix-bench/results/runs.2026-04-27/` and +`/tmp/cix-bench/results/results.2026-04-27.csv`. + +--- + +## 1. Headline comparison (16 runs each) + +| Metric | Worker A (grep-only) | Worker B (cix-first) | Δ (B − A) | Δ % | +|--------------------------|----------------------|----------------------|-----------|---------| +| Mean elapsed time (s) | 102.5 | **94.9** | −7.6 | −7.4 % | +| Median elapsed time (s) | 78.5 | **77.0** | −1.5 | −1.9 % | +| Mean tool calls | 20.3 | **19.3** | −1.0 | −4.6 % | +| Mean tokens_in | 1629† | **43** | † | † | +| Mean tokens_out | 3222 | **3111** | −112 | −3.4 % | +| Pass rate | 13 / 16 | **15 / 16** | +2 | +15.4 % | + +† Worker A's `tokens_in` mean is dominated by a single anomaly: +`refactor_04_A` reported 25 641 input tokens (likely a cache-miss accounting +spike), versus 16–26 for the other 15 A cells. **Excluding that one cell, A's +mean tokens_in is 28.9** — the cleaner number for comparison. Both workers' +input-token totals are uncached `input_tokens` only; cache-creation tokens +that dominate real cost on Sonnet are not included by `metrics.sh`. + +**One-glance read:** B is faster, leaner, and more reliable than A on every +headline metric. This is the inverse of the 2026-04-27 run, where B was +*slower and more expensive* than A on average. The pass-rate gap closed +slightly (was 14/16 vs 16/16, now 13/16 vs 15/16) — both workers +regressed by one cell each, but B is still the more reliable navigator. + +--- + +## 1.5 Delta vs 2026-04-27 + +### Worker B (the cell where the new code is exercised) + +| Metric (Worker B) | 2026-04-27 | 2026-04-28 | Δ | Δ % | +|--------------------|------------|------------|------|--------| +| Mean elapsed s | 69.9 | 94.9 | +25.0 | +35.8 % | +| Mean tool calls | 19.2 | 19.3 | +0.1 | +0.5 % | +| Mean tokens_in | 38 | 43 | +5 | +13.2 % | +| Mean tokens_out | 2754 | 3111 | +357 | +13.0 % | +| Pass rate | 16/16 | 15/16 | −1 | −6.3 % | + +### Worker A (control — A doesn't use the cix server) + +| Metric (Worker A) | 2026-04-27 | 2026-04-28 | Δ | Δ % | +|--------------------|------------|------------|-------|---------| +| Mean elapsed s | 62.2 | 102.5 | +40.3 | +64.8 % | +| Mean tool calls | 14.5 | 20.3 | +5.8 | +40.0 % | +| Mean tokens_in† | 33 | 28.9 | −4.1 | −12.4 % | +| Mean tokens_out | 2447 | 3222 | +775 | +31.7 % | +| Pass rate | 14/16 | 13/16 | −1 | −7.1 % | + +† Excluding `refactor_04_A` token-count anomaly (25 641 in). + +**Both workers' absolute numbers grew.** This is Sonnet-side variance — A +doesn't even talk to the cix server, yet it slowed down 65 % on elapsed and +spent 32 % more output tokens. The dev box was idle and on the same +hardware, so the most plausible explanation is run-to-run variance from +the model itself. The 2026-04-27 run finished in ~75 minutes; this run +took ~110 minutes, consistent with a slower-but-equally-clean execution. + +The honest story is therefore in the **A↔B gap within each run**, not the +absolute deltas vs the prior run: + +- Prior run: B was +12 % slower, +32 % more tool calls, +13 % more + output tokens than A. B's only win was pass rate. +- New run: B is −7 % faster, −5 % fewer tool calls, −3 % fewer output + tokens than A — *and* still wins on pass rate. + +The cix-first strategy went from "more expensive, more reliable" to +"strictly better than grep on every headline metric." That flip is what +the new code bought. + +--- + +## 2. Per-task comparison (where the gap moved) + +### bugfix — flat (cix overhead always negligible here) + +| Metric | A (new) | B (new) | Δ B−A | Δ % | (prior B−A %) | +|-------------------|---------|---------|---------|---------|---------------| +| Mean elapsed s | 70.3 | 69.0 | −1.3 | −1.8 % | (−10.2 %) | +| Mean tool calls | 13.3 | 13.5 | +0.2 | +1.5 % | (+3.7 %) | +| Mean tokens_in | 20.5 | 21.0 | +0.5 | +2.4 % | (−4.8 %) | +| Mean tokens_out | 1600.0 | 1665.8 | +65.8 | +4.1 % | (−5.0 %) | +| Pass rate | 4/4 | 4/4 | 0 | 0 % | (0 %) | + +bugfix is a draw both times — when there's a failing test pointing at the +call site, neither navigator needs much exploration. + +### refactor — A regressed, B held steady, gap widened + +| Metric | A (new) | B (new) | Δ B−A | Δ % | (prior B−A %) | +|-------------------|---------|---------|-----------|----------|---------------| +| Mean elapsed s | 79.8 | 96.0 | +16.2 | +20.3 % | (+4.0 %) | +| Mean tool calls | 16.8 | 19.8 | +3.0 | +18.0 % | (+6.2 %) | +| Mean tokens_in† | 23.3 | 28.3 | +5.0 | +21.4 % | (+4.8 %) | +| Mean tokens_out | 2497.5 | 2879.3 | +381.8 | +15.3 % | (−8.1 %) | +| Pass rate | 1/4 | 3/4 | +2 | +200 % | (+50 %) | + +† A excludes refactor_04_A 25 641 anomaly. + +B is slower than A on time *and* tokens here — this is the one task type +where the cix-first overhead still bites. But B's pass rate is 3× A's: +A picked non-seeded ambient inefficiencies (`chunkSlidingWindow`, `topN`) +in 3 of 4 variants, while B hit the seeded function in 3 of 4 (refactor_03 +was the only B-miss, where B picked `topN` instead of `joinLines`). Net: +B trades wall-clock for a much higher chance of finding the right +function. + +### tests — biggest win for B (was the prior tax cell) + +| Metric | A (new) | B (new) | Δ B−A | Δ % | (prior B−A %) | +|-------------------|---------|---------|-----------|----------|---------------| +| Mean elapsed s | 191.3 | **154.3** | −37.0 | **−19.3 %** | (+36.8 %) | +| Mean tool calls | 36.3 | **26.8** | −9.5 | **−26.2 %** | (+103 %) | +| Mean tokens_in | 52.5 | **37.8** | −14.7 | **−28.0 %** | (+79 %) | +| Mean tokens_out | 6789.8 | **5728.8** | −1061.0 | **−15.6 %** | (+26.9 %) | +| Pass rate | 4/4 | 4/4 | 0 | 0 % | (0 %) | + +This is the cell that motivated the search-quality work. **B paid a ++103 % tool-call tax in the prior run; in this run it's a −26 % win.** +And mechanically B did much less reading: B's per-cell `files_read_count` +mean dropped to **7.25** vs A's **15.25** — half. The path-aware +embeddings + min-score 0.4 made the top-K hits relevant enough that B +didn't need to range-read the codebase. + +The most striking single cell: `tests_03_B` finished in 146 s with 6 files +read; `tests_03_A` took 245 s and read 28 files. B chose the public +`Service.CancelIndexing` method (a real exported function); A picked +`splitPath` (unexported) on 3 of 4 variants — the runbook's verification +gap from the prior report is still there. + +### summary — small but consistent flip + +| Metric | A (new) | B (new) | Δ B−A | Δ % | (prior B−A %) | +|-------------------|---------|---------|-----------|----------|---------------| +| Mean elapsed s | 68.8 | **60.3** | −8.5 | **−12.4 %** | (+11.7 %) | +| Mean tool calls | 14.8 | 17.3 | +2.5 | +16.9 % | (+12.1 %) | +| Mean tokens_in† | 17.8 | 19.3 | +1.5 | +8.6 % | (+3.1 %) | +| Mean tokens_out | 2000.8 | 2168.5 | +167.7 | +8.4 % | (+24.0 %) | +| Pass rate | 4/4 | 4/4 | 0 | 0 % | (0 %) | + +† B excludes summary_04_B 285-token-in anomaly. + +Both workers grounded the summaries; rubric scores are flat at 6/7 across +all 8 cells (vs prior A=6,6,6,7 / B=6,5,6,6). B is now ~12 % faster and +spent only +8 % output tokens (vs +24 % before). + +--- + +## 3. Per-run table (all 32 rows, sorted) + +| run_id | elapsed_s | tools | toks_total | toks_in | toks_out | cix_ops | grep_ops | files_read | outcome | +|-----------------|-----------|-------|------------|---------|----------|---------|----------|------------|---------| +| bugfix_01_A | 78 | 15 | 1643 | 24 | 1619 | 0 | 1 | 2 | pass | +| bugfix_01_B | 75 | 13 | 1710 | 21 | 1689 | 0 | 0 | 2 | pass | +| bugfix_02_A | 67 | 10 | 1190 | 16 | 1174 | 0 | 0 | 2 | pass | +| bugfix_02_B | 48 | 11 | 1307 | 16 | 1291 | 0 | 0 | 2 | pass | +| bugfix_03_A | 67 | 13 | 1760 | 19 | 1741 | 0 | 2 | 2 | pass | +| bugfix_03_B | 83 | 15 | 1988 | 26 | 1962 | 0 | 2 | 2 | pass | +| bugfix_04_A | 69 | 15 | 1889 | 23 | 1866 | 0 | 1 | 2 | pass | +| bugfix_04_B | 70 | 15 | 1742 | 21 | 1721 | 0 | 1 | 2 | pass | +| refactor_01_A | 68 | 15 | 2306 | 22 | 2284 | 0 | 3 | 5 | partial | +| refactor_01_B | 104 | 19 | 3052 | 32 | 3020 | 2 | 3 | 1 | pass | +| refactor_02_A | 86 | 16 | 2267 | 22 | 2245 | 0 | 4 | 1 | pass | +| refactor_02_B | 90 | 21 | 2875 | 29 | 2846 | 2 | 5 | 1 | pass | +| refactor_03_A | 80 | 18 | 2263 | 26 | 2237 | 0 | 5 | 1 | partial | +| refactor_03_B | 91 | 18 | 3093 | 25 | 3068 | 2 | 6 | 2 | partial | +| refactor_04_A | 85 | 18 | 28865 | 25641 | 3224 | 0 | 6 | 4 | partial | +| refactor_04_B | 99 | 21 | 2610 | 27 | 2583 | 2 | 2 | 2 | pass | +| summary_01_A | 65 | 12 | 1497 | 15 | 1482 | 0 | 0 | 0 | pass | +| summary_01_B | 64 | 20 | 2156 | 23 | 2133 | 0 | 0 | 8 | pass | +| summary_02_A | 65 | 15 | 2076 | 18 | 2058 | 0 | 0 | 7 | pass | +| summary_02_B | 41 | 13 | 1829 | 16 | 1813 | 1 | 0 | 5 | pass | +| summary_03_A | 79 | 19 | 2398 | 22 | 2376 | 0 | 1 | 10 | pass | +| summary_03_B | 74 | 16 | 2043 | 19 | 2024 | 0 | 1 | 8 | pass | +| summary_04_A | 66 | 13 | 2103 | 16 | 2087 | 0 | 0 | 0 | pass | +| summary_04_B | 62 | 20 | 2989 | 285 | 2704 | 6 | 0 | 0 | pass | +| tests_01_A | 200 | 37 | 7345 | 51 | 7294 | 0 | 3 | 16 | pass | +| tests_01_B | 189 | 31 | 6482 | 46 | 6436 | 0 | 1 | 14 | pass | +| tests_02_A | 163 | 29 | 6042 | 45 | 5997 | 0 | 4 | 9 | pass | +| tests_02_B | 148 | 23 | 6689 | 32 | 6657 | 1 | 2 | 2 | pass | +| tests_03_A | 245 | 50 | 8422 | 66 | 8356 | 0 | 6 | 28 | pass | +| tests_03_B | 146 | 30 | 5490 | 39 | 5451 | 1 | 3 | 6 | pass | +| tests_04_A | 157 | 29 | 5560 | 48 | 5512 | 0 | 5 | 8 | pass | +| tests_04_B | 134 | 23 | 4405 | 34 | 4371 | 1 | 2 | 7 | pass | + +Pass = 28/32 (15 B + 13 A). Partial = 4/32 (3 A refactor + 1 B refactor). +No `(violation)` rows: every A cell has `cix_ops = 0`. + +Summary rubric scores: A = {6, 6, 6, 6}, B = {6, 6, 6, 6}. Both pass +(threshold ≥5). + +--- + +## 4. Methodology (abridged) + +Same as 2026-04-27 (see `docs/benchmark-runbook.md` for the runbook). +Two procedural deviations from the runbook, **identical to the prior +run unless noted**: + +1. PREAMBLE_B URL = `http://192.168.1.168:21847` (RTX 3090 prod box, + not literal `localhost`). Same as prior run. +2. **Per-cell unique workspace** at `/tmp/cix-bench-runs/${RUN_ID}/` + instead of one shared `/tmp/cix-bench-run/`. Different paths produce + different `projectHash` on the server, so each B-cell hits a fresh + index — no residual chunks bleeding between cells. **This is new in + this run.** Effect: every B cell pays a one-time index cost (180-s + wait deadline; observed 30–60 s actual), absorbed inside cell setup + and excluded from `elapsed_s`. + +The cix server on .168 ran the working-tree binary with +`CIX_EMBED_INCLUDE_PATH=true` (default) and the new `min-score=0.4` +default. Spot check before launch: `cix search "main entry point server"` +ranked `server/cmd/cix-server/main.go` first at 0.52, confirming the +path-aware embeddings were live. + +All 32 transcripts identify the worker model as `claude-sonnet-4-6` — +audited via `grep -L 'claude-sonnet-4-6' /tmp/cix-bench/results/runs/*.log` +returning zero lines. + +Fixture manifest (`fixture-manifest.txt`, 3744 hashed files) verified +clean both before and after the run. + +--- + +## 5. Headline numbers (executive summary) + +The 2026-04-27 run found that cix-first navigation was *more reliable but +no faster* than grep-only. The 2026-04-28 re-run, with path-aware +embeddings + `min-score=0.4` shipped, finds cix-first is now +**−7.4 % faster**, **−4.6 % fewer tool calls**, and **−3.4 % fewer +output tokens** than grep-only — while still beating it on pass rate +(15/16 vs 13/16). The single biggest gain is the **tests** task, which +flipped from a +37 % B-tax to a −19 % B-win, with B reading half as many +files per cell. The summary task also flipped (+12 % B-tax → −12 % +B-win). Refactor remains the one task where B costs more wall-clock +than A on average, but B's pass rate (3/4) is 3× A's (1/4) — same +direction as the prior run. + +--- + +## 6. Caveats + +- **Both workers got slower in absolute terms vs 2026-04-27.** A grew + +65 % on elapsed and +32 % on output tokens despite never talking to + the cix server — pure Sonnet variance. B grew +36 % on elapsed. + The honest comparison is therefore the *within-run gap* between A and + B, not the absolute delta vs the prior run. Both within-run gap + measurements are in §1.5 and §2. +- **Per-cell unique paths** are new this run. Prior run reused a single + `/tmp/cix-bench-run/` path so all 32 cells hit the same `projectHash` + on the server. This run isolates each cell on a fresh hash. Effect on + B should be small (server-side caches keyed by chunk content, not + project), but it's a real procedural difference worth flagging. +- **`refactor_04_A` token spike**: 25 641 input tokens vs 16–26 for the + other 15 A cells. Almost certainly cache-miss accounting; treated as + an outlier in the per-task means but kept in the per-run table. +- **`tokens_in` is uncached input only.** Cache-creation and cache-read + tokens dominate real Sonnet cost and are not summed by `metrics.sh`. + This is consistent with the prior run's accounting — the relative gap + is comparable, the absolute number is not the whole bill. +- **Fixture is a snapshot of the cix project itself** — the model may + recognise it from training. Same caveat as 2026-04-27. +- **Tool restriction is enforced via prompt, not at the harness level.** + No A cell violated (`cix_ops = 0` everywhere); we still trust the + prompt because of post-hoc audit, not architecture. +- **Single machine, single model (`claude-sonnet-4-6`), single embedding + model, single random seed per worker.** No warm/cold cache split. +- **Pre-run cix indexing time is excluded from `elapsed_s`** (B gets a + "free" index), as before. Indexing took 30–60 s per B cell on .168 — + not amortised in the workload comparison. +- **Refactor verification still depends on naming the seeded function.** + A's "asymptotically inefficient" picks (`chunkSlidingWindow`, + insertion sort, `topN`) are real wins on the merits but score + `partial` because they aren't the runbook's planted target. The + runbook gap from the prior report (§7.2 too strict) hasn't been + patched. +- **Tests verification is exportedness-blind.** Both workers picked + unexported helpers (`splitPath` and friends) on tests_01/02 and still + scored `pass`. The new code didn't change this. + +--- + +## 7. Verbatim prompts + +Identical to 2026-04-27 (see `docs/benchmark-runbook.md` §3 and §4): +COMMON_PREAMBLE, PREAMBLE_A, PREAMBLE_B, BUGFIX_PROMPT, REFACTOR_PROMPT, +TESTS_PROMPT, SUMMARY_PROMPT — all unchanged. The only deltas in +PREAMBLE_B vs the runbook's literal text are the api URL +(`http://192.168.1.168:21847`) and the per-cell `cd` path +(`/tmp/cix-bench-runs/${RUN_ID}/`). + +For Worker A, the runbook §5.2 auth-error gate line was appended to +every assembled prompt: +> Note: the env var CIX_API_KEY is set to an invalid value for this run; +> any cix call will fail with an auth error. + +--- + +## 8. Where the artefacts live + +- This report: + `doc/benchmark-cix-vs-grep-2026-04-28.md` +- Prior report (preserved): + `doc/benchmark-cix-vs-grep.md` (2026-04-27) +- New CSV: `/tmp/cix-bench/results/results.csv` +- Prior CSV (preserved): `/tmp/cix-bench/results/results.2026-04-27.csv` +- New per-run logs + metrics: `/tmp/cix-bench/results/runs/` +- Prior per-run logs + metrics (preserved): + `/tmp/cix-bench/results/runs.2026-04-27/` +- Summary rubric scores (this run only): + `/tmp/cix-bench/results/rubric.json` +- Fixture (frozen, byte-identical to 2026-04-27): + `/tmp/cix-bench/baseline/`, `/tmp/cix-bench/variants/`, + `/tmp/cix-bench/fixture-manifest.txt` diff --git a/doc/benchmark-cix-vs-grep.md b/doc/benchmark-cix-vs-grep.md new file mode 100644 index 0000000..2f08b8d --- /dev/null +++ b/doc/benchmark-cix-vs-grep.md @@ -0,0 +1,331 @@ +# Benchmark — CIX-first vs grep-only navigation + +Single-machine, single-model (`claude-sonnet-4-6`) head-to-head: 32 hint-free tasks +across 4 task types × 4 variants × 2 navigation strategies (Worker A: grep-only, +Worker B: cix-first). Operator: `claude-opus-4-7`. Run on 2026-04-27. + +The fixture is a frozen snapshot of this same `claude-code-index` project. +All raw transcripts and metric JSON live in `/tmp/cix-bench/results/runs/`; +this report does not include them. + +--- + +## 1. Headline comparison (16 runs each) + +| Metric | Worker A (grep-only) | Worker B (cix-first) | Δ (B − A) | Δ % | +|--------------------------|----------------------|----------------------|-----------|---------| +| Mean elapsed time (s) | **62.2** | 69.9 | +7.7 | +12.4 % | +| Median elapsed time (s) | **58.5** | **58.5** | 0.0 | 0.0 % | +| Mean tool calls | **14.5** | 19.2 | +4.7 | +32.4 % | +| Mean tokens_in | **33** | 38 | +5 | +15.2 % | +| Mean tokens_out | **2447** | 2754 | +307 | +12.5 % | +| Pass rate | 14 / 16 | **16 / 16** | +2 | +12.5 % | + +Δ is `B − A`. Negative on time/tokens means B was faster/cheaper. Bold = better cell per row. + +Token counts are uncached `input_tokens` / `output_tokens` summed across the +worker's assistant messages (per runbook §6). Cache-creation tokens, which +dominate real cost on Sonnet, are reported in §6 as a caveat but not in the +headline because the runbook fixed the metric definition before the run. + +**One-glance read:** B is *more reliable* (16 / 16 pass vs 14 / 16) but *not* +faster or cheaper on average. Median elapsed is identical; the mean gap comes +from a few long B-runs in `tests` and `summary` (see §2). The only clean B +win on time is `bugfix`. + +--- + +## 2. Per-task comparison + +| Task type | Metric | Worker A | Worker B | Δ (B − A) | Δ % | +|-----------|---------------------|----------|----------|-----------|---------| +| bugfix | mean elapsed s | 61.5 | **55.2** | −6.3 | −10.2 % | +| bugfix | mean tool calls | **13.5** | 14.0 | +0.5 | +3.7 % | +| bugfix | mean tokens_in | 21 | **20** | −1 | −4.8 % | +| bugfix | mean tokens_out | 1837 | **1745** | −92 | −5.0 % | +| bugfix | pass rate | 4 / 4 | 4 / 4 | 0 | 0 % | +| refactor | mean elapsed s | **62.0** | 64.5 | +2.5 | +4.0 % | +| refactor | mean tool calls | **13.0** | 13.8 | +0.8 | +6.2 % | +| refactor | mean tokens_in | **21** | 22 | +1 | +4.8 % | +| refactor | mean tokens_out | 2195 | **2018** | −177 | −8.1 % | +| refactor | pass rate | 2 / 4 | **4 / 4**| +2 | +50 % | +| tests | mean elapsed s | **78.2** | 107.0 | +28.8 | +36.8 % | +| tests | mean tool calls | **15.0** | 30.5 | +15.5 | +103 % | +| tests | mean tokens_in | **24** | 43 | +19 | +79 % | +| tests | mean tokens_out | **3865** | 4906 | +1041 | +26.9 % | +| tests | pass rate | 4 / 4 | 4 / 4 | 0 | 0 % | +| summary | mean elapsed s | **47.2** | 52.8 | +5.5 | +11.7 % | +| summary | mean tool calls | **16.5** | 18.5 | +2.0 | +12.1 % | +| summary | mean tokens_in | **64** | 66 | +2 | +3.1 % | +| summary | mean tokens_out | **1892** | 2347 | +454 | +24.0 % | +| summary | pass rate | 4 / 4 | 4 / 4 | 0 | 0 % | + +Where the strategy mattered most — and what it actually changed: + +- **`refactor` is the only place B's pass rate dominates.** A picked the same + non-seeded inefficiency (`chunkSlidingWindow`) twice — for variants 01 and 04 + — and was scored `partial`. B used `cix symbols` / `cix references` to + enumerate candidates more broadly and hit the seeded function in all 4 runs. +- **`bugfix` favors A on wall-clock**, ~10 % faster. With a failing test + pointing at the call site, neither navigator needs much exploration; the + extra round-trip through `cix` is pure overhead. +- **`tests` is where B paid the biggest tax** — +29 s, +1041 output tokens. + B consistently selected real exported functions (`DynamicChromaPersistDir`, + `DeleteByProject`, `DefaultSettings`) which require harness setup + (DB / temp dir) and write longer test bodies. A took the literal cheap path + 4 / 4 times: it picked an *unexported* helper (`splitChunk` ×3, + `sortRanges` ×1) every variant, which the prompt forbade ("public function"). + Verification per §7.3 still scored both as `pass` — §7.3 doesn't gate on + exportedness. See §6. +- **`summary` is a draw on quality** (rubric: A=6,6,6,7 / B=6,5,6,6) but B used + ~24 % more output tokens. Both configs read enough of the tree to ground the + paragraph; neither shape of navigation seems to help here. + +--- + +## 3. Per-run table (all 32 rows) + +| run_id | elapsed_s | tools | toks_total | toks_in | toks_out | cix_ops | grep_ops | files_read | outcome | +|-----------------|-----------|-------|------------|---------|----------|---------|----------|------------|---------| +| bugfix_01_A | 92 | 18 | 3129 | 25 | 3104 | 0 | 3 | 3 | pass | +| bugfix_01_B | 66 | 17 | 2129 | 25 | 2104 | 0 | 0 | 4 | pass | +| bugfix_02_A | 45 | 11 | 1104 | 20 | 1084 | 0 | 0 | 3 | pass | +| bugfix_02_B | 42 | 12 | 1465 | 17 | 1448 | 1 | 0 | 2 | pass | +| bugfix_03_A | 35 | 9 | 1401 | 14 | 1387 | 0 | 0 | 1 | pass | +| bugfix_03_B | 47 | 12 | 1636 | 18 | 1618 | 0 | 1 | 2 | pass | +| bugfix_04_A | 74 | 16 | 1798 | 26 | 1772 | 0 | 1 | 2 | pass | +| bugfix_04_B | 66 | 15 | 1831 | 22 | 1809 | 3 | 0 | 1 | pass | +| refactor_01_A | 55 | 13 | 2127 | 20 | 2107 | 0 | 1 | 3 | partial | +| refactor_01_B | 88 | 15 | 2646 | 25 | 2621 | 2 | 1 | 2 | pass | +| refactor_02_A | 76 | 15 | 2708 | 25 | 2683 | 0 | 3 | 2 | pass | +| refactor_02_B | 62 | 15 | 2229 | 22 | 2207 | 4 | 2 | 1 | pass | +| refactor_03_A | 59 | 11 | 1574 | 19 | 1555 | 0 | 0 | 2 | pass | +| refactor_03_B | 55 | 14 | 1835 | 23 | 1812 | 1 | 0 | 1 | pass | +| refactor_04_A | 58 | 13 | 2455 | 21 | 2434 | 0 | 3 | 3 | partial | +| refactor_04_B | 53 | 11 | 1452 | 19 | 1433 | 1 | 1 | 1 | pass | +| tests_01_A | 88 | 15 | 3600 | 24 | 3576 | 0 | 4 | 2 | pass | +| tests_01_B | 87 | 26 | 4054 | 35 | 4019 | 1 | 0 | 13 | pass | +| tests_02_A | 82 | 14 | 4857 | 23 | 4834 | 0 | 3 | 2 | pass | +| tests_02_B | 122 | 38 | 6779 | 58 | 6721 | 0 | 10 | 15 | pass | +| tests_03_A | 75 | 19 | 3227 | 29 | 3198 | 0 | 4 | 2 | pass | +| tests_03_B | 110 | 26 | 4367 | 37 | 4330 | 1 | 3 | 11 | pass | +| tests_04_A | 68 | 12 | 3873 | 20 | 3853 | 0 | 0 | 2 | pass | +| tests_04_B | 109 | 32 | 4598 | 43 | 4555 | 3 | 2 | 12 | pass | +| summary_01_A | 54 | 20 | 2557 | 199 | 2358 | 0 | 0 | 13 | pass | +| summary_01_B | 47 | 17 | 1845 | 20 | 1825 | 2 | 0 | 0 | pass | +| summary_02_A | 55 | 16 | 1714 | 19 | 1695 | 0 | 0 | 0 | pass | +| summary_02_B | 54 | 24 | 3296 | 27 | 3269 | 3 | 0 | 4 | pass | +| summary_03_A | 37 | 15 | 1836 | 18 | 1818 | 0 | 1 | 10 | pass | +| summary_03_B | 55 | 14 | 2163 | 17 | 2146 | 8 | 0 | 0 | pass | +| summary_04_A | 43 | 15 | 1719 | 21 | 1698 | 0 | 0 | 10 | pass | +| summary_04_B | 55 | 19 | 2345 | 198 | 2147 | 8 | 0 | 5 | pass | + +`cix_ops > 0` for an A row would mean the worker violated the prompt-level +restriction; **no A row has `cix_ops > 0`**, so no `(violation)` flag is needed. + +--- + +## 4. Methodology (abridged from §§0–7 of the runbook) + +**Subjects.** Two prompt-level configurations of `claude-sonnet-4-6` running as +sub-agents (operator is `claude-opus-4-7`): +- **Worker A — grep-only**: PREAMBLE_A restricts tools to Bash / Read / Edit / + Glob / Grep and forbids `cix`. The prompt also tells A that `CIX_API_KEY` + is set to an invalid value, so any cix call would 401. +- **Worker B — cix-first**: PREAMBLE_B advertises `cix search`, `cix + definitions`, `cix references`, `cix symbols`, `cix files` against + `http://192.168.1.168:21847` and notes the project has already been indexed. + Falling back to grep is permitted only when cix returns nothing relevant. + +Verbatim preambles and task prompts are in §7 below. + +**Fixture.** A frozen snapshot of `claude-code-index` at HEAD (`/tmp/cix-bench/baseline/`, +`.venv/` and built bench binaries removed). 16 variants under +`/tmp/cix-bench/variants/{bugfix,refactor,tests,summary}/{01..04}/`. SHA-256 +manifest of every variant file written to `/tmp/cix-bench/fixture-manifest.txt` +before any run; not modified afterwards. + +**Mutations (one per `bugfix` and `refactor` variant).** +- `bugfix/01`: drop the `!` in `IsBinary` (`cli/internal/fileutil/binary.go`). +- `bugfix/02`: change `".go": "go"` to `".go": "golang"` in `extensionMap`. +- `bugfix/03`: in `splitLines`, change `start = i + 1` to `start = i`. +- `bugfix/04`: legacy-key target `auto_watch:` becomes `auto-watch:`. +- `refactor/01`: replace map-based `dedupByLocation` with O(n²) nested loop. +- `refactor/02`: replace `sortRanges` (already insertion sort in baseline) with bubble sort. +- `refactor/03`: replace `joinLines`'s `strings.Join` with `+=` loop. +- `refactor/04`: fall-back per runbook — replace `repeatComma` byte-slice + build with a `+=` loop in `server/internal/symbolindex/symbolindex.go`. Recorded in manifest. + +`tests/01..04` and `summary/01..04` are identical to baseline. + +**Per-run procedure (serial, A before B per variant).** +1. `cix watch stop --all` to clear daemons; `rm -rf /tmp/cix-bench-run`. +2. `cp -R variants///. /tmp/cix-bench-run/`. +3. **B only:** `cix init --watch=false` against the server and wait for + `Status: ✓ Indexed` (192 files / 1669 chunks). Indexing is not counted in + `elapsed_s` — the worker prints its first `date +%s` only after the index + is ready. +4. Launch `Agent` with `subagent_type:"general-purpose"`, `model:"sonnet"`, the + assembled prompt, and a unique `description` (the run_id). +5. Locate transcript at `~/.claude/projects/.../subagents/agent-.jsonl`, + copy to `results/runs/.log`. +6. Compute metrics via `metrics.sh` (jq over JSONL); append CSV row. +7. Verify outcome per §7 of the runbook. + +**Outcome rules used in this run.** +- `bugfix`: `pass` iff `go test ./...` is green in **both** Go modules + (`cli/`, `server/`) — there is no top-level `go.mod`, so the runbook's + literal `go test ./...` from project root would test nothing. This is the + only verification deviation from §7.1; it applies identically to A and B. +- `refactor`: `pass` iff tests green AND a seeded function from §2.3 was + modified; `partial` iff tests green but a different function was "improved". +- `tests`: `pass` iff package builds, package tests pass, and ≥4 `func Test` + declarations exist in the new/modified test file. (Section 7.3 does not + gate on the function being exported, even though the prompt asks for one.) +- `summary`: paragraph scored 0–7 by a fresh Sonnet rubric agent (§7.4). + `pass` iff total ≥ 5; `partial` 3–4; `fail` ≤ 2. + +--- + +## 5. Executive summary (3 sentences) + +Worker A (grep-only) was faster on average (62.2 s vs 69.9 s), used fewer tool +calls, and produced fewer output tokens, but Worker B (cix-first) was strictly +more reliable — 16 / 16 pass vs 14 / 16. The two `partial` outcomes were both +on `refactor` runs where Worker A converged on the same non-seeded inefficiency +(`chunkSlidingWindow`) instead of the seeded target, while Worker B used +`cix symbols` / `cix references` to enumerate the codebase more broadly and hit +the seeded function in all four refactor variants. The strategy gap was +largest on `tests`: Worker B chose harder *exported* targets that required +real fixture setup (+29 s, +1041 output tokens), while Worker A consistently +picked unexported helpers like `splitChunk` even though the prompt asked for a +"public function" — a gap §7.3's verification doesn't penalize. + +--- + +## 6. Caveats + +- **The fixture is a snapshot of `claude-code-index` itself.** Both Sonnet + workers may recognize package layout / symbol names from training. Effect + is the same for A and B but inflates absolute "specificity" scores in §summary. +- **Tool restriction is prompt-level, not harness-level.** Worker A could have + called `cix` and we'd only catch it post-hoc via `cix_ops > 0`. None did + (16 / 16 A rows have `cix_ops = 0`). +- **Single machine, single model (`claude-sonnet-4-6`)**, single embedding + model, no warm/cold-cache split between A and B. The cix server is at + `http://192.168.1.168:21847` (remote on the LAN), not on `localhost`. + Both PREAMBLE_B and §5.2 indexing scripts were retargeted to that URL — + this is the only deviation from the verbatim preambles in the runbook, + applied identically before any A or B run started. +- **Pre-run cix indexing is excluded from `elapsed_s`** by construction — `cix + init --watch=false` returned synchronously before the Agent was spawned. + Reindex was incremental from variant 01 onward (only mutated files re-chunked). +- **Token counts are uncached `input_tokens` / `output_tokens` only.** Sonnet + cache-creation tokens — which dominate real spend on identical prompt scaffolds — + are *not* in the headline. For reference, the smoke test reported + `cache_creation_input_tokens=11775` per call against `input_tokens=3`. The + ranking between A and B does not change under cache-aware costing because + both pay nearly identical cache costs per run; cache-creation scales with + prompt length and the preambles differ by only a few sentences. +- **Outcome scoring for the `summary` task is itself done by Sonnet.** One of + the 8 scorer runs (`summary_03_A`) reasoned about port 21847 being wrong — + 21847 is in fact the correct cix-server port — and deducted a point as a + "fabrication". The total still cleared the `pass` threshold (5/7), but the + rubric run is not a perfect oracle. +- **`tests/01..04` evaluation is loose.** §7.3 doesn't gate on the function + being exported, even though TESTS_PROMPT explicitly asks for "one public + function". Worker A picked an unexported helper in all 4 tests runs, which + the verification still scores `pass`. Treating that as `partial` would + flip the tests pass-rate to 0 / 4 (A) vs 4 / 4 (B). Reported here as `pass` + to honor §7.3 letter-of-the-law. +- **`bugfix/01` actually breaks 8 tests, not 1**, because the runbook-prescribed + mutation inverts the entire `IsBinary` decision. The BUGFIX_PROMPT line + "Exactly one test is failing" is therefore mildly misleading — but the bug + is still a one-line root cause and both A and B fixed it cleanly. Recorded + in `fixture-manifest.txt`. +- **`refactor/02` baseline already used a hand-rolled insertion sort** (not + `sort.Slice` as the runbook assumed). Mutation applied in spirit: + insertion → bubble. Recorded in `fixture-manifest.txt`. +- **`refactor/04` had no `map[..]`-in-loop or `sort.Slice` in `symbolindex.go`.** + Used the runbook's documented fall-back: seeded inefficiency in + `repeatComma` (byte-slice → `+=` loop). Recorded in `fixture-manifest.txt`. + +--- + +## 7. Verbatim prompts (copy of runbook §3 + §4) + +### 7.1 Task prompts + +**BUGFIX_PROMPT** +``` +You are working in a Go project at the current directory. Run its test suite from the project root. Exactly one test is failing. Find and fix the underlying bug in the source code (do NOT modify the failing test or any other test). After your fix, re-run the full test suite from the project root and confirm everything is green. Report what you changed and why in 3–5 sentences. +``` + +**REFACTOR_PROMPT** +``` +You are working in a Go project at the current directory. Somewhere in this codebase there is a function whose implementation is asymptotically inefficient (its complexity is worse than necessary) while still being correct. Find one such function. Replace its body with an algorithmically better implementation that has the same observable behaviour. After your change, run the full test suite from the project root and confirm everything is green. Report what you changed and why in 3–5 sentences. +``` + +**TESTS_PROMPT** +``` +You are working in a Go project at the current directory. Pick one public function that currently has no unit-test coverage and write at least four meaningful unit tests for it covering distinct cases (typical input, edge case, error path, boundary). Place the new tests in the same package as the function. Run the package's tests and confirm they pass. Report which function you chose and why in 2–3 sentences. +``` + +**SUMMARY_PROMPT** +``` +You are working in a software project at the current directory. Read enough of the code to understand its overall purpose and structure. Produce a single-paragraph (≈200 words) summary covering: what the project does, its top-level architecture, the role of each major component or package, and the main entry points. The summary must be specific to THIS code base — no generic phrasing. +``` + +### 7.2 Preambles + +**COMMON_PREAMBLE** (prepended to every worker) +``` +AUTO MODE — execute autonomously, no clarifying questions, no skill invocations, code only. Begin by printing `date +%s` and end by printing `date +%s` so elapsed time can be measured from the transcript. +``` + +**PREAMBLE_A** (Worker A — grep-only) +``` +TOOL CONSTRAINT — you may use ONLY the following tools: Bash, Read, Edit, Glob, Grep. You MUST NOT call the `cix` CLI under any circumstance. Use grep, find, ls, ripgrep, etc. for navigation. +``` + +**PREAMBLE_B** (Worker B — cix-first; URL retargeted from `localhost` to `192.168.1.168` per §6) +``` +TOOL CONSTRAINT — a cix index of this project is available. Prefer the cix CLI for navigation: `cix search ""`, `cix definitions `, `cix references `, `cix symbols `, `cix files `. The cix server is at http://192.168.1.168:21847 and the project at the current working directory has already been registered and indexed for you. You MAY fall back to grep only if a cix command genuinely returns nothing relevant. Do not run `cix init`, `cix reindex`, or modify the cix configuration. +``` + +### 7.3 Final prompt assembly + +For Worker A: +``` + + + + + + +The project is at /tmp/cix-bench-run. Begin by `cd /tmp/cix-bench-run`. + +Note: the env var CIX_API_KEY is set to an invalid value for this run; any cix call will fail with an auth error. +``` + +For Worker B: +``` + + + + + + +The project is at /tmp/cix-bench-run. Begin by `cd /tmp/cix-bench-run`. +``` + +--- + +## 8. Where to look + +- Raw per-run JSONL transcripts: `/tmp/cix-bench/results/runs/.log` +- Per-run metric JSON: `/tmp/cix-bench/results/runs/.metrics.json` +- Summary task texts + scoring: `/tmp/cix-bench/results/runs/summary_*_*.txt` + + `summary_*_*.score.json` +- Combined CSV: `/tmp/cix-bench/results/results.csv` +- Frozen fixture manifest (with deviation notes): `/tmp/cix-bench/fixture-manifest.txt` diff --git a/doc/openapi.yaml b/doc/openapi.yaml new file mode 100644 index 0000000..32799c9 --- /dev/null +++ b/doc/openapi.yaml @@ -0,0 +1,2294 @@ +openapi: 3.0.3 +info: + title: cix-server API + version: v1 + description: | + HTTP API for the `cix-server` semantic code-index daemon. + + The wire format is byte-stable across server versions; the `api_version` + field in `/api/v1/status` ticks independently from `server_version` when + a backwards-incompatible change lands. + + ## Authentication + + Two parallel auth paths back the same identity model: + + - **Browsers / dashboard**: `POST /api/v1/auth/login` with email + + password issues an HttpOnly cookie `cix_session`. The cookie is sent + automatically on subsequent same-origin requests. Sessions roll + forward 14 days from the last request. + - **CLI / SDK**: `Authorization: Bearer ` where the key was + issued by `POST /api/v1/api-keys`. Keys are owner-scoped and can be + revoked individually without affecting other clients. + + Public endpoints (no auth required): `GET /health`, `GET /docs`, + `GET /openapi.yaml`, `GET /api/v1/auth/bootstrap-status`, + `POST /api/v1/auth/login`. Setting `CIX_AUTH_DISABLED=true` skips the + check on every endpoint (development only — a warning is logged). + + When the server starts with an empty users table it requires + `CIX_BOOTSTRAP_ADMIN_EMAIL` + `CIX_BOOTSTRAP_ADMIN_PASSWORD` to seed + the first admin (forced to change password on first login). A legacy + `CIX_API_KEY` set on a fresh database is imported as a single + `env-bootstrap` API key owned by that admin. + + ## Project addressing + + Project `host_path` values contain slashes that cannot be embedded in + URL segments cleanly, so project-scoped endpoints take a `{path}` URL + parameter that is the **first 16 hex chars of `SHA1(host_path)`**. + Compute it with `internal/projects.HashPath`. + + ## Streaming indexing + + `POST /api/v1/projects/{path}/index/files` honours the `Accept` header: + sending `Accept: application/x-ndjson` switches the response to a + newline-delimited stream of `IndexProgressEvent` objects, with a + `heartbeat` event every 10 seconds. Old clients that send no Accept + header (or `application/json`) get the legacy single-JSON response. + + ## Errors + + All error responses use the same body shape: `{"detail": ""}`. + `GET /health` is the only exception — the unhealthy variant additionally + carries `{"reason": "..."}`. + +servers: + # Relative URL — Swagger UI's "Try it out" sends requests to whatever + # origin served /openapi.json, so localhost:8001, localhost:21847, and a + # remote deployment all just work without CORS preflight surprises. + - url: / + description: Same-origin (auto-detected from the URL serving this spec) + +security: + - bearerAuth: [] + +tags: + - name: probe + description: Health and status probes + - name: projects + description: Project lifecycle (CRUD) + - name: search + description: Symbol, definition, reference, file, and semantic search + - name: indexing + description: Three-phase indexing protocol + - name: docs + description: API documentation + - name: auth + description: Sessions, login/logout, password change, current user + - name: admin + description: Admin-only user management + - name: api-keys + description: Issue and revoke owner-scoped API keys for CLI/SDK use + +paths: + /health: + get: + operationId: getHealth + tags: [probe] + summary: Liveness probe (public) + description: | + Returns `{"status":"ok"}` when the server can reach SQLite within 1 + second. Returns 503 with `{"status":"unhealthy","reason":"..."}` when + the DB ping fails. Public — no `Authorization` header required. + security: [] + responses: + "200": + description: Server is healthy + content: + application/json: + schema: + $ref: "#/components/schemas/HealthResponse" + "503": + description: Server is unhealthy (e.g. DB unreachable) + content: + application/json: + schema: + $ref: "#/components/schemas/HealthResponse" + + /api/v1/status: + get: + operationId: getStatus + tags: [probe] + summary: Server / sidecar status (authenticated) + description: | + Returns server metadata: version, configured embedding model, whether + the llama-server sidecar is reachable (`model_loaded`), number of + registered projects, and number of currently-running indexing jobs. + responses: + "200": + description: Status payload + content: + application/json: + schema: + $ref: "#/components/schemas/StatusResponse" + "401": + $ref: "#/components/responses/Unauthorized" + + /api/v1/auth/bootstrap-status: + get: + operationId: getBootstrapStatus + tags: [auth] + summary: Whether the dashboard needs first-run bootstrap (public) + description: | + Returns `{"needs_bootstrap": true}` when the users table is empty. + The dashboard renders an explanatory screen in that case ("ask the + operator to deploy with CIX_BOOTSTRAP_ADMIN_* env vars and + restart"). No authentication required. + security: [] + responses: + "200": + description: Bootstrap status + content: + application/json: + schema: + $ref: "#/components/schemas/BootstrapStatusResponse" + + /api/v1/auth/login: + post: + operationId: login + tags: [auth] + summary: Exchange email + password for a session cookie (public) + description: | + On success, sets `Set-Cookie: cix_session=; HttpOnly; + SameSite=Strict; Path=/`. Returns the user payload plus a + `must_change_password` flag — when true, the dashboard forces a + change-password screen before any other action. + security: [] + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/LoginRequest" + responses: + "200": + description: Logged in + headers: + Set-Cookie: + schema: + type: string + description: Session cookie (HttpOnly, SameSite=Strict) + content: + application/json: + schema: + $ref: "#/components/schemas/LoginResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "422": + $ref: "#/components/responses/Unprocessable" + + /api/v1/auth/logout: + post: + operationId: logout + tags: [auth] + summary: End the current session + description: | + Deletes the server-side session row and instructs the browser to + clear `cix_session` via `Set-Cookie: cix_session=; Max-Age=0`. + responses: + "204": + description: Session ended + "401": + $ref: "#/components/responses/Unauthorized" + + /api/v1/auth/me: + get: + operationId: getMe + tags: [auth] + summary: Current authenticated user + description: | + Returns the user attached to the active session OR API key. + Includes `must_change_password` so the dashboard knows whether to + gate further navigation behind a change-password screen. + responses: + "200": + description: Current user + content: + application/json: + schema: + $ref: "#/components/schemas/MeResponse" + "401": + $ref: "#/components/responses/Unauthorized" + + /api/v1/auth/change-password: + post: + operationId: changePassword + tags: [auth] + summary: Change the current user's password + description: | + Verifies `current_password`, updates to `new_password`, clears + `must_change_password`, and revokes every other session of this + user (the cookie carrying the change-password request is kept + alive). Does NOT touch API keys — those are revoked individually. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/ChangePasswordRequest" + responses: + "204": + description: Password updated + "401": + $ref: "#/components/responses/Unauthorized" + "422": + $ref: "#/components/responses/Unprocessable" + + /api/v1/auth/sessions: + get: + operationId: listMySessions + tags: [auth] + summary: Active sessions of the current user + description: | + Returns every non-expired session of the caller, newest-first, with + `last_seen_at`, `last_seen_ip`, and `last_seen_ua` so the user can + spot unfamiliar logins. The `is_current` flag marks the session + carrying this request. + responses: + "200": + description: Session list + content: + application/json: + schema: + $ref: "#/components/schemas/SessionListResponse" + "401": + $ref: "#/components/responses/Unauthorized" + + /api/v1/auth/sessions/{id}: + delete: + operationId: deleteMySession + tags: [auth] + summary: End one of my sessions (sign out a single device) + parameters: + - name: id + in: path + required: true + schema: + type: string + responses: + "204": + description: Session ended + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + + /api/v1/admin/users: + get: + operationId: listUsers + tags: [admin] + summary: List all users (admin only) + responses: + "200": + description: User list + content: + application/json: + schema: + $ref: "#/components/schemas/UserListResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + post: + operationId: createUser + tags: [admin] + summary: Invite a new user (admin only) + description: | + The admin sets an `initial_password` and shares it out-of-band. + The new user is flagged `must_change_password=true` and will be + forced to change it on first login. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/CreateUserRequest" + responses: + "201": + description: Created + content: + application/json: + schema: + $ref: "#/components/schemas/User" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "409": + $ref: "#/components/responses/Conflict" + "422": + $ref: "#/components/responses/Unprocessable" + + /api/v1/admin/users/{id}: + parameters: + - name: id + in: path + required: true + schema: + type: string + patch: + operationId: updateUser + tags: [admin] + summary: Change role or disabled flag (admin only) + description: | + Refuses to demote or disable the last enabled admin in the system. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/UpdateUserRequest" + responses: + "200": + description: Updated + content: + application/json: + schema: + $ref: "#/components/schemas/User" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + delete: + operationId: deleteUser + tags: [admin] + summary: Delete a user (admin only) + description: | + Cascades to the user's sessions and API keys. Refuses to delete + the last enabled admin. + responses: + "204": + description: Deleted + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "404": + $ref: "#/components/responses/NotFound" + + /api/v1/admin/runtime-config: + get: + operationId: getRuntimeConfig + tags: [admin] + summary: Read effective runtime config (admin only) + description: | + Returns the resolved runtime config (DB row → env → recommended) the + sidecar is currently configured against, plus a `source` map labelling + each field's origin so the dashboard can render the "DB" / "Env" / + "Recommended" pill next to every value. + responses: + "200": + description: Effective runtime config + content: + application/json: + schema: + $ref: "#/components/schemas/RuntimeConfig" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + put: + operationId: putRuntimeConfig + tags: [admin] + summary: Save runtime config overrides (admin only) + description: | + Replaces the runtime_settings row. Fields omitted from the request + clear their override (= fall back to env / recommended on next Get). + Does NOT restart the sidecar — the dashboard issues a separate + POST /admin/sidecar/restart after a successful PUT. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/RuntimeConfigUpdate" + responses: + "200": + description: Updated config + content: + application/json: + schema: + $ref: "#/components/schemas/RuntimeConfig" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "422": + $ref: "#/components/responses/Unprocessable" + + /api/v1/admin/sidecar/restart: + post: + operationId: restartSidecar + tags: [admin] + summary: Restart the llama-server sidecar (admin only) + description: | + Drains the embedding queue (30s timeout), terminates the current + child process, and respawns with the latest runtime config. + Returns 202 immediately; poll GET /admin/sidecar/status to observe + the running → restarting → running transition. In-flight indexing + batches at the moment of restart will fail with ErrSupervisor and + must be re-driven by the operator (`cix reindex `). + responses: + "202": + description: Restart accepted + content: + application/json: + schema: + $ref: "#/components/schemas/RestartAccepted" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "503": + description: Embeddings disabled at boot — restart is a no-op + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + + /api/v1/admin/sidecar/status: + get: + operationId: getSidecarStatus + tags: [admin] + summary: Sidecar process status (admin only) + responses: + "200": + description: Status snapshot + content: + application/json: + schema: + $ref: "#/components/schemas/SidecarStatus" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + + /api/v1/admin/models: + get: + operationId: listModels + tags: [admin] + summary: List GGUF model files cached on disk (admin only) + description: | + Walks `CIX_GGUF_CACHE_DIR` and returns one entry per .gguf file. Used + by the dashboard's embedding-model picker so admins don't have to + type HF repo IDs by hand. Empty list when the cache is empty — + dashboard falls back to a free-text path input in that case. + responses: + "200": + description: Cached model list + content: + application/json: + schema: + $ref: "#/components/schemas/ModelList" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + + /api/v1/api-keys: + get: + operationId: listApiKeys + tags: [api-keys] + summary: List my API keys (or all keys if admin) + parameters: + - name: owner + in: query + required: false + description: | + `all` — admin-only, returns every key in the system. + Anything else (or unset) returns the caller's keys. + schema: + type: string + enum: [all] + responses: + "200": + description: Key list + content: + application/json: + schema: + $ref: "#/components/schemas/ApiKeyListResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + post: + operationId: createApiKey + tags: [api-keys] + summary: Issue a new API key + description: | + Returns the **plaintext** `full_key` exactly once in the response. + The dashboard shows it with a copy button and a "this is the only + time you will see this value" warning. Subsequent reads only + return the `prefix`. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/CreateApiKeyRequest" + responses: + "201": + description: Key created + content: + application/json: + schema: + $ref: "#/components/schemas/ApiKeyCreated" + "401": + $ref: "#/components/responses/Unauthorized" + "422": + $ref: "#/components/responses/Unprocessable" + + /api/v1/api-keys/{id}: + delete: + operationId: revokeApiKey + tags: [api-keys] + summary: Revoke an API key + description: | + The owner can revoke their own keys. An admin can revoke any + key. Revoking is permanent — the row stays in the table marked + with `revoked_at` so the audit trail is preserved, but + subsequent Bearer auth attempts with the value fail with 401. + parameters: + - name: id + in: path + required: true + schema: + type: string + responses: + "204": + description: Revoked + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "404": + $ref: "#/components/responses/NotFound" + + /api/v1/projects: + post: + operationId: createProject + tags: [projects] + summary: Register a new project + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/CreateProjectRequest" + responses: + "201": + description: Project created + content: + application/json: + schema: + $ref: "#/components/schemas/Project" + "401": + $ref: "#/components/responses/Unauthorized" + "409": + description: A project with this `host_path` already exists + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + get: + operationId: listProjects + tags: [projects] + summary: List all registered projects + responses: + "200": + description: Project list + content: + application/json: + schema: + $ref: "#/components/schemas/ProjectListResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}: + parameters: + - $ref: "#/components/parameters/ProjectHash" + get: + operationId: getProject + tags: [projects] + summary: Get one project by hash + responses: + "200": + description: Project + content: + application/json: + schema: + $ref: "#/components/schemas/Project" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "500": + $ref: "#/components/responses/InternalError" + patch: + operationId: updateProject + tags: [projects] + summary: Patch project settings (admin only) + description: | + Admin-only. Settings changes can shrink the indexing surface + (exclude_patterns, max_file_size); viewers must not be able to + silently de-index a project. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/UpdateProjectRequest" + responses: + "200": + description: Updated project + content: + application/json: + schema: + $ref: "#/components/schemas/Project" + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + delete: + operationId: deleteProject + tags: [projects] + summary: Delete a project and all its indexed data (admin only) + description: | + Admin-only. Drops the project plus its symbols, refs, file hashes, + and embeddings. Destructive enough that viewer-scoped sessions and + API keys must not reach it. + responses: + "204": + description: Deleted (no body) + "401": + $ref: "#/components/responses/Unauthorized" + "403": + $ref: "#/components/responses/Forbidden" + "404": + $ref: "#/components/responses/NotFound" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/summary: + parameters: + - $ref: "#/components/parameters/ProjectHash" + get: + operationId: getProjectSummary + tags: [projects] + summary: Project overview (top dirs, recent symbols, totals) + responses: + "200": + description: Summary + content: + application/json: + schema: + $ref: "#/components/schemas/ProjectSummary" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/search: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: semanticSearch + tags: [search] + summary: Semantic (vector) search + description: | + Embeds the query and runs an approximate nearest-neighbour search + against the project's chromem-go collection. Results are + post-filtered by `min_score`, `paths` (whitelist, prefix-OR-substring + match), `excludes` (blacklist, same matching), and `languages` — + then merged into per-file groups and ranked by best match score. + + `min_score` semantics: + - omitted → server default `0.4` (calibrated for CodeRankEmbed-Q8) + - explicit `0` → return everything above HNSW floor + - explicit positive → that floor + + `query_time_ms` is rounded to 1 decimal place. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/SemanticSearchRequest" + responses: + "200": + description: Per-file grouped semantic results + content: + application/json: + schema: + $ref: "#/components/schemas/SemanticSearchResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "503": + description: | + Embeddings disabled, vector store missing, or sidecar busy + (Retry-After header set). + headers: + Retry-After: + schema: { type: integer } + description: Seconds to wait when the embedder is busy + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/search/symbols: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: searchSymbols + tags: [search] + summary: Symbol search by name (prefix/substring) + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/SymbolSearchRequest" + responses: + "200": + description: Matching symbols + content: + application/json: + schema: + $ref: "#/components/schemas/SymbolSearchResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/search/definitions: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: searchDefinitions + tags: [search] + summary: Go-to-definition by symbol name + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/DefinitionRequest" + responses: + "200": + description: Matching definitions + content: + application/json: + schema: + $ref: "#/components/schemas/DefinitionResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/search/references: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: searchReferences + tags: [search] + summary: Find references to a symbol + description: | + Returns the locations where `symbol` appears as an identifier token. + `content` is intentionally empty and `end_line == start_line` — + populating snippets here would require a full file re-read per + result; clients should follow up with semantic search or read the + file directly. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/ReferenceRequest" + responses: + "200": + description: References + content: + application/json: + schema: + $ref: "#/components/schemas/ReferenceResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/search/files: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: searchFiles + tags: [search] + summary: File-path substring search + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/FileSearchRequest" + responses: + "200": + description: Matching file paths + content: + application/json: + schema: + $ref: "#/components/schemas/FileSearchResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "422": + $ref: "#/components/responses/Unprocessable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/index/begin: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: indexBegin + tags: [indexing] + summary: Open an indexing session + description: | + Returns a `run_id` and the map of currently-stored content hashes + (`stored_hashes`) so the client can compute a delta. Pass `full:true` + to wipe project state before indexing. Body is optional. + requestBody: + required: false + content: + application/json: + schema: + $ref: "#/components/schemas/IndexBeginRequest" + responses: + "200": + description: Session opened + content: + application/json: + schema: + $ref: "#/components/schemas/IndexBeginResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "409": + description: An indexing session is already active for this project + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "422": + $ref: "#/components/responses/Unprocessable" + "503": + $ref: "#/components/responses/IndexerUnavailable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/index/files: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: indexFiles + tags: [indexing] + summary: Submit a batch of files (max 50) + description: | + Sends a batch of file payloads belonging to the open `run_id`. + Maximum 50 files per call. + + **Streaming negotiation**: send `Accept: application/x-ndjson` to + receive a newline-delimited stream of `IndexProgressEvent` objects + (one event per line, plus a `heartbeat` every 10 s). Without that + header (or with `Accept: application/json`) the response is the + legacy single-JSON `IndexFilesResponse` returned after the batch + completes. + parameters: + - in: header + name: Accept + required: false + schema: + type: string + enum: [application/json, application/x-ndjson] + description: | + `application/x-ndjson` switches to a streamed response + (one `IndexProgressEvent` per line). Default: `application/json`. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/IndexFilesRequest" + responses: + "200": + description: | + Either a single JSON summary (default) or a stream of NDJSON + events (when the client opted in via `Accept: application/x-ndjson`). + content: + application/json: + schema: + $ref: "#/components/schemas/IndexFilesResponse" + application/x-ndjson: + schema: + $ref: "#/components/schemas/IndexProgressEvent" + examples: + stream: + summary: NDJSON stream (one event per line) + value: | + {"event":"file_started","run_id":"r-1","path":"main.go","file_index":1,"batch_size":20} + {"event":"file_chunked","path":"main.go","chunks":12} + {"event":"file_embedded","path":"main.go","chunks":12,"embed_ms":540} + {"event":"file_done","path":"main.go","chunks":12} + {"event":"heartbeat","ts":"2026-04-27T17:25:00Z"} + {"event":"batch_done","files_accepted":20,"chunks_created":347,"files_processed_total":300} + "401": + $ref: "#/components/responses/Unauthorized" + "404": + description: Project not found OR run_id not found / project mismatch + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "422": + $ref: "#/components/responses/Unprocessable" + "503": + description: | + Indexer disabled, or GPU sidecar busy. When busy, `Retry-After` + header is set with a suggested wait (seconds). + headers: + Retry-After: + schema: { type: integer } + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/index/finish: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: indexFinish + tags: [indexing] + summary: Commit the indexing session + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/IndexFinishRequest" + responses: + "200": + description: Session committed + content: + application/json: + schema: + $ref: "#/components/schemas/IndexFinishResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + description: Project not found OR run_id unknown / project mismatch + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "422": + $ref: "#/components/responses/Unprocessable" + "503": + $ref: "#/components/responses/IndexerUnavailable" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/index/cancel: + parameters: + - $ref: "#/components/parameters/ProjectHash" + post: + operationId: indexCancel + tags: [indexing] + summary: Cancel any active indexing session (idempotent) + description: | + Open to any authenticated user. Returns `{"cancelled": true}` if a + session was killed, `false` if none was active. The CLI calls this + in defer-cleanup on early exit, so gating it on admin would leave + run locks hanging for viewers until the 1-hour TTL. + responses: + "200": + description: Cancellation result + content: + application/json: + schema: + $ref: "#/components/schemas/IndexCancelResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + "500": + $ref: "#/components/responses/InternalError" + + /api/v1/projects/{path}/index/status: + parameters: + - $ref: "#/components/parameters/ProjectHash" + get: + operationId: indexStatus + tags: [indexing] + summary: Live progress of the current run, or last completed run + description: | + When a session is active: returns mid-run progress with + `phase`, `files_discovered/processed/total`, `chunks_created`, + `elapsed_seconds`, and `run_id`. When no session is active: + falls back to the most recent `index_runs` row, returning only + `files_processed/total` and `chunks_created`. If the project + has no history at all: `{"status":"idle"}`. + responses: + "200": + description: Progress payload (or idle) + content: + application/json: + schema: + $ref: "#/components/schemas/IndexProgressResponse" + "401": + $ref: "#/components/responses/Unauthorized" + "404": + $ref: "#/components/responses/NotFound" + +components: + securitySchemes: + bearerAuth: + type: http + scheme: bearer + description: "API key passed as `Authorization: Bearer `" + + parameters: + ProjectHash: + name: path + in: path + required: true + description: | + First 16 hex chars of `SHA1(host_path)`. See + `internal/projects.HashPath`. + schema: + type: string + pattern: "^[a-f0-9]{16}$" + example: "5b7d2c9e1a3f8042" + + responses: + Unauthorized: + description: Missing or invalid API key + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + NotFound: + description: Resource not found + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + Unprocessable: + description: Malformed request body or missing required fields + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + InternalError: + description: Unhandled server error + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + IndexerUnavailable: + description: Indexing service not configured + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + Forbidden: + description: Authenticated, but lacks the required role + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + Conflict: + description: Resource already exists (e.g. email taken) + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + + schemas: + Error: + type: object + required: [detail] + properties: + detail: + type: string + + BootstrapStatusResponse: + type: object + required: [needs_bootstrap] + properties: + needs_bootstrap: + type: boolean + description: True when the users table is empty. + + User: + type: object + required: [id, email, role, must_change_password, created_at, updated_at, disabled] + properties: + id: + type: string + email: + type: string + format: email + role: + type: string + enum: [admin, viewer] + must_change_password: + type: boolean + created_at: + type: string + format: date-time + updated_at: + type: string + format: date-time + disabled: + type: boolean + description: | + True when `disabled_at` is set. Disabled users cannot + authenticate via password OR API key. + disabled_at: + type: string + format: date-time + nullable: true + + UserWithStats: + allOf: + - $ref: "#/components/schemas/User" + - type: object + required: [active_sessions_count, api_keys_count] + properties: + last_login_at: + type: string + format: date-time + nullable: true + description: | + Most recent session creation timestamp (RFC3339). + Null if the user has never logged in. + active_sessions_count: + type: integer + minimum: 0 + description: Count of non-expired sessions for this user. + api_keys_count: + type: integer + minimum: 0 + description: Count of non-revoked API keys owned by this user. + + UserListResponse: + type: object + required: [users, total] + properties: + users: + type: array + items: + $ref: "#/components/schemas/UserWithStats" + total: + type: integer + + LoginRequest: + type: object + required: [email, password] + properties: + email: + type: string + format: email + password: + type: string + minLength: 1 + + LoginResponse: + type: object + required: [user] + properties: + user: + $ref: "#/components/schemas/User" + + MeResponse: + type: object + required: [user, auth_method] + properties: + user: + $ref: "#/components/schemas/User" + auth_method: + type: string + enum: [session, api_key] + description: | + Tells the dashboard whether to surface "logout" (session) or + hide it (api_key access — there's nothing to log out of). + + ChangePasswordRequest: + type: object + required: [current_password, new_password] + properties: + current_password: + type: string + minLength: 1 + new_password: + type: string + minLength: 8 + description: Minimum 8 characters. No upper bound. + + CreateUserRequest: + type: object + required: [email, initial_password, role] + properties: + email: + type: string + format: email + initial_password: + type: string + minLength: 8 + description: | + One-time password the new user must change on first login. + The admin shares this out-of-band. + role: + type: string + enum: [admin, viewer] + + UpdateUserRequest: + type: object + properties: + role: + type: string + enum: [admin, viewer] + description: | + New role for the user. Refused for the last enabled admin + when set to `viewer`. + disabled: + type: boolean + description: | + When true, the user can no longer authenticate. Refused for + the last enabled admin when set to true. + + RuntimeConfig: + type: object + required: + - embedding_model + - llama_ctx_size + - llama_n_gpu_layers + - llama_n_threads + - max_embedding_concurrency + - llama_batch_size + - source + properties: + embedding_model: + type: string + description: HF repo ID or absolute filesystem path to a .gguf file. + llama_ctx_size: + type: integer + minimum: 1 + llama_n_gpu_layers: + type: integer + description: -1 = all layers (Metal/CUDA), 0 = CPU only. + llama_n_threads: + type: integer + minimum: 0 + description: 0 = let llama-server auto-detect. + max_embedding_concurrency: + type: integer + minimum: 1 + llama_batch_size: + type: integer + minimum: 1 + source: + type: object + additionalProperties: + type: string + enum: [db, env, recommended] + description: | + Per-field origin label so the dashboard can render a "DB" / + "Env" / "Recommended" pill next to each value. Keys match the + other field names: `embedding_model`, `llama_ctx_size`, ... + recommended: + $ref: "#/components/schemas/RuntimeConfigRecommended" + updated_at: + type: string + format: date-time + nullable: true + description: When the runtime_settings row was last written, or null when only env/recommended are in effect. + updated_by: + type: string + nullable: true + description: Who issued the last PUT, captured from the active session. + + RuntimeConfigRecommended: + type: object + required: + - embedding_model + - llama_ctx_size + - llama_n_gpu_layers + - llama_n_threads + - max_embedding_concurrency + - llama_batch_size + properties: + embedding_model: { type: string } + llama_ctx_size: { type: integer } + llama_n_gpu_layers: { type: integer } + llama_n_threads: { type: integer } + max_embedding_concurrency: { type: integer } + llama_batch_size: { type: integer } + + RuntimeConfigUpdate: + type: object + description: | + All fields optional. Send a value to set/replace the override for + that field, send `""` (string fields) or `0` (numeric fields) to + CLEAR the override (next read falls back to env / recommended). + Omitted fields keep their current value. + properties: + embedding_model: + type: string + nullable: true + llama_ctx_size: + type: integer + nullable: true + llama_n_gpu_layers: + type: integer + nullable: true + llama_n_threads: + type: integer + nullable: true + max_embedding_concurrency: + type: integer + nullable: true + llama_batch_size: + type: integer + nullable: true + + SidecarStatus: + type: object + required: [state, ready, in_flight] + properties: + state: + type: string + enum: [running, starting, restarting, failed, disabled] + pid: + type: integer + minimum: 0 + description: 0 when no child process is alive (failed / disabled). + uptime_seconds: + type: integer + minimum: 0 + model: + type: string + ready: + type: boolean + last_error: + type: string + in_flight: + type: integer + minimum: 0 + description: Embedding queue depth at the moment of sampling. + restart_in_flight: + type: boolean + description: True between accept of POST /sidecar/restart and respawn completion. + + RestartAccepted: + type: object + required: [restart_id] + properties: + restart_id: + type: string + description: Opaque ID; future versions may expose per-restart progress under this id. + + ModelEntry: + type: object + required: [id, path, size_bytes] + properties: + id: + type: string + description: HF repo ID derived from the cache directory name (e.g. owner/model). + path: + type: string + description: Absolute path to the .gguf file on disk. + size_bytes: + type: integer + format: int64 + minimum: 0 + + ModelList: + type: object + required: [models, cache_dir] + properties: + models: + type: array + items: + $ref: "#/components/schemas/ModelEntry" + cache_dir: + type: string + description: The CIX_GGUF_CACHE_DIR that was scanned. Empty list with non-empty cache_dir = no .gguf files found. + + Session: + type: object + required: [id, created_at, expires_at, last_seen_at, is_current] + properties: + id: + type: string + created_at: + type: string + format: date-time + expires_at: + type: string + format: date-time + last_seen_at: + type: string + format: date-time + last_seen_ip: + type: string + nullable: true + last_seen_ua: + type: string + nullable: true + is_current: + type: boolean + description: True for the session carrying this request. + + SessionListResponse: + type: object + required: [sessions, total] + properties: + sessions: + type: array + items: + $ref: "#/components/schemas/Session" + total: + type: integer + + ApiKey: + type: object + required: [id, owner_user_id, name, prefix, created_at, revoked] + properties: + id: + type: string + owner_user_id: + type: string + name: + type: string + prefix: + type: string + description: | + Display-only prefix of the full key (e.g. `cix_a1b2c3d4`). + Long enough to recognise in lists, short enough that it + cannot reconstruct the original. + created_at: + type: string + format: date-time + last_used_at: + type: string + format: date-time + nullable: true + last_used_ip: + type: string + nullable: true + last_used_ua: + type: string + nullable: true + revoked: + type: boolean + revoked_at: + type: string + format: date-time + nullable: true + + ApiKeyListResponse: + type: object + required: [api_keys, total] + properties: + api_keys: + type: array + items: + $ref: "#/components/schemas/ApiKey" + total: + type: integer + + CreateApiKeyRequest: + type: object + required: [name] + properties: + name: + type: string + minLength: 1 + description: | + Human-friendly label shown in the dashboard. The full key + value is generated server-side and returned exactly once. + + ApiKeyCreated: + type: object + required: [api_key, full_key] + properties: + api_key: + $ref: "#/components/schemas/ApiKey" + full_key: + type: string + description: | + The plaintext key value. **Returned exactly once.** Store it + securely — there is no way to retrieve it later. + + HealthResponse: + type: object + required: [status] + properties: + status: + type: string + enum: [ok, unhealthy] + reason: + type: string + description: Set only when `status` is `unhealthy`. + + StatusResponse: + type: object + required: + - status + - backend + - server_version + - api_version + - model_loaded + - embedding_model + - projects + - active_indexing_jobs + properties: + status: + type: string + enum: [ok] + backend: + type: string + description: Backend identifier (e.g. `go`). + server_version: + type: string + api_version: + type: string + example: v1 + model_loaded: + type: boolean + description: | + Whether the llama-server sidecar reports ready within 500 ms. + False when the sidecar is starting or has crashed. + embedding_model: + type: string + description: Hugging Face model id (e.g. `awhiteside/CodeRankEmbed-Q8_0-GGUF`). + projects: + type: integer + minimum: 0 + description: Total registered projects. + active_indexing_jobs: + type: integer + minimum: 0 + description: Currently-running `index_runs` rows. + update_available: + type: boolean + description: | + True when the version-check service has found a `server/v*` + release on GitHub strictly newer than the running server. + Field is omitted entirely when version-check is not wired + (set `CIX_VERSION_CHECK_ENABLED=false` to disable polling). + latest_version: + type: string + nullable: true + description: | + Latest released server version (without the `server/v` prefix, + e.g. `0.5.1`). Null until the first successful poll completes. + release_url: + type: string + nullable: true + description: GitHub release page URL for `latest_version`. Null when unknown. + version_check: + $ref: "#/components/schemas/VersionCheckStatus" + + VersionCheckStatus: + type: object + required: [enabled] + properties: + enabled: + type: boolean + description: Whether the periodic GitHub poll is running. + checked_at: + type: string + format: date-time + nullable: true + description: Last poll timestamp (UTC, RFC 3339). Null before the first poll. + error: + type: string + nullable: true + description: Last error message, if the most recent poll failed. Null on success. + + ProjectSettings: + type: object + required: [exclude_patterns, max_file_size] + properties: + exclude_patterns: + type: array + items: { type: string } + max_file_size: + type: integer + minimum: 0 + + ProjectStats: + type: object + required: [total_files, indexed_files, total_chunks, total_symbols] + properties: + total_files: + type: integer + minimum: 0 + indexed_files: + type: integer + minimum: 0 + total_chunks: + type: integer + minimum: 0 + total_symbols: + type: integer + minimum: 0 + + Project: + type: object + required: + - path_hash + - host_path + - container_path + - languages + - settings + - stats + - status + - created_at + - updated_at + - last_indexed_at + properties: + path_hash: + type: string + pattern: "^[a-f0-9]{16}$" + description: First 16 hex chars of SHA1(host_path) — stable URL identifier. + host_path: + type: string + description: Absolute filesystem path on the operator's machine. + container_path: + type: string + description: Path inside the container (often equal to host_path). + languages: + type: array + items: { type: string } + settings: + $ref: "#/components/schemas/ProjectSettings" + stats: + $ref: "#/components/schemas/ProjectStats" + status: + type: string + enum: [created, indexing, indexed, error] + created_at: + type: string + format: date-time + updated_at: + type: string + format: date-time + last_indexed_at: + type: string + format: date-time + nullable: true + indexed_with_model: + type: string + nullable: true + description: | + Embedding model identifier active when this project was last + (re)indexed. NULL on rows that pre-date drift tracking — the + dashboard treats NULL as "Unknown" rather than as drift. + sqlite_path: + type: string + nullable: true + description: Resolved SQLite database path for the active model. NULL on dashboards that don't expose storage info. + chroma_path: + type: string + nullable: true + description: Resolved chromem-go collection directory for this project. NULL when not computed. + sqlite_size_bytes: + type: integer + format: int64 + nullable: true + minimum: 0 + chroma_size_bytes: + type: integer + format: int64 + nullable: true + minimum: 0 + + ProjectListResponse: + type: object + required: [projects, total] + properties: + projects: + type: array + items: + $ref: "#/components/schemas/Project" + total: + type: integer + minimum: 0 + + CreateProjectRequest: + type: object + required: [host_path] + properties: + host_path: + type: string + + UpdateProjectRequest: + type: object + properties: + settings: + $ref: "#/components/schemas/ProjectSettings" + + DirEntry: + type: object + required: [path, file_count] + properties: + path: + type: string + file_count: + type: integer + minimum: 0 + + SymbolEntry: + type: object + required: [name, kind, file_path, language] + properties: + name: + type: string + kind: + type: string + file_path: + type: string + language: + type: string + + ProjectSummary: + type: object + required: + - path_hash + - host_path + - status + - languages + - total_files + - total_chunks + - total_symbols + - top_directories + - recent_symbols + properties: + path_hash: + type: string + pattern: "^[a-f0-9]{16}$" + description: First 16 hex chars of SHA1(host_path) — stable URL identifier. + host_path: + type: string + status: + type: string + languages: + type: array + items: { type: string } + total_files: + type: integer + minimum: 0 + total_chunks: + type: integer + minimum: 0 + total_symbols: + type: integer + minimum: 0 + top_directories: + type: array + items: + $ref: "#/components/schemas/DirEntry" + recent_symbols: + type: array + items: + $ref: "#/components/schemas/SymbolEntry" + + SymbolSearchRequest: + type: object + required: [query] + properties: + query: + type: string + minLength: 1 + kinds: + type: array + items: { type: string } + limit: + type: integer + minimum: 0 + default: 20 + + SymbolResultItem: + type: object + required: [name, kind, file_path, line, end_line, language] + properties: + name: { type: string } + kind: { type: string } + file_path: { type: string } + line: { type: integer } + end_line: { type: integer } + language: { type: string } + signature: { type: string } + parent_name: { type: string } + + SymbolSearchResponse: + type: object + required: [results, total] + properties: + results: + type: array + items: + $ref: "#/components/schemas/SymbolResultItem" + total: + type: integer + minimum: 0 + + DefinitionRequest: + type: object + required: [symbol] + properties: + symbol: + type: string + minLength: 1 + kind: + type: string + file_path: + type: string + limit: + type: integer + minimum: 0 + default: 10 + + DefinitionItem: + type: object + required: [name, kind, file_path, line, end_line, language] + properties: + name: { type: string } + kind: { type: string } + file_path: { type: string } + line: { type: integer } + end_line: { type: integer } + language: { type: string } + signature: { type: string } + parent_name: { type: string } + + DefinitionResponse: + type: object + required: [results, total] + properties: + results: + type: array + items: + $ref: "#/components/schemas/DefinitionItem" + total: + type: integer + minimum: 0 + + ReferenceRequest: + type: object + required: [symbol] + properties: + symbol: + type: string + minLength: 1 + limit: + type: integer + minimum: 0 + default: 50 + file_path: + type: string + + ReferenceItem: + type: object + required: + - file_path + - start_line + - end_line + - content + - chunk_type + - symbol_name + - language + properties: + file_path: { type: string } + start_line: { type: integer } + end_line: + type: integer + description: Always equal to `start_line` (refs table stores tokens, not ranges). + content: + type: string + description: Always empty — see endpoint description. + chunk_type: + type: string + enum: [reference] + symbol_name: { type: string } + language: { type: string } + + ReferenceResponse: + type: object + required: [results, total] + properties: + results: + type: array + items: + $ref: "#/components/schemas/ReferenceItem" + total: + type: integer + minimum: 0 + + FileSearchRequest: + type: object + required: [query] + properties: + query: + type: string + minLength: 1 + description: Substring matched against `file_path`. + limit: + type: integer + minimum: 0 + default: 20 + + FileResultItem: + type: object + required: [file_path, language] + properties: + file_path: { type: string } + language: + type: string + nullable: true + description: Detected language, or null if undetected. + + FileSearchResponse: + type: object + required: [results, total] + properties: + results: + type: array + items: + $ref: "#/components/schemas/FileResultItem" + total: + type: integer + minimum: 0 + + SemanticSearchRequest: + type: object + required: [query] + properties: + query: + type: string + minLength: 1 + limit: + type: integer + minimum: 0 + default: 10 + description: Maximum number of FILE groups (not chunks) to return. + languages: + type: array + items: { type: string } + paths: + type: array + items: { type: string } + description: Whitelist — keep only results whose path matches any prefix or substring. + excludes: + type: array + items: { type: string } + description: Blacklist — drop results whose path matches any prefix or substring. + min_score: + type: number + format: float + description: | + Minimum cosine similarity. Omit for server default (0.4 for + CodeRankEmbed-Q8). Send `0` explicitly to disable the floor. + + NestedHit: + type: object + required: [start_line, end_line, chunk_type, score] + properties: + start_line: { type: integer } + end_line: { type: integer } + symbol_name: { type: string } + chunk_type: { type: string } + score: + type: number + format: float + + FileMatch: + type: object + required: [start_line, end_line, content, score, chunk_type] + properties: + start_line: { type: integer } + end_line: { type: integer } + content: { type: string } + score: + type: number + format: float + chunk_type: { type: string } + symbol_name: { type: string } + nested_hits: + type: array + items: + $ref: "#/components/schemas/NestedHit" + + FileGroupResult: + type: object + required: [file_path, best_score, matches] + properties: + file_path: { type: string } + language: { type: string } + best_score: + type: number + format: float + matches: + type: array + items: + $ref: "#/components/schemas/FileMatch" + + SemanticSearchResponse: + type: object + required: [results, total, query_time_ms] + properties: + results: + type: array + items: + $ref: "#/components/schemas/FileGroupResult" + total: + type: integer + minimum: 0 + query_time_ms: + type: number + format: double + description: Wall-clock query latency, rounded to 1 decimal place. + + IndexBeginRequest: + type: object + properties: + full: + type: boolean + default: false + description: When true, wipes existing project state before opening the session. + + IndexBeginResponse: + type: object + required: [run_id, stored_hashes] + properties: + run_id: + type: string + stored_hashes: + type: object + additionalProperties: + type: string + description: | + Map from file path → SHA-256 of currently-stored content. Empty + when the project has never been indexed (or `full:true` was passed). + + FilePayload: + type: object + required: [path, content, content_hash, size] + properties: + path: + type: string + content: + type: string + description: UTF-8 text. Binary files should not be submitted. + content_hash: + type: string + description: SHA-256 hex digest of `content`. + language: + type: string + size: + type: integer + minimum: 0 + + IndexFilesRequest: + type: object + required: [run_id, files] + properties: + run_id: + type: string + minLength: 1 + files: + type: array + maxItems: 50 + items: + $ref: "#/components/schemas/FilePayload" + + IndexFilesResponse: + type: object + required: [files_accepted, chunks_created, files_processed_total] + properties: + files_accepted: + type: integer + minimum: 0 + chunks_created: + type: integer + minimum: 0 + files_processed_total: + type: integer + minimum: 0 + + IndexFinishRequest: + type: object + required: [run_id] + properties: + run_id: + type: string + minLength: 1 + deleted_paths: + type: array + items: { type: string } + total_files_discovered: + type: integer + minimum: 0 + + IndexFinishResponse: + type: object + required: [status, files_processed, chunks_created] + properties: + status: + type: string + enum: [completed] + files_processed: + type: integer + minimum: 0 + chunks_created: + type: integer + minimum: 0 + + IndexCancelResponse: + type: object + required: [cancelled] + properties: + cancelled: + type: boolean + + IndexProgressInfo: + type: object + description: | + Progress payload. The active-session variant carries every field; + the historical-fallback variant only carries `files_processed`, + `files_total`, and `chunks_created`. + properties: + phase: + type: string + enum: [receiving, completed] + files_discovered: + type: integer + minimum: 0 + files_processed: + type: integer + minimum: 0 + files_total: + type: integer + minimum: 0 + chunks_created: + type: integer + minimum: 0 + elapsed_seconds: + type: number + format: double + run_id: + type: string + + IndexProgressResponse: + type: object + required: [status] + properties: + status: + type: string + enum: [idle, indexing, completed, cancelled, failed, running] + description: | + `idle` — no session ever / fallback unavailable. + `indexing` — session active. + `completed`/`cancelled`/`failed`/`running` — last-run status from `index_runs`. + progress: + $ref: "#/components/schemas/IndexProgressInfo" + + IndexProgressEvent: + type: object + description: | + One event in the NDJSON stream emitted by `POST /index/files` when + the client sends `Accept: application/x-ndjson`. The `event` field + discriminates the variant; other fields are populated as relevant. + required: [event] + properties: + event: + type: string + enum: + - file_started + - file_chunked + - file_embedded + - file_done + - file_error + - heartbeat + - batch_done + - error + run_id: + type: string + path: + type: string + file_index: + type: integer + batch_size: + type: integer + chunks: + type: integer + embed_ms: + type: integer + format: int64 + ts: + type: string + format: date-time + message: + type: string + fatal: + type: boolean + files_accepted: + type: integer + chunks_created: + type: integer + files_processed_total: + type: integer diff --git a/docker-compose.cuda.yml b/docker-compose.cuda.yml index 0cc5dc9..a40032a 100644 --- a/docker-compose.cuda.yml +++ b/docker-compose.cuda.yml @@ -7,17 +7,61 @@ services: - "${PORT:-21847}:21847" environment: - CIX_API_KEY=${CIX_API_KEY} + # Defense in depth — the image already defaults to 21847 but + # pinning it here keeps the host:container port mapping honest + # if a third-party fork or custom build sets a different default. + - CIX_PORT=${CIX_PORT:-21847} - CIX_EMBEDDING_MODEL=${CIX_EMBEDDING_MODEL:-awhiteside/CodeRankEmbed-Q8_0-GGUF} - CIX_CHROMA_PERSIST_DIR=/data/chroma - CIX_SQLITE_PATH=/data/sqlite/projects.db - CIX_MAX_FILE_SIZE=${CIX_MAX_FILE_SIZE:-524288} - CIX_EXCLUDED_DIRS=${CIX_EXCLUDED_DIRS:-node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store} - CIX_N_GPU_LAYERS=99 + # GGUF cache lives on the named volume below — survives `docker compose + # down` (without -v) and is owned by the image's 1001:1001 user, so the + # cix-server process can always write to it regardless of host + # bind-mount permissions. - CIX_GGUF_CACHE_DIR=/data/models + - CIX_LLAMA_BIN_DIR=/app - CIX_LLAMA_STARTUP_TIMEOUT=120 + - CIX_EMBEDDINGS_ENABLED=${CIX_EMBEDDINGS_ENABLED:-true} + # ── First-boot admin seed (required when the DB has no users yet) ── + # cix-server refuses to start when the users table is empty AND these + # are unset. Set BOTH in your .env, log in once, change the password + # immediately (the user is flagged must_change_password=true). + - CIX_BOOTSTRAP_ADMIN_EMAIL=${CIX_BOOTSTRAP_ADMIN_EMAIL:-} + - CIX_BOOTSTRAP_ADMIN_PASSWORD=${CIX_BOOTSTRAP_ADMIN_PASSWORD:-} + # ── PR-E runtime tunables (all DB-overridable from /dashboard/server) ── + # 0 = auto. Threads → runtime.NumCPU()/2; batch → match n_ctx. + - CIX_LLAMA_THREADS=${CIX_LLAMA_THREADS:-0} + - CIX_LLAMA_BATCH=${CIX_LLAMA_BATCH:-0} + # Embedding queue parallelism. Default 5 (was 1) — pipelines host-side + # prep with device inference. Drop to 1 if you observe contention. + - CIX_MAX_EMBEDDING_CONCURRENCY=${CIX_MAX_EMBEDDING_CONCURRENCY:-5} + - CIX_EMBEDDING_QUEUE_TIMEOUT=${CIX_EMBEDDING_QUEUE_TIMEOUT:-300} + # Optional: skip the first-boot HF download by pointing at a GGUF + # file the operator already has on disk. cix copies it into the + # cix-models named volume once (atomic .partial → rename) and never + # touches the source again. Subsequent boots find the file in cache + # and ignore the env. See volumes block below for an example bind. + - CIX_BOOTSTRAP_GGUF_PATH=${CIX_BOOTSTRAP_GGUF_PATH:-} - NVIDIA_VISIBLE_DEVICES=all volumes: + # Operator-managed bind for sqlite + chroma so backups and inspection + # are one `cd` away on the host. Make sure the directory is owned by + # 1001:1001 OR use `user: "0:0"` — see CLAUDE.md. - ${HOME}/.cix/data:/data + # Docker-managed named volume layered ON TOP of /data/models. This + # isolates the GGUF cache from host-side bind permission issues and + # guarantees the model is downloaded exactly once across container + # recreates (`docker compose up --force-recreate`, image bumps, etc.). + - cix-models:/data/models + # Optional bootstrap: bind a host-side .gguf read-only into + # /bootstrap/model.gguf and set CIX_BOOTSTRAP_GGUF_PATH=/bootstrap/model.gguf + # in your .env. cix imports it into the cix-models cache on first boot, + # then ignores both the env and the bind. After verifying the cache is + # seeded, the bind can be removed entirely. + # - /srv/hf-cache/coderankembed-q8_0.gguf:/bootstrap/model.gguf:ro deploy: resources: limits: @@ -29,8 +73,13 @@ services: count: 1 capabilities: [gpu] healthcheck: - test: ["/cix-server", "-healthcheck"] + test: ["CMD", "/cix-server", "-healthcheck"] interval: 30s timeout: 10s start_period: 120s retries: 3 + +volumes: + cix-models: + # GGUF model cache. Persisted by Docker; only `docker compose down -v` + # (or explicit `docker volume rm _cix-models`) wipes it. diff --git a/docker-compose.yml b/docker-compose.yml index e1e2633..e758c30 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -7,17 +7,62 @@ services: - "${PORT:-21847}:21847" environment: - CIX_API_KEY=${CIX_API_KEY} + # Defense in depth — the image already defaults to 21847 (since + # v0.5.1) but pinning it here keeps the host:container port mapping + # honest if a third-party fork or custom build sets a different + # default. + - CIX_PORT=${CIX_PORT:-21847} - CIX_EMBEDDING_MODEL=${CIX_EMBEDDING_MODEL:-awhiteside/CodeRankEmbed-Q8_0-GGUF} - CIX_CHROMA_PERSIST_DIR=/data/chroma - CIX_SQLITE_PATH=/data/sqlite/projects.db - CIX_MAX_FILE_SIZE=${CIX_MAX_FILE_SIZE:-524288} - CIX_EXCLUDED_DIRS=${CIX_EXCLUDED_DIRS:-node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store} + # GGUF cache lives on the named volume below — survives `docker compose + # down` (without -v) and is owned by the image's 65532:65532 (nonroot) + # user on the CPU image, so the cix-server process can always write to + # it regardless of host bind-mount permissions. - CIX_GGUF_CACHE_DIR=/data/models - CIX_LLAMA_BIN_DIR=/app - CIX_LLAMA_STARTUP_TIMEOUT=120 - CIX_EMBEDDINGS_ENABLED=${CIX_EMBEDDINGS_ENABLED:-true} + # ── First-boot admin seed (required when the DB has no users yet) ── + # cix-server refuses to start when the users table is empty AND these + # are unset. Set BOTH in your .env, log in once, change the password + # immediately (the user is flagged must_change_password=true). + - CIX_BOOTSTRAP_ADMIN_EMAIL=${CIX_BOOTSTRAP_ADMIN_EMAIL:-} + - CIX_BOOTSTRAP_ADMIN_PASSWORD=${CIX_BOOTSTRAP_ADMIN_PASSWORD:-} + # ── PR-E runtime tunables (all DB-overridable from /dashboard/server) ── + # 0 = auto. Threads → runtime.NumCPU()/2; batch → match n_ctx. + - CIX_LLAMA_THREADS=${CIX_LLAMA_THREADS:-0} + - CIX_LLAMA_BATCH=${CIX_LLAMA_BATCH:-0} + # Embedding queue parallelism. Default 5 (was 1) — pipelines host-side + # prep with device inference. Drop to 1 if you observe contention. + - CIX_MAX_EMBEDDING_CONCURRENCY=${CIX_MAX_EMBEDDING_CONCURRENCY:-5} + - CIX_EMBEDDING_QUEUE_TIMEOUT=${CIX_EMBEDDING_QUEUE_TIMEOUT:-300} + # Optional: skip the first-boot HF download by pointing at a GGUF + # file the operator already has on disk. cix copies it into the + # cix-models named volume once (atomic .partial → rename) and never + # touches the source again. Subsequent boots find the file in cache + # and ignore the env. See volumes block below for an example bind. + - CIX_BOOTSTRAP_GGUF_PATH=${CIX_BOOTSTRAP_GGUF_PATH:-} volumes: + # Operator-managed bind for sqlite + chroma so backups and inspection + # are one `cd` away on the host. The CPU image runs as + # nonroot:nonroot (uid 65532) — chown your bind directory to + # 65532:65532 OR add `user: "0:0"` to fall back to root. See + # doc/SECURITY_DEPLOYMENT.md. - ${HOME}/.cix/data:/data + # Docker-managed named volume layered ON TOP of /data/models. This + # isolates the GGUF cache from host-side bind permission issues and + # guarantees the model is downloaded exactly once across container + # recreates (`docker compose up --force-recreate`, image bumps, etc.). + - cix-models:/data/models + # Optional bootstrap: bind a host-side .gguf read-only into + # /bootstrap/model.gguf and set CIX_BOOTSTRAP_GGUF_PATH=/bootstrap/model.gguf + # in your .env. cix imports it into the cix-models cache on first boot, + # then ignores both the env and the bind. After verifying the cache is + # seeded, the bind can be removed entirely. + # - /Users/me/.cache/huggingface/hub/.../coderankembed-q8_0.gguf:/bootstrap/model.gguf:ro deploy: resources: limits: @@ -26,8 +71,13 @@ services: reservations: memory: 1G healthcheck: - test: ["/cix-server", "-healthcheck"] + test: ["CMD", "/cix-server", "-healthcheck"] interval: 30s timeout: 10s start_period: 120s retries: 3 + +volumes: + cix-models: + # GGUF model cache. Persisted by Docker; only `docker compose down -v` + # (or explicit `docker volume rm cix_cix-models`) wipes it. diff --git a/install.sh b/install.sh index 976ac21..10a9443 100755 --- a/install.sh +++ b/install.sh @@ -2,8 +2,18 @@ set -euo pipefail # cix installer -# Usage: curl -fsSL https://raw.githubusercontent.com//cix/main/install.sh | bash -# or: ./install.sh [--version v1.0.0] [--bin-dir /usr/local/bin] +# +# Usage: +# curl -fsSL https://raw.githubusercontent.com/dvcdsys/code-index/main/install.sh | bash +# ./install.sh [--version cli/v0.4.0] [--bin-dir /usr/local/bin] [--force] +# +# Re-running upgrades to the latest CLI release. If the requested version +# is already installed the script exits early — pass --force to reinstall +# anyway. +# +# Tag scheme: CLI releases live under `cli/v*`, server releases under +# `server/v*`. Bare `v*` tags are the historical pre-split CLI line and +# are used as a fallback only when no `cli/v*` release exists yet. REPO="dvcdsys/code-index" BINARY_NAME="cix" @@ -13,12 +23,27 @@ DEFAULT_BIN_DIR="/usr/local/bin" VERSION="" BIN_DIR="$DEFAULT_BIN_DIR" +FORCE=0 + +usage() { + cat <] [--bin-dir ] [--force] + +Options: + --version Install a specific tag (e.g. cli/v0.4.0). Default: latest cli/v*. + --bin-dir Install directory. Default: ${DEFAULT_BIN_DIR}. + --force Reinstall even if the same version is already present. + -h, --help Show this help. +EOF +} while [[ $# -gt 0 ]]; do case "$1" in --version) VERSION="$2"; shift 2 ;; --bin-dir) BIN_DIR="$2"; shift 2 ;; - *) echo "Unknown argument: $1"; exit 1 ;; + --force) FORCE=1; shift ;; + -h|--help) usage; exit 0 ;; + *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;; esac done @@ -31,7 +56,7 @@ case "$OS" in Darwin) OS="darwin" ;; Linux) OS="linux" ;; *) - echo "Unsupported OS: $OS (supported: macOS, Linux)" + echo "Unsupported OS: $OS (supported: macOS, Linux)" >&2 exit 1 ;; esac @@ -40,7 +65,7 @@ case "$ARCH" in x86_64) ARCH="amd64" ;; arm64|aarch64) ARCH="arm64" ;; *) - echo "Unsupported architecture: $ARCH (supported: x86_64, arm64)" + echo "Unsupported architecture: $ARCH (supported: x86_64, arm64)" >&2 exit 1 ;; esac @@ -51,42 +76,72 @@ PLATFORM="${OS}-${ARCH}" if [ -z "$VERSION" ]; then echo "Fetching latest CLI release..." - # Search for latest tag starting with cli/ - VERSION=$(curl -fsSL "https://api.github.com/repos/${REPO}/releases" \ + RELEASES_JSON=$(curl -fsSL "https://api.github.com/repos/${REPO}/releases?per_page=30") + + # 1) Prefer cli/v* tags (post-split scheme). + VERSION=$(printf '%s' "$RELEASES_JSON" \ | grep '"tag_name"' \ - | grep 'cli/' \ - | head -1 \ - | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/') - + | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/' \ + | grep '^cli/v' \ + | head -1 || true) + + # 2) Fall back to bare v* (historical CLI line), explicitly excluding server/v*. if [ -z "$VERSION" ]; then - echo "Failed to fetch latest version from cli/* tags. Trying latest release..." - VERSION=$(curl -fsSL "https://api.github.com/repos/${REPO}/releases/latest" \ + VERSION=$(printf '%s' "$RELEASES_JSON" \ | grep '"tag_name"' \ - | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/') + | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/' \ + | grep '^v' \ + | head -1 || true) fi - + if [ -z "$VERSION" ]; then - echo "Failed to fetch version. Specify with --version." + echo "Failed to find a CLI release. Specify with --version ." >&2 exit 1 fi fi -# Strip cli/ prefix for display and download if present +# Strip cli/ prefix for display and binary `--version` comparison. CLEAN_VERSION="${VERSION#cli/}" -echo "Installing cix ${CLEAN_VERSION} (${PLATFORM})..." +# ── Skip if already installed at the same version ───────────────────────────── + +if [ "$FORCE" -ne 1 ] && command -v "$BINARY_NAME" >/dev/null 2>&1; then + # New binaries print "cix v0.4.0 darwin/arm64"; + # historical binaries print "cix version v0.2.7". + # Pick the first v-prefixed semver-looking token. + CURRENT=$("$BINARY_NAME" --version 2>/dev/null \ + | head -1 \ + | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+[A-Za-z0-9.+-]*' \ + | head -1 || true) + if [ -n "$CURRENT" ] && [ "$CURRENT" = "$CLEAN_VERSION" ]; then + echo "✓ cix ${CLEAN_VERSION} already installed at $(command -v "$BINARY_NAME")" + echo " Pass --force to reinstall." + exit 0 + fi + if [ -n "$CURRENT" ]; then + echo "Upgrading cix ${CURRENT} → ${CLEAN_VERSION}..." + else + echo "Installing cix ${CLEAN_VERSION} (existing binary version unknown)..." + fi +else + echo "Installing cix ${CLEAN_VERSION} (${PLATFORM})..." +fi # ── Download ────────────────────────────────────────────────────────────────── ARCHIVE="${BINARY_NAME}-${PLATFORM}.tar.gz" -# Note: GitHub release assets are attached to the tag. -# If tag is cli/v0.2.0, the download URL uses the full tag name. +# GitHub release download URLs preserve slashes in tag names verbatim, +# so `cli/v0.4.0` becomes `.../releases/download/cli/v0.4.0/...`. DOWNLOAD_URL="https://github.com/${REPO}/releases/download/${VERSION}/${ARCHIVE}" TMP_DIR="$(mktemp -d)" trap 'rm -rf "$TMP_DIR"' EXIT echo "Downloading ${DOWNLOAD_URL}..." -curl -fsSL "$DOWNLOAD_URL" -o "${TMP_DIR}/${ARCHIVE}" +if ! curl -fsSL "$DOWNLOAD_URL" -o "${TMP_DIR}/${ARCHIVE}"; then + echo "Failed to download ${DOWNLOAD_URL}" >&2 + echo "Check that the release exists and contains ${ARCHIVE}." >&2 + exit 1 +fi tar -xzf "${TMP_DIR}/${ARCHIVE}" -C "$TMP_DIR" @@ -94,7 +149,7 @@ tar -xzf "${TMP_DIR}/${ARCHIVE}" -C "$TMP_DIR" BINARY="${TMP_DIR}/${BINARY_NAME}" if [ ! -f "$BINARY" ]; then - echo "Binary not found in archive: ${BINARY_NAME}" + echo "Binary not found in archive: ${BINARY_NAME}" >&2 exit 1 fi @@ -109,18 +164,31 @@ fi # ── Verify ──────────────────────────────────────────────────────────────────── -if command -v "$BINARY_NAME" &>/dev/null; then - INSTALLED_VERSION=$("$BINARY_NAME" --version 2>&1 | head -1) - echo "" - echo "✓ cix installed: ${INSTALLED_VERSION}" - echo " Location: $(command -v $BINARY_NAME)" - echo "" - echo "Next steps:" - echo " cix config set api.url http://localhost:21847" - echo " cix config set api.key " - echo " cix init /path/to/your/project" +INSTALLED_PATH="${BIN_DIR}/${BINARY_NAME}" +INSTALLED_VERSION=$("$INSTALLED_PATH" --version 2>/dev/null \ + | head -1 \ + | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+[A-Za-z0-9.+-]*' \ + | head -1 || true) + +echo "" +if [ -n "$INSTALLED_VERSION" ]; then + echo "✓ cix ${INSTALLED_VERSION} installed at ${INSTALLED_PATH}" else + echo "✓ cix ${CLEAN_VERSION} installed at ${INSTALLED_PATH}" +fi + +# Warn if a different cix is shadowing this one on PATH. +PATH_BIN=$(command -v "$BINARY_NAME" 2>/dev/null || true) +if [ -n "$PATH_BIN" ] && [ "$PATH_BIN" != "$INSTALLED_PATH" ]; then echo "" - echo "✓ cix installed to ${BIN_DIR}/${BINARY_NAME}" - echo " Add ${BIN_DIR} to your PATH if needed." -fi \ No newline at end of file + echo "⚠ Another cix is first on PATH: ${PATH_BIN}" + echo " Add ${BIN_DIR} earlier in PATH or remove the other binary." +elif [ -z "$PATH_BIN" ]; then + echo " Add ${BIN_DIR} to your PATH if needed." +fi + +echo "" +echo "Next steps:" +echo " cix config set api.url http://localhost:21847" +echo " cix config set api.key " +echo " cix init /path/to/your/project" diff --git a/legacy/python-api/Makefile b/legacy/python-api/Makefile deleted file mode 100644 index 8c90dcd..0000000 --- a/legacy/python-api/Makefile +++ /dev/null @@ -1,244 +0,0 @@ -.PHONY: server-local-setup server-local-start server-local-stop server-local-restart \ - server-local-status server-local-logs \ - server-docker-start server-docker-stop server-docker-restart \ - server-docker-status server-docker-logs \ - server-cuda-start server-cuda-stop server-cuda-restart \ - server-cuda-status server-cuda-logs \ - docker-setup docker-push-all docker-push-cuda \ - test test-server test-client test-setup help - -PORT ?= 21847 -PYTHON ?= $(shell test -f .venv/bin/python && echo .venv/bin/python || (command -v uv >/dev/null 2>&1 && echo "uv run --python 3.12 python" || echo python3)) -DOCKER_USER ?= $(error DOCKER_USER is not set. Run: make docker-push-all DOCKER_USER=yourname) -IMAGE_NAME ?= code-index -CLI_VERSION ?= $(shell git describe --tags --match "cli/*" --abbrev=0 2>/dev/null | sed 's/^cli\///' || echo v0.2.0) -SERVER_VERSION ?= $(shell git describe --tags --match "server/*" --abbrev=0 2>/dev/null | sed 's/^server\///' || echo v0.2.0) -DATA_DIR ?= $(HOME)/.cix/data - -# ─── Server: Local (native, MPS on Mac) ───────────────────────────── - -# First-time setup + start (installs uv, Python 3.12, deps) -server-local-setup: - ./setup-local.sh - -# Start server from existing .venv -server-local-start: - @if [ ! -f .venv/bin/uvicorn ]; then \ - echo "ERROR: Run 'make server-local-setup' first."; \ - exit 1; \ - fi - @if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - echo "Already running on port $(PORT)"; \ - exit 0; \ - fi - @. .env && \ - mkdir -p "$(DATA_DIR)/chroma" "$(DATA_DIR)/sqlite" && \ - echo "Starting server on port $(PORT)..." && \ - cd api && \ - PYTHONPATH="$$(pwd)" \ - API_KEY="$$API_KEY" \ - CHROMA_PERSIST_DIR="$${CHROMA_PERSIST_DIR:-$(DATA_DIR)/chroma}" \ - SQLITE_PATH="$${SQLITE_PATH:-$(DATA_DIR)/sqlite/projects.db}" \ - EMBEDDING_MODEL="$${EMBEDDING_MODEL:-awhiteside/CodeRankEmbed-Q8_0-GGUF}" \ - MAX_FILE_SIZE="$${MAX_FILE_SIZE:-524288}" \ - EXCLUDED_DIRS="$${EXCLUDED_DIRS:-node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store}" \ - nohup ../.venv/bin/uvicorn app.main:app \ - --host 0.0.0.0 --port $(PORT) \ - > "$(DATA_DIR)/server.log" 2>&1 & \ - echo "$$!" > "$(DATA_DIR)/server.pid" && \ - echo "PID: $$(cat $(DATA_DIR)/server.pid)" && \ - cd .. && \ - for i in $$(seq 1 30); do \ - if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - echo "Healthy: http://localhost:$(PORT)"; \ - exit 0; \ - fi; \ - sleep 2; \ - done; \ - echo "ERROR: Failed to start. Run: make server-local-logs"; exit 1 - -server-local-stop: - @if [ -f "$(DATA_DIR)/server.pid" ]; then \ - PID=$$(cat "$(DATA_DIR)/server.pid"); \ - if kill -0 "$$PID" 2>/dev/null; then \ - echo "Stopping server (PID $$PID)..."; \ - kill "$$PID"; \ - fi; \ - rm -f "$(DATA_DIR)/server.pid"; \ - fi - @PIDS=$$(lsof -ti :$(PORT) 2>/dev/null); \ - if [ -n "$$PIDS" ]; then \ - echo "Killing process(es) on port $(PORT): $$PIDS"; \ - echo "$$PIDS" | xargs kill 2>/dev/null || true; \ - fi - @echo "Stopped" - -server-local-restart: server-local-stop server-local-start - -server-local-status: - @if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - echo "Running on port $(PORT)"; \ - curl -sf http://localhost:$(PORT)/health; echo; \ - else \ - echo "Not running"; \ - fi - @if [ -f "$(DATA_DIR)/server.pid" ] && kill -0 $$(cat "$(DATA_DIR)/server.pid") 2>/dev/null; then \ - echo "PID: $$(cat $(DATA_DIR)/server.pid)"; \ - fi - -server-local-logs: - @if [ -f "$(DATA_DIR)/server.log" ]; then \ - tail -f "$(DATA_DIR)/server.log"; \ - else \ - echo "No log file at $(DATA_DIR)/server.log"; \ - fi - -# ─── Server: Docker (CPU, multi-arch) ─────────────────────────────── - -server-docker-start: - @if [ ! -f .env ]; then \ - echo "Generating .env..."; \ - API_KEY="cix_$$(openssl rand -hex 32)"; \ - printf "API_KEY=$$API_KEY\nPORT=$(PORT)\nEMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF\nMAX_FILE_SIZE=524288\nEXCLUDED_DIRS=node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store\n" > .env; \ - echo "Created .env"; \ - fi - @mkdir -p "$(DATA_DIR)/chroma" "$(DATA_DIR)/sqlite" - docker compose up -d --build - @echo "Waiting for health..." - @for i in $$(seq 1 30); do \ - if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - echo "Healthy: http://localhost:$(PORT)"; \ - exit 0; \ - fi; \ - sleep 2; \ - done; \ - echo "ERROR: Failed to start. Run: make server-docker-logs"; exit 1 - -server-docker-stop: - docker compose down - -server-docker-restart: server-docker-stop server-docker-start - -server-docker-status: - @docker compose ps - @if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - curl -sf http://localhost:$(PORT)/health; echo; \ - fi - -server-docker-logs: - docker compose logs -f - -# ─── Server: CUDA (NVIDIA GPU) ────────────────────────────────────── - -server-cuda-start: - @if [ ! -f .env ]; then \ - echo "Generating .env..."; \ - API_KEY="cix_$$(openssl rand -hex 32)"; \ - printf "API_KEY=$$API_KEY\nPORT=$(PORT)\nEMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF\nMAX_FILE_SIZE=524288\nEXCLUDED_DIRS=node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store\n" > .env; \ - echo "Created .env"; \ - fi - @mkdir -p "$(DATA_DIR)/chroma" "$(DATA_DIR)/sqlite" - docker compose -f docker-compose.cuda.yml up -d --build - @echo "Waiting for health (CUDA)..." - @for i in $$(seq 1 45); do \ - if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - echo "Healthy (CUDA): http://localhost:$(PORT)"; \ - exit 0; \ - fi; \ - sleep 2; \ - done; \ - echo "ERROR: Failed to start. Run: make server-cuda-logs"; exit 1 - -server-cuda-stop: - docker compose -f docker-compose.cuda.yml down - -server-cuda-restart: server-cuda-stop server-cuda-start - -server-cuda-status: - @docker compose -f docker-compose.cuda.yml ps - @if curl -sf http://localhost:$(PORT)/health > /dev/null 2>&1; then \ - curl -sf http://localhost:$(PORT)/health; echo; \ - fi - -server-cuda-logs: - docker compose -f docker-compose.cuda.yml logs -f - -# ─── Build & Push ─────────────────────────────────────────────────── - -docker-setup: - @if ! docker buildx inspect cix-builder > /dev/null 2>&1; then \ - echo "Creating buildx builder 'cix-builder'..."; \ - docker buildx create --name cix-builder --driver docker-container --bootstrap; \ - fi - docker buildx use cix-builder - @echo "Builder ready. Run: docker login" - -docker-push-cuda: - docker buildx build \ - --builder cix-builder \ - --platform linux/amd64 \ - --tag $(DOCKER_USER)/$(IMAGE_NAME):latest-cu130 \ - --tag $(DOCKER_USER)/$(IMAGE_NAME):$(SERVER_VERSION)-cu130 \ - --file api/Dockerfile.cuda \ - --push \ - . - -docker-push-all: - docker buildx build \ - --builder cix-builder \ - --platform linux/arm64,linux/amd64 \ - --tag $(DOCKER_USER)/$(IMAGE_NAME):latest \ - --tag $(DOCKER_USER)/$(IMAGE_NAME):$(SERVER_VERSION) \ - --file api/Dockerfile \ - --push \ - . - -# ─── Tests ─────────────────────────────────────────────────────────── - -test-setup: - $(PYTHON) -m pip install -r api/requirements-dev.txt - -test: test-server test-client - -test-server: - $(PYTHON) -m pytest api/ -v; code=$$?; [ $$code -eq 5 ] && exit 0 || exit $$code - -test-client: - cd cli && go test -v ./... - -# ─── Help ──────────────────────────────────────────────────────────── - -help: - @echo "=== Claude Code Index ===" - @echo "" - @echo "Server — Local (native, MPS on Mac):" - @echo " server-local-setup First-time setup (installs uv, Python, deps)" - @echo " server-local-start Start server" - @echo " server-local-stop Stop server" - @echo " server-local-restart Restart server" - @echo " server-local-status Check status" - @echo " server-local-logs Tail logs" - @echo "" - @echo "Server — Docker (CPU):" - @echo " server-docker-start Start server" - @echo " server-docker-stop Stop server" - @echo " server-docker-restart Restart server" - @echo " server-docker-status Check status" - @echo " server-docker-logs Tail logs" - @echo "" - @echo "Server — CUDA (NVIDIA GPU):" - @echo " server-cuda-start Start server" - @echo " server-cuda-stop Stop server" - @echo " server-cuda-restart Restart server" - @echo " server-cuda-status Check status" - @echo " server-cuda-logs Tail logs" - @echo "" - @echo "Build & Push:" - @echo " docker-setup Create buildx builder (run once)" - @echo " docker-push-all Build & push :latest + :$(SERVER_VERSION) (multi-arch)" - @echo " docker-push-cuda Build & push :latest-cu130 + :$(SERVER_VERSION)-cu130" - @echo "" - @echo "Tests:" - @echo " test Run all tests" - @echo " test-server Python API tests" - @echo " test-client Go CLI tests" \ No newline at end of file diff --git a/legacy/python-api/README.md b/legacy/python-api/README.md deleted file mode 100644 index cd17c5c..0000000 --- a/legacy/python-api/README.md +++ /dev/null @@ -1,9 +0,0 @@ -This directory contains the Python FastAPI implementation of cix-server, -deprecated as of server/v0.3.0 (2026-04-24). - -The Go server (`server/`) replaces it with identical HTTP API contract, -better performance, and a pure-Go binary with no Python runtime dependency. - -See `doc/MIGRATION_FROM_PYTHON.md` for migration instructions. - -Timeline: will be deleted in server/v0.4.0 (~90 days from deprecation). diff --git a/legacy/python-api/app-root/Dockerfile b/legacy/python-api/app-root/Dockerfile deleted file mode 100644 index 3cca86e..0000000 --- a/legacy/python-api/app-root/Dockerfile +++ /dev/null @@ -1,53 +0,0 @@ -# Stage 1: builder — compile deps on Ubuntu 24.04 -FROM ubuntu:24.04 AS builder - -ENV DEBIAN_FRONTEND=noninteractive - -RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends \ - python3 python3-dev python3-venv python3-pip \ - build-essential gcc curl cmake \ - && rm -rf /var/lib/apt/lists/* \ - && update-alternatives --install /usr/bin/python python /usr/bin/python3 1 - -# Clean pip/setuptools/wheel and reinstall patched versions -RUN rm -f /usr/lib/python3.12/EXTERNALLY-MANAGED && \ - apt-get purge -y python3-setuptools python3-wheel python3-pip 2>/dev/null; \ - curl -sS https://bootstrap.pypa.io/get-pip.py | python && \ - pip install --no-cache-dir "setuptools>=78.1.1" "wheel>=0.46.2" - -# Install all deps (llama-cpp-python will be compiled for CPU) -WORKDIR /build -COPY api/requirements.txt . -RUN CMAKE_ARGS="-DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS" \ - pip install --no-cache-dir --prefix=/install -r requirements.txt && \ - pip install --no-cache-dir --prefix=/install --force-reinstall --no-deps packaging - -# Pre-download embedding model at build time -ARG EMBEDDING_MODEL="awhiteside/CodeRankEmbed-Q8_0-GGUF" -RUN PYTHONPATH=/install/local/lib/python3.12/dist-packages python -c \ - "from huggingface_hub import hf_hub_download, list_repo_files; \ - files = list_repo_files('${EMBEDDING_MODEL}'); \ - gguf_file = next((f for f in files if f.endswith('.gguf')), None); \ - hf_hub_download(repo_id='${EMBEDDING_MODEL}', filename=gguf_file)" - -# Stage 2: runtime — lightweight image without compilers -FROM ubuntu:24.04 - -ENV DEBIAN_FRONTEND=noninteractive - -RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends \ - python3 curl libopenblas-dev \ - && rm -rf /var/lib/apt/lists/* \ - && update-alternatives --install /usr/bin/python python /usr/bin/python3 1 - -# Copy installed Python packages and model from builder -COPY --from=builder /install/local /usr/local -COPY --from=builder /root/.cache/huggingface /root/.cache/huggingface - -WORKDIR /app -COPY api/app/ ./app/ -RUN mkdir -p /data/chroma /data/sqlite -EXPOSE 21847 -HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \ - CMD curl -f http://localhost:21847/health || exit 1 -CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "21847"] diff --git a/legacy/python-api/app-root/Dockerfile.cuda b/legacy/python-api/app-root/Dockerfile.cuda deleted file mode 100644 index 7c8cf10..0000000 --- a/legacy/python-api/app-root/Dockerfile.cuda +++ /dev/null @@ -1,69 +0,0 @@ -# Stage 1: builder — compile deps in full devel image -FROM nvidia/cuda:12.6.3-devel-ubuntu24.04 AS builder - -ENV DEBIAN_FRONTEND=noninteractive - -RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends \ - python3 python3-dev python3-venv python3-pip \ - build-essential gcc curl cmake \ - && rm -rf /var/lib/apt/lists/* \ - && update-alternatives --install /usr/bin/python python /usr/bin/python3 1 - -# Clean pip/setuptools/wheel and reinstall patched versions -RUN rm -f /usr/lib/python3.12/EXTERNALLY-MANAGED && \ - apt-get purge -y python3-setuptools python3-wheel python3-pip 2>/dev/null; \ - curl -sS https://bootstrap.pypa.io/get-pip.py | python && \ - pip install --no-cache-dir "setuptools>=78.1.1" "wheel>=0.46.2" - -# Install Python deps into /install prefix -WORKDIR /build -COPY api/requirements-cuda.txt requirements.txt - -# Make CUDA driver stub findable when linking the llama-cpp-python wheel. -# The devel image ships /usr/local/cuda/lib64/stubs/libcuda.so but tools like -# llama.cpp's mtmd-cli look for libcuda.so.1 — create the expected symlink and -# add the stub dir to LIBRARY_PATH (link-time search, runtime uses the driver). -RUN ln -sf /usr/local/cuda/lib64/stubs/libcuda.so /usr/local/cuda/lib64/stubs/libcuda.so.1 -ENV LIBRARY_PATH=/usr/local/cuda/lib64/stubs:${LIBRARY_PATH} - -# Enable CUDA for llama-cpp-python. Skip llama.cpp tools/examples (mtmd-cli etc.) -# — we only need embeddings, and those binaries link against libcuda.so.1 which -# isn't available in the builder image (only the stub is). -RUN CMAKE_ARGS="-DGGML_CUDA=on -DLLAMA_BUILD_TOOLS=OFF -DLLAMA_BUILD_EXAMPLES=OFF" \ - LDFLAGS="-Wl,-rpath-link,/usr/local/cuda/lib64/stubs" \ - pip install --no-cache-dir --prefix=/install -r requirements.txt && \ - pip install --no-cache-dir --prefix=/install --force-reinstall --no-deps packaging - -# Pre-download embedding model at build time -ARG EMBEDDING_MODEL="awhiteside/CodeRankEmbed-Q8_0-GGUF" -RUN PYTHONPATH=/install/local/lib/python3.12/dist-packages python -c \ - "from huggingface_hub import hf_hub_download, list_repo_files; \ - files = list_repo_files('${EMBEDDING_MODEL}'); \ - gguf_file = next((f for f in files if f.endswith('.gguf')), None); \ - hf_hub_download(repo_id='${EMBEDDING_MODEL}', filename=gguf_file)" - -# Stage 2: runtime — lightweight image without compilers -FROM nvidia/cuda:12.6.3-runtime-ubuntu24.04 - -ENV DEBIAN_FRONTEND=noninteractive -ENV TZ=Etc/UTC -ENV NVIDIA_VISIBLE_DEVICES=all -ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility - -RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends \ - python3 curl \ - && rm -rf /var/lib/apt/lists/* \ - && update-alternatives --install /usr/bin/python python /usr/bin/python3 1 - -# Copy installed Python packages and model from builder -COPY --from=builder /install/local /usr/local -COPY --from=builder /root/.cache/huggingface /root/.cache/huggingface - -WORKDIR /app -COPY api/app/ ./app/ -RUN mkdir -p /data/chroma /data/sqlite - -EXPOSE 21847 -HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \ - CMD curl -f http://localhost:21847/health || exit 1 -CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "21847"] \ No newline at end of file diff --git a/legacy/python-api/app-root/app/auth.py b/legacy/python-api/app-root/app/auth.py deleted file mode 100644 index 1cacbc7..0000000 --- a/legacy/python-api/app-root/app/auth.py +++ /dev/null @@ -1,18 +0,0 @@ -from fastapi import Depends, HTTPException, status -from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer - -from .config import settings - -_scheme = HTTPBearer() - - -async def verify_api_key( - credentials: HTTPAuthorizationCredentials = Depends(_scheme), -) -> str: - token = credentials.credentials - if not settings.api_key or token != settings.api_key: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="Invalid or missing API key", - ) - return token diff --git a/legacy/python-api/app-root/app/config.py b/legacy/python-api/app-root/app/config.py deleted file mode 100644 index 59330b6..0000000 --- a/legacy/python-api/app-root/app/config.py +++ /dev/null @@ -1,54 +0,0 @@ -import os -from pydantic_settings import BaseSettings, SettingsConfigDict - - -class Settings(BaseSettings): - api_key: str = "" - port: int = 21847 - embedding_model: str = "awhiteside/CodeRankEmbed-Q8_0-GGUF" - chroma_persist_dir: str = "/data/chroma" - sqlite_path: str = "/data/sqlite/projects.db" - max_file_size: int = 524288 - excluded_dirs: str = "node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store" - - @property - def model_safe_name(self) -> str: - return self.embedding_model.replace("/", "_").replace("-", "_").lower() - - @property - def dynamic_chroma_persist_dir(self) -> str: - return f"{self.chroma_persist_dir}_{self.model_safe_name}" - - @property - def dynamic_sqlite_path(self) -> str: - base, ext = os.path.splitext(self.sqlite_path) - return f"{base}_{self.model_safe_name}{ext}" - - # Concurrent embedding calls. llama-cpp-python holds a single context per Llama - # instance, so parallel create_embedding() calls on the same model serialize - # anyway. Keep at 1 unless you instantiate separate models. - max_embedding_concurrency: int = 1 - - # Seconds an /index/files request waits for a free embedding slot before the - # server returns HTTP 503 with Retry-After (the Go client auto-retries). - # 0 = reject immediately. - embedding_queue_timeout: int = 300 - - # Maximum chunk length in tokens. 1 token ≈ 4 ASCII chars. - # The chunker enforces this via MAX_CHUNK_SIZE = max_chunk_tokens * 4. - # Also drives n_ctx for the llama.cpp context buffer. - max_chunk_tokens: int = 1500 - - model_config = SettingsConfigDict( - env_file=os.path.join(os.path.dirname(__file__), "../../.env"), - env_file_encoding="utf-8", - case_sensitive=False, - extra="ignore", - ) - - @property - def excluded_dirs_list(self) -> list[str]: - return [d.strip() for d in self.excluded_dirs.split(",") if d.strip()] - - -settings = Settings() diff --git a/legacy/python-api/app-root/app/core/__init__.py b/legacy/python-api/app-root/app/core/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/legacy/python-api/app-root/app/core/exceptions.py b/legacy/python-api/app-root/app/core/exceptions.py deleted file mode 100644 index 67214c9..0000000 --- a/legacy/python-api/app-root/app/core/exceptions.py +++ /dev/null @@ -1,15 +0,0 @@ -class ProjectNotFoundError(Exception): - def __init__(self, project_id: str): - self.project_id = project_id - super().__init__(f"Project not found: {project_id}") - - -class IndexingError(Exception): - def __init__(self, message: str, project_id: str | None = None): - self.project_id = project_id - super().__init__(message) - - -class AuthError(Exception): - def __init__(self, message: str = "Invalid or missing API key"): - super().__init__(message) diff --git a/legacy/python-api/app-root/app/core/language.py b/legacy/python-api/app-root/app/core/language.py deleted file mode 100644 index 7fe9a97..0000000 --- a/legacy/python-api/app-root/app/core/language.py +++ /dev/null @@ -1,88 +0,0 @@ -EXTENSION_MAP: dict[str, str] = { - # Systems / compiled - ".py": "python", - ".go": "go", - ".rs": "rust", - ".java": "java", - ".c": "c", - ".h": "c", - ".cpp": "cpp", - ".cc": "cpp", - ".cxx": "cpp", - ".hpp": "cpp", - ".cs": "c_sharp", - ".swift": "swift", - ".kt": "kotlin", - ".scala": "scala", - ".zig": "zig", - ".jl": "julia", - ".f90": "fortran", - ".f95": "fortran", - ".f03": "fortran", - ".f": "fortran", - ".m": "objc", - ".mm": "objc", - # Web / scripting - ".ts": "typescript", - ".tsx": "typescript", - ".js": "javascript", - ".jsx": "javascript", - ".rb": "ruby", - ".php": "php", - ".lua": "lua", - ".sh": "bash", - ".bash": "bash", - ".zsh": "bash", - ".r": "r", - ".R": "r", - ".dart": "dart", - ".ex": "elixir", - ".exs": "elixir", - ".erl": "erlang", - ".hs": "haskell", - ".ml": "ocaml", - ".lisp": "commonlisp", - ".cl": "commonlisp", - ".svelte": "svelte", - # Markup / config / data - ".html": "html", - ".css": "css", - ".scss": "scss", - ".sql": "sql", - ".yaml": "yaml", - ".yml": "yaml", - ".json": "json", - ".toml": "toml", - ".xml": "xml", - ".md": "markdown", - ".graphql": "graphql", - ".gql": "graphql", - ".re": "regex", - # Infra / build - ".tf": "hcl", - ".hcl": "hcl", - ".cmake": "cmake", - "CMakeLists.txt": "cmake", - "Makefile": "make", - "Dockerfile": "dockerfile", -} - -# Filename-based detection (no extension or special names) -FILENAME_MAP: dict[str, str] = { - "CMakeLists.txt": "cmake", - "Makefile": "make", - "GNUmakefile": "make", - "Dockerfile": "dockerfile", -} - - -def detect_language(file_path: str) -> str | None: - from pathlib import Path - p = Path(file_path) - # Check filename first (Makefile, Dockerfile, CMakeLists.txt) - name = p.name - lang = FILENAME_MAP.get(name) - if lang: - return lang - ext = p.suffix.lower() - return EXTENSION_MAP.get(ext) diff --git a/legacy/python-api/app-root/app/core/path_encoding.py b/legacy/python-api/app-root/app/core/path_encoding.py deleted file mode 100644 index 412d9da..0000000 --- a/legacy/python-api/app-root/app/core/path_encoding.py +++ /dev/null @@ -1,29 +0,0 @@ -"""Project path hashing for safe URL routing. - -Project paths contain slashes which conflict with FastAPI path routing. -We use SHA1 hash as a short, URL-safe identifier for projects. -The actual path is stored in the database and resolved by hash. -""" - -import hashlib - - -def hash_project_path(path: str) -> str: - """Compute SHA1 hash of a project path (first 16 hex chars).""" - return hashlib.sha1(path.encode()).hexdigest()[:16] - - -async def resolve_project_path(path_hash: str) -> str: - """Look up the actual project path by its SHA1 hash prefix.""" - from ..core.exceptions import ProjectNotFoundError - from ..database import get_db - - db = await get_db() - cursor = await db.execute("SELECT host_path FROM projects") - rows = await cursor.fetchall() - - for row in rows: - if hash_project_path(row["host_path"]) == path_hash: - return row["host_path"] - - raise ProjectNotFoundError(path_hash) diff --git a/legacy/python-api/app-root/app/database.py b/legacy/python-api/app-root/app/database.py deleted file mode 100644 index a964e05..0000000 --- a/legacy/python-api/app-root/app/database.py +++ /dev/null @@ -1,101 +0,0 @@ -import aiosqlite -from pathlib import Path - -from .config import settings - -_db: aiosqlite.Connection | None = None - -_SCHEMA = """ -CREATE TABLE IF NOT EXISTS projects ( - host_path TEXT PRIMARY KEY, - container_path TEXT NOT NULL, - languages TEXT DEFAULT '[]', - settings TEXT DEFAULT '{}', - stats TEXT DEFAULT '{"total_files":0,"indexed_files":0,"total_chunks":0,"total_symbols":0}', - status TEXT DEFAULT 'created', - created_at TEXT NOT NULL, - updated_at TEXT NOT NULL, - last_indexed_at TEXT -); - -CREATE TABLE IF NOT EXISTS file_hashes ( - project_path TEXT NOT NULL, - file_path TEXT NOT NULL, - content_hash TEXT NOT NULL, - indexed_at TEXT NOT NULL, - PRIMARY KEY (project_path, file_path), - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE -); - -CREATE TABLE IF NOT EXISTS symbols ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - name TEXT NOT NULL, - kind TEXT NOT NULL, - file_path TEXT NOT NULL, - line INTEGER NOT NULL, - end_line INTEGER NOT NULL, - language TEXT NOT NULL, - signature TEXT, - parent_name TEXT, - docstring TEXT, - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE -); - -CREATE INDEX IF NOT EXISTS idx_symbols_project_name ON symbols(project_path, name); -CREATE INDEX IF NOT EXISTS idx_symbols_project_kind ON symbols(project_path, kind); -CREATE INDEX IF NOT EXISTS idx_symbols_project_file ON symbols(project_path, file_path); - -CREATE TABLE IF NOT EXISTS refs ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - project_path TEXT NOT NULL, - name TEXT NOT NULL, - file_path TEXT NOT NULL, - line INTEGER NOT NULL, - col INTEGER NOT NULL, - language TEXT NOT NULL, - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE -); - -CREATE INDEX IF NOT EXISTS idx_refs_project_name ON refs(project_path, name); -CREATE INDEX IF NOT EXISTS idx_refs_project_file ON refs(project_path, file_path); - -CREATE TABLE IF NOT EXISTS index_runs ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - started_at TEXT NOT NULL, - completed_at TEXT, - files_processed INTEGER DEFAULT 0, - files_total INTEGER DEFAULT 0, - chunks_created INTEGER DEFAULT 0, - status TEXT DEFAULT 'running', - error_message TEXT, - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE -); -""" - - -async def init_db() -> aiosqlite.Connection: - global _db - db_path = Path(settings.dynamic_sqlite_path) - db_path.parent.mkdir(parents=True, exist_ok=True) - _db = await aiosqlite.connect(str(db_path)) - _db.row_factory = aiosqlite.Row - await _db.execute("PRAGMA journal_mode=WAL") - await _db.execute("PRAGMA foreign_keys=ON") - await _db.executescript(_SCHEMA) - await _db.commit() - return _db - - -async def get_db() -> aiosqlite.Connection: - if _db is None: - raise RuntimeError("Database not initialized") - return _db - - -async def close_db() -> None: - global _db - if _db is not None: - await _db.close() - _db = None diff --git a/legacy/python-api/app-root/app/main.py b/legacy/python-api/app-root/app/main.py deleted file mode 100644 index ee2902b..0000000 --- a/legacy/python-api/app-root/app/main.py +++ /dev/null @@ -1,69 +0,0 @@ -import logging -from contextlib import asynccontextmanager - -from fastapi import FastAPI, Request -from fastapi.responses import JSONResponse - -from .config import settings -from .core.exceptions import ProjectNotFoundError, IndexingError, AuthError -from .database import init_db, close_db -from .routers import health, projects, indexing, search - -from .version import SERVER_VERSION - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger(__name__) - - -@asynccontextmanager -async def lifespan(app: FastAPI): - logger.info("Starting up (v%s) — initializing database...", SERVER_VERSION) - await init_db() - logger.info("Database initialized") - - logger.info("Loading embedding model: %s", settings.embedding_model) - from .services.embeddings import embedding_service - await embedding_service.load_model() - logger.info("Embedding model loaded") - - yield - - logger.info("Shutting down...") - await close_db() - - -app = FastAPI( - title="Claude Code Index API", - version=SERVER_VERSION, - lifespan=lifespan, -) - - -@app.middleware("http") -async def log_client_version(request: Request, call_next): - client_version = request.headers.get("X-Client-Version", "unknown") - if client_version != "unknown": - logger.info("Request from client version: %s", client_version) - response = await call_next(request) - return response - - -app.include_router(health.router) -app.include_router(projects.router) -app.include_router(indexing.router) -app.include_router(search.router) - - -@app.exception_handler(ProjectNotFoundError) -async def project_not_found_handler(request: Request, exc: ProjectNotFoundError): - return JSONResponse(status_code=404, content={"detail": str(exc)}) - - -@app.exception_handler(IndexingError) -async def indexing_error_handler(request: Request, exc: IndexingError): - return JSONResponse(status_code=500, content={"detail": str(exc)}) - - -@app.exception_handler(AuthError) -async def auth_error_handler(request: Request, exc: AuthError): - return JSONResponse(status_code=401, content={"detail": str(exc)}) diff --git a/legacy/python-api/app-root/app/routers/__init__.py b/legacy/python-api/app-root/app/routers/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/legacy/python-api/app-root/app/routers/health.py b/legacy/python-api/app-root/app/routers/health.py deleted file mode 100644 index 0857cbd..0000000 --- a/legacy/python-api/app-root/app/routers/health.py +++ /dev/null @@ -1,36 +0,0 @@ -from fastapi import APIRouter, Depends - -from ..auth import verify_api_key -from ..database import get_db - -from ..version import SERVER_VERSION, API_VERSION - -router = APIRouter() - - -@router.get("/health") -async def health(): - return {"status": "ok"} - - -@router.get("/api/v1/status", dependencies=[Depends(verify_api_key)]) -async def status(): - db = await get_db() - cursor = await db.execute("SELECT COUNT(*) FROM projects") - row = await cursor.fetchone() - project_count = row[0] if row else 0 - - cursor = await db.execute( - "SELECT COUNT(*) FROM index_runs WHERE status = 'running'" - ) - row = await cursor.fetchone() - active_jobs = row[0] if row else 0 - - return { - "status": "ok", - "server_version": SERVER_VERSION, - "api_version": API_VERSION, - "model_loaded": True, - "projects": project_count, - "active_indexing_jobs": active_jobs, - } diff --git a/legacy/python-api/app-root/app/routers/indexing.py b/legacy/python-api/app-root/app/routers/indexing.py deleted file mode 100644 index 665d850..0000000 --- a/legacy/python-api/app-root/app/routers/indexing.py +++ /dev/null @@ -1,157 +0,0 @@ -from ..core.path_encoding import resolve_project_path - -from fastapi import APIRouter, Depends, HTTPException, status - -from ..auth import verify_api_key -from ..core.exceptions import ProjectNotFoundError -from ..database import get_db -from ..schemas.indexing import ( - IndexBeginRequest, - IndexBeginResponse, - IndexFilesRequest, - IndexFilesResponse, - IndexFinishRequest, - IndexFinishResponse, - IndexProgressResponse, - IndexRequest, - IndexTriggerResponse, -) -from ..services.embeddings import EmbeddingBusyError -from ..services.indexer import indexer_service - -router = APIRouter( - prefix="/api/v1/projects", - dependencies=[Depends(verify_api_key)], -) - - -async def _ensure_project(project_path: str): - db = await get_db() - cursor = await db.execute("SELECT host_path FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - if not row: - raise ProjectNotFoundError(project_path) - - -@router.post( - "/{project_path}/index", - status_code=status.HTTP_202_ACCEPTED, - response_model=IndexTriggerResponse, -) -async def trigger_index(project_path: str, body: IndexRequest | None = None): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - full = body.full if body else False - batch_size = body.batch_size if body else 20 - run_id = await indexer_service.start_indexing(project_path, full=full, batch_size=batch_size) - return IndexTriggerResponse( - run_id=run_id, - message="Indexing started" if not full else "Full reindex started", - ) - - -@router.get("/{project_path}/index/status", response_model=IndexProgressResponse) -async def index_status(project_path: str): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - progress = await indexer_service.get_progress(project_path) - - if progress is None: - # Check last run - db = await get_db() - cursor = await db.execute( - "SELECT * FROM index_runs WHERE project_path = ? ORDER BY started_at DESC LIMIT 1", - (project_path,), - ) - row = await cursor.fetchone() - if row: - return IndexProgressResponse( - status=row["status"], - progress={ - "files_processed": row["files_processed"], - "files_total": row["files_total"], - "chunks_created": row["chunks_created"], - }, - ) - return IndexProgressResponse(status="idle") - - return IndexProgressResponse( - status=progress.status, - progress={ - "phase": progress.phase, - "files_discovered": progress.files_discovered, - "files_processed": progress.files_processed, - "files_total": progress.files_total, - "chunks_created": progress.chunks_created, - "elapsed_seconds": round(progress.elapsed_seconds, 1), - "estimated_remaining": round(progress.estimated_remaining, 1), - }, - ) - - -@router.post("/{project_path}/index/cancel") -async def cancel_index(project_path: str): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - cancelled = await indexer_service.cancel(project_path) - if not cancelled: - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, - detail="No active indexing job found", - ) - return {"message": "Indexing cancellation requested"} - - -# --- New three-phase protocol endpoints --- - -@router.post( - "/{project_path}/index/begin", - response_model=IndexBeginResponse, -) -async def begin_index(project_path: str, body: IndexBeginRequest | None = None): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - full = body.full if body else False - run_id, stored_hashes = await indexer_service.begin_indexing(project_path, full=full) - return IndexBeginResponse(run_id=run_id, stored_hashes=stored_hashes) - - -@router.post( - "/{project_path}/index/files", - response_model=IndexFilesResponse, -) -async def index_files(project_path: str, body: IndexFilesRequest): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - try: - files_accepted, chunks_created, total = await indexer_service.process_files( - project_path, body.run_id, body.files, - ) - except EmbeddingBusyError as exc: - raise HTTPException( - status_code=status.HTTP_503_SERVICE_UNAVAILABLE, - detail=f"GPU is busy processing another embedding request, retry after {exc.retry_after}s", - headers={"Retry-After": str(exc.retry_after)}, - ) - return IndexFilesResponse( - files_accepted=files_accepted, - chunks_created=chunks_created, - files_processed_total=total, - ) - - -@router.post( - "/{project_path}/index/finish", - response_model=IndexFinishResponse, -) -async def finish_index(project_path: str, body: IndexFinishRequest): - project_path = await resolve_project_path(project_path) - await _ensure_project(project_path) - status_str, files_processed, chunks_created = await indexer_service.finish_indexing( - project_path, body.run_id, body.deleted_paths, body.total_files_discovered, - ) - return IndexFinishResponse( - status=status_str, - files_processed=files_processed, - chunks_created=chunks_created, - ) diff --git a/legacy/python-api/app-root/app/routers/projects.py b/legacy/python-api/app-root/app/routers/projects.py deleted file mode 100644 index e65dedd..0000000 --- a/legacy/python-api/app-root/app/routers/projects.py +++ /dev/null @@ -1,141 +0,0 @@ -import json -from datetime import datetime, timezone -from ..core.path_encoding import resolve_project_path - -from fastapi import APIRouter, Depends, HTTPException, status - -from ..auth import verify_api_key -from ..core.exceptions import ProjectNotFoundError -from ..database import get_db -from ..schemas.project import ( - ProjectCreate, - ProjectListResponse, - ProjectResponse, - ProjectSettings, - ProjectStats, - ProjectUpdate, -) - -router = APIRouter( - prefix="/api/v1/projects", - dependencies=[Depends(verify_api_key)], -) - - -def _row_to_project(row) -> ProjectResponse: - return ProjectResponse( - host_path=row["host_path"], - container_path=row["container_path"], - languages=json.loads(row["languages"]), - settings=ProjectSettings(**json.loads(row["settings"])), - stats=ProjectStats(**json.loads(row["stats"])), - status=row["status"], - created_at=row["created_at"], - updated_at=row["updated_at"], - last_indexed_at=row["last_indexed_at"], - ) - - -@router.post("", status_code=status.HTTP_201_CREATED, response_model=ProjectResponse) -async def create_project(body: ProjectCreate): - db = await get_db() - now = datetime.now(timezone.utc).isoformat() - container_path = body.host_path - default_settings = ProjectSettings() - default_stats = ProjectStats() - - try: - await db.execute( - """INSERT INTO projects (host_path, container_path, languages, settings, stats, status, created_at, updated_at) - VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", - ( - body.host_path, - container_path, - "[]", - default_settings.model_dump_json(), - default_stats.model_dump_json(), - "created", - now, - now, - ), - ) - await db.commit() - except Exception as e: - if "UNIQUE" in str(e): - raise HTTPException( - status_code=status.HTTP_409_CONFLICT, - detail=f"Project at path '{body.host_path}' already exists", - ) - raise - - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (body.host_path,)) - row = await cursor.fetchone() - return _row_to_project(row) - - -@router.get("", response_model=ProjectListResponse) -async def list_projects(): - db = await get_db() - cursor = await db.execute("SELECT * FROM projects ORDER BY created_at DESC") - rows = await cursor.fetchall() - projects = [_row_to_project(row) for row in rows] - return ProjectListResponse(projects=projects, total=len(projects)) - - -@router.get("/{project_path}", response_model=ProjectResponse) -async def get_project(project_path: str): - project_path = await resolve_project_path(project_path) - db = await get_db() - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - if not row: - raise ProjectNotFoundError(project_path) - return _row_to_project(row) - - -@router.patch("/{project_path}", response_model=ProjectResponse) -async def update_project(project_path: str, body: ProjectUpdate): - project_path = await resolve_project_path(project_path) - db = await get_db() - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - if not row: - raise ProjectNotFoundError(project_path) - - now = datetime.now(timezone.utc).isoformat() - updates = [] - values = [] - - if body.settings is not None: - updates.append("settings = ?") - values.append(body.settings.model_dump_json()) - - if updates: - updates.append("updated_at = ?") - values.append(now) - values.append(project_path) - await db.execute( - f"UPDATE projects SET {', '.join(updates)} WHERE host_path = ?", values - ) - await db.commit() - - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - return _row_to_project(row) - - -@router.delete("/{project_path}", status_code=status.HTTP_204_NO_CONTENT) -async def delete_project(project_path: str): - project_path = await resolve_project_path(project_path) - db = await get_db() - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - if not row: - raise ProjectNotFoundError(project_path) - - # Delete ChromaDB collection - from ..services.vector_store import vector_store_service - vector_store_service.delete_collection(project_path) - - await db.execute("DELETE FROM projects WHERE host_path = ?", (project_path,)) - await db.commit() diff --git a/legacy/python-api/app-root/app/routers/search.py b/legacy/python-api/app-root/app/routers/search.py deleted file mode 100644 index b843dc6..0000000 --- a/legacy/python-api/app-root/app/routers/search.py +++ /dev/null @@ -1,280 +0,0 @@ -import json -import time -from collections import Counter -from pathlib import Path -from ..core.path_encoding import resolve_project_path - -from fastapi import APIRouter, Depends - -from ..auth import verify_api_key -from ..core.exceptions import ProjectNotFoundError -from ..database import get_db -from ..schemas.search import ( - DefinitionItem, - DefinitionRequest, - DefinitionResponse, - FileResultItem, - FileSearchRequest, - FileSearchResponse, - ProjectSummary, - ReferenceItem, - ReferenceRequest, - ReferenceResponse, - SearchRequest, - SearchResponse, - SearchResultItem, - SymbolResultItem, - SymbolSearchRequest, - SymbolSearchResponse, -) -from ..services.embeddings import embedding_service -from ..services.reference_index import reference_index_service -from ..services.symbol_index import symbol_index_service -from ..services.vector_store import vector_store_service - -router = APIRouter( - prefix="/api/v1/projects", - dependencies=[Depends(verify_api_key)], -) - - -async def _get_project(project_path: str): - db = await get_db() - cursor = await db.execute("SELECT * FROM projects WHERE host_path = ?", (project_path,)) - row = await cursor.fetchone() - if not row: - raise ProjectNotFoundError(project_path) - return row - - -@router.post("/{project_path}/search", response_model=SearchResponse) -async def semantic_search(project_path: str, body: SearchRequest): - project_path = await resolve_project_path(project_path) - await _get_project(project_path) - start = time.time() - - query_embedding = await embedding_service.embed_query(body.query) - - where = {} - if body.languages: - if len(body.languages) == 1: - where["language"] = body.languages[0] - else: - where["$or"] = [{"language": lang} for lang in body.languages] - - results = await vector_store_service.search( - project_path, query_embedding, limit=body.limit * 2, where=where or None, - ) - - # Filter by min_score and path patterns - filtered = [] - for r in results: - if r["score"] < body.min_score: - continue - if body.paths: - if not any(r["file_path"].startswith(p) or p in r["file_path"] for p in body.paths): - continue - filtered.append(r) - - filtered = filtered[:body.limit] - elapsed = (time.time() - start) * 1000 - - return SearchResponse( - results=[SearchResultItem(**r) for r in filtered], - total=len(filtered), - query_time_ms=round(elapsed, 1), - ) - - -@router.post("/{project_path}/search/symbols", response_model=SymbolSearchResponse) -async def symbol_search(project_path: str, body: SymbolSearchRequest): - project_path = await resolve_project_path(project_path) - await _get_project(project_path) - - symbols = await symbol_index_service.search( - project_path, body.query, kinds=body.kinds or None, limit=body.limit, - ) - - results = [ - SymbolResultItem( - name=s.name, - kind=s.kind, - file_path=s.file_path, - line=s.line, - end_line=s.end_line, - language=s.language, - signature=s.signature, - parent_name=s.parent_name, - ) - for s in symbols - ] - - return SymbolSearchResponse(results=results, total=len(results)) - - -@router.post("/{project_path}/search/files", response_model=FileSearchResponse) -async def file_search(project_path: str, body: FileSearchRequest): - project_path = await resolve_project_path(project_path) - await _get_project(project_path) - - db = await get_db() - cursor = await db.execute( - "SELECT file_path FROM file_hashes WHERE project_path = ? AND file_path LIKE ?", - (project_path, f"%{body.query}%"), - ) - rows = await cursor.fetchall() - - from ..core.language import detect_language - - results = [] - for row in rows[:body.limit]: - fp = row["file_path"] - results.append(FileResultItem(file_path=fp, language=detect_language(fp))) - - return FileSearchResponse(results=results, total=len(results)) - - -@router.post("/{project_path}/search/definitions", response_model=DefinitionResponse) -async def definition_search(project_path: str, body: DefinitionRequest): - """Go to Definition — find where a symbol is defined.""" - project_path = await resolve_project_path(project_path) - await _get_project(project_path) - - db = await get_db() - - # Exact name match in symbols table - sql = "SELECT * FROM symbols WHERE project_path = ? AND name = ?" - params: list = [project_path, body.symbol] - - if body.kind: - sql += " AND kind = ?" - params.append(body.kind) - - if body.file_path: - sql += " AND file_path = ?" - params.append(body.file_path) - - sql += " ORDER BY name LIMIT ?" - params.append(body.limit) - - cursor = await db.execute(sql, params) - rows = await cursor.fetchall() - - # If no exact match, try case-insensitive - if not rows: - sql = "SELECT * FROM symbols WHERE project_path = ? AND name LIKE ?" - params = [project_path, body.symbol] - - if body.kind: - sql += " AND kind = ?" - params.append(body.kind) - - if body.file_path: - sql += " AND file_path = ?" - params.append(body.file_path) - - sql += " ORDER BY name LIMIT ?" - params.append(body.limit) - - cursor = await db.execute(sql, params) - rows = await cursor.fetchall() - - results = [ - DefinitionItem( - name=row["name"], - kind=row["kind"], - file_path=row["file_path"], - line=row["line"], - end_line=row["end_line"], - language=row["language"], - signature=row["signature"], - parent_name=row["parent_name"], - ) - for row in rows - ] - - return DefinitionResponse(results=results, total=len(results)) - - -@router.post("/{project_path}/search/references", response_model=ReferenceResponse) -async def reference_search(project_path: str, body: ReferenceRequest): - """Find References — find all places where a symbol is used (AST-based).""" - project_path = await resolve_project_path(project_path) - await _get_project(project_path) - - refs = await reference_index_service.search( - project_path, body.symbol, file_path=body.file_path, limit=body.limit, - ) - - results = [ - ReferenceItem( - file_path=ref.file_path, - start_line=ref.line, - end_line=ref.line, - content="", - chunk_type="reference", - symbol_name=ref.name, - language=ref.language, - ) - for ref in refs - ] - - return ReferenceResponse(results=results, total=len(results)) - - -@router.get("/{project_path}/summary", response_model=ProjectSummary) -async def project_summary(project_path: str): - project_path = await resolve_project_path(project_path) - project = await _get_project(project_path) - stats = json.loads(project["stats"]) - languages = json.loads(project["languages"]) - - # Top directories - db = await get_db() - cursor = await db.execute( - "SELECT file_path FROM file_hashes WHERE project_path = ?", - (project_path,), - ) - rows = await cursor.fetchall() - - dir_counter: Counter = Counter() - for row in rows: - parts = Path(row["file_path"]).parts - if len(parts) > 3: - dir_counter[str(Path(*parts[:4]))] += 1 - elif len(parts) > 1: - dir_counter[str(Path(*parts[:2]))] += 1 - - top_dirs = [ - {"path": path, "file_count": count} - for path, count in dir_counter.most_common(10) - ] - - # Recent symbols + accurate count directly from DB - cursor = await db.execute( - "SELECT name, kind, file_path, language FROM symbols WHERE project_path = ? LIMIT 20", - (project_path,), - ) - symbol_rows = await cursor.fetchall() - recent_symbols = [ - {"name": r["name"], "kind": r["kind"], "file_path": r["file_path"], "language": r["language"]} - for r in symbol_rows - ] - - cursor = await db.execute( - "SELECT COUNT(*) as cnt FROM symbols WHERE project_path = ?", - (project_path,), - ) - row = await cursor.fetchone() - total_symbols = row["cnt"] if row else 0 - - return ProjectSummary( - host_path=project_path, - status=project["status"], - languages=languages, - total_files=stats.get("total_files", 0), - total_chunks=stats.get("total_chunks", 0), - total_symbols=total_symbols, - top_directories=top_dirs, - recent_symbols=recent_symbols, - ) diff --git a/legacy/python-api/app-root/app/schemas/__init__.py b/legacy/python-api/app-root/app/schemas/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/legacy/python-api/app-root/app/schemas/common.py b/legacy/python-api/app-root/app/schemas/common.py deleted file mode 100644 index d5511be..0000000 --- a/legacy/python-api/app-root/app/schemas/common.py +++ /dev/null @@ -1,9 +0,0 @@ -from pydantic import BaseModel - - -class ErrorResponse(BaseModel): - detail: str - - -class MessageResponse(BaseModel): - message: str diff --git a/legacy/python-api/app-root/app/schemas/indexing.py b/legacy/python-api/app-root/app/schemas/indexing.py deleted file mode 100644 index 0346429..0000000 --- a/legacy/python-api/app-root/app/schemas/indexing.py +++ /dev/null @@ -1,59 +0,0 @@ -from pydantic import BaseModel, Field - - -class IndexRequest(BaseModel): - """DEPRECATED: Use the three-phase protocol instead.""" - full: bool = False - batch_size: int = 20 # files per batch (lower = less memory, slower) - - -class IndexProgressResponse(BaseModel): - status: str # idle|queued|indexing|completed|failed|cancelled - progress: dict | None = None - - -class IndexTriggerResponse(BaseModel): - run_id: str - message: str - - -# --- New three-phase protocol --- - -class IndexBeginRequest(BaseModel): - full: bool = False - - -class IndexBeginResponse(BaseModel): - run_id: str - stored_hashes: dict[str, str] # {file_path: sha256_hash} - - -class FilePayload(BaseModel): - path: str - content: str - content_hash: str # SHA-256 - language: str | None = None - size: int = 0 - - -class IndexFilesRequest(BaseModel): - run_id: str - files: list[FilePayload] = Field(..., max_length=50) - - -class IndexFilesResponse(BaseModel): - files_accepted: int - chunks_created: int - files_processed_total: int - - -class IndexFinishRequest(BaseModel): - run_id: str - deleted_paths: list[str] = [] - total_files_discovered: int = 0 - - -class IndexFinishResponse(BaseModel): - status: str - files_processed: int - chunks_created: int diff --git a/legacy/python-api/app-root/app/schemas/project.py b/legacy/python-api/app-root/app/schemas/project.py deleted file mode 100644 index c71b3fe..0000000 --- a/legacy/python-api/app-root/app/schemas/project.py +++ /dev/null @@ -1,42 +0,0 @@ -from datetime import datetime - -from pydantic import BaseModel, Field - - -class ProjectSettings(BaseModel): - exclude_patterns: list[str] = Field( - default_factory=lambda: ["node_modules", ".git", ".venv", "__pycache__", "dist", "build", ".next", ".cache", ".DS_Store"] - ) - max_file_size: int = 524288 - - -class ProjectStats(BaseModel): - total_files: int = 0 - indexed_files: int = 0 - total_chunks: int = 0 - total_symbols: int = 0 - - -class ProjectCreate(BaseModel): - host_path: str - - -class ProjectUpdate(BaseModel): - settings: ProjectSettings | None = None - - -class ProjectResponse(BaseModel): - host_path: str - container_path: str - languages: list[str] = Field(default_factory=list) - settings: ProjectSettings = Field(default_factory=ProjectSettings) - stats: ProjectStats = Field(default_factory=ProjectStats) - status: str = "created" - created_at: datetime - updated_at: datetime - last_indexed_at: datetime | None = None - - -class ProjectListResponse(BaseModel): - projects: list[ProjectResponse] - total: int diff --git a/legacy/python-api/app-root/app/schemas/search.py b/legacy/python-api/app-root/app/schemas/search.py deleted file mode 100644 index 1a6c8eb..0000000 --- a/legacy/python-api/app-root/app/schemas/search.py +++ /dev/null @@ -1,118 +0,0 @@ -from pydantic import BaseModel, Field - - -class SearchRequest(BaseModel): - query: str - limit: int = 10 - languages: list[str] = Field(default_factory=list) - paths: list[str] = Field(default_factory=list) - min_score: float = 0.1 - - -class SymbolSearchRequest(BaseModel): - query: str - kinds: list[str] = Field(default_factory=list) - limit: int = 20 - - -class FileSearchRequest(BaseModel): - query: str - limit: int = 20 - - -class SearchResultItem(BaseModel): - file_path: str - start_line: int - end_line: int - content: str - score: float - chunk_type: str - symbol_name: str - language: str - - -class SearchResponse(BaseModel): - results: list[SearchResultItem] - total: int - query_time_ms: float - - -class SymbolResultItem(BaseModel): - name: str - kind: str - file_path: str - line: int - end_line: int - language: str - signature: str | None = None - parent_name: str | None = None - - -class SymbolSearchResponse(BaseModel): - results: list[SymbolResultItem] - total: int - - -class FileResultItem(BaseModel): - file_path: str - language: str | None - - -class FileSearchResponse(BaseModel): - results: list[FileResultItem] - total: int - - -class DefinitionRequest(BaseModel): - symbol: str - kind: str | None = None # function|class|method|type - file_path: str | None = None # narrow to a specific file - limit: int = 10 - - -class DefinitionItem(BaseModel): - name: str - kind: str - file_path: str - line: int - end_line: int - language: str - signature: str | None = None - parent_name: str | None = None - - -class DefinitionResponse(BaseModel): - results: list[DefinitionItem] - total: int - - -class ReferenceRequest(BaseModel): - symbol: str - limit: int = 50 - file_path: str | None = None # narrow to a specific file - - -class ReferenceItem(BaseModel): - file_path: str - start_line: int - end_line: int - content: str - chunk_type: str - symbol_name: str - language: str - - -class ReferenceResponse(BaseModel): - results: list[ReferenceItem] - total: int - - -class ProjectSummary(BaseModel): - host_path: str - status: str - languages: list[str] - total_files: int - total_chunks: int - total_symbols: int - top_directories: list[dict] - recent_symbols: list[dict] diff --git a/legacy/python-api/app-root/app/services/__init__.py b/legacy/python-api/app-root/app/services/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/legacy/python-api/app-root/app/services/chunker.py b/legacy/python-api/app-root/app/services/chunker.py deleted file mode 100644 index 8b8a272..0000000 --- a/legacy/python-api/app-root/app/services/chunker.py +++ /dev/null @@ -1,454 +0,0 @@ -import logging -from dataclasses import dataclass - -logger = logging.getLogger(__name__) - -# Tree-sitter node types to extract per language -LANGUAGE_NODES: dict[str, dict[str, list[str]]] = { - "python": { - "function": ["function_definition"], - "class": ["class_definition"], - }, - "typescript": { - "function": ["function_declaration", "arrow_function"], - "class": ["class_declaration"], - "method": ["method_definition"], - "type": ["interface_declaration", "type_alias_declaration"], - }, - "javascript": { - "function": ["function_declaration", "arrow_function"], - "class": ["class_declaration"], - "method": ["method_definition"], - }, - "go": { - "function": ["function_declaration"], - "method": ["method_declaration"], - "type": ["type_spec"], - }, - "rust": { - "function": ["function_item"], - "class": ["struct_item", "enum_item"], - "type": ["trait_item"], - }, - "java": { - "function": ["method_declaration"], - "class": ["class_declaration"], - "type": ["interface_declaration"], - }, -} - -from ..config import settings - -MAX_CHUNK_SIZE = settings.max_chunk_tokens * 4 # chars; 1 token ≈ 4 ASCII chars - -# Identifier leaf-node types per language (for reference extraction) -IDENTIFIER_NODES: dict[str, set[str]] = { - "python": {"identifier"}, - "typescript": {"identifier", "type_identifier", "property_identifier"}, - "javascript": {"identifier", "property_identifier"}, - "go": {"identifier", "type_identifier", "field_identifier"}, - "rust": {"identifier", "type_identifier", "field_identifier"}, - "java": {"identifier", "type_identifier"}, -} - -# Names to skip when extracting references (keywords, builtins, noise) -SKIP_NAMES: set[str] = { - # Python - "self", "cls", "None", "True", "False", "print", "len", "range", "type", - "list", "dict", "set", "tuple", "int", "str", "float", "bool", "bytes", - "object", "Exception", "isinstance", "hasattr", "getattr", "setattr", - # JS/TS - "undefined", "null", "true", "false", "console", "window", "document", - "Array", "Object", "String", "Number", "Boolean", "Promise", "Map", "Set", - # Go - "nil", "fmt", "err", "ctx", - # Rust - "Ok", "Err", "Some", - # Common - "this", "super", "void", -} - -MIN_REF_NAME_LENGTH = 2 - - -@dataclass -class ReferenceInfo: - name: str - file_path: str - line: int # 1-based - col: int # 0-based - language: str - - -@dataclass -class ChunkResult: - chunks: list["CodeChunk"] - references: list[ReferenceInfo] - - -@dataclass -class CodeChunk: - content: str - chunk_type: str # function|class|method|type|module|block - file_path: str - start_line: int - end_line: int - language: str - symbol_name: str | None - symbol_signature: str | None - parent_name: str | None - - -class ChunkerService: - def __init__(self): - self._parsers: dict[str, object] = {} - - def chunk_file(self, file_path: str, content: str, language: str) -> ChunkResult: - try: - return self._chunk_with_treesitter(content, language, file_path) - except Exception as e: - logger.debug("Tree-sitter failed for %s (%s): %s, falling back to sliding window", file_path, language, e) - return ChunkResult( - chunks=self._chunk_sliding_window(content, file_path, language), - references=[], - ) - - # Map cix language names to (module_name, language_function_name). - # Each entry corresponds to a PyPI package tree-sitter-. - _LANGUAGE_BINDINGS: dict[str, tuple[str, str]] = { - "python": ("tree_sitter_python", "language"), - "typescript": ("tree_sitter_typescript", "language_typescript"), - "javascript": ("tree_sitter_javascript", "language"), - "go": ("tree_sitter_go", "language"), - "rust": ("tree_sitter_rust", "language"), - "java": ("tree_sitter_java", "language"), - "c": ("tree_sitter_c", "language"), - "cpp": ("tree_sitter_cpp", "language"), - "c_sharp": ("tree_sitter_c_sharp", "language"), - "ruby": ("tree_sitter_ruby", "language"), - "php": ("tree_sitter_php", "language_php"), - "swift": ("tree_sitter_swift", "language"), - "kotlin": ("tree_sitter_kotlin", "language"), - "scala": ("tree_sitter_scala", "language"), - "bash": ("tree_sitter_bash", "language"), - "html": ("tree_sitter_html", "language"), - "css": ("tree_sitter_css", "language"), - "scss": ("tree_sitter_scss", "language"), - "lua": ("tree_sitter_lua", "language"), - "sql": ("tree_sitter_sql", "language"), - "json": ("tree_sitter_json", "language"), - "yaml": ("tree_sitter_yaml", "language"), - "toml": ("tree_sitter_toml", "language"), - "xml": ("tree_sitter_xml", "language_xml"), - "markdown": ("tree_sitter_markdown", "language"), - "haskell": ("tree_sitter_haskell", "language"), - "ocaml": ("tree_sitter_ocaml", "language_ocaml"), - "hcl": ("tree_sitter_hcl", "language"), - "dart": ("tree_sitter_dart", "language"), - "elixir": ("tree_sitter_elixir", "language"), - "erlang": ("tree_sitter_erlang", "language"), - "zig": ("tree_sitter_zig", "language"), - "julia": ("tree_sitter_julia", "language"), - "r": ("tree_sitter_r", "language"), - "svelte": ("tree_sitter_svelte", "language"), - "graphql": ("tree_sitter_graphql", "language"), - "dockerfile": ("tree_sitter_dockerfile", "language"), - "cmake": ("tree_sitter_cmake", "language"), - "make": ("tree_sitter_make", "language"), - "fortran": ("tree_sitter_fortran", "language"), - "objc": ("tree_sitter_objc", "language"), - "commonlisp": ("tree_sitter_commonlisp", "language"), - "regex": ("tree_sitter_regex", "language"), - } - - def _get_parser(self, language: str): - if language not in self._parsers: - try: - from tree_sitter import Language, Parser - binding = self._LANGUAGE_BINDINGS.get(language) - if not binding: - return None - mod_name, func_name = binding - mod = __import__(mod_name) - lang = Language(getattr(mod, func_name)()) - self._parsers[language] = Parser(lang) - except Exception: - return None - return self._parsers[language] - - def _chunk_with_treesitter(self, content: str, language: str, file_path: str) -> ChunkResult: - parser = self._get_parser(language) - if parser is None: - return ChunkResult( - chunks=self._chunk_sliding_window(content, file_path, language), - references=[], - ) - - tree = parser.parse(content.encode("utf-8")) - node_types = LANGUAGE_NODES.get(language, {}) - if not node_types: - return ChunkResult( - chunks=self._chunk_sliding_window(content, file_path, language), - references=[], - ) - - # Build flat list of all target node types - target_types = set() - type_to_kind: dict[str, str] = {} - for kind, types in node_types.items(): - for t in types: - target_types.add(t) - type_to_kind[t] = kind - - lines = content.split("\n") - chunks: list[CodeChunk] = [] - covered_ranges: list[tuple[int, int]] = [] - - self._extract_nodes( - tree.root_node, target_types, type_to_kind, lines, - file_path, language, chunks, covered_ranges, parent_name=None, - ) - - # Extract references from AST - references = self._extract_references( - tree.root_node, target_types, file_path, language, - ) - - # Collect gaps as module chunks - covered_ranges.sort() - gap_lines = self._find_gaps(covered_ranges, len(lines)) - for start, end in gap_lines: - gap_content = "\n".join(lines[start:end + 1]).strip() - if gap_content: - chunks.append(CodeChunk( - content=gap_content, - chunk_type="module", - file_path=file_path, - start_line=start + 1, - end_line=end + 1, - language=language, - symbol_name=None, - symbol_signature=None, - parent_name=None, - )) - - # Split oversized chunks - final_chunks = [] - for chunk in chunks: - if len(chunk.content) > MAX_CHUNK_SIZE: - final_chunks.extend(self._split_chunk(chunk)) - else: - final_chunks.append(chunk) - - if not final_chunks: - return ChunkResult( - chunks=self._chunk_sliding_window(content, file_path, language), - references=[], - ) - - return ChunkResult(chunks=final_chunks, references=references) - - def _extract_nodes( - self, node, target_types, type_to_kind, lines, - file_path, language, chunks, covered_ranges, parent_name, - ): - if node.type in target_types: - start_line = node.start_point[0] - end_line = node.end_point[0] - content = "\n".join(lines[start_line:end_line + 1]) - kind = type_to_kind[node.type] - - # Detect if this is a method (function inside a class) - actual_kind = kind - if kind == "function" and parent_name is not None: - actual_kind = "method" - - # Extract symbol name - symbol_name = self._extract_name(node) - - # Extract signature (first line) - signature = lines[start_line].strip() if start_line < len(lines) else None - - chunks.append(CodeChunk( - content=content, - chunk_type=actual_kind, - file_path=file_path, - start_line=start_line + 1, - end_line=end_line + 1, - language=language, - symbol_name=symbol_name, - symbol_signature=signature, - parent_name=parent_name, - )) - covered_ranges.append((start_line, end_line)) - - # For classes, recurse with class name as parent - if kind == "class": - current_parent = symbol_name or parent_name - for child in node.children: - self._extract_nodes( - child, target_types, type_to_kind, lines, - file_path, language, chunks, covered_ranges, - parent_name=current_parent, - ) - return - - for child in node.children: - self._extract_nodes( - child, target_types, type_to_kind, lines, - file_path, language, chunks, covered_ranges, - parent_name=parent_name, - ) - - def _extract_references( - self, root_node, target_types: set, file_path: str, language: str, - ) -> list[ReferenceInfo]: - """Walk AST and collect identifier nodes that are usages (not definitions).""" - id_node_types = IDENTIFIER_NODES.get(language) - if not id_node_types: - return [] - - refs: list[ReferenceInfo] = [] - seen: set[tuple[str, int, int]] = set() - - def _walk(node): - if node.type in id_node_types: - name = node.text.decode("utf-8") if isinstance(node.text, bytes) else node.text - if ( - name - and len(name) >= MIN_REF_NAME_LENGTH - and name not in SKIP_NAMES - ): - # Skip if this identifier is the name child of a definition node - parent = node.parent - if parent and parent.type in target_types: - # Check if this is the "name" child (first identifier) - is_def_name = False - for child in parent.children: - if child.type in id_node_types: - is_def_name = (child.id == node.id) - break - if is_def_name: - return - - line = node.start_point[0] + 1 # 1-based - col = node.start_point[1] # 0-based - key = (name, line, col) - if key not in seen: - seen.add(key) - refs.append(ReferenceInfo( - name=name, - file_path=file_path, - line=line, - col=col, - language=language, - )) - return # leaf node, no children to recurse - - for child in node.children: - _walk(child) - - _walk(root_node) - return refs - - @staticmethod - def _extract_name(node) -> str | None: - for child in node.children: - if child.type in ("identifier", "name", "property_identifier", "type_identifier"): - return child.text.decode("utf-8") if isinstance(child.text, bytes) else child.text - return None - - @staticmethod - def _find_gaps(covered: list[tuple[int, int]], total_lines: int) -> list[tuple[int, int]]: - if not covered: - return [(0, total_lines - 1)] if total_lines > 0 else [] - - gaps = [] - prev_end = -1 - for start, end in covered: - if start > prev_end + 1: - gaps.append((prev_end + 1, start - 1)) - prev_end = max(prev_end, end) - if prev_end < total_lines - 1: - gaps.append((prev_end + 1, total_lines - 1)) - return gaps - - @staticmethod - def _split_chunk(chunk: CodeChunk) -> list[CodeChunk]: - lines = chunk.content.split("\n") - sub_chunks = [] - current_lines = [] - current_start = chunk.start_line - - for i, line in enumerate(lines): - current_lines.append(line) - current_content = "\n".join(current_lines) - if len(current_content) >= MAX_CHUNK_SIZE and len(current_lines) > 1: - # Split here - split_content = "\n".join(current_lines[:-1]) - sub_chunks.append(CodeChunk( - content=split_content, - chunk_type=chunk.chunk_type, - file_path=chunk.file_path, - start_line=current_start, - end_line=current_start + len(current_lines) - 2, - language=chunk.language, - symbol_name=chunk.symbol_name, - symbol_signature=chunk.symbol_signature, - parent_name=chunk.parent_name, - )) - current_start = current_start + len(current_lines) - 1 - current_lines = [line] - - if current_lines: - sub_chunks.append(CodeChunk( - content="\n".join(current_lines), - chunk_type=chunk.chunk_type, - file_path=chunk.file_path, - start_line=current_start, - end_line=chunk.end_line, - language=chunk.language, - symbol_name=chunk.symbol_name, - symbol_signature=chunk.symbol_signature, - parent_name=chunk.parent_name, - )) - - return sub_chunks - - def _chunk_sliding_window(self, content: str, file_path: str, language: str) -> list[CodeChunk]: - window_size = 4000 # chars (~1000 tokens) - overlap = 500 # chars (~125 tokens) - chunks = [] - - lines = content.split("\n") - current_pos = 0 - chunk_start_line = 0 - - while current_pos < len(content): - end_pos = min(current_pos + window_size, len(content)) - chunk_content = content[current_pos:end_pos] - - # Count lines - start_line = content[:current_pos].count("\n") - end_line = content[:end_pos].count("\n") - - chunks.append(CodeChunk( - content=chunk_content, - chunk_type="block", - file_path=file_path, - start_line=start_line + 1, - end_line=end_line + 1, - language=language, - symbol_name=None, - symbol_signature=None, - parent_name=None, - )) - - if end_pos >= len(content): - break - current_pos = end_pos - overlap - - return chunks - - -chunker_service = ChunkerService() diff --git a/legacy/python-api/app-root/app/services/embeddings.py b/legacy/python-api/app-root/app/services/embeddings.py deleted file mode 100644 index f76d5cc..0000000 --- a/legacy/python-api/app-root/app/services/embeddings.py +++ /dev/null @@ -1,184 +0,0 @@ -import asyncio -import logging -import os -import platform -import subprocess -import time as _time -from concurrent.futures import ThreadPoolExecutor -from typing import Any - -from ..config import settings - -logger = logging.getLogger(__name__) - -_AVG_BATCH_SEC_DEFAULT = 3.0 -_EMA_ALPHA = 0.25 - -# Models that require a query prefix for asymmetric retrieval. -QUERY_PREFIX_MODELS = { - "nomic-ai/CodeRankEmbed": "Represent this query for searching relevant code: ", - "nomic-ai/nomic-embed-text-v1.5": "search_query: ", - "BAAI/bge-base-en-v1.5": "Represent this sentence for searching relevant passages: ", - "BAAI/bge-large-en-v1.5": "Represent this sentence for searching relevant passages: ", - "awhiteside/CodeRankEmbed-Q8_0-GGUF": "Represent this query for searching relevant code: ", -} - - -def _resolve_query_prefix(model_name: str) -> str: - if model_name in QUERY_PREFIX_MODELS: - return QUERY_PREFIX_MODELS[model_name] - lowered = model_name.lower() - if "coderankembed" in lowered: - return QUERY_PREFIX_MODELS["nomic-ai/CodeRankEmbed"] - if "nomic-embed-text" in lowered: - return QUERY_PREFIX_MODELS["nomic-ai/nomic-embed-text-v1.5"] - if "bge-base" in lowered: - return QUERY_PREFIX_MODELS["BAAI/bge-base-en-v1.5"] - if "bge-large" in lowered: - return QUERY_PREFIX_MODELS["BAAI/bge-large-en-v1.5"] - return "" - - -def _detect_gpu_layers() -> int: - # Explicit override wins — e.g. CIX_N_GPU_LAYERS=0 forces CPU on a GPU box. - explicit = os.environ.get("CIX_N_GPU_LAYERS") - if explicit is not None: - return int(explicit) - # macOS: llama-cpp-python pip wheel ships with Metal enabled. - if platform.system() == "Darwin": - return -1 - # Linux: if nvidia-smi responds, llama.cpp was built against CUDA (Dockerfile.cuda). - try: - subprocess.run( - ["nvidia-smi"], - capture_output=True, - timeout=1, - check=True, - ) - return -1 - except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired): - return 0 - - -class EmbeddingBusyError(RuntimeError): - """Raised when the embedding queue is full and the request timed out waiting.""" - - def __init__(self, message: str, retry_after: int = 5) -> None: - super().__init__(message) - self.retry_after = retry_after - - -class EmbeddingService: - def __init__(self): - self._model: Any = None - self._executor = ThreadPoolExecutor( - max_workers=max(1, settings.max_embedding_concurrency) - ) - self._query_prefix = "" - self._semaphore = asyncio.Semaphore(settings.max_embedding_concurrency) - self._avg_batch_sec: float = _AVG_BATCH_SEC_DEFAULT - self._estimated_finish_at: float = 0.0 - - async def load_model(self): - loop = asyncio.get_event_loop() - self._model = await loop.run_in_executor( - self._executor, self._load_model_sync - ) - self._query_prefix = _resolve_query_prefix(settings.embedding_model) - - logger.info( - "Embedding model loaded: %s (dims=%d, query_prefix=%r)", - settings.embedding_model, - self._model.n_embd(), - self._query_prefix, - ) - - def _load_model_sync(self): - os.environ["TOKENIZERS_PARALLELISM"] = "false" - os.environ.setdefault("OMP_NUM_THREADS", str(os.cpu_count() or 2)) - - from huggingface_hub import hf_hub_download, list_repo_files - from llama_cpp import Llama - - model_path = settings.embedding_model - - if "/" in model_path and not os.path.exists(model_path): - logger.info("Downloading GGUF model from Hugging Face: %s", model_path) - files = list_repo_files(model_path) - gguf_file = next((f for f in files if f.endswith(".gguf")), None) - if not gguf_file: - raise ValueError( - f"No .gguf file found in repo {model_path}. " - "Only GGUF repositories are supported." - ) - model_path = hf_hub_download(repo_id=model_path, filename=gguf_file) - - n_gpu_layers = _detect_gpu_layers() - logger.info( - "Loading Llama (n_ctx=%d, n_gpu_layers=%d)", - settings.max_chunk_tokens + 128, - n_gpu_layers, - ) - - return Llama( - model_path=model_path, - embedding=True, - n_ctx=settings.max_chunk_tokens + 128, - n_threads=int(os.environ.get("OMP_NUM_THREADS", "4")), - n_gpu_layers=n_gpu_layers, - verbose=False, - ) - - async def embed_texts(self, texts: list[str]) -> list[list[float]]: - if not self._model: - raise RuntimeError("Model not loaded") - - timeout = settings.embedding_queue_timeout - try: - async with asyncio.timeout(timeout if timeout > 0 else 0): - async with self._semaphore: - return await self._embed_locked(texts) - except TimeoutError: - retry_after = max(5, int(self._estimated_finish_at - _time.monotonic())) - raise EmbeddingBusyError( - f"Queue is full — request waited {timeout}s without a free slot", - retry_after=retry_after, - ) - - async def _embed_locked(self, texts: list[str]) -> list[list[float]]: - if not texts: - return [] - - self._estimated_finish_at = _time.monotonic() + self._avg_batch_sec - loop = asyncio.get_event_loop() - t0 = _time.monotonic() - - result = await loop.run_in_executor( - self._executor, - lambda: self._model.create_embedding(texts), - ) - - batch_sec = _time.monotonic() - t0 - self._avg_batch_sec = ( - (1 - _EMA_ALPHA) * self._avg_batch_sec + _EMA_ALPHA * batch_sec - ) - self._estimated_finish_at = 0.0 - - logger.debug("Embedded %d texts in %.2fs", len(texts), batch_sec) - return [item["embedding"] for item in result["data"]] - - async def embed_query(self, query: str) -> list[float]: - if not self._model: - raise RuntimeError("Model not loaded") - - prefixed_query = self._query_prefix + query - loop = asyncio.get_event_loop() - - result = await loop.run_in_executor( - self._executor, - lambda: self._model.create_embedding(prefixed_query), - ) - return result["data"][0]["embedding"] - - -embedding_service = EmbeddingService() diff --git a/legacy/python-api/app-root/app/services/file_discovery.py b/legacy/python-api/app-root/app/services/file_discovery.py deleted file mode 100644 index a837262..0000000 --- a/legacy/python-api/app-root/app/services/file_discovery.py +++ /dev/null @@ -1,121 +0,0 @@ -import hashlib -from dataclasses import dataclass -from pathlib import Path - -import pathspec - -from ..core.language import detect_language -from .project_config import load_project_config, parse_submodule_paths - - -@dataclass -class DiscoveredFile: - path: str # container path - host_path: str # original host path - size: int - content_hash: str # SHA256 - language: str | None # detected from extension - - -class FileDiscoveryService: - def discover( - self, - project_container_path: str, - exclude_patterns: list[str], - max_file_size: int, - ) -> list[DiscoveredFile]: - root = Path(project_container_path) - if not root.exists(): - return [] - - # Load .gitignore and .cixignore if present (same format, merged) - ignore_patterns: list[str] = [] - for ignore_file in (".gitignore", ".cixignore"): - ignore_path = root / ignore_file - if ignore_path.exists(): - with open(ignore_path, "r", errors="ignore") as f: - ignore_patterns.extend(f.readlines()) - - # Load .cixconfig.yaml — if ignore.submodules is true, exclude submodule paths - proj_cfg = load_project_config(project_container_path) - if proj_cfg.ignore.submodules: - for sp in parse_submodule_paths(project_container_path): - ignore_patterns.append(sp + "/\n") - - ignore_spec = pathspec.PathSpec.from_lines("gitwildmatch", ignore_patterns) if ignore_patterns else None - - discovered = [] - exclude_set = set(exclude_patterns) - - for file_path in root.rglob("*"): - if not file_path.is_file(): - continue - - # Check excluded directory names - parts = file_path.relative_to(root).parts - if any(part in exclude_set for part in parts): - continue - - # Check .gitignore / .cixignore - relative = str(file_path.relative_to(root)) - if ignore_spec and ignore_spec.match_file(relative): - continue - - # Check file size - try: - size = file_path.stat().st_size - except OSError: - continue - if size > max_file_size or size == 0: - continue - - # Detect language - language = detect_language(str(file_path)) - - # Compute hash - try: - content_hash = self._hash_file(file_path) - except OSError: - continue - - host_path = str(file_path) - - discovered.append( - DiscoveredFile( - path=str(file_path), - host_path=host_path, - size=size, - content_hash=content_hash, - language=language, - ) - ) - - return discovered - - def get_changed_files( - self, - discovered: list[DiscoveredFile], - stored_hashes: dict[str, str], - ) -> tuple[list[DiscoveredFile], list[str]]: - changed_or_new = [] - current_paths = set() - - for f in discovered: - current_paths.add(f.host_path) - stored_hash = stored_hashes.get(f.host_path) - if stored_hash is None or stored_hash != f.content_hash: - changed_or_new.append(f) - - deleted = [p for p in stored_hashes if p not in current_paths] - return changed_or_new, deleted - - @staticmethod - def _hash_file(path: Path) -> str: - h = hashlib.sha256() - with open(path, "rb") as f: - for chunk in iter(lambda: f.read(8192), b""): - h.update(chunk) - return h.hexdigest() - - -file_discovery_service = FileDiscoveryService() diff --git a/legacy/python-api/app-root/app/services/indexer.py b/legacy/python-api/app-root/app/services/indexer.py deleted file mode 100644 index 885e53c..0000000 --- a/legacy/python-api/app-root/app/services/indexer.py +++ /dev/null @@ -1,614 +0,0 @@ -import asyncio -import gc -import json -import logging -import time -import uuid -from dataclasses import dataclass, field -from datetime import datetime, timezone - -from ..config import settings -from ..database import get_db -from .chunker import chunker_service -from .embeddings import embedding_service -from .file_discovery import file_discovery_service -from .reference_index import reference_index_service -from .symbol_index import SymbolInfo, symbol_index_service -from .vector_store import vector_store_service - -logger = logging.getLogger(__name__) - - -@dataclass -class IndexProgress: - run_id: str - project_path: str - status: str = "queued" # queued|indexing|completed|failed|cancelled - phase: str = "queued" # queued|discovering|chunking|embedding|storing|completed - files_discovered: int = 0 - files_processed: int = 0 - files_total: int = 0 - chunks_created: int = 0 - elapsed_seconds: float = 0 - estimated_remaining: float = 0 - error_message: str | None = None - - -@dataclass -class SessionState: - run_id: str - project_path: str - files_processed: int = 0 - chunks_created: int = 0 - languages_seen: set = field(default_factory=set) - start_time: float = field(default_factory=time.time) - status: str = "active" - - -class IndexerService: - def __init__(self): - self._active_jobs: dict[str, IndexProgress] = {} - self._cancel_events: dict[str, asyncio.Event] = {} - self._active_sessions: dict[str, SessionState] = {} # run_id -> SessionState - - # ---- New three-phase protocol ---- - - async def begin_indexing(self, project_path: str, full: bool = False) -> tuple[str, dict[str, str]]: - """Phase 1: Create indexing session, return stored hashes.""" - run_id = str(uuid.uuid4()) - db = await get_db() - now = datetime.now(timezone.utc).isoformat() - - await db.execute( - "INSERT INTO index_runs (id, project_path, started_at, status) VALUES (?, ?, ?, ?)", - (run_id, project_path, now, "running"), - ) - await db.execute( - "UPDATE projects SET status = 'indexing', updated_at = ? WHERE host_path = ?", - (now, project_path), - ) - await db.commit() - - stored_hashes: dict[str, str] = {} - - if full: - vector_store_service.delete_collection(project_path) - await db.execute("DELETE FROM file_hashes WHERE project_path = ?", (project_path,)) - await db.execute("DELETE FROM symbols WHERE project_path = ?", (project_path,)) - await db.execute("DELETE FROM refs WHERE project_path = ?", (project_path,)) - await db.commit() - else: - cursor = await db.execute( - "SELECT file_path, content_hash FROM file_hashes WHERE project_path = ?", - (project_path,), - ) - rows = await cursor.fetchall() - stored_hashes = {row["file_path"]: row["content_hash"] for row in rows} - - session = SessionState(run_id=run_id, project_path=project_path) - self._active_sessions[run_id] = session - - progress = IndexProgress(run_id=run_id, project_path=project_path, status="indexing", phase="receiving") - self._active_jobs[project_path] = progress - - asyncio.create_task(self._session_ttl_cleanup(run_id)) - - return run_id, stored_hashes - - async def process_files(self, project_path: str, run_id: str, files: list) -> tuple[int, int, int]: - """Phase 2: Process a batch of files (chunk, embed, store). Synchronous within request.""" - session = self._active_sessions.get(run_id) - if not session: - raise ValueError(f"No active session for run_id {run_id}") - if session.project_path != project_path: - raise ValueError("run_id does not match project") - - logger.info("Processing batch of %d files for session %s", len(files), run_id) - - db = await get_db() - now = datetime.now(timezone.utc).isoformat() - files_accepted = 0 - batch_chunks = 0 - batch_symbols: list[SymbolInfo] = [] - batch_references = [] - - for file_payload in files: - try: - content = file_payload.content - if not content.strip(): - continue - - language = file_payload.language or "text" - session.languages_seen.add(language) - - result = chunker_service.chunk_file(file_payload.path, content, language) - chunks = result.chunks - if not chunks: - continue - - for chunk in chunks: - if chunk.symbol_name and chunk.chunk_type in ( - "function", "class", "method", "type" - ): - batch_symbols.append( - SymbolInfo( - name=chunk.symbol_name, - kind=chunk.chunk_type, - file_path=chunk.file_path, - line=chunk.start_line, - end_line=chunk.end_line, - language=chunk.language, - signature=chunk.symbol_signature, - parent_name=chunk.parent_name, - ) - ) - - batch_references.extend(result.references) - - texts = [f"{c.chunk_type}: {c.content}" for c in chunks] - embeddings = await embedding_service.embed_texts(texts) - - # Delete old chunks, symbols, and references BEFORE inserting new ones - await vector_store_service.delete_by_file(project_path, file_payload.path) - await symbol_index_service.delete_by_file(project_path, file_payload.path) - await reference_index_service.delete_by_file(project_path, file_payload.path) - - await vector_store_service.upsert_chunks(project_path, chunks, embeddings) - batch_chunks += len(chunks) - - await db.execute( - """INSERT OR REPLACE INTO file_hashes - (project_path, file_path, content_hash, indexed_at) - VALUES (?, ?, ?, ?)""", - (project_path, file_payload.path, file_payload.content_hash, now), - ) - files_accepted += 1 - - except Exception as e: - logger.error("Error processing %s: %s", file_payload.path, e) - continue - - if batch_symbols: - await symbol_index_service.upsert_symbols(project_path, batch_symbols) - if batch_references: - await reference_index_service.upsert_references(project_path, batch_references) - await db.commit() - gc.collect() - - session.files_processed += files_accepted - session.chunks_created += batch_chunks - - progress = self._active_jobs.get(project_path) - if progress: - progress.files_processed = session.files_processed - progress.chunks_created = session.chunks_created - progress.elapsed_seconds = time.time() - session.start_time - - logger.info( - "Batch done: %d files accepted, %d chunks. Total: %d files, %d chunks", - files_accepted, batch_chunks, session.files_processed, session.chunks_created, - ) - - return files_accepted, batch_chunks, session.files_processed - - async def finish_indexing( - self, project_path: str, run_id: str, - deleted_paths: list[str], total_files_discovered: int, - ) -> tuple[str, int, int]: - """Phase 3: Clean up deleted files, update project stats, close session.""" - session = self._active_sessions.get(run_id) - if not session: - raise ValueError(f"No active session for run_id {run_id}") - if session.project_path != project_path: - raise ValueError("run_id does not match project") - - db = await get_db() - now = datetime.now(timezone.utc).isoformat() - - for del_path in deleted_paths: - await vector_store_service.delete_by_file(project_path, del_path) - await symbol_index_service.delete_by_file(project_path, del_path) - await reference_index_service.delete_by_file(project_path, del_path) - await db.execute( - "DELETE FROM file_hashes WHERE project_path = ? AND file_path = ?", - (project_path, del_path), - ) - - # Compute accurate stats from DB (not just this session) - cursor = await db.execute( - "SELECT COUNT(*) as cnt FROM file_hashes WHERE project_path = ?", - (project_path,), - ) - row = await cursor.fetchone() - total_indexed_files = row["cnt"] if row else session.files_processed - - cursor = await db.execute( - "SELECT COUNT(*) as cnt FROM symbols WHERE project_path = ?", - (project_path,), - ) - row = await cursor.fetchone() - total_symbols = row["cnt"] if row else 0 - - # Get total chunks from vector store collection - try: - collection = vector_store_service.get_or_create_collection(project_path) - total_chunks = collection.count() - except Exception: - total_chunks = session.chunks_created - - # Collect all languages from indexed files - from ..core.language import detect_language - cursor = await db.execute( - "SELECT file_path FROM file_hashes WHERE project_path = ?", - (project_path,), - ) - all_files = await cursor.fetchall() - all_languages: set[str] = set() - for f in all_files: - lang = detect_language(f["file_path"]) - if lang: - all_languages.add(lang) - - stats = { - "total_files": total_files_discovered, - "indexed_files": total_indexed_files, - "total_chunks": total_chunks, - "total_symbols": total_symbols, - } - await db.execute( - """UPDATE projects - SET stats = ?, languages = ?, status = 'indexed', - last_indexed_at = ?, updated_at = ? - WHERE host_path = ?""", - ( - json.dumps(stats), - json.dumps(sorted(all_languages)), - now, now, project_path, - ), - ) - - await db.execute( - """UPDATE index_runs - SET status = 'completed', completed_at = ?, - files_processed = ?, chunks_created = ? - WHERE id = ?""", - (now, session.files_processed, session.chunks_created, run_id), - ) - await db.commit() - - progress = self._active_jobs.get(project_path) - if progress: - progress.status = "completed" - progress.phase = "completed" - - session.status = "completed" - - async def _cleanup(): - await asyncio.sleep(60) - self._active_sessions.pop(run_id, None) - self._active_jobs.pop(project_path, None) - - asyncio.create_task(_cleanup()) - - return "completed", session.files_processed, session.chunks_created - - async def _session_ttl_cleanup(self, run_id: str): - """Remove stale sessions after 1 hour.""" - await asyncio.sleep(3600) - session = self._active_sessions.pop(run_id, None) - if session and session.status == "active": - logger.warning("Session %s timed out, cleaning up", run_id) - self._active_jobs.pop(session.project_path, None) - - # ---- Legacy methods ---- - - async def start_indexing(self, project_path: str, full: bool = False, batch_size: int = 20) -> str: - if project_path in self._active_jobs: - existing = self._active_jobs[project_path] - if existing.status in ("queued", "indexing"): - return existing.run_id - - run_id = str(uuid.uuid4()) - progress = IndexProgress(run_id=run_id, project_path=project_path) - self._active_jobs[project_path] = progress - - cancel_event = asyncio.Event() - self._cancel_events[project_path] = cancel_event - - # Record run in DB - db = await get_db() - now = datetime.now(timezone.utc).isoformat() - await db.execute( - "INSERT INTO index_runs (id, project_path, started_at, status) VALUES (?, ?, ?, ?)", - (run_id, project_path, now, "running"), - ) - await db.execute( - "UPDATE projects SET status = 'indexing', updated_at = ? WHERE host_path = ?", - (now, project_path), - ) - await db.commit() - - asyncio.create_task(self._run_pipeline(project_path, run_id, cancel_event, full, batch_size)) - return run_id - - async def get_progress(self, project_path: str) -> IndexProgress | None: - return self._active_jobs.get(project_path) - - async def cancel(self, project_path: str) -> bool: - event = self._cancel_events.get(project_path) - if event: - event.set() - return True - return False - - async def _run_pipeline( - self, project_path: str, run_id: str, - cancel_event: asyncio.Event, full: bool = False, - batch_size: int = 20, - ): - progress = self._active_jobs[project_path] - progress.status = "indexing" - start_time = time.time() - - try: - db = await get_db() - - # Get project info - cursor = await db.execute( - "SELECT * FROM projects WHERE host_path = ?", (project_path,) - ) - project = await cursor.fetchone() - if not project: - raise ValueError(f"Project {project_path} not found") - - container_path = project["container_path"] - proj_settings = json.loads(project["settings"]) - exclude_patterns = proj_settings.get( - "exclude_patterns", settings.excluded_dirs_list - ) - max_file_size = proj_settings.get("max_file_size", settings.max_file_size) - - # Phase 1: Discover files - progress.phase = "discovering" - discovered = await asyncio.get_event_loop().run_in_executor( - None, - lambda: file_discovery_service.discover( - container_path, exclude_patterns, max_file_size - ), - ) - progress.files_discovered = len(discovered) - - if cancel_event.is_set(): - await self._finish_run(project_path, run_id, "cancelled", progress) - return - - # Get stored hashes for incremental - if not full: - cursor = await db.execute( - "SELECT file_path, content_hash FROM file_hashes WHERE project_path = ?", - (project_path,), - ) - rows = await cursor.fetchall() - stored_hashes = {row["file_path"]: row["content_hash"] for row in rows} - to_process, deleted = file_discovery_service.get_changed_files( - discovered, stored_hashes - ) - - # Remove deleted files - for del_path in deleted: - await vector_store_service.delete_by_file(project_path, del_path) - await symbol_index_service.delete_by_file(project_path, del_path) - await reference_index_service.delete_by_file(project_path, del_path) - await db.execute( - "DELETE FROM file_hashes WHERE project_path = ? AND file_path = ?", - (project_path, del_path), - ) - else: - to_process = discovered - # Clear all existing data for full reindex - vector_store_service.delete_collection(project_path) - await db.execute( - "DELETE FROM file_hashes WHERE project_path = ?", (project_path,) - ) - await db.execute( - "DELETE FROM symbols WHERE project_path = ?", (project_path,) - ) - await db.execute( - "DELETE FROM refs WHERE project_path = ?", (project_path,) - ) - - progress.files_total = len(to_process) - files_discovered_count = len(discovered) - # Free discovery data — no longer needed - del discovered - gc.collect() - - await db.execute( - "UPDATE index_runs SET files_total = ? WHERE id = ?", - (len(to_process), run_id), - ) - await db.commit() - - if not to_process: - await self._finish_run(project_path, run_id, "completed", progress) - return - - # Phase 2-4: Process files in batches to limit memory usage - BATCH_COMMIT_SIZE = max(1, batch_size) # commit DB and flush symbols every N files - batch_symbols: list[SymbolInfo] = [] - batch_references = [] - total_chunks = 0 - total_symbols = 0 - now = datetime.now(timezone.utc).isoformat() - languages_seen: set[str] = set() - - for i, file_info in enumerate(to_process): - if cancel_event.is_set(): - await self._finish_run(project_path, run_id, "cancelled", progress) - return - - progress.phase = "chunking" - progress.files_processed = i - progress.elapsed_seconds = time.time() - start_time - if i > 0: - progress.estimated_remaining = ( - progress.elapsed_seconds / i * (len(to_process) - i) - ) - - try: - # Read file - with open(file_info.path, "r", errors="ignore") as f: - content = f.read() - - if not content.strip(): - continue - - language = file_info.language or "text" - languages_seen.add(language) - - # Chunk - result = chunker_service.chunk_file( - file_info.host_path, content, language - ) - chunks = result.chunks - if not chunks: - continue - - # Collect symbols from this file - for chunk in chunks: - if chunk.symbol_name and chunk.chunk_type in ( - "function", "class", "method", "type" - ): - batch_symbols.append( - SymbolInfo( - name=chunk.symbol_name, - kind=chunk.chunk_type, - file_path=chunk.file_path, - line=chunk.start_line, - end_line=chunk.end_line, - language=chunk.language, - signature=chunk.symbol_signature, - parent_name=chunk.parent_name, - ) - ) - - batch_references.extend(result.references) - - # Embed - progress.phase = "embedding" - texts = [ - f"{c.chunk_type}: {c.content}" for c in chunks - ] - embeddings = await embedding_service.embed_texts(texts) - - # Delete old data BEFORE inserting new - progress.phase = "storing" - await vector_store_service.delete_by_file(project_path, file_info.host_path) - await symbol_index_service.delete_by_file(project_path, file_info.host_path) - await reference_index_service.delete_by_file(project_path, file_info.host_path) - - # Store in vector DB - await vector_store_service.upsert_chunks( - project_path, chunks, embeddings - ) - - total_chunks += len(chunks) - progress.chunks_created = total_chunks - - # Update file hash - await db.execute( - """INSERT OR REPLACE INTO file_hashes - (project_path, file_path, content_hash, indexed_at) - VALUES (?, ?, ?, ?)""", - (project_path, file_info.host_path, file_info.content_hash, now), - ) - - except Exception as e: - logger.error("Error processing %s: %s", file_info.path, e) - continue - - # Flush batch: commit DB, store symbols/refs, free memory every N files - if (i + 1) % BATCH_COMMIT_SIZE == 0: - if batch_symbols: - await symbol_index_service.upsert_symbols(project_path, batch_symbols) - total_symbols += len(batch_symbols) - batch_symbols = [] - if batch_references: - await reference_index_service.upsert_references(project_path, batch_references) - batch_references = [] - await db.commit() - gc.collect() - logger.debug("Batch committed: %d/%d files", i + 1, len(to_process)) - - # Flush remaining symbols and references - if batch_symbols: - await symbol_index_service.upsert_symbols(project_path, batch_symbols) - total_symbols += len(batch_symbols) - if batch_references: - await reference_index_service.upsert_references(project_path, batch_references) - - # Update project stats - progress.files_processed = len(to_process) - stats = { - "total_files": files_discovered_count, - "indexed_files": progress.files_processed, - "total_chunks": total_chunks, - "total_symbols": total_symbols, - } - await db.execute( - """UPDATE projects - SET stats = ?, languages = ?, status = 'indexed', - last_indexed_at = ?, updated_at = ? - WHERE host_path = ?""", - ( - json.dumps(stats), - json.dumps(sorted(languages_seen)), - now, - now, - project_path, - ), - ) - await db.commit() - - await self._finish_run(project_path, run_id, "completed", progress) - - except Exception as e: - logger.exception("Indexing failed for project %s", project_path) - progress.status = "failed" - progress.error_message = str(e) - await self._finish_run(project_path, run_id, "failed", progress, str(e)) - - async def _finish_run( - self, project_path: str, run_id: str, status: str, - progress: IndexProgress, error: str | None = None, - ): - progress.status = status - progress.phase = "completed" if status == "completed" else status - now = datetime.now(timezone.utc).isoformat() - - db = await get_db() - await db.execute( - """UPDATE index_runs - SET status = ?, completed_at = ?, files_processed = ?, - chunks_created = ?, error_message = ? - WHERE id = ?""", - (status, now, progress.files_processed, progress.chunks_created, error, run_id), - ) - - if status != "completed": - await db.execute( - "UPDATE projects SET status = ?, updated_at = ? WHERE host_path = ?", - ("error" if status == "failed" else status, now, project_path), - ) - await db.commit() - - # Clean up after a delay - async def _cleanup(): - await asyncio.sleep(60) - self._active_jobs.pop(project_path, None) - self._cancel_events.pop(project_path, None) - - asyncio.create_task(_cleanup()) - - -indexer_service = IndexerService() diff --git a/legacy/python-api/app-root/app/services/project_config.py b/legacy/python-api/app-root/app/services/project_config.py deleted file mode 100644 index e6d425b..0000000 --- a/legacy/python-api/app-root/app/services/project_config.py +++ /dev/null @@ -1,61 +0,0 @@ -import re -from dataclasses import dataclass, field -from pathlib import Path - -import yaml - - -@dataclass -class IgnoreConfig: - submodules: bool = False - - -@dataclass -class ProjectConfig: - ignore: IgnoreConfig = field(default_factory=IgnoreConfig) - - -def load_project_config(project_root: str) -> ProjectConfig: - """Load .cixconfig.yaml from the project root. - Returns default config if the file does not exist.""" - config_path = Path(project_root) / ".cixconfig.yaml" - if not config_path.exists(): - return ProjectConfig() - - try: - data = yaml.safe_load(config_path.read_text()) - except Exception: - return ProjectConfig() - - if not isinstance(data, dict): - return ProjectConfig() - - ignore_data = data.get("ignore", {}) - return ProjectConfig( - ignore=IgnoreConfig( - submodules=bool(ignore_data.get("submodules", False)), - ) - ) - - -def parse_submodule_paths(project_root: str) -> list[str]: - """Parse .gitmodules and return list of submodule paths. - Returns empty list if .gitmodules does not exist.""" - gitmodules_path = Path(project_root) / ".gitmodules" - if not gitmodules_path.exists(): - return [] - - paths: list[str] = [] - try: - for line in gitmodules_path.read_text().splitlines(): - line = line.strip() - if line.startswith("path"): - parts = line.split("=", 1) - if len(parts) == 2: - p = parts[1].strip() - if p: - paths.append(p) - except Exception: - pass - - return paths \ No newline at end of file diff --git a/legacy/python-api/app-root/app/services/reference_index.py b/legacy/python-api/app-root/app/services/reference_index.py deleted file mode 100644 index bff60f4..0000000 --- a/legacy/python-api/app-root/app/services/reference_index.py +++ /dev/null @@ -1,70 +0,0 @@ -from dataclasses import dataclass - -from ..database import get_db -from .chunker import ReferenceInfo - - -class ReferenceIndexService: - async def upsert_references(self, project_path: str, refs: list[ReferenceInfo]): - if not refs: - return - db = await get_db() - await db.executemany( - """INSERT INTO refs (project_path, name, file_path, line, col, language) - VALUES (?, ?, ?, ?, ?, ?)""", - [ - (project_path, r.name, r.file_path, r.line, r.col, r.language) - for r in refs - ], - ) - await db.commit() - - async def delete_by_file(self, project_path: str, file_path: str): - db = await get_db() - await db.execute( - "DELETE FROM refs WHERE project_path = ? AND file_path = ?", - (project_path, file_path), - ) - await db.commit() - - async def delete_by_project(self, project_path: str): - db = await get_db() - await db.execute( - "DELETE FROM refs WHERE project_path = ?", - (project_path,), - ) - await db.commit() - - async def search( - self, - project_path: str, - name: str, - file_path: str | None = None, - limit: int = 50, - ) -> list[ReferenceInfo]: - db = await get_db() - sql = "SELECT name, file_path, line, col, language FROM refs WHERE project_path = ? AND name = ?" - params: list = [project_path, name] - - if file_path: - sql += " AND file_path = ?" - params.append(file_path) - - sql += " ORDER BY file_path, line LIMIT ?" - params.append(limit) - - cursor = await db.execute(sql, params) - rows = await cursor.fetchall() - return [ - ReferenceInfo( - name=row["name"], - file_path=row["file_path"], - line=row["line"], - col=row["col"], - language=row["language"], - ) - for row in rows - ] - - -reference_index_service = ReferenceIndexService() \ No newline at end of file diff --git a/legacy/python-api/app-root/app/services/symbol_index.py b/legacy/python-api/app-root/app/services/symbol_index.py deleted file mode 100644 index b5276c2..0000000 --- a/legacy/python-api/app-root/app/services/symbol_index.py +++ /dev/null @@ -1,119 +0,0 @@ -import uuid -from dataclasses import dataclass - -from ..database import get_db - - -@dataclass -class SymbolInfo: - name: str - kind: str # function|class|method|type - file_path: str # host path - line: int - end_line: int - language: str - signature: str | None = None - parent_name: str | None = None - docstring: str | None = None - - -class SymbolIndexService: - async def upsert_symbols(self, project_path: str, symbols: list[SymbolInfo]): - db = await get_db() - for symbol in symbols: - symbol_id = str(uuid.uuid4()) - await db.execute( - """INSERT OR REPLACE INTO symbols - (id, project_path, name, kind, file_path, line, end_line, language, signature, parent_name, docstring) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", - ( - symbol_id, - project_path, - symbol.name, - symbol.kind, - symbol.file_path, - symbol.line, - symbol.end_line, - symbol.language, - symbol.signature, - symbol.parent_name, - symbol.docstring, - ), - ) - await db.commit() - - async def search( - self, - project_path: str, - query: str, - kinds: list[str] | None = None, - limit: int = 20, - ) -> list[SymbolInfo]: - db = await get_db() - - # Try exact match first, then prefix, then contains - for pattern in [query, f"{query}%", f"%{query}%"]: - sql = "SELECT * FROM symbols WHERE project_path = ? AND name LIKE ?" - params: list = [project_path, pattern] - - if kinds: - placeholders = ",".join("?" for _ in kinds) - sql += f" AND kind IN ({placeholders})" - params.extend(kinds) - - sql += f" ORDER BY name LIMIT ?" - params.append(limit) - - cursor = await db.execute(sql, params) - rows = await cursor.fetchall() - - if rows: - return [ - SymbolInfo( - name=row["name"], - kind=row["kind"], - file_path=row["file_path"], - line=row["line"], - end_line=row["end_line"], - language=row["language"], - signature=row["signature"], - parent_name=row["parent_name"], - docstring=row["docstring"], - ) - for row in rows - ] - - return [] - - async def delete_by_file(self, project_path: str, file_path: str): - db = await get_db() - await db.execute( - "DELETE FROM symbols WHERE project_path = ? AND file_path = ?", - (project_path, file_path), - ) - await db.commit() - - async def get_project_symbols(self, project_path: str) -> list[SymbolInfo]: - db = await get_db() - cursor = await db.execute( - "SELECT * FROM symbols WHERE project_path = ? ORDER BY kind, name", - (project_path,), - ) - rows = await cursor.fetchall() - return [ - SymbolInfo( - name=row["name"], - kind=row["kind"], - file_path=row["file_path"], - line=row["line"], - end_line=row["end_line"], - language=row["language"], - signature=row["signature"], - parent_name=row["parent_name"], - docstring=row["docstring"], - ) - for row in rows - ] - - -symbol_index_service = SymbolIndexService() diff --git a/legacy/python-api/app-root/app/services/vector_store.py b/legacy/python-api/app-root/app/services/vector_store.py deleted file mode 100644 index f493073..0000000 --- a/legacy/python-api/app-root/app/services/vector_store.py +++ /dev/null @@ -1,135 +0,0 @@ -import hashlib -import logging - -import chromadb - -from ..config import settings - -logger = logging.getLogger(__name__) - - -class VectorStoreService: - def __init__(self): - self._client: chromadb.ClientAPI | None = None - - def init(self): - self._client = chromadb.PersistentClient(path=settings.dynamic_chroma_persist_dir) - logger.info("ChromaDB initialized at %s", settings.dynamic_chroma_persist_dir) - - @property - def client(self) -> chromadb.ClientAPI: - if self._client is None: - self.init() - return self._client - - def _collection_name(self, project_path: str) -> str: - # Use hash of path to create valid collection name - path_hash = hashlib.md5(project_path.encode()).hexdigest() - return f"project_{path_hash}" - - def get_or_create_collection(self, project_path: str) -> chromadb.Collection: - return self.client.get_or_create_collection( - name=self._collection_name(project_path), - metadata={"hnsw:space": "cosine"}, - ) - - async def upsert_chunks( - self, - project_path: str, - chunks: list, - embeddings: list[list[float]], - ): - collection = self.get_or_create_collection(project_path) - - ids = [] - documents = [] - metadatas = [] - embs = [] - - for idx, (chunk, embedding) in enumerate(zip(chunks, embeddings)): - path_hash = hashlib.md5(chunk.file_path.encode()).hexdigest()[:12] - doc_id = f"{path_hash}:{chunk.start_line}-{chunk.end_line}:{idx}" - - ids.append(doc_id) - documents.append(chunk.content) - metadatas.append({ - "file_path": chunk.file_path, - "start_line": chunk.start_line, - "end_line": chunk.end_line, - "chunk_type": chunk.chunk_type, - "symbol_name": chunk.symbol_name or "", - "language": chunk.language, - }) - embs.append(embedding) - - # Upsert in batches of 500 (ChromaDB limit) - batch_size = 500 - for i in range(0, len(ids), batch_size): - end = i + batch_size - collection.upsert( - ids=ids[i:end], - documents=documents[i:end], - metadatas=metadatas[i:end], - embeddings=embs[i:end], - ) - - async def search( - self, - project_path: str, - query_embedding: list[float], - limit: int = 10, - where: dict | None = None, - ) -> list[dict]: - collection = self.get_or_create_collection(project_path) - - kwargs = { - "query_embeddings": [query_embedding], - "n_results": limit, - "include": ["documents", "metadatas", "distances"], - } - if where: - kwargs["where"] = where - - try: - results = collection.query(**kwargs) - except Exception as e: - logger.error("ChromaDB search error: %s", e) - return [] - - items = [] - if results and results["ids"] and results["ids"][0]: - for i in range(len(results["ids"][0])): - metadata = results["metadatas"][0][i] - distance = results["distances"][0][i] - # Cosine distance to similarity score - score = 1.0 - distance - - items.append({ - "file_path": metadata["file_path"], - "start_line": metadata["start_line"], - "end_line": metadata["end_line"], - "content": results["documents"][0][i], - "score": round(score, 4), - "chunk_type": metadata["chunk_type"], - "symbol_name": metadata.get("symbol_name", ""), - "language": metadata.get("language", ""), - }) - - return items - - async def delete_by_file(self, project_path: str, file_path: str): - collection = self.get_or_create_collection(project_path) - try: - collection.delete(where={"file_path": file_path}) - except Exception as e: - logger.warning("Failed to delete chunks for %s: %s", file_path, e) - - def delete_collection(self, project_path: str): - name = self._collection_name(project_path) - try: - self.client.delete_collection(name) - except Exception: - pass - - -vector_store_service = VectorStoreService() diff --git a/legacy/python-api/app-root/app/version.py b/legacy/python-api/app-root/app/version.py deleted file mode 100644 index cce8bcd..0000000 --- a/legacy/python-api/app-root/app/version.py +++ /dev/null @@ -1,2 +0,0 @@ -SERVER_VERSION = "0.2.0" -API_VERSION = "v1" diff --git a/legacy/python-api/app-root/migrate_to_path_based.py b/legacy/python-api/app-root/migrate_to_path_based.py deleted file mode 100644 index d25480e..0000000 --- a/legacy/python-api/app-root/migrate_to_path_based.py +++ /dev/null @@ -1,299 +0,0 @@ -""" -Migration script to convert from UUID-based project IDs to path-based identification. - -This script: -1. Creates backup of the database -2. Creates new tables with path-based schema -3. Migrates data from old tables to new ones -4. Renames tables (old -> backup, new -> main) - -Usage: - python migrate_to_path_based.py --db-path /path/to/projects.db -""" -import argparse -import asyncio -import shutil -import sqlite3 -from datetime import datetime -from pathlib import Path - - -async def migrate_database(db_path: str, dry_run: bool = False): - """Migrate database from UUID-based to path-based schema.""" - db_file = Path(db_path) - - if not db_file.exists(): - print(f"❌ Database file not found: {db_path}") - return False - - # Create backup - backup_path = db_file.parent / f"{db_file.stem}_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db" - if not dry_run: - print(f"📦 Creating backup: {backup_path}") - shutil.copy2(db_path, backup_path) - else: - print(f"[DRY RUN] Would create backup: {backup_path}") - - conn = sqlite3.connect(db_path) - conn.row_factory = sqlite3.Row - cursor = conn.cursor() - - try: - # Check if migration is needed - cursor.execute("SELECT sql FROM sqlite_master WHERE type='table' AND name='projects'") - table_schema = cursor.fetchone() - if table_schema and 'host_path TEXT PRIMARY KEY' in table_schema[0]: - print("✅ Database already using path-based schema. No migration needed.") - return True - - # Get existing projects - cursor.execute("SELECT * FROM projects") - projects = cursor.fetchall() - - if not projects: - print("ℹ️ No projects found. Creating new schema...") - if not dry_run: - # Just rename tables and create new ones - cursor.execute("DROP TABLE IF EXISTS projects_old") - cursor.execute("ALTER TABLE projects RENAME TO projects_old") - _create_new_tables(cursor) - conn.commit() - return True - - print(f"📊 Found {len(projects)} project(s) to migrate") - - # Create new tables with _new suffix - if not dry_run: - _create_new_tables_with_suffix(cursor, "_new") - - # Migrate data - for project in projects: - host_path = project['host_path'] - print(f" Migrating: {host_path}") - - if dry_run: - print(f" [DRY RUN] Would migrate project {project['id']} -> {host_path}") - continue - - # Insert into new projects table - cursor.execute(""" - INSERT INTO projects_new (host_path, container_path, languages, settings, stats, - status, created_at, updated_at, last_indexed_at) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) - """, ( - project['host_path'], - project['container_path'], - project['languages'], - project['settings'], - project['stats'], - project['status'], - project['created_at'], - project['updated_at'], - project['last_indexed_at'] - )) - - # Migrate file_hashes - cursor.execute(""" - INSERT INTO file_hashes_new (project_path, file_path, content_hash, indexed_at) - SELECT ?, file_path, content_hash, indexed_at - FROM file_hashes - WHERE project_id = ? - """, (host_path, project['id'])) - - # Migrate symbols - cursor.execute(""" - INSERT INTO symbols_new (id, project_path, name, kind, file_path, line, end_line, - language, signature, parent_name, docstring) - SELECT id, ?, name, kind, file_path, line, end_line, - language, signature, parent_name, docstring - FROM symbols - WHERE project_id = ? - """, (host_path, project['id'])) - - # Migrate index_runs - cursor.execute(""" - INSERT INTO index_runs_new (id, project_path, started_at, completed_at, - files_processed, files_total, chunks_created, - status, error_message) - SELECT id, ?, started_at, completed_at, files_processed, files_total, - chunks_created, status, error_message - FROM index_runs - WHERE project_id = ? - """, (host_path, project['id'])) - - if not dry_run: - # Rename old tables to _old - cursor.execute("ALTER TABLE projects RENAME TO projects_old") - cursor.execute("ALTER TABLE file_hashes RENAME TO file_hashes_old") - cursor.execute("ALTER TABLE symbols RENAME TO symbols_old") - cursor.execute("ALTER TABLE index_runs RENAME TO index_runs_old") - - # Rename new tables to main names - cursor.execute("ALTER TABLE projects_new RENAME TO projects") - cursor.execute("ALTER TABLE file_hashes_new RENAME TO file_hashes") - cursor.execute("ALTER TABLE symbols_new RENAME TO symbols") - cursor.execute("ALTER TABLE index_runs_new RENAME TO index_runs") - - conn.commit() - print("✅ Migration completed successfully!") - print(f" Old tables kept as: projects_old, file_hashes_old, symbols_old, index_runs_old") - print(f" You can drop them manually if everything works correctly") - else: - print("[DRY RUN] Migration would complete successfully") - - return True - - except Exception as e: - print(f"❌ Migration failed: {e}") - if not dry_run: - conn.rollback() - return False - finally: - conn.close() - - -def _create_new_tables(cursor): - """Create new schema tables.""" - cursor.executescript(""" - CREATE TABLE IF NOT EXISTS projects ( - host_path TEXT PRIMARY KEY, - container_path TEXT NOT NULL, - languages TEXT DEFAULT '[]', - settings TEXT DEFAULT '{}', - stats TEXT DEFAULT '{"total_files":0,"indexed_files":0,"total_chunks":0,"total_symbols":0}', - status TEXT DEFAULT 'created', - created_at TEXT NOT NULL, - updated_at TEXT NOT NULL, - last_indexed_at TEXT - ); - - CREATE TABLE IF NOT EXISTS file_hashes ( - project_path TEXT NOT NULL, - file_path TEXT NOT NULL, - content_hash TEXT NOT NULL, - indexed_at TEXT NOT NULL, - PRIMARY KEY (project_path, file_path), - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE - ); - - CREATE TABLE IF NOT EXISTS symbols ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - name TEXT NOT NULL, - kind TEXT NOT NULL, - file_path TEXT NOT NULL, - line INTEGER NOT NULL, - end_line INTEGER NOT NULL, - language TEXT NOT NULL, - signature TEXT, - parent_name TEXT, - docstring TEXT, - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE - ); - - CREATE INDEX IF NOT EXISTS idx_symbols_project_name ON symbols(project_path, name); - CREATE INDEX IF NOT EXISTS idx_symbols_project_kind ON symbols(project_path, kind); - CREATE INDEX IF NOT EXISTS idx_symbols_project_file ON symbols(project_path, file_path); - - CREATE TABLE IF NOT EXISTS index_runs ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - started_at TEXT NOT NULL, - completed_at TEXT, - files_processed INTEGER DEFAULT 0, - files_total INTEGER DEFAULT 0, - chunks_created INTEGER DEFAULT 0, - status TEXT DEFAULT 'running', - error_message TEXT, - FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE - ); - """) - - -def _create_new_tables_with_suffix(cursor, suffix: str): - """Create new schema tables with a suffix.""" - cursor.executescript(f""" - CREATE TABLE projects{suffix} ( - host_path TEXT PRIMARY KEY, - container_path TEXT NOT NULL, - languages TEXT DEFAULT '[]', - settings TEXT DEFAULT '{{}}', - stats TEXT DEFAULT '{{"total_files":0,"indexed_files":0,"total_chunks":0,"total_symbols":0}}', - status TEXT DEFAULT 'created', - created_at TEXT NOT NULL, - updated_at TEXT NOT NULL, - last_indexed_at TEXT - ); - - CREATE TABLE file_hashes{suffix} ( - project_path TEXT NOT NULL, - file_path TEXT NOT NULL, - content_hash TEXT NOT NULL, - indexed_at TEXT NOT NULL, - PRIMARY KEY (project_path, file_path), - FOREIGN KEY (project_path) REFERENCES projects{suffix}(host_path) ON DELETE CASCADE - ); - - CREATE TABLE symbols{suffix} ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - name TEXT NOT NULL, - kind TEXT NOT NULL, - file_path TEXT NOT NULL, - line INTEGER NOT NULL, - end_line INTEGER NOT NULL, - language TEXT NOT NULL, - signature TEXT, - parent_name TEXT, - docstring TEXT, - FOREIGN KEY (project_path) REFERENCES projects{suffix}(host_path) ON DELETE CASCADE - ); - - CREATE INDEX idx_symbols{suffix}_project_name ON symbols{suffix}(project_path, name); - CREATE INDEX idx_symbols{suffix}_project_kind ON symbols{suffix}(project_path, kind); - CREATE INDEX idx_symbols{suffix}_project_file ON symbols{suffix}(project_path, file_path); - - CREATE TABLE index_runs{suffix} ( - id TEXT PRIMARY KEY, - project_path TEXT NOT NULL, - started_at TEXT NOT NULL, - completed_at TEXT, - files_processed INTEGER DEFAULT 0, - files_total INTEGER DEFAULT 0, - chunks_created INTEGER DEFAULT 0, - status TEXT DEFAULT 'running', - error_message TEXT, - FOREIGN KEY (project_path) REFERENCES projects{suffix}(host_path) ON DELETE CASCADE - ); - """) - - -def main(): - parser = argparse.ArgumentParser(description="Migrate database from UUID to path-based schema") - parser.add_argument("--db-path", required=True, help="Path to the SQLite database file") - parser.add_argument("--dry-run", action="store_true", help="Show what would be done without making changes") - - args = parser.parse_args() - - print("🔄 Starting database migration...") - print(f" Database: {args.db_path}") - print(f" Dry run: {args.dry_run}") - print() - - success = asyncio.run(migrate_database(args.db_path, args.dry_run)) - - if success: - print("\n✨ Migration process completed") - if not args.dry_run: - print("\n⚠️ IMPORTANT: You should also delete old ChromaDB collections manually if needed") - print(" Old collection names were: project_") - print(" New collection names are: project_") - else: - print("\n❌ Migration failed") - return 1 - - return 0 - - -if __name__ == "__main__": - exit(main()) diff --git a/legacy/python-api/app-root/requirements-cuda.txt b/legacy/python-api/app-root/requirements-cuda.txt deleted file mode 100644 index a83ca9e..0000000 --- a/legacy/python-api/app-root/requirements-cuda.txt +++ /dev/null @@ -1,53 +0,0 @@ -# CUDA build deps — mirrors requirements.txt -# llama-cpp-python is compiled with CUDA support in the Dockerfile -fastapi>=0.115 -uvicorn[standard]>=0.34 -llama-cpp-python>=0.3 -huggingface-hub>=0.29 -chromadb>=0.6 -tree-sitter>=0.24,<0.26 -# tree-sitter language grammars (individual packages replace tree-sitter-languages) -tree-sitter-python>=0.23 -tree-sitter-javascript>=0.23 -tree-sitter-typescript>=0.23 -tree-sitter-go>=0.23 -tree-sitter-rust>=0.23 -tree-sitter-java>=0.23 -tree-sitter-c>=0.23 -tree-sitter-cpp>=0.23 -tree-sitter-c-sharp>=0.23 -tree-sitter-ruby>=0.23 -tree-sitter-php>=0.23 -tree-sitter-swift>=0.0.1 -tree-sitter-kotlin>=1.0 -tree-sitter-scala>=0.23 -tree-sitter-bash>=0.23 -tree-sitter-html>=0.23 -tree-sitter-css>=0.23 -tree-sitter-scss>=1.0 -tree-sitter-lua>=0.5 -tree-sitter-sql>=0.3 -tree-sitter-json>=0.23 -tree-sitter-yaml>=0.7 -tree-sitter-toml>=0.7 -tree-sitter-xml>=0.7 -tree-sitter-markdown>=0.5 -tree-sitter-haskell>=0.23 -tree-sitter-ocaml>=0.23 -tree-sitter-hcl>=1.0 -tree-sitter-elixir>=0.3 -tree-sitter-zig>=1.0 -tree-sitter-julia>=0.23 -tree-sitter-svelte>=1.0 -tree-sitter-graphql>=0.1 -tree-sitter-dockerfile>=0.2 -tree-sitter-cmake>=0.7 -tree-sitter-make>=1.0 -tree-sitter-fortran>=0.5 -tree-sitter-objc>=3.0 -tree-sitter-commonlisp>=0.4 -tree-sitter-regex>=0.23 -pydantic>=2.10 -pydantic-settings>=2.7 -aiosqlite>=0.20 -pathspec>=0.12 diff --git a/legacy/python-api/app-root/requirements-dev.txt b/legacy/python-api/app-root/requirements-dev.txt deleted file mode 100644 index 8f004bd..0000000 --- a/legacy/python-api/app-root/requirements-dev.txt +++ /dev/null @@ -1,2 +0,0 @@ -pytest>=8.0 -httpx>=0.27 \ No newline at end of file diff --git a/legacy/python-api/app-root/requirements.txt b/legacy/python-api/app-root/requirements.txt deleted file mode 100644 index 1ba4a08..0000000 --- a/legacy/python-api/app-root/requirements.txt +++ /dev/null @@ -1,51 +0,0 @@ -fastapi>=0.115 -uvicorn[standard]>=0.34 -llama-cpp-python>=0.3 -huggingface-hub>=0.29 -chromadb>=0.6 -tree-sitter>=0.24,<0.26 -# tree-sitter language grammars (individual packages replace tree-sitter-languages) -tree-sitter-python>=0.23 -tree-sitter-javascript>=0.23 -tree-sitter-typescript>=0.23 -tree-sitter-go>=0.23 -tree-sitter-rust>=0.23 -tree-sitter-java>=0.23 -tree-sitter-c>=0.23 -tree-sitter-cpp>=0.23 -tree-sitter-c-sharp>=0.23 -tree-sitter-ruby>=0.23 -tree-sitter-php>=0.23 -tree-sitter-swift>=0.0.1 -tree-sitter-kotlin>=1.0 -tree-sitter-scala>=0.23 -tree-sitter-bash>=0.23 -tree-sitter-html>=0.23 -tree-sitter-css>=0.23 -tree-sitter-scss>=1.0 -tree-sitter-lua>=0.5 -tree-sitter-sql>=0.3 -tree-sitter-json>=0.23 -tree-sitter-yaml>=0.7 -tree-sitter-toml>=0.7 -tree-sitter-xml>=0.7 -tree-sitter-markdown>=0.5 -tree-sitter-haskell>=0.23 -tree-sitter-ocaml>=0.23 -tree-sitter-hcl>=1.0 -tree-sitter-elixir>=0.3 -tree-sitter-zig>=1.0 -tree-sitter-julia>=0.23 -tree-sitter-svelte>=1.0 -tree-sitter-graphql>=0.1 -tree-sitter-dockerfile>=0.2 -tree-sitter-cmake>=0.7 -tree-sitter-make>=1.0 -tree-sitter-fortran>=0.5 -tree-sitter-objc>=3.0 -tree-sitter-commonlisp>=0.4 -tree-sitter-regex>=0.23 -pydantic>=2.10 -pydantic-settings>=2.7 -aiosqlite>=0.20 -pathspec>=0.12 diff --git a/legacy/python-api/pyproject.toml b/legacy/python-api/pyproject.toml deleted file mode 100644 index dfc9d6e..0000000 --- a/legacy/python-api/pyproject.toml +++ /dev/null @@ -1,10 +0,0 @@ -[project] -name = "code-index-mcp" -version = "0.1.0" -requires-python = ">=3.11" -dependencies = [ - "mcp>=1.7", - "httpx>=0.27", - "pyjwt>=2.12.0", - "pyyaml>=6.0", -] diff --git a/legacy/python-api/scripts/benchmark_embeddings.py b/legacy/python-api/scripts/benchmark_embeddings.py deleted file mode 100755 index 68a2f8a..0000000 --- a/legacy/python-api/scripts/benchmark_embeddings.py +++ /dev/null @@ -1,428 +0,0 @@ -#!/usr/bin/env python3 -""" -Benchmark GGUF embedding quality against fp16 sentence-transformers baseline. - -Validates the claim that the Q8_0 GGUF build of CodeRankEmbed has negligible -retrieval-quality loss compared to the fp16 reference. Reports Jaccard@k, -Recall@k, and rank-correlation (Kendall tau) on a fixed query set run against -a local code corpus (defaults to this repository). - -Install before running: - uv pip install sentence-transformers torch einops # fp16 reference - uv pip install llama-cpp-python huggingface-hub # already in requirements.txt - -Usage: - python scripts/benchmark_embeddings.py \ - --corpus . \ - --gguf-repo awhiteside/CodeRankEmbed-Q8_0-GGUF \ - --fp16-repo nomic-ai/CodeRankEmbed \ - --k 10 \ - --output doc/benchmark-q8-vs-fp16.md - -Acceptance thresholds: - Jaccard@10 >= 0.7 - Recall@10 >= 0.9 - Kendall tau >= 0.5 -""" -from __future__ import annotations - -import argparse -import json -import logging -import math -import os -import sys -import time -from dataclasses import dataclass, field -from pathlib import Path -from typing import Any, Callable - -logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") -logger = logging.getLogger("benchmark") - -QUERIES: list[str] = [ - "async queue timeout", - "parse tree-sitter chunk", - "chroma collection upsert", - "cli root command version", - "embedding service load model", - "project root detection", - "file watcher branch switch", - "config yaml migration legacy keys", - "indexing status estimated finish", - "search by meaning code", - "api key authentication middleware", - "health endpoint status response", - "docker compose cuda healthcheck", - "gitignore pattern matching", - "sqlite projects table schema", - "mean pooling embedding", - "batch size inference throughput", - "incremental reindex sha256", - "client version header compatibility", - "goroutine concurrent walk", -] - -CODE_EXTENSIONS = {".py", ".go", ".js", ".ts", ".rs", ".java", ".cpp", ".c", ".h"} -MAX_CHUNK_CHARS = 2000 -EXCLUDE_DIRS = {".git", ".venv", "node_modules", "build", "dist", "__pycache__", "data"} -QUERY_PREFIX = "Represent this query for searching relevant code: " - - -@dataclass -class Chunk: - chunk_id: str # "relative/path.py:0" - path: str - content: str - - -@dataclass -class BackendResult: - name: str - load_seconds: float = 0.0 - embed_seconds: float = 0.0 - dim: int = 0 - top_k: dict[str, list[str]] = field(default_factory=dict) # query -> chunk_ids - - -def collect_chunks(corpus_root: Path) -> list[Chunk]: - chunks: list[Chunk] = [] - for path in corpus_root.rglob("*"): - if not path.is_file(): - continue - if path.suffix not in CODE_EXTENSIONS: - continue - if any(part in EXCLUDE_DIRS for part in path.parts): - continue - try: - text = path.read_text(encoding="utf-8", errors="replace") - except OSError: - continue - if not text.strip(): - continue - rel = path.relative_to(corpus_root).as_posix() - # Slice to ≤MAX_CHUNK_CHARS chunks, line-aligned where possible. - if len(text) <= MAX_CHUNK_CHARS: - chunks.append(Chunk(f"{rel}:0", rel, text)) - continue - idx = 0 - part = 0 - while idx < len(text): - end = min(idx + MAX_CHUNK_CHARS, len(text)) - # extend to next newline to avoid slicing mid-token - nl = text.find("\n", end) - if nl != -1 and nl - end < 200: - end = nl + 1 - chunks.append(Chunk(f"{rel}:{part}", rel, text[idx:end])) - idx = end - part += 1 - return chunks - - -def cosine(a: list[float], b: list[float]) -> float: - # Fast enough on pure-Python for a few thousand vectors * 20 queries. - num = sum(x * y for x, y in zip(a, b)) - da = math.sqrt(sum(x * x for x in a)) - db = math.sqrt(sum(y * y for y in b)) - if da == 0 or db == 0: - return 0.0 - return num / (da * db) - - -def top_k_per_query( - chunk_vecs: dict[str, list[float]], - query_vecs: dict[str, list[float]], - k: int, -) -> dict[str, list[str]]: - result: dict[str, list[str]] = {} - for q, qv in query_vecs.items(): - scored = [(cid, cosine(qv, cv)) for cid, cv in chunk_vecs.items()] - scored.sort(key=lambda x: x[1], reverse=True) - result[q] = [cid for cid, _ in scored[:k]] - return result - - -def run_fp16( - chunks: list[Chunk], - queries: list[str], - repo: str, -) -> BackendResult: - from sentence_transformers import SentenceTransformer # type: ignore - - t0 = time.monotonic() - model = SentenceTransformer(repo, trust_remote_code=True) - load_s = time.monotonic() - t0 - - t0 = time.monotonic() - chunk_embeddings = model.encode( - [c.content for c in chunks], show_progress_bar=True, batch_size=8 - ).tolist() - query_embeddings = model.encode( - [QUERY_PREFIX + q for q in queries], show_progress_bar=False - ).tolist() - embed_s = time.monotonic() - t0 - - chunk_vecs = {c.chunk_id: v for c, v in zip(chunks, chunk_embeddings)} - query_vecs = dict(zip(queries, query_embeddings)) - return BackendResult( - name=f"fp16/{repo}", - load_seconds=load_s, - embed_seconds=embed_s, - dim=len(chunk_embeddings[0]) if chunk_embeddings else 0, - top_k=top_k_per_query(chunk_vecs, query_vecs, 10), - ) - - -def run_gguf( - chunks: list[Chunk], - queries: list[str], - repo: str, - gguf_filename: str | None = None, -) -> BackendResult: - from huggingface_hub import hf_hub_download, list_repo_files # type: ignore - from llama_cpp import Llama # type: ignore - - t0 = time.monotonic() - files = list(list_repo_files(repo)) - if gguf_filename: - gguf_file = gguf_filename if gguf_filename in files else None - if not gguf_file: - raise RuntimeError(f"File {gguf_filename} not found in {repo}. Available: {[f for f in files if f.endswith('.gguf')]}") - else: - gguf_file = next((f for f in files if f.endswith(".gguf")), None) - if not gguf_file: - raise RuntimeError(f"No .gguf file in {repo}") - model_path = hf_hub_download(repo_id=repo, filename=gguf_file) - - n_gpu_layers = int(os.environ.get("CIX_N_GPU_LAYERS", "-1")) - # n_ctx matches production config (max_chunk_tokens=1500 + 128 headroom) - model = Llama( - model_path=model_path, - embedding=True, - n_ctx=1628, - n_gpu_layers=n_gpu_layers, - verbose=False, - ) - load_s = time.monotonic() - t0 - - t0 = time.monotonic() - # Embed one text at a time to avoid context-window overflow across chunks - chunk_vecs: dict[str, list[float]] = {} - for i, c in enumerate(chunks): - result = model.create_embedding([c.content]) - chunk_vecs[c.chunk_id] = result["data"][0]["embedding"] - if (i + 1) % 50 == 0: - logger.info(" GGUF embedded %d/%d chunks", i + 1, len(chunks)) - query_vecs: dict[str, list[float]] = {} - for q in queries: - result = model.create_embedding([QUERY_PREFIX + q]) - query_vecs[q] = result["data"][0]["embedding"] - embed_s = time.monotonic() - t0 - - # derive dim from first embedding - first_vec = next(iter(chunk_vecs.values()), []) - dim = len(first_vec) - return BackendResult( - name=f"gguf/{repo}/{gguf_filename or 'auto'}", - load_seconds=load_s, - embed_seconds=embed_s, - dim=dim, - top_k=top_k_per_query(chunk_vecs, query_vecs, 10), - ) - - -def jaccard(a: list[str], b: list[str]) -> float: - sa, sb = set(a), set(b) - if not sa and not sb: - return 1.0 - return len(sa & sb) / len(sa | sb) - - -def recall_at_k(reference: list[str], candidate: list[str]) -> float: - if not reference: - return 1.0 - hits = sum(1 for item in reference if item in candidate) - return hits / len(reference) - - -def kendall_tau(reference: list[str], candidate: list[str]) -> float: - # Rank-correlation restricted to items that appear in both lists. - common = [item for item in reference if item in candidate] - if len(common) < 2: - return 1.0 if len(common) == len(reference) else 0.0 - ref_rank = {item: i for i, item in enumerate(reference)} - cand_rank = {item: i for i, item in enumerate(candidate)} - concordant = discordant = 0 - for i in range(len(common)): - for j in range(i + 1, len(common)): - a, b = common[i], common[j] - ra, rb = ref_rank[a] - ref_rank[b], cand_rank[a] - cand_rank[b] - if ra * rb > 0: - concordant += 1 - elif ra * rb < 0: - discordant += 1 - total = concordant + discordant - return (concordant - discordant) / total if total else 0.0 - - -def write_report( - output: Path, - reference: BackendResult, - candidate: BackendResult, - k: int, - raw_path: Path, -) -> dict[str, float]: - per_query = [] - jaccards: list[float] = [] - recalls: list[float] = [] - taus: list[float] = [] - for q in reference.top_k: - ref = reference.top_k[q] - cand = candidate.top_k.get(q, []) - j = jaccard(ref, cand) - r = recall_at_k(ref, cand) - t = kendall_tau(ref, cand) - jaccards.append(j) - recalls.append(r) - taus.append(t) - per_query.append((q, j, r, t)) - - def mean(xs: list[float]) -> float: - return sum(xs) / len(xs) if xs else 0.0 - - summary = { - "jaccard_mean": mean(jaccards), - "recall_mean": mean(recalls), - "kendall_tau_mean": mean(taus), - "reference_embed_seconds": reference.embed_seconds, - "candidate_embed_seconds": candidate.embed_seconds, - "speedup": ( - reference.embed_seconds / candidate.embed_seconds - if candidate.embed_seconds > 0 - else 0.0 - ), - } - - lines: list[str] = [] - lines.append(f"# Embedding Quality Benchmark — {candidate.name} vs {reference.name}\n") - lines.append("") - lines.append(f"**k** = {k} | **queries** = {len(reference.top_k)} | **dim ref/cand** = {reference.dim}/{candidate.dim}") - lines.append("") - lines.append("## Summary") - lines.append("") - lines.append("| Metric | Value | Acceptance |") - lines.append("|---|---:|---:|") - lines.append(f"| Jaccard@{k} (mean) | {summary['jaccard_mean']:.3f} | ≥ 0.70 |") - lines.append(f"| Recall@{k} (mean) | {summary['recall_mean']:.3f} | ≥ 0.90 |") - lines.append(f"| Kendall tau (mean) | {summary['kendall_tau_mean']:.3f} | ≥ 0.50 |") - lines.append(f"| Reference embed time | {reference.embed_seconds:.1f}s | — |") - lines.append(f"| Candidate embed time | {candidate.embed_seconds:.1f}s | — |") - lines.append(f"| Speedup (ref/cand) | {summary['speedup']:.2f}× | — |") - lines.append("") - lines.append("## Per-query scores") - lines.append("") - lines.append("| Query | Jaccard | Recall | Kendall τ |") - lines.append("|---|---:|---:|---:|") - for q, j, r, t in per_query: - lines.append(f"| `{q}` | {j:.3f} | {r:.3f} | {t:.3f} |") - lines.append("") - lines.append(f"Raw top-k lists: `{raw_path.name}`") - lines.append("") - - output.write_text("\n".join(lines), encoding="utf-8") - return summary - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--corpus", type=Path, default=Path.cwd(), - help="Directory to index (default: CWD)") - parser.add_argument("--gguf-repo", default="awhiteside/CodeRankEmbed-Q8_0-GGUF") - parser.add_argument("--gguf-file", default=None, - help="Specific .gguf filename to use from the repo (optional)") - parser.add_argument("--fp16-repo", default="nomic-ai/CodeRankEmbed") - parser.add_argument("--fp16-cache", type=Path, default=None, - help="Path to JSON file for caching/loading fp16 results. " - "If file exists, load from it; otherwise run fp16 and save.") - parser.add_argument("--k", type=int, default=10) - parser.add_argument("--output", type=Path, default=Path("doc/benchmark-q8-vs-fp16.md")) - parser.add_argument("--skip-fp16", action="store_true", - help="Skip fp16 reference — useful for quick sanity checks") - args = parser.parse_args() - - logger.info("Collecting chunks from %s", args.corpus) - chunks = collect_chunks(args.corpus) - logger.info("Collected %d chunks", len(chunks)) - if not chunks: - logger.error("No chunks to benchmark") - return 1 - - logger.info("Running GGUF backend: %s (file: %s)", args.gguf_repo, args.gguf_file or "auto") - gguf = run_gguf(chunks, QUERIES, args.gguf_repo, gguf_filename=args.gguf_file) - - if args.skip_fp16: - logger.info("Skipping fp16 reference (--skip-fp16)") - args.output.parent.mkdir(parents=True, exist_ok=True) - raw_dir = args.output.parent / "benchmark-data" - raw_dir.mkdir(parents=True, exist_ok=True) - raw = raw_dir / (args.output.stem + ".json") - raw.write_text(json.dumps({"gguf": gguf.top_k}, indent=2), encoding="utf-8") - logger.info("Wrote top-k to %s (no comparison possible)", raw) - return 0 - - # fp16 caching: load from cache file if available, else run and save - fp16: BackendResult - if args.fp16_cache and args.fp16_cache.exists(): - logger.info("Loading fp16 results from cache: %s", args.fp16_cache) - cache_data = json.loads(args.fp16_cache.read_text(encoding="utf-8")) - fp16 = BackendResult( - name=cache_data["name"], - load_seconds=cache_data["load_seconds"], - embed_seconds=cache_data["embed_seconds"], - dim=cache_data["dim"], - top_k=cache_data["top_k"], - ) - else: - logger.info("Running fp16 reference backend: %s", args.fp16_repo) - fp16 = run_fp16(chunks, QUERIES, args.fp16_repo) - if args.fp16_cache: - args.fp16_cache.parent.mkdir(parents=True, exist_ok=True) - cache_payload = { - "name": fp16.name, - "load_seconds": fp16.load_seconds, - "embed_seconds": fp16.embed_seconds, - "dim": fp16.dim, - "top_k": fp16.top_k, - } - args.fp16_cache.write_text(json.dumps(cache_payload, indent=2), encoding="utf-8") - logger.info("Saved fp16 cache to %s", args.fp16_cache) - - args.output.parent.mkdir(parents=True, exist_ok=True) - raw_dir = args.output.parent / "benchmark-data" - raw_dir.mkdir(parents=True, exist_ok=True) - raw_path = raw_dir / (args.output.stem + ".json") - raw_path.write_text( - json.dumps({"fp16": fp16.top_k, "gguf": gguf.top_k}, indent=2), - encoding="utf-8", - ) - summary = write_report(args.output, fp16, gguf, args.k, raw_path) - - logger.info("Summary: %s", summary) - logger.info("Report written to %s", args.output) - - failed = [] - if summary["jaccard_mean"] < 0.7: - failed.append(f"Jaccard {summary['jaccard_mean']:.3f} < 0.70") - if summary["recall_mean"] < 0.9: - failed.append(f"Recall {summary['recall_mean']:.3f} < 0.90") - if summary["kendall_tau_mean"] < 0.5: - failed.append(f"Kendall τ {summary['kendall_tau_mean']:.3f} < 0.50") - if failed: - logger.error("Acceptance criteria failed: %s", "; ".join(failed)) - return 2 - logger.info("All acceptance criteria passed") - return 0 - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/legacy/python-api/scripts/profile_vram.py b/legacy/python-api/scripts/profile_vram.py deleted file mode 100644 index 780fd4d..0000000 --- a/legacy/python-api/scripts/profile_vram.py +++ /dev/null @@ -1,115 +0,0 @@ -#!/usr/bin/env python3 -""" -VRAM profiling for the GGUF embedding model. - -Measures peak GPU memory for a GGUF model using llama-cpp-python. -Run this with the indexing server STOPPED so measurements are clean. - -Usage on the server: - docker compose -f /path/to/stack/docker-compose.yml stop code-index-api - docker run --rm --gpus all \ - -e EMBEDDING_MODEL=awhiteside/CodeRankEmbed-Q8_0-GGUF \ - -v cix_cix_data:/data \ - dvcdsys/code-index:test-cu130 \ - python3 /app/scripts/profile_vram.py - docker compose ... start code-index-api - -Override GPU/CPU behaviour with CIX_N_GPU_LAYERS=0 (CPU) or =-1 (all layers on GPU). -""" -import gc -import json -import os -import sys -import time -import subprocess - -os.environ["TOKENIZERS_PARALLELISM"] = "false" - -from llama_cpp import Llama -from huggingface_hub import hf_hub_download, list_repo_files - -MODEL_NAME = os.environ.get("EMBEDDING_MODEL", "awhiteside/CodeRankEmbed-Q8_0-GGUF") - -def get_gpu_memory(): - """Returns (used, total) in MB via nvidia-smi.""" - try: - output = subprocess.check_output( - ["nvidia-smi", "--query-gpu=memory.used,memory.total", "--format=csv,nounits,noheader"], - encoding="utf-8" - ) - used, total = map(int, output.strip().split(",")) - return used, total - except Exception: - return 0, 0 - -def synthetic_text(n_tokens: int) -> str: - """Code-like text with ~n_tokens tokens.""" - word = "variableName" - count = max(1, n_tokens * 4 // len(word)) - return " ".join(f"{word}_{i}" for i in range(count)) - -def main(): - used_start, total_vram = get_gpu_memory() - if total_vram == 0: - print("nvidia-smi unavailable — running on CPU or GPU access is missing.") - - print(f"GPU : NVIDIA (via nvidia-smi)") - print(f"VRAM : {total_vram} MB total, {used_start} MB used at start") - print(f"Model : {MODEL_NAME}") - print("Loading model...", flush=True) - - model_path = MODEL_NAME - if "/" in model_path and not os.path.exists(model_path): - files = list_repo_files(model_path) - gguf_file = next((f for f in files if f.endswith(".gguf")), None) - model_path = hf_hub_download(repo_id=model_path, filename=gguf_file) - - n_gpu_layers = int(os.environ.get("CIX_N_GPU_LAYERS", "-1" if total_vram else "0")) - model = Llama( - model_path=model_path, - embedding=True, - n_ctx=8192, - n_gpu_layers=n_gpu_layers, - verbose=False - ) - - used_after_load, _ = get_gpu_memory() - model_size_mb = used_after_load - used_start - print(f"Model loaded. VRAM used: {used_after_load} MB (Model ~{model_size_mb} MB)\n", flush=True) - - token_counts = [128, 256, 512, 1024, 2048, 4096, 8192] - results = [] - - print(f"{'tokens':>7} {'peak_used_MB':>12} {'delta_MB':>8}") - print("-" * 35) - - for n_tokens in token_counts: - text = synthetic_text(n_tokens) - - # GGUF usually doesn't show huge VRAM spikes for embeddings like PyTorch does - # because the context is pre-allocated. - model.create_embedding(text) - - used_now, _ = get_gpu_memory() - results.append({ - "n_tokens": n_tokens, - "used_mb": used_now, - "delta_mb": used_now - used_after_load - }) - - print(f"{n_tokens:>7} {used_now:>12d} {used_now - used_after_load:>8d}") - - # ---- save JSON ---- - out = "/tmp/vram_profile.json" - dump_data = { - "model": MODEL_NAME, - "total_vram_mb": total_vram, - "load_vram_mb": used_after_load, - "results": results - } - with open(out, "w") as f: - json.dump(dump_data, f, indent=2) - print(f"\nRaw data saved to {out}") - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/legacy/python-api/setup-local.sh b/legacy/python-api/setup-local.sh deleted file mode 100755 index fec4abb..0000000 --- a/legacy/python-api/setup-local.sh +++ /dev/null @@ -1,154 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail - -PROJECT_DIR="$(cd "$(dirname "$0")" && pwd)" -ENV_FILE="$PROJECT_DIR/.env" -DATA_DIR="$HOME/.cix/data" - -echo "=== Claude Code Index — Local Setup ===" - -# 1. Ensure uv is installed (manages Python automatically) -if ! command -v uv &>/dev/null; then - echo "Installing uv (Python package manager)..." - curl -LsSf https://astral.sh/uv/install.sh | sh - # Add to current session - export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH" - if ! command -v uv &>/dev/null; then - echo "ERROR: uv installation failed. Install manually: https://docs.astral.sh/uv/" - exit 1 - fi -fi -echo "uv: $(uv --version)" - -# 2. Create virtual environment with Python 3.12 (auto-downloads if needed) -if [ ! -d "$PROJECT_DIR/.venv" ]; then - echo "Creating virtual environment (Python 3.12)..." - uv venv --python 3.12 "$PROJECT_DIR/.venv" -fi - -# 3. Install API dependencies -echo "Installing dependencies (first time downloads ~650MB GGUF model)..." -uv pip install --python "$PROJECT_DIR/.venv/bin/python" -r "$PROJECT_DIR/api/requirements.txt" - -# 4. Create data directories -mkdir -p "$DATA_DIR/chroma" "$DATA_DIR/sqlite" - -# 5. Generate .env if not exists -if [ ! -f "$ENV_FILE" ]; then - echo "Generating configuration..." - API_KEY="cix_$(openssl rand -hex 32)" - cat > "$ENV_FILE" </dev/null - -# 7. Start API server in background -echo "Starting API server on port ${PORT:-21847}..." -cd "$PROJECT_DIR/api" -PYTHONPATH="$PROJECT_DIR/api" \ -API_KEY="$API_KEY" \ -CHROMA_PERSIST_DIR="${CHROMA_PERSIST_DIR:-$DATA_DIR/chroma}" \ -SQLITE_PATH="${SQLITE_PATH:-$DATA_DIR/sqlite/projects.db}" \ -EMBEDDING_MODEL="${EMBEDDING_MODEL:-awhiteside/CodeRankEmbed-Q8_0-GGUF}" \ -MAX_FILE_SIZE="${MAX_FILE_SIZE:-524288}" \ -EXCLUDED_DIRS="${EXCLUDED_DIRS:-node_modules,.git,.venv,__pycache__,dist,build,.next,.cache,.DS_Store}" \ -nohup "$PROJECT_DIR/.venv/bin/uvicorn" app.main:app \ - --host 0.0.0.0 --port "${PORT:-21847}" \ - > "$DATA_DIR/server.log" 2>&1 & - -SERVER_PID=$! -echo "$SERVER_PID" > "$DATA_DIR/server.pid" -echo "Server PID: $SERVER_PID (saved to $DATA_DIR/server.pid)" - -cd "$PROJECT_DIR" - -# 8. Wait for health -echo "Waiting for service to be healthy..." -for i in $(seq 1 30); do - if curl -sf "http://localhost:${PORT:-21847}/health" > /dev/null 2>&1; then - echo "Service is healthy!" - break - fi - if ! kill -0 "$SERVER_PID" 2>/dev/null; then - echo "ERROR: Server process died. Check logs: cat $DATA_DIR/server.log" - exit 1 - fi - [ "$i" -eq 30 ] && echo "ERROR: Service failed to start. Check logs: cat $DATA_DIR/server.log" && exit 1 - sleep 2 -done - -# 9. Add instructions to global CLAUDE.md -CLAUDE_DIR="$HOME/.claude" -CLAUDE_MD="$CLAUDE_DIR/CLAUDE.md" -MARKER="" - -if [ ! -f "$CLAUDE_MD" ] || ! grep -q "$MARKER" "$CLAUDE_MD" 2>/dev/null; then - echo "Adding code-index instructions to $CLAUDE_MD..." - mkdir -p "$CLAUDE_DIR" - cat >> "$CLAUDE_MD" <<'INSTRUCTIONS' - - -## Code Index (`cix`) - -This environment has a semantic code index. Use the `cix` CLI to search code and navigate the project. - -**IMPORTANT — search priority:** -1. ALWAYS use `cix search` or `cix symbols` FIRST when looking for code -2. Only fall back to Grep/Glob if the index returns no results or `cix` is not available -3. The index understands natural language — ask it like you would ask a developer - -**Commands (run via Bash tool):** -- `cix search "authentication middleware"` — semantic code search -- `cix search "error handling" --in ./api` — search within a directory -- `cix search "config" --in README.md` — search within a specific file -- `cix symbols "handleRequest" --kind function` — find symbols by name -- `cix files "config"` — search files by path pattern -- `cix summary` — project overview (languages, directories, symbols) -- `cix status` — check indexing status -- `cix reindex` — trigger incremental reindex after changes - -**First time setup:** -If the project is not yet indexed, run: `cix init` -This registers the project, starts indexing, and launches a file watcher daemon. -The watcher auto-reindexes when files change — no manual reindex needed. - -**Tips:** -- Use `--in` flag to narrow search to a specific file or directory -- Use `--lang go` to filter by language -- Use `--limit 20` to get more results -- If `cix` is not installed, fall back to MCP tools: search_code, find_symbols - -INSTRUCTIONS - echo "Added code-index instructions to $CLAUDE_MD" -else - echo "Code-index instructions already in $CLAUDE_MD" -fi - -echo "" -echo "=== Local Setup Complete ===" -echo "API server running on http://localhost:${PORT:-21847} (PID: $SERVER_PID)" -echo "Instructions added to $CLAUDE_MD." -echo "" -echo "Useful commands:" -echo " Stop server: kill \$(cat $DATA_DIR/server.pid)" -echo " View logs: tail -f $DATA_DIR/server.log" -echo " Restart server: kill \$(cat $DATA_DIR/server.pid) && ./setup-local.sh" diff --git a/legacy/python-api/setup.sh b/legacy/python-api/setup.sh deleted file mode 100755 index 5c37b0d..0000000 --- a/legacy/python-api/setup.sh +++ /dev/null @@ -1,75 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail - -PROJECT_DIR="$(cd "$(dirname "$0")" && pwd)" -ENV_FILE="$PROJECT_DIR/.env" -DATA_DIR="$HOME/.cix/data" - -echo "=== cix — Code IndeX Setup (Docker) ===" - -# 1. Generate .env if not exists -if [ ! -f "$ENV_FILE" ]; then - echo "Generating configuration..." - API_KEY="cix_$(openssl rand -hex 32)" - cat > "$ENV_FILE" < /dev/null 2>&1; then - echo "Service is healthy!" - break - fi - [ "$i" -eq 30 ] && echo "ERROR: Service failed to start. Check logs: docker compose logs" && exit 1 - sleep 2 -done - -# 6. Configure cix CLI (if installed) -if command -v cix &>/dev/null; then - echo "Configuring cix CLI..." - cix config set api.url "http://localhost:${PORT:-21847}" - cix config set api.key "$API_KEY" - echo "✓ cix configured" -else - echo "cix CLI not installed. Install it with: cd cli && make build && make install" - echo "Then configure it:" - echo " cix config set api.url http://localhost:${PORT:-21847}" - echo " cix config set api.key $API_KEY" -fi - -echo "" -echo "=== Setup Complete ===" -echo "" -echo "API: http://localhost:${PORT:-21847}" -echo "API key: $API_KEY" -echo "Data: $DATA_DIR" -echo "" -echo "Next steps:" -echo " Install CLI: cd cli && make build && make install" -echo " Index project: cix init /path/to/your/project" -echo " Search: cix search \"authentication middleware\"" diff --git a/legacy/python-api/tests/__init__.py b/legacy/python-api/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/legacy/python-api/tests/test_api.py b/legacy/python-api/tests/test_api.py deleted file mode 100644 index 0e9aed4..0000000 --- a/legacy/python-api/tests/test_api.py +++ /dev/null @@ -1,106 +0,0 @@ -"""API integration tests — require running Docker container.""" -import os - -import httpx -import pytest - -BASE_URL = os.environ.get("CODE_INDEX_API_URL", "http://localhost:21847") -API_KEY = os.environ.get("CODE_INDEX_API_KEY", "") - - -@pytest.fixture -def client(): - return httpx.Client( - base_url=BASE_URL, - headers={"Authorization": f"Bearer {API_KEY}"}, - timeout=30.0, - ) - - -def test_health_no_auth(): - r = httpx.get(f"{BASE_URL}/health", timeout=10.0) - assert r.status_code == 200 - assert r.json()["status"] == "ok" - - -def test_status_requires_auth(): - r = httpx.get(f"{BASE_URL}/api/v1/status", timeout=10.0) - assert r.status_code in (401, 403) - - -def test_status_with_auth(client): - if not API_KEY: - pytest.skip("API_KEY not set") - r = client.get("/api/v1/status") - assert r.status_code == 200 - data = r.json() - assert "model_loaded" in data - assert "server_version" in data - assert "api_version" in data - assert data["api_version"] == "v1" - - -def test_project_crud(client): - if not API_KEY: - pytest.skip("API_KEY not set") - - # Create - r = client.post( - "/api/v1/projects", - json={"name": "test-project", "host_path": "/tmp/test-project"}, - ) - assert r.status_code == 201 - project = r.json() - project_id = project["id"] - assert project["name"] == "test-project" - - # List - r = client.get("/api/v1/projects") - assert r.status_code == 200 - assert any(p["id"] == project_id for p in r.json()["projects"]) - - # Get - r = client.get(f"/api/v1/projects/{project_id}") - assert r.status_code == 200 - assert r.json()["name"] == "test-project" - - # Update - r = client.patch( - f"/api/v1/projects/{project_id}", - json={"name": "test-project-updated"}, - ) - assert r.status_code == 200 - assert r.json()["name"] == "test-project-updated" - - # Delete - r = client.delete(f"/api/v1/projects/{project_id}") - assert r.status_code == 204 - - # Verify deleted - r = client.get(f"/api/v1/projects/{project_id}") - assert r.status_code == 404 - - -def test_index_trigger(client): - if not API_KEY: - pytest.skip("API_KEY not set") - - # Create project first - r = client.post( - "/api/v1/projects", - json={"name": "test-index", "host_path": "/tmp/test-index"}, - ) - project_id = r.json()["id"] - - # Trigger index - r = client.post(f"/api/v1/projects/{project_id}/index") - assert r.status_code == 202 - assert "run_id" in r.json() - - # Check status - r = client.get(f"/api/v1/projects/{project_id}/index/status") - assert r.status_code == 200 - assert "status" in r.json() - - # Cleanup - client.delete(f"/api/v1/projects/{project_id}") diff --git a/legacy/python-api/tests/test_chunker.py b/legacy/python-api/tests/test_chunker.py deleted file mode 100644 index 2f3c5f2..0000000 --- a/legacy/python-api/tests/test_chunker.py +++ /dev/null @@ -1,406 +0,0 @@ -"""Tests for the chunker service — runs locally without Docker.""" -import sys -from pathlib import Path - -# Add api directory to path for local testing -sys.path.insert(0, str(Path(__file__).parent.parent / "api")) - -import pytest - - -def _make_chunker(): - """Create chunker service instance.""" - from app.services.chunker import ChunkerService - return ChunkerService() - - -PYTHON_CODE = ''' -import os -import sys - -CONSTANT = 42 - -def hello(name: str) -> str: - """Say hello.""" - return f"Hello, {name}!" - -class Calculator: - """A simple calculator.""" - - def __init__(self, initial: int = 0): - self.value = initial - - def add(self, n: int) -> int: - self.value += n - return self.value - - def subtract(self, n: int) -> int: - self.value -= n - return self.value - -def main(): - calc = Calculator(10) - print(hello("World")) - print(calc.add(5)) -''' - -GO_CODE = '''package main - -import "fmt" - -type Server struct { - host string - port int -} - -func NewServer(host string, port int) *Server { - return &Server{host: host, port: port} -} - -func (s *Server) Start() error { - fmt.Printf("Starting on %s:%d\\n", s.host, s.port) - return nil -} - -func main() { - s := NewServer("localhost", 8080) - s.Start() -} -''' - -PLAIN_TEXT = "Just some plain text that has no code structure at all. " * 20 - - -class TestTreeSitterIntegration: - """Verify tree-sitter bindings load correctly — catches version incompatibilities.""" - - def test_parser_loads_for_all_language_nodes(self): - """Every language in LANGUAGE_NODES must have a working parser (not None).""" - from app.services.chunker import LANGUAGE_NODES - chunker = _make_chunker() - for language in LANGUAGE_NODES: - parser = chunker._get_parser(language) - assert parser is not None, ( - f"_get_parser('{language}') returned None — " - f"tree-sitter binding broken or missing for '{language}'" - ) - - def test_parser_produces_ast(self): - """Parser.parse() must return a tree with a root_node.""" - chunker = _make_chunker() - parser = chunker._get_parser("python") - assert parser is not None - tree = parser.parse(b"def foo(): pass") - assert tree.root_node is not None - assert tree.root_node.type == "module" - - -class TestChunkerPython: - def test_extracts_functions(self): - chunker = _make_chunker() - result = chunker.chunk_file("test.py", PYTHON_CODE, "python") - chunks = result.chunks - func_chunks = [c for c in chunks if c.chunk_type == "function"] - func_names = {c.symbol_name for c in func_chunks} - assert "hello" in func_names - assert "main" in func_names - - def test_extracts_class(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("test.py", PYTHON_CODE, "python").chunks - class_chunks = [c for c in chunks if c.chunk_type == "class"] - assert any(c.symbol_name == "Calculator" for c in class_chunks) - - def test_extracts_methods(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("test.py", PYTHON_CODE, "python").chunks - method_chunks = [c for c in chunks if c.chunk_type == "method"] - method_names = {c.symbol_name for c in method_chunks} - assert "add" in method_names - assert "__init__" in method_names - - def test_module_chunks(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("test.py", PYTHON_CODE, "python").chunks - module_chunks = [c for c in chunks if c.chunk_type == "module"] - # Should capture imports and constants - assert len(module_chunks) > 0 - - def test_line_numbers(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("test.py", PYTHON_CODE, "python").chunks - for chunk in chunks: - assert chunk.start_line >= 1 - assert chunk.end_line >= chunk.start_line - - -class TestChunkerGo: - def test_extracts_functions(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("main.go", GO_CODE, "go").chunks - func_chunks = [c for c in chunks if c.chunk_type == "function"] - func_names = {c.symbol_name for c in func_chunks} - assert "NewServer" in func_names or "main" in func_names - - def test_extracts_type(self): - chunker = _make_chunker() - chunks = chunker.chunk_file("main.go", GO_CODE, "go").chunks - type_chunks = [c for c in chunks if c.chunk_type == "type"] - assert any(c.symbol_name == "Server" for c in type_chunks) - - -TYPESCRIPT_CODE = ''' -import { Request, Response } from "express"; - -interface User { - id: number; - name: string; -} - -type UserRole = "admin" | "user"; - -function getUser(id: number): User { - return { id, name: "test" }; -} - -class UserService { - private users: User[] = []; - - addUser(user: User): void { - this.users.push(user); - } -} - -const fetchUser = (id: number): Promise => { - return Promise.resolve({ id, name: "test" }); -}; -''' - -JAVASCRIPT_CODE = ''' -const express = require("express"); - -function createApp() { - const app = express(); - return app; -} - -class Router { - constructor() { - this.routes = []; - } - - addRoute(path, handler) { - this.routes.push({ path, handler }); - } -} - -const handler = (req, res) => { - res.json({ ok: true }); -}; -''' - -RUST_CODE = ''' -use std::collections::HashMap; - -struct Config { - host: String, - port: u16, -} - -enum AppError { - NotFound, - Internal(String), -} - -trait Handler { - fn handle(&self, req: &str) -> Result; -} - -fn create_config() -> Config { - Config { host: "localhost".to_string(), port: 8080 } -} -''' - -JAVA_CODE = ''' -package com.example; - -import java.util.List; - -interface Repository { - List findAll(); -} - -class UserService { - private final Repository repo; - - UserService(Repository repo) { - this.repo = repo; - } - - public List getUsers() { - return repo.findAll(); - } -} -''' - -LUA_CODE = ''' -local M = {} - -function M.setup(opts) - opts = opts or {} - M.debug = opts.debug or false -end - -function M.greet(name) - return "Hello, " .. name -end - -return M -''' - -YAML_CODE = ''' -name: CI Pipeline -on: - push: - branches: [main] -jobs: - build: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - run: make test -''' - -JSON_CODE = ''' -{ - "name": "my-project", - "version": "1.0.0", - "dependencies": { - "express": "^4.18.0" - }, - "scripts": { - "start": "node index.js", - "test": "jest" - } -} -''' - - -class TestChunkerMultiLanguage: - """Verify tree-sitter parses all LANGUAGE_NODES languages (not falling back to sliding window).""" - - @pytest.mark.parametrize("filename,code,language,expected_symbols", [ - ("test.py", PYTHON_CODE, "python", {"hello", "Calculator"}), - ("test.ts", TYPESCRIPT_CODE, "typescript", {"getUser", "UserService"}), - ("test.js", JAVASCRIPT_CODE, "javascript", {"createApp", "Router"}), - ("main.go", GO_CODE, "go", {"NewServer", "Server"}), - ("lib.rs", RUST_CODE, "rust", {"Config", "Handler", "create_config"}), - ("Main.java", JAVA_CODE, "java", {"UserService", "Repository"}), - ]) - def test_treesitter_parses_language(self, filename, code, language, expected_symbols): - chunker = _make_chunker() - result = chunker.chunk_file(filename, code, language) - structured_types = {"function", "class", "method", "type"} - structured = [c for c in result.chunks if c.chunk_type in structured_types] - assert len(structured) > 0, f"{language}: fell back to sliding window, no structured chunks" - found_names = {c.symbol_name for c in structured if c.symbol_name} - for sym in expected_symbols: - assert sym in found_names, f"{language}: expected symbol '{sym}' not found in {found_names}" - - @pytest.mark.parametrize("filename,code,language", [ - ("test.py", PYTHON_CODE, "python"), - ("test.ts", TYPESCRIPT_CODE, "typescript"), - ("test.js", JAVASCRIPT_CODE, "javascript"), - ("main.go", GO_CODE, "go"), - ("lib.rs", RUST_CODE, "rust"), - ("Main.java", JAVA_CODE, "java"), - ]) - def test_references_extracted(self, filename, code, language): - chunker = _make_chunker() - result = chunker.chunk_file(filename, code, language) - assert len(result.references) > 0, f"{language}: no references extracted" - for ref in result.references: - assert ref.file_path == filename - assert ref.line >= 1 - assert ref.language == language - - @pytest.mark.parametrize("filename,code,language", [ - ("script.lua", LUA_CODE, "lua"), - ("config.yaml", YAML_CODE, "yaml"), - ("package.json", JSON_CODE, "json"), - ]) - def test_no_crash_on_data_languages(self, filename, code, language): - """Languages without LANGUAGE_NODES fall back to sliding window without errors.""" - chunker = _make_chunker() - result = chunker.chunk_file(filename, code, language) - assert len(result.chunks) > 0, f"{language}: produced no chunks at all" - assert all(c.chunk_type == "block" for c in result.chunks), ( - f"{language}: expected sliding-window blocks" - ) - - -class TestChunkerFallback: - def test_sliding_window(self): - chunker = _make_chunker() - result = chunker.chunk_file("readme.txt", PLAIN_TEXT, "text") - assert len(result.chunks) > 0 - assert all(c.chunk_type == "block" for c in result.chunks) - assert result.references == [] - - def test_empty_file(self): - chunker = _make_chunker() - result = chunker.chunk_file("empty.py", "", "python") - assert len(result.chunks) == 0 - - -class TestReferenceExtraction: - def test_extracts_references_python(self): - chunker = _make_chunker() - result = chunker.chunk_file("test.py", PYTHON_CODE, "python") - ref_names = {r.name for r in result.references} - # Calculator and hello are used in main() - assert "Calculator" in ref_names - assert "hello" in ref_names - - def test_skips_definition_names(self): - chunker = _make_chunker() - result = chunker.chunk_file("test.py", PYTHON_CODE, "python") - # "hello" should appear as reference (in main), but not at def line - hello_refs = [r for r in result.references if r.name == "hello"] - # The definition is at line 7 (def hello(...)), refs should not be there - hello_def_line = None - for c in result.chunks: - if c.symbol_name == "hello" and c.chunk_type == "function": - hello_def_line = c.start_line - break - assert hello_def_line is not None - assert all(r.line != hello_def_line for r in hello_refs) - - def test_skips_keywords(self): - chunker = _make_chunker() - result = chunker.chunk_file("test.py", PYTHON_CODE, "python") - ref_names = {r.name for r in result.references} - assert "self" not in ref_names - assert "None" not in ref_names - assert "True" not in ref_names - - def test_refs_have_correct_file_path(self): - chunker = _make_chunker() - result = chunker.chunk_file("test.py", PYTHON_CODE, "python") - for ref in result.references: - assert ref.file_path == "test.py" - assert ref.line >= 1 - assert ref.col >= 0 - assert ref.language == "python" - - def test_extracts_references_go(self): - chunker = _make_chunker() - result = chunker.chunk_file("main.go", GO_CODE, "go") - ref_names = {r.name for r in result.references} - # NewServer and Start are used in main() - assert "NewServer" in ref_names or "Server" in ref_names - - def test_no_refs_for_unsupported_language(self): - chunker = _make_chunker() - result = chunker.chunk_file("readme.txt", PLAIN_TEXT, "text") - assert result.references == [] diff --git a/legacy/python-api/tests/test_file_discovery.py b/legacy/python-api/tests/test_file_discovery.py deleted file mode 100644 index 192ac37..0000000 --- a/legacy/python-api/tests/test_file_discovery.py +++ /dev/null @@ -1,111 +0,0 @@ -import os -import tempfile -from pathlib import Path - -import pytest - -from api.app.services.file_discovery import FileDiscoveryService - - -def _write(root: Path, rel_path: str, content: str = "hello") -> None: - p = root / rel_path - p.parent.mkdir(parents=True, exist_ok=True) - p.write_text(content) - - -@pytest.fixture -def svc() -> FileDiscoveryService: - return FileDiscoveryService() - - -class TestCixignore: - def test_root_cixignore_excludes_files(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".cixignore", "*.log\nsecret.txt\n") - _write(root, "main.go", "package main") - _write(root, "app.log", "log data") - _write(root, "secret.txt", "password") - _write(root, "readme.txt", "hello") - - files = svc.discover(tmp, [], 524288) - paths = sorted(f.path for f in files) - - assert any("main.go" in p for p in paths) - assert any("readme.txt" in p for p in paths) - assert not any("app.log" in p for p in paths) - assert not any("secret.txt" in p for p in paths) - - def test_cixignore_directory_pattern(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".cixignore", "submodules/\n") - _write(root, "main.go", "package main") - _write(root, "submodules/vendor/lib.go", "package lib") - _write(root, "src/app.go", "package src") - - files = svc.discover(tmp, [], 524288) - paths = [f.path for f in files] - - assert any("main.go" in p for p in paths) - assert any("app.go" in p for p in paths) - assert not any("submodules" in p for p in paths) - - def test_cixignore_and_gitignore_merged(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".gitignore", "*.log\n") - _write(root, ".cixignore", "*.tmp\n") - _write(root, "main.go", "package main") - _write(root, "app.log", "log") - _write(root, "cache.tmp", "temp") - _write(root, "readme.txt", "hello") - - files = svc.discover(tmp, [], 524288) - paths = sorted(f.path for f in files) - - assert any("main.go" in p for p in paths) - assert any("readme.txt" in p for p in paths) - assert not any("app.log" in p for p in paths) - assert not any("cache.tmp" in p for p in paths) - - def test_only_cixignore_no_gitignore(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".cixignore", "generated/\n*.bak\n") - _write(root, "main.go", "package main") - _write(root, "config.bak", "old config") - _write(root, "generated/api.go", "package gen") - - files = svc.discover(tmp, [], 524288) - paths = [f.path for f in files] - - assert any("main.go" in p for p in paths) - assert not any("config.bak" in p for p in paths) - assert not any("generated" in p for p in paths) - - def test_only_gitignore_no_cixignore(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".gitignore", "*.log\n") - _write(root, "main.go", "package main") - _write(root, "app.log", "log data") - - files = svc.discover(tmp, [], 524288) - paths = [f.path for f in files] - - assert any("main.go" in p for p in paths) - assert not any("app.log" in p for p in paths) - - def test_no_ignore_files(self, svc: FileDiscoveryService) -> None: - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, "main.go", "package main") - _write(root, "data.txt", "data") - - files = svc.discover(tmp, [], 524288) - paths = sorted(f.path for f in files) - - assert len(paths) == 2 - assert any("main.go" in p for p in paths) - assert any("data.txt" in p for p in paths) \ No newline at end of file diff --git a/legacy/python-api/tests/test_project_config.py b/legacy/python-api/tests/test_project_config.py deleted file mode 100644 index 51f528b..0000000 --- a/legacy/python-api/tests/test_project_config.py +++ /dev/null @@ -1,136 +0,0 @@ -import tempfile -from pathlib import Path - -import pytest - -from api.app.services.project_config import ( - IgnoreConfig, - ProjectConfig, - load_project_config, - parse_submodule_paths, -) - - -def _write(root: Path, rel_path: str, content: str) -> None: - p = root / rel_path - p.parent.mkdir(parents=True, exist_ok=True) - p.write_text(content) - - -class TestLoadProjectConfig: - def test_submodules_true(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write(Path(tmp), ".cixconfig.yaml", "ignore:\n submodules: true\n") - cfg = load_project_config(tmp) - assert cfg.ignore.submodules is True - - def test_submodules_false(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write(Path(tmp), ".cixconfig.yaml", "ignore:\n submodules: false\n") - cfg = load_project_config(tmp) - assert cfg.ignore.submodules is False - - def test_no_file(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - cfg = load_project_config(tmp) - assert cfg.ignore.submodules is False - - def test_empty_file(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write(Path(tmp), ".cixconfig.yaml", "") - cfg = load_project_config(tmp) - assert cfg.ignore.submodules is False - - def test_invalid_yaml(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write(Path(tmp), ".cixconfig.yaml", ":::bad{{{yaml") - cfg = load_project_config(tmp) - # Should return default config, not crash - assert cfg.ignore.submodules is False - - -class TestParseSubmodulePaths: - def test_standard_gitmodules(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write( - Path(tmp), - ".gitmodules", - '[submodule "api/schema"]\n' - "\tpath = api/schema\n" - "\turl = https://example.com/schema.git\n" - '[submodule "libs/vendor"]\n' - "\tpath = libs/vendor\n" - "\turl = https://example.com/vendor.git\n", - ) - paths = parse_submodule_paths(tmp) - assert sorted(paths) == ["api/schema", "libs/vendor"] - - def test_no_gitmodules(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - paths = parse_submodule_paths(tmp) - assert paths == [] - - def test_empty_gitmodules(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write(Path(tmp), ".gitmodules", "") - paths = parse_submodule_paths(tmp) - assert paths == [] - - def test_single_submodule(self) -> None: - with tempfile.TemporaryDirectory() as tmp: - _write( - Path(tmp), - ".gitmodules", - '[submodule "vendor"]\n\tpath = vendor\n\turl = https://example.com/v.git\n', - ) - paths = parse_submodule_paths(tmp) - assert paths == ["vendor"] - - -class TestFileDiscoveryWithSubmodules: - def test_submodules_excluded(self) -> None: - from api.app.services.file_discovery import FileDiscoveryService - - svc = FileDiscoveryService() - - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".cixconfig.yaml", "ignore:\n submodules: true\n") - _write( - root, - ".gitmodules", - '[submodule "vendor"]\n\tpath = vendor\n\turl = https://example.com/v.git\n', - ) - _write(root, "main.go", "package main") - _write(root, "vendor/lib.go", "package vendor") - _write(root, "vendor/deep/util.go", "package deep") - _write(root, "src/app.go", "package src") - - files = svc.discover(tmp, [], 524288) - paths = sorted(f.path for f in files) - - assert any("main.go" in p for p in paths) - assert any("app.go" in p for p in paths) - assert not any("vendor" in p for p in paths) - - def test_submodules_not_excluded_when_false(self) -> None: - from api.app.services.file_discovery import FileDiscoveryService - - svc = FileDiscoveryService() - - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - _write(root, ".cixconfig.yaml", "ignore:\n submodules: false\n") - _write( - root, - ".gitmodules", - '[submodule "vendor"]\n\tpath = vendor\n\turl = https://example.com/v.git\n', - ) - _write(root, "main.go", "package main") - _write(root, "vendor/lib.go", "package vendor") - - files = svc.discover(tmp, [], 524288) - paths = [f.path for f in files] - - assert any("main.go" in p for p in paths) - assert any("vendor" in p for p in paths) \ No newline at end of file diff --git a/legacy/python-api/tests/test_search.py b/legacy/python-api/tests/test_search.py deleted file mode 100644 index e162765..0000000 --- a/legacy/python-api/tests/test_search.py +++ /dev/null @@ -1,111 +0,0 @@ -"""Search integration tests — require running Docker container with indexed project.""" -import os - -import httpx -import pytest - -BASE_URL = os.environ.get("CODE_INDEX_API_URL", "http://localhost:21847") -API_KEY = os.environ.get("CODE_INDEX_API_KEY", "") - - -@pytest.fixture -def client(): - return httpx.Client( - base_url=BASE_URL, - headers={"Authorization": f"Bearer {API_KEY}"}, - timeout=60.0, - ) - - -@pytest.fixture -def project_with_index(client): - """Create a project, wait for indexing, return project_id. Cleanup after.""" - if not API_KEY: - pytest.skip("API_KEY not set") - - r = client.post( - "/api/v1/projects", - json={"name": "test-search", "host_path": "/tmp/test-search"}, - ) - if r.status_code == 409: - # Already exists, find it - r = client.get("/api/v1/projects") - for p in r.json()["projects"]: - if p["name"] == "test-search": - yield p["id"] - client.delete(f"/api/v1/projects/{p['id']}") - return - - project_id = r.json()["id"] - yield project_id - client.delete(f"/api/v1/projects/{project_id}") - - -def test_semantic_search(client, project_with_index): - r = client.post( - f"/api/v1/projects/{project_with_index}/search", - json={"query": "test function", "limit": 5}, - ) - assert r.status_code == 200 - data = r.json() - assert "results" in data - assert "total" in data - assert "query_time_ms" in data - - -def test_symbol_search(client, project_with_index): - r = client.post( - f"/api/v1/projects/{project_with_index}/search/symbols", - json={"query": "main", "limit": 5}, - ) - assert r.status_code == 200 - data = r.json() - assert "results" in data - assert "total" in data - - -def test_file_search(client, project_with_index): - r = client.post( - f"/api/v1/projects/{project_with_index}/search/files", - json={"query": "test", "limit": 5}, - ) - assert r.status_code == 200 - data = r.json() - assert "files" in data - assert "total" in data - - -def test_project_summary(client, project_with_index): - r = client.get(f"/api/v1/projects/{project_with_index}/summary") - assert r.status_code == 200 - data = r.json() - assert "name" in data - assert "languages" in data - assert "total_files" in data - - -def test_search_with_filters(client, project_with_index): - r = client.post( - f"/api/v1/projects/{project_with_index}/search", - json={ - "query": "function", - "limit": 5, - "languages": ["python"], - "min_score": 0.1, - }, - ) - assert r.status_code == 200 - data = r.json() - assert "results" in data - assert "total" in data - assert "query_time_ms" in data - - -def test_search_nonexistent_project(client): - if not API_KEY: - pytest.skip("API_KEY not set") - r = client.post( - "/api/v1/projects/nonexistent-id/search", - json={"query": "test"}, - ) - assert r.status_code == 404 diff --git a/legacy/python-api/uv.lock b/legacy/python-api/uv.lock deleted file mode 100644 index bc0614e..0000000 --- a/legacy/python-api/uv.lock +++ /dev/null @@ -1,742 +0,0 @@ -version = 1 -revision = 3 -requires-python = ">=3.11" - -[[package]] -name = "annotated-types" -version = "0.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, -] - -[[package]] -name = "anyio" -version = "4.12.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "idna" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, -] - -[[package]] -name = "attrs" -version = "25.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, -] - -[[package]] -name = "certifi" -version = "2026.2.25" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, -] - -[[package]] -name = "cffi" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pycparser", marker = "implementation_name != 'PyPy'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, - { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, - { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, - { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, - { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, - { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, - { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, - { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, - { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, - { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, - { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, - { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, - { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, - { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, - { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, - { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, - { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, - { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, - { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, - { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, - { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, - { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, - { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, - { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, - { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, - { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, - { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, - { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, - { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, - { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, - { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, - { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, - { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, - { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, - { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, - { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, - { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, - { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, - { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, - { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, - { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, - { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, - { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, - { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, - { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, - { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, - { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, - { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, - { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, - { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, - { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, - { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, - { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, - { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, - { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, - { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, - { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, - { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, - { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, -] - -[[package]] -name = "click" -version = "8.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, -] - -[[package]] -name = "code-index-mcp" -version = "0.1.0" -source = { virtual = "." } -dependencies = [ - { name = "httpx" }, - { name = "mcp" }, - { name = "pyjwt" }, - { name = "pyyaml" }, -] - -[package.metadata] -requires-dist = [ - { name = "httpx", specifier = ">=0.27" }, - { name = "mcp", specifier = ">=1.7" }, - { name = "pyjwt", specifier = ">=2.12.0" }, - { name = "pyyaml", specifier = ">=6.0" }, -] - -[[package]] -name = "colorama" -version = "0.4.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, -] - -[[package]] -name = "cryptography" -version = "46.0.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" }, - { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" }, - { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" }, - { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" }, - { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" }, - { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" }, - { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" }, - { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" }, - { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" }, - { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" }, - { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" }, - { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" }, - { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" }, - { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" }, - { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" }, - { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" }, - { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" }, - { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" }, - { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" }, - { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" }, - { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" }, - { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" }, - { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" }, - { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" }, - { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" }, - { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" }, - { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" }, - { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" }, - { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" }, - { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" }, - { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" }, - { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" }, - { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" }, - { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" }, - { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" }, - { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" }, - { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" }, - { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" }, - { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" }, - { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" }, - { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" }, - { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" }, - { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" }, - { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" }, - { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" }, - { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" }, - { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" }, - { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" }, -] - -[[package]] -name = "h11" -version = "0.16.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, -] - -[[package]] -name = "httpcore" -version = "1.0.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, -] - -[[package]] -name = "httpx" -version = "0.28.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "certifi" }, - { name = "httpcore" }, - { name = "idna" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, -] - -[[package]] -name = "httpx-sse" -version = "0.4.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, -] - -[[package]] -name = "idna" -version = "3.11" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, -] - -[[package]] -name = "jsonschema" -version = "4.26.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "jsonschema-specifications" }, - { name = "referencing" }, - { name = "rpds-py" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, -] - -[[package]] -name = "jsonschema-specifications" -version = "2025.9.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "referencing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, -] - -[[package]] -name = "mcp" -version = "1.26.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "httpx" }, - { name = "httpx-sse" }, - { name = "jsonschema" }, - { name = "pydantic" }, - { name = "pydantic-settings" }, - { name = "pyjwt", extra = ["crypto"] }, - { name = "python-multipart" }, - { name = "pywin32", marker = "sys_platform == 'win32'" }, - { name = "sse-starlette" }, - { name = "starlette" }, - { name = "typing-extensions" }, - { name = "typing-inspection" }, - { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/fc/6d/62e76bbb8144d6ed86e202b5edd8a4cb631e7c8130f3f4893c3f90262b10/mcp-1.26.0.tar.gz", hash = "sha256:db6e2ef491eecc1a0d93711a76f28dec2e05999f93afd48795da1c1137142c66", size = 608005, upload-time = "2026-01-24T19:40:32.468Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/d9/eaa1f80170d2b7c5ba23f3b59f766f3a0bb41155fbc32a69adfa1adaaef9/mcp-1.26.0-py3-none-any.whl", hash = "sha256:904a21c33c25aa98ddbeb47273033c435e595bbacfdb177f4bd87f6dceebe1ca", size = 233615, upload-time = "2026-01-24T19:40:30.652Z" }, -] - -[[package]] -name = "pycparser" -version = "3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, -] - -[[package]] -name = "pydantic" -version = "2.12.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "annotated-types" }, - { name = "pydantic-core" }, - { name = "typing-extensions" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, -] - -[[package]] -name = "pydantic-core" -version = "2.41.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, - { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, - { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, - { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, - { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, - { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, - { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, - { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, - { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, - { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, - { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, - { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, - { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, - { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, - { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, - { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, - { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, - { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, - { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, - { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, - { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, - { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, - { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, - { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, - { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, - { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, - { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, - { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, - { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, - { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, - { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, - { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, - { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, - { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, - { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, - { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, - { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, - { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, - { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, - { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, - { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, - { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, - { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, - { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, - { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, - { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, - { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, - { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, - { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, - { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, - { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, - { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, - { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, - { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, - { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, - { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, - { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, - { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, - { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, - { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, - { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, - { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, - { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, - { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, - { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, - { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, - { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, - { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, - { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, - { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, - { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, - { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, - { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, - { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, - { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, - { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, - { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, - { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, - { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, - { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, - { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, - { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, - { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, - { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, - { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, - { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, -] - -[[package]] -name = "pydantic-settings" -version = "2.13.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "python-dotenv" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" }, -] - -[[package]] -name = "pyjwt" -version = "2.12.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" }, -] - -[package.optional-dependencies] -crypto = [ - { name = "cryptography" }, -] - -[[package]] -name = "python-dotenv" -version = "1.2.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, -] - -[[package]] -name = "python-multipart" -version = "0.0.22" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" }, -] - -[[package]] -name = "pywin32" -version = "311" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" }, - { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" }, - { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" }, - { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, - { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, - { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, - { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, - { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, - { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, - { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, - { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, - { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, -] - -[[package]] -name = "pyyaml" -version = "6.0.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, - { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, - { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, - { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, - { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, - { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, - { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, - { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, - { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, - { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, - { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, - { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, - { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, - { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, - { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, - { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, - { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, - { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, - { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, - { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, - { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, - { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, - { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, - { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, - { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, - { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, - { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, - { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, - { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, - { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, - { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, - { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, - { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, - { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, - { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, - { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, - { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, - { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, - { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, - { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, - { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, - { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, - { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, - { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, - { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, - { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, - { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, -] - -[[package]] -name = "referencing" -version = "0.37.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "rpds-py" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, -] - -[[package]] -name = "rpds-py" -version = "0.30.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" }, - { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" }, - { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" }, - { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" }, - { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" }, - { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" }, - { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" }, - { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" }, - { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" }, - { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" }, - { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" }, - { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" }, - { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" }, - { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" }, - { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" }, - { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, - { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, - { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, - { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" }, - { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" }, - { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" }, - { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" }, - { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" }, - { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" }, - { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" }, - { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" }, - { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" }, - { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" }, - { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" }, - { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" }, - { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, - { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, - { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, - { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, - { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, - { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, - { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, - { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, - { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, - { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, - { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, - { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, - { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, - { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, - { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, - { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, - { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, - { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, - { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, - { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, - { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, - { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, - { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, - { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, - { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, - { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, - { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, - { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, - { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, - { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, - { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, - { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, - { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, - { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, - { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, - { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, - { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, - { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, - { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, - { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, - { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, - { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, - { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, - { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, - { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, - { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, - { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, - { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, - { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, - { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, - { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, - { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, - { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, - { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, - { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, - { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, - { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, - { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, - { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" }, - { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" }, - { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" }, - { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" }, - { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" }, - { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" }, - { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" }, - { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" }, - { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" }, - { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" }, - { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" }, - { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" }, -] - -[[package]] -name = "sse-starlette" -version = "3.3.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "starlette" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5a/9f/c3695c2d2d4ef70072c3a06992850498b01c6bc9be531950813716b426fa/sse_starlette-3.3.2.tar.gz", hash = "sha256:678fca55a1945c734d8472a6cad186a55ab02840b4f6786f5ee8770970579dcd", size = 32326, upload-time = "2026-02-28T11:24:34.36Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/61/28/8cb142d3fe80c4a2d8af54ca0b003f47ce0ba920974e7990fa6e016402d1/sse_starlette-3.3.2-py3-none-any.whl", hash = "sha256:5c3ea3dad425c601236726af2f27689b74494643f57017cafcb6f8c9acfbb862", size = 14270, upload-time = "2026-02-28T11:24:32.984Z" }, -] - -[[package]] -name = "starlette" -version = "0.52.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" }, -] - -[[package]] -name = "typing-extensions" -version = "4.15.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, -] - -[[package]] -name = "typing-inspection" -version = "0.4.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, -] - -[[package]] -name = "uvicorn" -version = "0.41.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/32/ce/eeb58ae4ac36fe09e3842eb02e0eb676bf2c53ae062b98f1b2531673efdd/uvicorn-0.41.0.tar.gz", hash = "sha256:09d11cf7008da33113824ee5a1c6422d89fbc2ff476540d69a34c87fab8b571a", size = 82633, upload-time = "2026-02-16T23:07:24.1Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/83/e4/d04a086285c20886c0daad0e026f250869201013d18f81d9ff5eada73a88/uvicorn-0.41.0-py3-none-any.whl", hash = "sha256:29e35b1d2c36a04b9e180d4007ede3bcb32a85fbdfd6c6aeb3f26839de088187", size = 68783, upload-time = "2026-02-16T23:07:22.357Z" }, -] diff --git a/plugins/cix/.claude-plugin/plugin.json b/plugins/cix/.claude-plugin/plugin.json new file mode 100644 index 0000000..a193e5a --- /dev/null +++ b/plugins/cix/.claude-plugin/plugin.json @@ -0,0 +1,14 @@ +{ + "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", + "name": "cix", + "version": "0.1.0", + "description": "Semantic code search and navigation for Claude Code via the cix index. Bundles the cix CLI (auto-installs if missing) and nudges Claude to prefer cix over Grep for semantic queries.", + "author": { + "name": "dvcdsys", + "email": "dvcdsys@gmail.com" + }, + "homepage": "https://github.com/dvcdsys/code-index", + "repository": "https://github.com/dvcdsys/code-index", + "license": "MIT", + "keywords": ["search", "code-search", "semantic", "navigation", "indexing", "embeddings", "ai"] +} diff --git a/plugins/cix/README.md b/plugins/cix/README.md new file mode 100644 index 0000000..052cf02 --- /dev/null +++ b/plugins/cix/README.md @@ -0,0 +1,164 @@ +# cix — Claude Code plugin + +Semantic code search and navigation for Claude Code, powered by the +[cix](https://github.com/dvcdsys/code-index) index. + +## What you get + +- **`/cix:search`, `/cix:def`, `/cix:refs`, `/cix:init`, `/cix:status`, + `/cix:summary`** — slash commands wrapping the most-used `cix` CLI + operations. +- **Bundled cix CLI** — the plugin auto-installs `cix` on first use if + it isn't already in your `PATH` (no sudo, installs to `~/.local/bin`). + If you already have `cix` installed via the official `install.sh`, the + plugin just uses it. +- **`cix` skill (SKILL.md)** — lazy-loaded full instruction sheet + covering when to use cix vs Grep, query patterns, scoring landscape, + and CLI flags. Loads into the conversation only when Claude or you + invoke it (`/cix:search`, `/cix-skill`, or auto-trigger on a relevant + prompt). Stays in context for the rest of the session — never + duplicated. +- **Behavioral nudges (5 hooks):** + - **SessionStart** — calls `cix status` (2 s timeout). Caches the + yes/no verdict in `$CLAUDE_PLUGIN_DATA/cix-aware-$SESSION_ID-$DIR_HASH`, + injects a one-line reminder on success. + - **CwdChanged** — when Claude `cd`s into another directory mid-session, + re-runs `cix status` for the new dir and caches the verdict. Silent + (no reminder); PreToolUse handles the first-Grep-in-new-project + nudge through its per-project backoff. + - **PreToolUse(Grep|Glob)** — reads the cache for the current + `(session, project_dir)` pair; no inline `cix` calls. If the + verdict is "yes" (`1`), suggests `cix search` with exponential + backoff per project (fires on call #1, 2, 4, 8, …). Missing cache + or "no" (`0`) → silent for the rest of the session in that project. + - **PostCompact** — after auto-compaction in long sessions, re-injects + the SessionStart reminder if the current project is cix-aware + (skill body itself survives compaction natively; the SessionStart + one-liner does not). + - **SessionEnd** — glob-deletes every per-(session, dir) cache file + when the session terminates. Best-effort; the 30-day GC inside + SessionStart catches markers left over from forced kills. + +The cache key includes a project-dir hash (`shasum -a 256` first 8 +chars), so per-session, per-project state is isolated — Claude can +move between projects mid-session and each one keeps its own verdict +and backoff counter. + +## Install + +From an existing Claude Code marketplace: + +``` +/plugin marketplace add dvcdsys/code-index +/plugin install cix@code-index +/reload-plugins # or restart Claude Code +``` + +Or for local development against this repo: + +``` +/plugin marketplace add /path/to/code-index +/plugin install cix@code-index --scope local +``` + +## Requirements + +- **Claude Code v2.1.0+** (uses `hookSpecificOutput.additionalContext` + for hook-driven nudges). +- **`curl`** — only needed the first time, for the auto-bootstrap of + the `cix` CLI. +- **A reachable `cix-server`** — the CLI is a thin client. If you don't + yet have a server, see the project README for Docker setup + instructions. + +## How adoption works (the design) + +The plugin uses a 4-layer approach so SKILL.md loads at most once and +nudges don't spam the context: + +| Layer | Mechanism | Cost over a 100-prompt session | +|---|---|---| +| 1. Skill description | Native Claude Code (always-in-context, ~200 B) | ~200 B once | +| 2. SessionStart hook | One-time reminder in indexed projects | ~200 B once | +| 3. PreToolUse(Grep\|Glob) hook | Exponential-backoff nudge | ~80 B × ~7 calls = ~560 B | +| 4. SKILL.md body | Native lazy-load (skill mechanism) | ~7 KB **once** if invoked | + +Total plugin context overhead in a session that uses cix heavily: +~8 KB. In a session that doesn't touch cix at all: ~400 B (skill +description + slash command metadata). + +The SKILL.md body is **never duplicated** — Claude Code's skill +mechanism guarantees a single insertion that stays in context for the +session. See the [skill content lifecycle](https://code.claude.com/docs/en/skills#skill-content-lifecycle) +docs. + +## Configuration + +### Where the bundled CLI is installed + +The wrapper installs `cix` to `~/.local/bin/cix` by default. To override +the install location, set `CIX_PLUGIN_BIN_DIR` in your environment: + +```bash +export CIX_PLUGIN_BIN_DIR=/usr/local/bin # if you want sudo-installed +``` + +If you've already installed `cix` system-wide (e.g. via the project's +`install.sh`), the wrapper detects it and uses that binary — no second +copy is downloaded. + +### Skipping the auto-install + +Set `CIX_PLUGIN_BIN_DIR` to a directory that already contains a working +`cix` binary, or simply make sure `cix` is in your `$PATH` before +enabling the plugin. + +### Hook state cleanup + +Two per-session marker files live in `$CLAUDE_PLUGIN_DATA` +(resolves to `~/.claude/plugins/data/cix-code-index/`): +- `cix-aware-$SESSION_ID` — written by SessionStart, read by + PreToolUse. Single-byte file (`0` or `1`). +- `cix-grep-count-$SESSION_ID` — counter for the exponential backoff. + +This directory is plugin-managed and **not** cleaned by the OS +(unlike `/tmp`, which macOS purges daily). The plugin manages cleanup +in two tiers: +1. **SessionEnd hook** — deletes both markers when the session + terminates normally. Covers the common case. +2. **30-day GC in SessionStart** — opportunistically deletes markers + older than 30 days at every session start. Catches markers left + over from sessions that exited forcibly (kill -9, OOM). + +## Files + +| Path | Purpose | +|---|---| +| `.claude-plugin/plugin.json` | Plugin manifest | +| `skills/cix/SKILL.md` | Lazy-loaded usage skill (~7 KB) | +| `commands/*.md` | Six slash commands | +| `hooks/hooks.json` | SessionStart + PreToolUse(Grep\|Glob) registration | +| `scripts/cix-wrapper.sh` | "Use system or auto-install" CLI wrapper | +| `scripts/session-start.sh` | One-time session reminder | +| `scripts/grep-nudge.sh` | Exponential-backoff Grep nudge | +| `bin/cix` | Symlink to wrapper, exposed on `$PATH` while plugin enabled | + +## Troubleshooting + +- **"cix: command not found" inside Claude Code Bash tool** — the + plugin isn't enabled or `bin/cix` isn't on `$PATH`. Run + `/plugin list` and `which cix` from inside a Claude Code session. +- **Hooks not firing** — run Claude Code with `--debug` and look for + hook registration messages. Check `/Users/dvcdsys/.claude/...` (or + your local cache path) for the hook scripts and verify they're + executable: `ls -la $(claude plugin list ... | path)/scripts/`. +- **Nudges feel too frequent / too rare** — edit the power-of-2 check + in `scripts/grep-nudge.sh` to your taste. The current schedule + (1, 2, 4, 8, 16, …) was chosen to balance "loud at start" with + "fade away". +- **"This project has a cix semantic code index" never appears** — + the project must contain a `.cix/` directory. Run `/cix:init` first. + +## License + +MIT — same as the parent project. diff --git a/plugins/cix/bin/cix b/plugins/cix/bin/cix new file mode 120000 index 0000000..4263b5f --- /dev/null +++ b/plugins/cix/bin/cix @@ -0,0 +1 @@ +../scripts/cix-wrapper.sh \ No newline at end of file diff --git a/plugins/cix/commands/def.md b/plugins/cix/commands/def.md new file mode 100644 index 0000000..c53303e --- /dev/null +++ b/plugins/cix/commands/def.md @@ -0,0 +1,15 @@ +--- +description: Find symbol definition(s) via cix — go-to-definition across the indexed codebase +argument-hint: [--kind function|class|method|type] [--file ] +allowed-tools: Bash(cix *) +--- + +Look up the definition of the symbol **$ARGUMENTS** in the cix index: + +```! +cix definitions $ARGUMENTS +``` + +If multiple matches are returned, point out the most likely one based on +context. If nothing is found, suggest `cix symbols $ARGUMENTS` for a +broader name search. diff --git a/plugins/cix/commands/init.md b/plugins/cix/commands/init.md new file mode 100644 index 0000000..7fc49aa --- /dev/null +++ b/plugins/cix/commands/init.md @@ -0,0 +1,17 @@ +--- +description: Initialize the cix index for the current project (registers, indexes, starts file watcher) +allowed-tools: Bash(cix *) +--- + +Initialize the cix index for the current project. This registers the +project with the cix server, performs a full initial index, and starts +the file-watcher daemon for auto-reindex on changes. + +```! +cix init +``` + +If the indexing run is in-progress, you can monitor it with `/cix:status`. +If it fails, common causes are: cix-server not reachable, missing +`CIX_API_KEY` env var, or `~/.cix/data` permission issues. Check +`cix status` for details. diff --git a/plugins/cix/commands/refs.md b/plugins/cix/commands/refs.md new file mode 100644 index 0000000..a5e3adb --- /dev/null +++ b/plugins/cix/commands/refs.md @@ -0,0 +1,14 @@ +--- +description: Find symbol references via cix — locate every usage of a symbol across the codebase +argument-hint: [--file ] [--limit ] +allowed-tools: Bash(cix *) +--- + +Find references to the symbol **$ARGUMENTS** in the cix index: + +```! +cix references $ARGUMENTS +``` + +Group the references by file and call out any high-traffic call sites or +suspicious usage patterns. If you need fewer results, add `--limit 20`. diff --git a/plugins/cix/commands/search.md b/plugins/cix/commands/search.md new file mode 100644 index 0000000..7e3c1c7 --- /dev/null +++ b/plugins/cix/commands/search.md @@ -0,0 +1,18 @@ +--- +description: Semantic code search via cix — find code by meaning, not by exact strings +argument-hint: +allowed-tools: Bash(cix *) +--- + +Run a semantic search through the cix index for the query: **$ARGUMENTS** + +```! +cix search "$ARGUMENTS" +``` + +Summarize the most relevant matches above. If results look weak, try: +- A more specific phrasing that names the area or symbol +- `cix search "$ARGUMENTS" --min-score 0.2` to lower the relevance floor +- `cix search "$ARGUMENTS" --in ` to narrow scope + +If `cix` is not yet initialized in this project, run `/cix:init` first. diff --git a/plugins/cix/commands/status.md b/plugins/cix/commands/status.md new file mode 100644 index 0000000..3b9326e --- /dev/null +++ b/plugins/cix/commands/status.md @@ -0,0 +1,15 @@ +--- +description: Show cix indexing status and file-watcher state for the current project +allowed-tools: Bash(cix *) +--- + +Show the current cix indexing status — last sync, number of indexed +files, and whether the file watcher is active. + +```! +cix status +``` + +If `Watcher: ✗ not running`, search results may be stale. Run +`cix watch` to restart the auto-reindex daemon, or `cix reindex` for a +one-off refresh. diff --git a/plugins/cix/commands/summary.md b/plugins/cix/commands/summary.md new file mode 100644 index 0000000..4d1b8b8 --- /dev/null +++ b/plugins/cix/commands/summary.md @@ -0,0 +1,16 @@ +--- +description: Show project overview from the cix index — languages, top directories, key symbols +allowed-tools: Bash(cix *) +--- + +Print a project overview from the cix index — languages, file counts, +top directories, and most-referenced symbols. Useful when starting work +on an unfamiliar codebase. + +```! +cix summary +``` + +Use this output to orient yourself before diving into specific +subsystems. For deeper exploration, follow up with `cix search` on the +top-level concepts you see here. diff --git a/plugins/cix/hooks/hooks.json b/plugins/cix/hooks/hooks.json new file mode 100644 index 0000000..81435cd --- /dev/null +++ b/plugins/cix/hooks/hooks.json @@ -0,0 +1,55 @@ +{ + "hooks": { + "SessionStart": [ + { + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/session-start.sh" + } + ] + } + ], + "PreToolUse": [ + { + "matcher": "Grep|Glob", + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/grep-nudge.sh" + } + ] + } + ], + "CwdChanged": [ + { + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/cwd-changed.sh" + } + ] + } + ], + "PostCompact": [ + { + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/post-compact.sh" + } + ] + } + ], + "SessionEnd": [ + { + "hooks": [ + { + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/session-end.sh" + } + ] + } + ] + } +} diff --git a/plugins/cix/scripts/cix-wrapper.sh b/plugins/cix/scripts/cix-wrapper.sh new file mode 100755 index 0000000..28c504c --- /dev/null +++ b/plugins/cix/scripts/cix-wrapper.sh @@ -0,0 +1,91 @@ +#!/usr/bin/env bash +# cix CLI wrapper for the Claude Code plugin. +# +# Strategy: "use system cix if available, else bootstrap install via the +# official install.sh script". We do NOT bundle the binary in git or +# maintain a separate cache — install.sh is the single source of truth. +# +# Resolution order: +# 1. If `cix` is found anywhere in PATH (excluding our own dir), +# exec it directly. +# 2. Otherwise, run install.sh with --bin-dir=$HOME/.local/bin +# (no sudo required), then exec the freshly installed binary. + +set -euo pipefail + +# ── Resolve our own directory (real path, dereferencing symlinks) ───────────── +# bin/cix is a symlink to ../scripts/cix-wrapper.sh, so BASH_SOURCE points to +# the real script under scripts/, not the symlink under bin/. We need the +# directory of the symlink (which is what's actually on PATH) — derive it +# from $0 instead, which preserves the invocation path. + +if [ -n "${0:-}" ] && [ "${0:0:1}" = "/" ]; then + INVOKED_PATH="$0" +else + # When called as bare `cix` via PATH, $0 is just "cix" — fall back to + # which/command -v to find ourselves. + INVOKED_PATH="$(command -v "$0" 2>/dev/null || echo "$0")" +fi + +SELF_DIR="$(cd "$(dirname "$INVOKED_PATH")" 2>/dev/null && pwd 2>/dev/null || echo "")" + +# ── Look for a cix binary elsewhere in PATH ─────────────────────────────────── +# Build a "safe PATH" that excludes our own directory so command -v doesn't +# find us recursively. + +SYS_CIX="" +if [ -n "$SELF_DIR" ]; then + SAFE_PATH="" + OLD_IFS="$IFS" + IFS=':' + # shellcheck disable=SC2086 + for dir in $PATH; do + [ -z "$dir" ] && continue + DIR_REAL="$(cd "$dir" 2>/dev/null && pwd 2>/dev/null || echo "$dir")" + if [ "$DIR_REAL" != "$SELF_DIR" ]; then + SAFE_PATH="${SAFE_PATH:+$SAFE_PATH:}$dir" + fi + done + IFS="$OLD_IFS" + SYS_CIX="$(PATH="$SAFE_PATH" command -v cix 2>/dev/null || true)" +else + SYS_CIX="$(command -v cix 2>/dev/null || true)" +fi + +if [ -n "$SYS_CIX" ]; then + exec "$SYS_CIX" "$@" +fi + +# ── Bootstrap install via install.sh (one-time) ─────────────────────────────── +TARGET="${CIX_PLUGIN_BIN_DIR:-$HOME/.local/bin}" +CACHED_CIX="$TARGET/cix" + +if [ ! -x "$CACHED_CIX" ]; then + if ! command -v curl >/dev/null 2>&1; then + echo "Error: cix is not installed and curl is not available to bootstrap it." >&2 + echo "Install cix manually: https://github.com/dvcdsys/code-index" >&2 + exit 1 + fi + + mkdir -p "$TARGET" + echo "cix CLI not found — installing to $TARGET (one-time, no sudo)..." >&2 + + # Use the official install script. Pinned to main; future versions of the + # plugin can pin to a tag (e.g. cli/v0.4.0) for reproducibility. + INSTALL_URL="https://raw.githubusercontent.com/dvcdsys/code-index/main/install.sh" + + if ! curl -fsSL "$INSTALL_URL" | bash -s -- --bin-dir "$TARGET"; then + echo "Error: cix install failed. Check network connectivity and try again." >&2 + echo "You can install manually: curl -fsSL $INSTALL_URL | bash" >&2 + exit 1 + fi + + if [ ! -x "$CACHED_CIX" ]; then + echo "Error: install.sh ran but $CACHED_CIX was not created." >&2 + exit 1 + fi + + echo "cix installed successfully at $CACHED_CIX" >&2 +fi + +exec "$CACHED_CIX" "$@" diff --git a/plugins/cix/scripts/cwd-changed.sh b/plugins/cix/scripts/cwd-changed.sh new file mode 100755 index 0000000..6c49f8f --- /dev/null +++ b/plugins/cix/scripts/cwd-changed.sh @@ -0,0 +1,101 @@ +#!/usr/bin/env bash +# CwdChanged hook for the cix plugin. +# +# Behavior: when Claude changes working directory mid-session (e.g. via +# `cd`), evaluate cix-awareness for the new directory and cache the +# verdict. If we already have a verdict for this (session, project_dir) +# pair, this is a no-op — Claude probably came back to a project we +# already evaluated. +# +# Why no reminder injection: PreToolUse(Grep|Glob) handles the +# "first nudge in a fresh project" case via its per-project backoff +# counter (call #1 in a new project always fires). Re-inject a SessionStart +# reminder on every `cd` would be noisy if Claude bounces between +# directories. +# +# Behavior matrix: +# Cache exists for (session, NEW_DIR) → no-op (we know already) +# Cache absent + cix status exit 0 → write "1" (cix-aware) +# Cache absent + cix status exit ≠ 0 → write "0" (silent for this dir) +# Cache absent + cix CLI not found → write "0" +# Cache absent + cix status timeout → write "0" + +set -euo pipefail + +INPUT=$(cat 2>/dev/null || echo "{}") +if command -v jq >/dev/null 2>&1; then + SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "") +else + SESSION_ID=$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1) +fi + +[ -z "$SESSION_ID" ] && exit 0 + +CACHE_DIR="${CLAUDE_PLUGIN_DATA:-/tmp}" +mkdir -p "$CACHE_DIR" 2>/dev/null || CACHE_DIR="/tmp" + +PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}" + +DIR_HASH=$(printf '%s' "$PROJECT_DIR" | shasum -a 256 2>/dev/null | cut -c1-8) +if [ -z "$DIR_HASH" ]; then + DIR_HASH=$(printf '%s' "$PROJECT_DIR" | tr -c 'a-zA-Z0-9' '-' | tail -c 16) +fi + +CACHE_FILE="$CACHE_DIR/cix-aware-$SESSION_ID-$DIR_HASH" + +# ── Already evaluated this (session, project) — no-op ───────────────────────── +if [ -f "$CACHE_FILE" ]; then + exit 0 +fi + +# ── Resolve cix binary ──────────────────────────────────────────────────────── +CIX_BIN="" +if [ -x "${CLAUDE_PLUGIN_ROOT:-}/bin/cix" ]; then + CIX_BIN="${CLAUDE_PLUGIN_ROOT}/bin/cix" +elif command -v cix >/dev/null 2>&1; then + CIX_BIN="$(command -v cix)" +fi + +if [ -z "$CIX_BIN" ]; then + printf '0' > "$CACHE_FILE" + exit 0 +fi + +# ── Run cix status with 2s timeout (same pattern as session-start.sh) ───────── +EXIT_FILE="$CACHE_FILE.exit" +( + "$CIX_BIN" status -p "$PROJECT_DIR" >/dev/null 2>&1 + echo "$?" > "$EXIT_FILE" 2>/dev/null +) & +CIX_PID=$! + +SLEPT=0 +while kill -0 "$CIX_PID" 2>/dev/null && [ "$SLEPT" -lt 20 ]; do + sleep 0.1 + SLEPT=$((SLEPT + 1)) +done + +if kill -0 "$CIX_PID" 2>/dev/null; then + kill -9 "$CIX_PID" 2>/dev/null || true + wait "$CIX_PID" 2>/dev/null || true + printf '0' > "$CACHE_FILE" + rm -f "$EXIT_FILE" + exit 0 +fi +wait "$CIX_PID" 2>/dev/null || true + +EXIT_CODE=1 +if [ -f "$EXIT_FILE" ]; then + EXIT_CODE=$(cat "$EXIT_FILE" 2>/dev/null || echo 1) + rm -f "$EXIT_FILE" +fi + +if [ "$EXIT_CODE" = "0" ]; then + printf '1' > "$CACHE_FILE" +else + printf '0' > "$CACHE_FILE" +fi + +# Silent — no context injection. PreToolUse(Grep|Glob) will handle the +# first-Grep-in-new-project nudge through its own backoff counter. +exit 0 diff --git a/plugins/cix/scripts/grep-nudge.sh b/plugins/cix/scripts/grep-nudge.sh new file mode 100755 index 0000000..73fa12b --- /dev/null +++ b/plugins/cix/scripts/grep-nudge.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +# PreToolUse(Grep|Glob) hook for the cix plugin. +# +# Behavior: if SessionStart (or CwdChanged) concluded the current +# project is cix-indexed (cache file for this (session, project_dir) +# pair contains "1"), occasionally inject a system reminder pointing +# toward `cix search` instead of Grep/Glob. Otherwise stay silent. +# +# This hook does NOT call `cix status` itself — it relies entirely on +# the cache written by SessionStart and refreshed by CwdChanged. +# Trade-off: a session that started before the cix-server came up will +# stay in "silent" mode for the rest of its life in that project, even +# if the server later comes back online. Intentional: better to miss a +# few nudge opportunities than spam a developer whose server is down. +# +# Per-(session, project) backoff: each project Claude visits has its +# own exponential-backoff counter. A new `cd` into a fresh project +# starts the backoff from scratch (call #1 → nudge), so the first Grep +# in a new cix-aware project always gets a reminder. +# +# Throttling: exponential backoff. Reminders fire on the 1st, 2nd, 4th, +# 8th, 16th, 32nd, 64th, ... Grep/Glob invocation in the current +# project. ~7 reminders per 100-Grep span, loud at the start, fading +# as the model "learns" the workflow. + +set -euo pipefail + +INPUT=$(cat 2>/dev/null || echo "{}") +if command -v jq >/dev/null 2>&1; then + SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "") +else + SESSION_ID=$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1) +fi + +# No session_id → can't read the SessionStart cache. Stay silent. +[ -z "$SESSION_ID" ] && exit 0 + +CACHE_DIR="${CLAUDE_PLUGIN_DATA:-/tmp}" +PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}" + +# Compute per-project hash — same algorithm as session-start.sh. +DIR_HASH=$(printf '%s' "$PROJECT_DIR" | shasum -a 256 2>/dev/null | cut -c1-8) +if [ -z "$DIR_HASH" ]; then + DIR_HASH=$(printf '%s' "$PROJECT_DIR" | tr -c 'a-zA-Z0-9' '-' | tail -c 16) +fi + +# ── Read SessionStart's verdict for THIS project ────────────────────────────── +# Strict policy: only "1" allows nudges. Missing file or "0" → silent. +CACHE_FILE="$CACHE_DIR/cix-aware-$SESSION_ID-$DIR_HASH" + +if [ ! -f "$CACHE_FILE" ]; then + exit 0 +fi +if [ "$(cat "$CACHE_FILE" 2>/dev/null)" != "1" ]; then + exit 0 +fi + +# ── Increment per-(session, project) counter ────────────────────────────────── +COUNTER_FILE="$CACHE_DIR/cix-grep-count-$SESSION_ID-$DIR_HASH" +COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo 0) +case "$COUNT" in + ''|*[!0-9]*) COUNT=0 ;; +esac +COUNT=$((COUNT + 1)) +printf '%d' "$COUNT" > "$COUNTER_FILE" + +# Power-of-2 check: COUNT & (COUNT - 1) == 0 means COUNT is 1, 2, 4, 8, ... +if [ "$((COUNT & (COUNT - 1)))" -ne 0 ]; then + exit 0 +fi + +# ── Emit nudge ──────────────────────────────────────────────────────────────── +MESSAGE="💡 You're about to use Grep/Glob (call #$COUNT this session). This project has a cix semantic index — for queries by meaning (find by concept, cross-file lookups, symbol navigation), \`cix search\` / \`cix def\` / \`cix refs\` outperform Grep. Grep is best for exact strings (error messages, config keys, import paths). The \`/cix:search\` slash command is also available." + +if command -v jq >/dev/null 2>&1; then + jq -n --arg msg "$MESSAGE" \ + '{hookSpecificOutput: {hookEventName: "PreToolUse", additionalContext: $msg}}' +else + ESC=$(printf '%s' "$MESSAGE" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr '\n' ' ') + printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"%s"}}\n' "$ESC" +fi + +exit 0 diff --git a/plugins/cix/scripts/post-compact.sh b/plugins/cix/scripts/post-compact.sh new file mode 100755 index 0000000..b7d982b --- /dev/null +++ b/plugins/cix/scripts/post-compact.sh @@ -0,0 +1,62 @@ +#!/usr/bin/env bash +# PostCompact hook for the cix plugin. +# +# Behavior: after Claude Code compacts the conversation, re-inject the +# SessionStart reminder if this (session, project) is cix-aware. +# +# Why this matters: skill bodies survive auto-compaction (Claude Code +# re-attaches them with up to 5K tokens per skill, see +# https://code.claude.com/docs/en/skills#skill-content-lifecycle). +# But the SessionStart `additionalContext` reminder — and PreToolUse +# nudges — are NOT skills. They live as regular tool result messages +# and are dropped/summarised during compaction. +# +# In long sessions (8+ hours of work) where the cix skill hasn't been +# invoked yet, the model may "forget" cix exists after compaction. +# Re-injecting the same one-line reminder keeps cix-awareness alive. +# +# This is a no-op if SessionStart concluded the project is not indexed +# (cache=0) or if no verdict exists yet. + +set -euo pipefail + +INPUT=$(cat 2>/dev/null || echo "{}") +if command -v jq >/dev/null 2>&1; then + SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "") +else + SESSION_ID=$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1) +fi + +[ -z "$SESSION_ID" ] && exit 0 + +CACHE_DIR="${CLAUDE_PLUGIN_DATA:-/tmp}" +PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}" + +DIR_HASH=$(printf '%s' "$PROJECT_DIR" | shasum -a 256 2>/dev/null | cut -c1-8) +if [ -z "$DIR_HASH" ]; then + DIR_HASH=$(printf '%s' "$PROJECT_DIR" | tr -c 'a-zA-Z0-9' '-' | tail -c 16) +fi + +CACHE_FILE="$CACHE_DIR/cix-aware-$SESSION_ID-$DIR_HASH" + +# ── Read verdict ────────────────────────────────────────────────────────────── +# Strict policy mirrors grep-nudge.sh: only "1" triggers re-injection. +if [ ! -f "$CACHE_FILE" ]; then + exit 0 +fi +if [ "$(cat "$CACHE_FILE" 2>/dev/null)" != "1" ]; then + exit 0 +fi + +# ── Re-inject the SessionStart reminder ─────────────────────────────────────── +MESSAGE='💡 (Post-compact reminder) This project has a cix semantic code index. For semantic queries — finding code by meaning, cross-file lookups, symbol navigation, "where is X used", "how does Y work" — prefer `cix search`, `cix def`, `cix refs`, or the slash commands `/cix:search`, `/cix:def`, `/cix:refs`. Use Grep only for exact strings (error messages, config keys, import paths).' + +if command -v jq >/dev/null 2>&1; then + jq -n --arg msg "$MESSAGE" \ + '{hookSpecificOutput: {hookEventName: "PostCompact", additionalContext: $msg}}' +else + ESC=$(printf '%s' "$MESSAGE" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr '\n' ' ') + printf '{"hookSpecificOutput":{"hookEventName":"PostCompact","additionalContext":"%s"}}\n' "$ESC" +fi + +exit 0 diff --git a/plugins/cix/scripts/session-end.sh b/plugins/cix/scripts/session-end.sh new file mode 100755 index 0000000..d400a37 --- /dev/null +++ b/plugins/cix/scripts/session-end.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +# SessionEnd hook for the cix plugin. +# +# Behavior: when the Claude Code session terminates, remove every +# cache file belonging to this session from $CLAUDE_PLUGIN_DATA. +# A single session may have visited multiple projects (via `cd`), so +# we glob-delete by session_id prefix. Cleanup is best-effort: +# SessionEnd may not fire if the process was killed forcibly (kill -9, +# OOM, panic) — session-start.sh also runs a 30-day GC sweep as a +# safety net. +# +# Files removed (per session_id, all directory hashes): +# $CLAUDE_PLUGIN_DATA/cix-aware-$SESSION_ID-* (verdict caches) +# $CLAUDE_PLUGIN_DATA/cix-grep-count-$SESSION_ID-* (backoff counters) +# +# Output: nothing. Failures are silently ignored. + +set -euo pipefail + +INPUT=$(cat 2>/dev/null || echo "{}") +if command -v jq >/dev/null 2>&1; then + SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "") +else + SESSION_ID=$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1) +fi + +# Without a session_id we don't know what to clean. Exit cleanly. +[ -z "$SESSION_ID" ] && exit 0 + +CACHE_DIR="${CLAUDE_PLUGIN_DATA:-/tmp}" +[ -d "$CACHE_DIR" ] || exit 0 + +# Glob-delete every per-(session, dir) marker for this session. +# +# Safety is enforced by the find filters, not by where the cache dir is: +# -maxdepth 1 — never recurse into subdirectories +# -type f — files only (skips dirs and symlinks) +# -name 'cix-aware-$SESSION_ID-*' — exact prefix + this session_id +# -name 'cix-grep-count-$SESSION_ID-*' — exact prefix + this session_id +# +# $SESSION_ID is a UUID assigned by Claude Code, so the patterns +# practically cannot match anything but our own marker files even in +# unusual cache-dir locations. +# +# We never use `rm -rf` and never recurse — there's no path on which +# this script could touch a file that doesn't already match the strict +# name pattern. +find "$CACHE_DIR" -maxdepth 1 -type f \ + \( -name "cix-aware-$SESSION_ID-*" -o -name "cix-grep-count-$SESSION_ID-*" \) \ + -delete 2>/dev/null || true + +exit 0 diff --git a/plugins/cix/scripts/session-start.sh b/plugins/cix/scripts/session-start.sh new file mode 100755 index 0000000..a99c352 --- /dev/null +++ b/plugins/cix/scripts/session-start.sh @@ -0,0 +1,148 @@ +#!/usr/bin/env bash +# SessionStart hook for the cix plugin. +# +# Behavior: at session start, ask `cix status` whether the current +# project is indexed. The result is cached for the (session, project) +# pair in $CLAUDE_PLUGIN_DATA/cix-aware-$SESSION_ID-$DIR_HASH so the +# PreToolUse hook can short-circuit without re-querying the server. +# +# Cache key includes a hash of the project directory, so a single +# session that traverses multiple projects (via `cd`, see CwdChanged +# hook) keeps a separate verdict per project — fresh backoff counter +# per project, correct cix-aware state per directory. +# +# State location: $CLAUDE_PLUGIN_DATA is plugin-persistent storage +# managed by Claude Code (resolves to ~/.claude/plugins/data//). +# It survives plugin updates and is NOT periodically cleaned by the OS, +# unlike /tmp (macOS daily cleanup of 3-day-old files; Linux on reboot). +# Falls back to /tmp only when run outside a plugin context (tests). +# +# Decision contract (read by grep-nudge.sh, post-compact.sh): +# File present with content "1" → project is indexed, nudge allowed +# File present with content "0" → not indexed, nudge MUST stay silent +# File absent → no verdict yet, nudge stays silent +# +# Why no fallback in grep-nudge: if SessionStart (or CwdChanged) concluded +# "not indexed" (server unreachable, project not registered, etc.), the +# user should NOT see Grep nudges suggesting `cix search` for the rest +# of the session. Sending nudges based on `.cixignore` presence anyway +# would create false positives. + +set -euo pipefail + +# ── Read session_id from stdin JSON ─────────────────────────────────────────── +INPUT=$(cat 2>/dev/null || echo "{}") +if command -v jq >/dev/null 2>&1; then + SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "") +else + SESSION_ID=$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1) +fi + +# Without a session_id we can't write a session-scoped marker. Stay silent. +if [ -z "$SESSION_ID" ]; then + exit 0 +fi + +# ── Resolve cache directory ─────────────────────────────────────────────────── +# Prefer plugin-persistent storage; fall back to /tmp for ad-hoc/test invocations. +# We do NOT whitelist parent paths — users can have non-standard layouts +# (custom $CLAUDE_PLUGIN_DATA, XDG dirs, corporate setups). Safety comes +# from the file-level checks below: -maxdepth 1, -type f, exact -name +# patterns matching only our session-id-prefixed markers. +CACHE_DIR="${CLAUDE_PLUGIN_DATA:-/tmp}" +mkdir -p "$CACHE_DIR" 2>/dev/null || CACHE_DIR="/tmp" +[ -d "$CACHE_DIR" ] || exit 0 + +PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}" + +# Hash the project dir so the cache file name is short and stable. +# `shasum -a 256` exists on both macOS (Perl-based) and Linux (coreutils). +DIR_HASH=$(printf '%s' "$PROJECT_DIR" | shasum -a 256 2>/dev/null | cut -c1-8) +if [ -z "$DIR_HASH" ]; then + # shasum unavailable; fall back to a path-derived suffix. + DIR_HASH=$(printf '%s' "$PROJECT_DIR" | tr -c 'a-zA-Z0-9' '-' | tail -c 16) +fi + +CACHE_FILE="$CACHE_DIR/cix-aware-$SESSION_ID-$DIR_HASH" + +# ── Light maintenance: clear markers older than 30 days ─────────────────────── +# Long-running Claude Code installs would accumulate one-byte markers +# otherwise. Cheap, runs once per session. Failures ignored. +# +# Safety constraints on the find: +# -maxdepth 1 — never recurse into subdirectories +# -type f — files only (skips dirs, symlinks) +# -name 'cix-aware-*' OR +# -name 'cix-grep-count-*' — exact prefix match on our marker names +# -mtime +30 — older than 30 days +# +# A file outside this prefix is invisible to find — it's never even +# considered for deletion, regardless of how the cache dir is configured. +find "$CACHE_DIR" -maxdepth 1 -type f \ + \( -name 'cix-aware-*' -o -name 'cix-grep-count-*' \) \ + -mtime +30 -delete 2>/dev/null || true + +# ── Resolve a working `cix` binary ──────────────────────────────────────────── +CIX_BIN="" +if [ -x "${CLAUDE_PLUGIN_ROOT:-}/bin/cix" ]; then + CIX_BIN="${CLAUDE_PLUGIN_ROOT}/bin/cix" +elif command -v cix >/dev/null 2>&1; then + CIX_BIN="$(command -v cix)" +fi + +if [ -z "$CIX_BIN" ]; then + # CLI not yet installed (would auto-bootstrap on first call). Mark off. + printf '0' > "$CACHE_FILE" + exit 0 +fi + +# ── Run `cix status` with a 2-second timeout ────────────────────────────────── +# macOS lacks `timeout`/`gtimeout` by default — implement in pure bash. +EXIT_FILE="$CACHE_FILE.exit" +( + "$CIX_BIN" status -p "$PROJECT_DIR" >/dev/null 2>&1 + echo "$?" > "$EXIT_FILE" 2>/dev/null +) & +CIX_PID=$! + +SLEPT=0 +while kill -0 "$CIX_PID" 2>/dev/null && [ "$SLEPT" -lt 20 ]; do + sleep 0.1 + SLEPT=$((SLEPT + 1)) +done + +if kill -0 "$CIX_PID" 2>/dev/null; then + kill -9 "$CIX_PID" 2>/dev/null || true + wait "$CIX_PID" 2>/dev/null || true + printf '0' > "$CACHE_FILE" + rm -f "$EXIT_FILE" + exit 0 +fi +wait "$CIX_PID" 2>/dev/null || true + +EXIT_CODE=1 +if [ -f "$EXIT_FILE" ]; then + EXIT_CODE=$(cat "$EXIT_FILE" 2>/dev/null || echo 1) + rm -f "$EXIT_FILE" +fi + +if [ "$EXIT_CODE" != "0" ]; then + # Not indexed (or server unreachable). Lock the session into "off" mode. + printf '0' > "$CACHE_FILE" + exit 0 +fi + +# ── Project IS indexed — cache + inject reminder ────────────────────────────── +printf '1' > "$CACHE_FILE" + +MESSAGE='💡 This project has a cix semantic code index. For semantic queries — finding code by meaning, cross-file lookups, symbol navigation, "where is X used", "how does Y work" — prefer `cix search`, `cix def`, `cix refs`, or the slash commands `/cix:search`, `/cix:def`, `/cix:refs`. Use Grep only for exact strings (error messages, config keys, import paths). Run `cix status` if results seem stale.' + +if command -v jq >/dev/null 2>&1; then + jq -n --arg msg "$MESSAGE" \ + '{hookSpecificOutput: {hookEventName: "SessionStart", additionalContext: $msg}}' +else + ESC=$(printf '%s' "$MESSAGE" | sed 's/\\/\\\\/g; s/"/\\"/g' | tr '\n' ' ') + printf '{"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"%s"}}\n' "$ESC" +fi + +exit 0 diff --git a/plugins/cix/skills/cix/SKILL.md b/plugins/cix/skills/cix/SKILL.md new file mode 100644 index 0000000..13ea488 --- /dev/null +++ b/plugins/cix/skills/cix/SKILL.md @@ -0,0 +1,217 @@ +--- +name: cix +description: Semantic code search and navigation via the cix index. Use this when finding code by meaning rather than exact strings — cross-file lookups, symbol navigation, "where is X used", "how does Y work", "find authentication middleware", or exploring an unfamiliar codebase. Covers search, definitions, references, symbol search, file lookup, and indexing. +when_to_use: | + Trigger this skill when the user asks anything that requires semantic understanding of the codebase: + - "find authentication middleware" / "find the auth code" + - "where is X defined?" / "show me the definition of Y" + - "how does Z work in this codebase?" + - "what calls this function?" / "find references to ..." + - "search the codebase for ..." / "find by meaning" + - "explore this repo" / "give me an overview" + - Any time you would otherwise reach for Grep on a non-literal query + + Skip this skill (use Grep / Read instead) when: + - A stack trace or error already names file:line — just Read it + - Searching for an exact literal (specific error string, config key name, import path) + - Inside dependencies (node_modules, vendor, .venv) — they aren't indexed + - Editing a non-code file (Dockerfile, yaml, lockfile) +user-invocable: true +allowed-tools: Bash(cix *) +--- + +# Code Index (`cix`) — Semantic Code Search & Navigation + +You have access to `cix`, a semantic code index that understands the +codebase via embeddings + AST parsing. The right reflex is **"cix when +you don't have a pointer; grep when you do."** + +This plugin also exposes shortcuts: `/cix:search`, `/cix:def`, `/cix:refs`, +`/cix:init`, `/cix:status`, `/cix:summary`. The `cix` CLI is bundled — +the plugin auto-installs it on first use if your system doesn't have it. + +## When to use which + +**Reach for `cix` first when:** +- The starting point is open-ended ("how does indexing work?", "find the + authentication middleware", "where is the main entry point?") +- You need cross-file navigation (definitions / references / callers) +- You're searching by *meaning*, not by an exact string + (`"JWT validation"` should find `verifyToken` even without that phrase) +- You're exploring an unfamiliar package or codebase + +**Skip `cix`, use Read / Grep / Glob directly when:** +- A failing test or stack trace already names the file and function — + just `Read` it +- You're chasing an exact literal: a specific error message, a config + key, a commit-message phrase, an import path +- You're inside dependencies (`node_modules`, `vendor`, `.venv`) — they + aren't indexed +- You're editing a non-code file (Dockerfile, yaml, lockfile) + +If `cix` returns nothing relevant after one well-formed query, fall +back to grep — don't loop on cix. + +--- + +## Commands Reference + +### Semantic Search — find code by meaning +```bash +cix search "authentication middleware" +cix search "database connection retry logic" +cix search "error handling in payment flow" --limit 20 +cix search "config parsing" --in ./internal/config/ +cix search "API routes" --lang go +cix search "main entry point" --exclude bench/fixtures --exclude legacy +``` + +**Flags:** +- `--in ` — restrict to file or directory (can repeat) +- `--exclude ` — drop a directory or substring from results (can repeat) +- `--lang ` — filter by language (can repeat) +- `--limit ` — max **files** returned (default: 10) — output is + grouped per file with all matches inside, so 10 files ≈ many snippets +- `--min-score ` — minimum relevance 0.0–1.0 (default: **0.4**) + +### Go to Definition — find where a symbol is defined +```bash +cix definitions HandleRequest +cix def AuthMiddleware --kind function +cix def Config --file ./internal/config.go +``` +Aliases: `definitions`, `def`, `goto`. Flags: `--kind`, `--file`, `--limit`. + +### Find References — find where a symbol is used +```bash +cix references HandleRequest +cix refs AuthMiddleware --limit 50 +cix usages UserService --file ./internal/api/ +``` +Aliases: `references`, `refs`, `usages`. Flags: `--file`, `--limit`. + +### Symbol Search — find symbols by name +```bash +cix symbols handleRequest +cix symbols User --kind class +cix symbols Auth --kind function --kind method +``` +Flags: `--kind` (function/class/method/type, repeatable), `--limit`. + +### File Search — find files by path pattern +```bash +cix files "config" +cix files "middleware" --limit 20 +``` + +### Project Overview +```bash +cix summary # languages, top dirs, key symbols +cix status # indexing status + file watcher status +cix list # all indexed projects +``` + +### Indexing +```bash +cix init [path] # register + index + start watcher +cix reindex # incremental +cix reindex --full # full reindex +cix cancel # cancel an in-flight indexing run +cix watch # start file-change auto-reindex daemon +cix watch stop # stop daemon +``` + +The watcher auto-reindexes on file change — manual `reindex` is rarely +needed. `cix status` shows whether the watcher is running and the +last-sync timestamp. + +--- + +## Search quality — what scores mean + +Default `--min-score 0.4` is calibrated for the production embedding +model (CodeRankEmbed-Q8 with path-aware preamble). Rough landscape: + +| Score | Meaning | +|----------|---------------------------------------------------------| +| 0.65+ | Exact / very strong match — almost certainly relevant | +| 0.50–0.65| Strong match — usually relevant | +| 0.40–0.50| Weaker match — sometimes useful, sometimes not | +| <0.40 | Noise — filtered out by default | + +**If a query returns nothing**, lower the floor explicitly: +`--min-score 0.2` for very specific or long-tail queries. Don't drop +below 0.2 — results below that are noise. + +--- + +## Writing better queries — leverage path-aware embedding + +Each chunk is embedded with its file path, language, and symbol name in +the preamble. This means **mentioning a file/dir/symbol you already +know about boosts ranking**: + +```bash +# Generic +cix search "validation" +# Better — pins the search to the auth area +cix search "validation in auth middleware" +# Even better when you know the symbol +cix search "ValidateToken" --kind function +``` + +Natural-language queries that name the *kind of thing* and *where it +lives* outperform single-word queries. + +--- + +## Usage Patterns + +### Exploring unfamiliar code (`cix`'s strongest case) +```bash +cix summary # project structure, top dirs +cix search "main entry point server" # find where it starts +cix search "database connection setup" # find DB wiring +cix search "request handler" --in ./api # narrow to API +``` + +### Tracing a symbol end-to-end +```bash +cix def HandleRequest # where is it defined? +cix refs HandleRequest # who calls it? +cix search "HandleRequest error handling" # how are errors handled? +``` + +### Chasing a known target (often grep is enough) +```bash +# Stack trace says "internal/auth/middleware.go:42 — invalid token" +# → just Read that file. No cix needed. + +# Config key "max_concurrent_requests" used somewhere? +# → grep is more precise. +``` + +### Narrowing scope +```bash +cix search "middleware" --in ./api/ +cix search "config" --in ./cmd/ --exclude legacy +cix refs Config --file ./internal/server.go +``` + +--- + +## Tips + +- Search queries are natural language, not regex. Write what you'd ask + a colleague. +- Output groups by file: each result line is a file with all relevant + matches inside, ordered top-to-bottom by line number. The + `[best 0.NN]` is the score of the top hit in that file. +- `cix def` is a faster path than `cix symbols` when you already know + the exact name. +- `--exclude` complements `--in` — use it to drop noisy dirs (`bench/`, + `legacy/`, vendored code) inline without touching `.cixignore`. +- The watcher keeps the index fresh. If results feel stale, check + `cix status` first — `Watcher: ✗ not running` is the usual cause. +- Don't loop. If a query returns nothing useful after one well-phrased + attempt + one `--min-score 0.2` retry, drop to grep. diff --git a/plugins/cix/tests/README.md b/plugins/cix/tests/README.md new file mode 100644 index 0000000..51274dc --- /dev/null +++ b/plugins/cix/tests/README.md @@ -0,0 +1,94 @@ +# Plugin tests + +Hook script tests for the cix Claude Code plugin. Uses +[bats-core](https://bats-core.readthedocs.io/) with mocked `cix` binary, +isolated `$CLAUDE_PLUGIN_DATA`, and a per-test scratch project directory. + +## Run locally + +```bash +# Install bats + jq + shellcheck +brew install bats-core jq shellcheck # macOS +sudo apt-get install bats jq shellcheck # Debian / Ubuntu + +# From repo root: +bats plugins/cix/tests/*.bats + +# Or pick one suite: +bats plugins/cix/tests/session-end.bats + +# TAP-formatted output (what CI uses): +bats --tap plugins/cix/tests/*.bats +``` + +Each test runs in an isolated `$BATS_TMPDIR` scratch directory and +cleans up after itself — no state leaks between tests. + +## What's covered + +| Suite | Focus | +|---|---| +| `session-start.bats` | cix-status flow, cache write, 30-day GC, **non-matching files preserved** | +| `cwd-changed.bats` | First-cd evaluation, no-op on cached dir, multi-dir state | +| `grep-nudge.bats` | Exponential backoff (1, 2, 4, 8, 16), per-(session, dir) counters | +| `post-compact.bats` | Re-injection only when cache="1" | +| `session-end.bats` | **Security:** deletion never leaks to other sessions, non-cix files, or subdirs — even with custom `$CLAUDE_PLUGIN_DATA` | +| `cix-wrapper.bats` | System-cix passthrough, exit code propagation, self-recursion guard | + +## Security tests (the most important ones) + +Bash scripts that call `find -delete` get extra scrutiny. Safety comes +from **what** we delete (strict `-name` patterns + `-type f` + +`-maxdepth 1`), not **where** the cache dir lives. The plugin +deliberately does not whitelist parent paths, so users with custom +`$CLAUDE_PLUGIN_DATA` (corporate setups, XDG-style layouts) are +supported. + +`session-end.bats` and `session-start.bats` suites contain explicit +adversarial cases: + +- Other sessions' cache files → must NOT be touched +- Files with confusable names (`cix-other-pattern`, + `X-cix-aware-fake-...`, `cix` alone) → must NOT be touched +- Random files (`config.yaml`, `.env`, `secrets.json`) in cache dir + → must NOT be touched +- Subdirectories in cache dir + nested files → must NOT be touched + (only `-maxdepth 1`) +- 30-day GC → must spare files outside the `cix-aware-*` / + `cix-grep-count-*` prefixes, even if they're old +- `session_id` containing shell metacharacters → must NOT trigger + command injection (canary file survives) +- Custom non-standard `$CLAUDE_PLUGIN_DATA` → script proceeds without + refusing, deletes only matching files + +If any of these fail in CI, the offending change cannot land. + +## Mocks + +`tests/mocks/bin/cix` is a fake `cix` CLI controlled via env vars: + +- `MOCK_CIX_EXIT` — exit code (default 0) +- `MOCK_CIX_DELAY` — sleep before exit (for timeout tests) +- `MOCK_CIX_LOG_FILE` — append every invocation here so tests can + assert "was the script called with the right args?" + +`helpers.bash` puts the mock first on `$PATH` for every hook invocation, +so unqualified `cix` calls inside the hook scripts hit the mock. + +## Adding a new test + +1. Pick (or create) the right `.bats` file. +2. Use `setup() { setup_test_env; }` and `teardown() { teardown_test_env; }`. +3. Use `run_hook + + +
+ + + diff --git a/server/dashboard/package-lock.json b/server/dashboard/package-lock.json new file mode 100644 index 0000000..f4d39d8 --- /dev/null +++ b/server/dashboard/package-lock.json @@ -0,0 +1,4156 @@ +{ + "name": "cix-dashboard", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "cix-dashboard", + "version": "0.1.0", + "dependencies": { + "@radix-ui/react-dialog": "^1.1.6", + "@radix-ui/react-dropdown-menu": "^2.1.6", + "@radix-ui/react-label": "^2.1.2", + "@radix-ui/react-radio-group": "^1.3.8", + "@radix-ui/react-scroll-area": "^1.2.10", + "@radix-ui/react-select": "^2.2.6", + "@radix-ui/react-slider": "^1.3.6", + "@radix-ui/react-slot": "^1.2.4", + "@radix-ui/react-switch": "^1.2.6", + "@radix-ui/react-tabs": "^1.1.13", + "@radix-ui/react-tooltip": "^1.2.8", + "@tanstack/react-query": "^5.66.0", + "class-variance-authority": "^0.7.1", + "clsx": "^2.1.1", + "lucide-react": "^0.475.0", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "react-router-dom": "^6.28.0", + "sonner": "^1.7.4", + "tailwind-merge": "^3.0.1" + }, + "devDependencies": { + "@types/node": "^22.13.0", + "@types/react": "^18.3.18", + "@types/react-dom": "^18.3.5", + "@vitejs/plugin-react": "^4.3.4", + "autoprefixer": "^10.4.20", + "openapi-typescript": "^7.5.2", + "postcss": "^8.5.1", + "tailwindcss": "^3.4.17", + "tailwindcss-animate": "^1.0.7", + "typescript": "^5.7.3", + "vite": "^8.0.12" + } + }, + "node_modules/@alloc/quick-lru": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.3", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.3.tgz", + "integrity": "sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz", + "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.3", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.3.tgz", + "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@emnapi/core": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz", + "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/wasi-threads": "1.2.1", + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/runtime": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz", + "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/wasi-threads": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz", + "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@floating-ui/core": { + "version": "1.7.5", + "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz", + "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==", + "license": "MIT", + "dependencies": { + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/dom": { + "version": "1.7.6", + "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz", + "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==", + "license": "MIT", + "dependencies": { + "@floating-ui/core": "^1.7.5", + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/react-dom": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.8.tgz", + "integrity": "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==", + "license": "MIT", + "dependencies": { + "@floating-ui/dom": "^1.7.6" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/@floating-ui/utils": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz", + "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==", + "license": "MIT" + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@napi-rs/wasm-runtime": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.4.tgz", + "integrity": "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@tybys/wasm-util": "^0.10.1" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/Brooooooklyn" + }, + "peerDependencies": { + "@emnapi/core": "^1.7.1", + "@emnapi/runtime": "^1.7.1" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@oxc-project/types": { + "version": "0.129.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.129.0.tgz", + "integrity": "sha512-3oz8m3FGdr2nDXVqmFUw7jolKliC4MoyXYIG2c7gpjBnzUWQpUGIYcXYKxTdTi+N2jusvt610ckTMkxdwHkYEg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@radix-ui/number": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/number/-/number-1.1.1.tgz", + "integrity": "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==", + "license": "MIT" + }, + "node_modules/@radix-ui/primitive": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz", + "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==", + "license": "MIT" + }, + "node_modules/@radix-ui/react-arrow": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz", + "integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-collection": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.7.tgz", + "integrity": "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-slot": "1.2.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-collection/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-compose-refs": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz", + "integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-context": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz", + "integrity": "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dialog": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dialog/-/react-dialog-1.1.15.tgz", + "integrity": "sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-dismissable-layer": "1.1.11", + "@radix-ui/react-focus-guards": "1.1.3", + "@radix-ui/react-focus-scope": "1.1.7", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-portal": "1.1.9", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-slot": "1.2.3", + "@radix-ui/react-use-controllable-state": "1.2.2", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.6.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-direction": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-direction/-/react-direction-1.1.1.tgz", + "integrity": "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dismissable-layer": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz", + "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "@radix-ui/react-use-escape-keydown": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-dropdown-menu": { + "version": "2.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.16.tgz", + "integrity": "sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-menu": "2.1.16", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-controllable-state": "1.2.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-focus-guards": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz", + "integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-focus-scope": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz", + "integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-callback-ref": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-id": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz", + "integrity": "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-label": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/@radix-ui/react-label/-/react-label-2.1.8.tgz", + "integrity": "sha512-FmXs37I6hSBVDlO4y764TNz1rLgKwjJMQ0EGte6F3Cb3f4bIuHB/iLa/8I9VKkmOy+gNHq8rql3j686ACVV21A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-label/node_modules/@radix-ui/react-primitive": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.4.tgz", + "integrity": "sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-slot": "1.2.4" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-menu": { + "version": "2.1.16", + "resolved": "https://registry.npmjs.org/@radix-ui/react-menu/-/react-menu-2.1.16.tgz", + "integrity": "sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-collection": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-dismissable-layer": "1.1.11", + "@radix-ui/react-focus-guards": "1.1.3", + "@radix-ui/react-focus-scope": "1.1.7", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-popper": "1.2.8", + "@radix-ui/react-portal": "1.1.9", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-roving-focus": "1.1.11", + "@radix-ui/react-slot": "1.2.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.6.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-menu/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-popper": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz", + "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==", + "license": "MIT", + "dependencies": { + "@floating-ui/react-dom": "^2.0.0", + "@radix-ui/react-arrow": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "@radix-ui/react-use-layout-effect": "1.1.1", + "@radix-ui/react-use-rect": "1.1.1", + "@radix-ui/react-use-size": "1.1.1", + "@radix-ui/rect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-portal": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz", + "integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-presence": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz", + "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-primitive": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz", + "integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-slot": "1.2.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-primitive/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-radio-group": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/@radix-ui/react-radio-group/-/react-radio-group-1.3.8.tgz", + "integrity": "sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-roving-focus": "1.1.11", + "@radix-ui/react-use-controllable-state": "1.2.2", + "@radix-ui/react-use-previous": "1.1.1", + "@radix-ui/react-use-size": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-roving-focus": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/@radix-ui/react-roving-focus/-/react-roving-focus-1.1.11.tgz", + "integrity": "sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-collection": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "@radix-ui/react-use-controllable-state": "1.2.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-scroll-area": { + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/@radix-ui/react-scroll-area/-/react-scroll-area-1.2.10.tgz", + "integrity": "sha512-tAXIa1g3sM5CGpVT0uIbUx/U3Gs5N8T52IICuCtObaos1S8fzsrPXG5WObkQN3S6NVl6wKgPhAIiBGbWnvc97A==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.1", + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-select": { + "version": "2.2.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.6.tgz", + "integrity": "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.1", + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-collection": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-dismissable-layer": "1.1.11", + "@radix-ui/react-focus-guards": "1.1.3", + "@radix-ui/react-focus-scope": "1.1.7", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-popper": "1.2.8", + "@radix-ui/react-portal": "1.1.9", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-slot": "1.2.3", + "@radix-ui/react-use-callback-ref": "1.1.1", + "@radix-ui/react-use-controllable-state": "1.2.2", + "@radix-ui/react-use-layout-effect": "1.1.1", + "@radix-ui/react-use-previous": "1.1.1", + "@radix-ui/react-visually-hidden": "1.2.3", + "aria-hidden": "^1.2.4", + "react-remove-scroll": "^2.6.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-slider": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slider/-/react-slider-1.3.6.tgz", + "integrity": "sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==", + "license": "MIT", + "dependencies": { + "@radix-ui/number": "1.1.1", + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-collection": "1.1.7", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-controllable-state": "1.2.2", + "@radix-ui/react-use-layout-effect": "1.1.1", + "@radix-ui/react-use-previous": "1.1.1", + "@radix-ui/react-use-size": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-slot": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.4.tgz", + "integrity": "sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-switch": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@radix-ui/react-switch/-/react-switch-1.2.6.tgz", + "integrity": "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-use-controllable-state": "1.2.2", + "@radix-ui/react-use-previous": "1.1.1", + "@radix-ui/react-use-size": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-tabs": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/@radix-ui/react-tabs/-/react-tabs-1.1.13.tgz", + "integrity": "sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-direction": "1.1.1", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-roving-focus": "1.1.11", + "@radix-ui/react-use-controllable-state": "1.2.2" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-tooltip": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz", + "integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==", + "license": "MIT", + "dependencies": { + "@radix-ui/primitive": "1.1.3", + "@radix-ui/react-compose-refs": "1.1.2", + "@radix-ui/react-context": "1.1.2", + "@radix-ui/react-dismissable-layer": "1.1.11", + "@radix-ui/react-id": "1.1.1", + "@radix-ui/react-popper": "1.2.8", + "@radix-ui/react-portal": "1.1.9", + "@radix-ui/react-presence": "1.1.5", + "@radix-ui/react-primitive": "2.1.3", + "@radix-ui/react-slot": "1.2.3", + "@radix-ui/react-use-controllable-state": "1.2.2", + "@radix-ui/react-visually-hidden": "1.2.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-tooltip/node_modules/@radix-ui/react-slot": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", + "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-compose-refs": "1.1.2" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-callback-ref": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz", + "integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-controllable-state": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz", + "integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-effect-event": "0.0.2", + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-effect-event": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz", + "integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-escape-keydown": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz", + "integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-callback-ref": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-layout-effect": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz", + "integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-previous": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz", + "integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-rect": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz", + "integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==", + "license": "MIT", + "dependencies": { + "@radix-ui/rect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-use-size": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz", + "integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-use-layout-effect": "1.1.1" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@radix-ui/react-visually-hidden": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz", + "integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==", + "license": "MIT", + "dependencies": { + "@radix-ui/react-primitive": "2.1.3" + }, + "peerDependencies": { + "@types/react": "*", + "@types/react-dom": "*", + "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", + "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@radix-ui/rect": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz", + "integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==", + "license": "MIT" + }, + "node_modules/@redocly/ajv": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/@redocly/ajv/-/ajv-8.11.2.tgz", + "integrity": "sha512-io1JpnwtIcvojV7QKDUSIuMN/ikdOUd1ReEnUnMKGfDVridQZ31J0MmIuqwuRjWDZfmvr+Q0MqCcfHM2gTivOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js-replace": "^1.0.1" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/@redocly/config": { + "version": "0.22.0", + "resolved": "https://registry.npmjs.org/@redocly/config/-/config-0.22.0.tgz", + "integrity": "sha512-gAy93Ddo01Z3bHuVdPWfCwzgfaYgMdaZPcfL7JZ7hWJoK9V0lXDbigTWkhiPFAaLWzbOJ+kbUQG1+XwIm0KRGQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@redocly/openapi-core": { + "version": "1.34.14", + "resolved": "https://registry.npmjs.org/@redocly/openapi-core/-/openapi-core-1.34.14.tgz", + "integrity": "sha512-y+xFx+Zz54Xhr8jUdnLENYnt7Y7GEDL6Q03ga7rTtX8DVwefX9H+hQEPgJp1nda7vdH+wJ9/HBVvyfBuW9x6rA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@redocly/ajv": "8.11.2", + "@redocly/config": "0.22.0", + "colorette": "1.4.0", + "https-proxy-agent": "7.0.6", + "js-levenshtein": "1.1.6", + "js-yaml": "4.1.1", + "minimatch": "5.1.9", + "pluralize": "8.0.0", + "yaml-ast-parser": "0.0.43" + }, + "engines": { + "node": ">=18.17.0", + "npm": ">=9.5.0" + } + }, + "node_modules/@remix-run/router": { + "version": "1.23.2", + "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.2.tgz", + "integrity": "sha512-Ic6m2U/rMjTkhERIa/0ZtXJP17QUi2CbWE7cqx4J58M8aA3QTfW+2UlQ4psvTX9IO1RfNVhK3pcpdjej7L+t2w==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0.tgz", + "integrity": "sha512-TWMZnRLMe63C2Lhyicviu7ZHaU4kxa6PS3rofvc9GmcvptzNN11BcfQ4Sl7MwTOsisQoa2keB/EBdNCAnUo8vA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0.tgz", + "integrity": "sha512-6XcD+8k0gPVItNagEw78/qqcBDwKcwDYS8V2hRmVsfUSIrd8cWe/CBvRDI5toqFyPfj+FJr6t8U6Xj2P2prEew==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0.tgz", + "integrity": "sha512-iN/tWVXRQDWvmZlKdceP1Dwug9GDpEymhb9p4xnEe6zvCg5lFmzVljl+1qR1NVx3yfGpr2Na+CuLmv5IU8uzfQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0.tgz", + "integrity": "sha512-jjQMDvvwSOuhOwMszD/klSOjyWMM3zI64hWTj9KT5x4MxRbZAf+7vLQ6qouRhtsLVFHr3f0ILaJAfgENPiQdAQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0.tgz", + "integrity": "sha512-d//Dtg2x6/m3mbV64yUGNnDGNZaDGRpDLLNGerHQUVObuNaIQaaDp25yUiqGXtHEXX+NP2d0wAlmKgpYgIAJ2A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0.tgz", + "integrity": "sha512-n7Ofp0mx+aB2cC+Sdy5YtMnXtY9lchnHbY+3Yt0uq9JsWQExf4f5Whu0tK0R8Jdc9S6RchTHjIFY7uc92puOVQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0.tgz", + "integrity": "sha512-EIVjy2cgd7uuMMo94FVkBp7F6DhcZAUwNURkSG3RwUmvAXR6s0ISxM81U+IydcZByPG0pZIHsf1b6kTxoFDgJA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-ppc64-gnu": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0.tgz", + "integrity": "sha512-JEwwOPcwTLAcpDQlqSmjEmfs63xJnSiUNIGvLcDLUHCWK4XowpS/7c7tUsUH6uT/ct6bMUTdXKfI8967FYj6mg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-s390x-gnu": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0.tgz", + "integrity": "sha512-0wjCFhLrihtAubnT9iA0N++0pSV0z5Hg7tNGdNJ4RFaINceHadoF+kiFGyY1qSSNVIAZtLotG8Ju1bgDPkjnFA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0.tgz", + "integrity": "sha512-Dfn7iak9BcMMePxcoJfpSbWqnEyrp/dRF63/8qW/eHBdOZov6x5aShLLEYGYdIeSJ6vMLK/XCVB+lGIxm41bQA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0.tgz", + "integrity": "sha512-5/utzzDmD/pD/bmuaUcbTf/sZYy0aztwIVlfpoW1fTjCZ0BaPOMVWGZL1zvgxyi7ZIVYWlxKONHmSbHuiOh8Jw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0.tgz", + "integrity": "sha512-ouJs8VcUomfLfpbUECqFMRqdV4x6aeAK3MA4m6vTrJJjKyWTV5KnxZx7Jd9G+GlDaQQxubcba00x16OyJ1meig==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-wasm32-wasi": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0.tgz", + "integrity": "sha512-E+oHKGiDA+lsKMmFtffDDw91EryDT7uJocrIuCHqhm6bCTM6xFK+3gaCkYOHfPwQr0cCNarSM2xaELoQDz9jJg==", + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "1.10.0", + "@emnapi/runtime": "1.10.0", + "@napi-rs/wasm-runtime": "^1.1.4" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0.tgz", + "integrity": "sha512-yYK02n8Rngo+gbm1y6G0+7jk1sJ/2Wt7K0me0Y7k/ErBpyf+LJ2gFpqWVTcRV1rUepBlQRmpgWkTQCiiwrK0Ow==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0.tgz", + "integrity": "sha512-14bpChMahXRRXiTwahSl+zzHPW6qQTXtkMuJBFlbo+pqSAews2d4BdCSHfrJ/MBsCZtpmTafsY+1QhBzitcmdg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@tanstack/query-core": { + "version": "5.100.8", + "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.100.8.tgz", + "integrity": "sha512-ceYwSFOqjPwET5TA6IOYxzxlGc0ekyH/gfOtWkP0PX43rzX9bxW48Iuw8KAduKCToi4rJAQ6nRy2kAe8gszdmg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/tannerlinsley" + } + }, + "node_modules/@tanstack/react-query": { + "version": "5.100.8", + "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.100.8.tgz", + "integrity": "sha512-iNNEekixXU5vtAGKKZX2lx3jTooG5yNY+kv0wSgEdEYG0Mj0JM5bcuQtC35ZAP3nDopT6jciUK3xeX65U7AnfA==", + "license": "MIT", + "dependencies": { + "@tanstack/query-core": "5.100.8" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/tannerlinsley" + }, + "peerDependencies": { + "react": "^18 || ^19" + } + }, + "node_modules/@tybys/wasm-util": { + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz", + "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/node": { + "version": "22.19.17", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.17.tgz", + "integrity": "sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/prop-types": { + "version": "15.7.15", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz", + "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.28", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.28.tgz", + "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.3.7", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz", + "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==", + "devOptional": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^18.0.0" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/agent-base": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", + "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz", + "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "dev": true, + "license": "MIT" + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "dev": true, + "license": "MIT" + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/aria-hidden": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz", + "integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/autoprefixer": { + "version": "10.5.0", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.5.0.tgz", + "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.28.2", + "caniuse-lite": "^1.0.30001787", + "fraction.js": "^5.3.4", + "picocolors": "^1.1.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.25", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.25.tgz", + "integrity": "sha512-QO/VHsXCQdnzADMfmkeOPvHdIAkoB7i0/rGjINPJEetLx75hNttVWGQ/jycHUDP9zZ9rupbm60WRxcwViB0MiA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/brace-expansion": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz", + "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.28.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz", + "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.10.12", + "caniuse-lite": "^1.0.30001782", + "electron-to-chromium": "^1.5.328", + "node-releases": "^2.0.36", + "update-browserslist-db": "^1.2.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/camelcase-css": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001791", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001791.tgz", + "integrity": "sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/change-case": { + "version": "5.4.4", + "resolved": "https://registry.npmjs.org/change-case/-/change-case-5.4.4.tgz", + "integrity": "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/class-variance-authority": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz", + "integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==", + "license": "Apache-2.0", + "dependencies": { + "clsx": "^2.1.1" + }, + "funding": { + "url": "https://polar.sh/cva" + } + }, + "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/colorette": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-1.4.0.tgz", + "integrity": "sha512-Y2oEozpomLn7Q3HFP7dpww7AtMJplbM9lGZP6RDfHqmbeRjiwRg4n6VM6j4KLmRke85uWEI7JqF17f3pqdRA0g==", + "dev": true, + "license": "MIT" + }, + "node_modules/commander": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "dev": true, + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/detect-node-es": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz", + "integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==", + "license": "MIT" + }, + "node_modules/didyoumean": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/dlv": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "dev": true, + "license": "MIT" + }, + "node_modules/electron-to-chromium": { + "version": "1.5.349", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.349.tgz", + "integrity": "sha512-QsWVGyRuY07Aqb234QytTfwd5d9AJlfNIQ5wIOl1L+PZDzI9d9+Fn0FRale/QYlFxt/bUnB0/nLd1jFPGxGK1A==", + "dev": true, + "license": "ISC" + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fastq": { + "version": "1.20.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz", + "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fraction.js": { + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz", + "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-nonce": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz", + "integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/hasown": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz", + "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/https-proxy-agent": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", + "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/index-to-position": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.2.0.tgz", + "integrity": "sha512-Yg7+ztRkqslMAS2iFaU+Oa4KTSidr63OsFGlOrJoW981kIYO3CGCS3wA95P1mUi/IVSJkn0D479KTJpVpvFNuw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/jiti": { + "version": "1.21.7", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "bin/jiti.js" + } + }, + "node_modules/js-levenshtein": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/js-levenshtein/-/js-levenshtein-1.1.6.tgz", + "integrity": "sha512-X2BB11YZtrRqY4EnQcLX5Rh373zbK4alC1FW7D7MBhL2gtcC17cTnr6DmfHZeS0s2rTHjUTMMHfG7gO8SSdw+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/lightningcss": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz", + "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.32.0", + "lightningcss-darwin-arm64": "1.32.0", + "lightningcss-darwin-x64": "1.32.0", + "lightningcss-freebsd-x64": "1.32.0", + "lightningcss-linux-arm-gnueabihf": "1.32.0", + "lightningcss-linux-arm64-gnu": "1.32.0", + "lightningcss-linux-arm64-musl": "1.32.0", + "lightningcss-linux-x64-gnu": "1.32.0", + "lightningcss-linux-x64-musl": "1.32.0", + "lightningcss-win32-arm64-msvc": "1.32.0", + "lightningcss-win32-x64-msvc": "1.32.0" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz", + "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-arm64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz", + "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-x64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz", + "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-freebsd-x64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz", + "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz", + "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz", + "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz", + "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz", + "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz", + "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz", + "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-x64-msvc": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz", + "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lilconfig": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/lucide-react": { + "version": "0.475.0", + "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.475.0.tgz", + "integrity": "sha512-NJzvVu1HwFVeZ+Gwq2q00KygM1aBhy/ZrhY9FsAgJtpB+E4R7uxRk9M2iKvHa6/vNxZydIB59htha4c2vvwvVg==", + "license": "ISC", + "peerDependencies": { + "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "node_modules/nanoid": { + "version": "3.3.12", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz", + "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/node-releases": { + "version": "2.0.38", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.38.tgz", + "integrity": "sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==", + "dev": true, + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/openapi-typescript": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/openapi-typescript/-/openapi-typescript-7.13.0.tgz", + "integrity": "sha512-EFP392gcqXS7ntPvbhBzbF8TyBA+baIYEm791Hy5YkjDYKTnk/Tn5OQeKm5BIZvJihpp8Zzr4hzx0Irde1LNGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@redocly/openapi-core": "^1.34.6", + "ansi-colors": "^4.1.3", + "change-case": "^5.4.4", + "parse-json": "^8.3.0", + "supports-color": "^10.2.2", + "yargs-parser": "^21.1.1" + }, + "bin": { + "openapi-typescript": "bin/cli.js" + }, + "peerDependencies": { + "typescript": "^5.x" + } + }, + "node_modules/parse-json": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz", + "integrity": "sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.26.2", + "index-to-position": "^1.1.0", + "type-fest": "^4.39.1" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pirates": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", + "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/pluralize": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz", + "integrity": "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss": { + "version": "8.5.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.14.tgz", + "integrity": "sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-import": { + "version": "15.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", + "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.0.0", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-js": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz", + "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, + "peerDependencies": { + "postcss": "^8.4.21" + } + }, + "node_modules/postcss-load-config": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz", + "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "lilconfig": "^3.1.1" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "jiti": ">=1.21.0", + "postcss": ">=8.0.9", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + }, + "postcss": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/postcss-nested": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.1" + }, + "engines": { + "node": ">=12.0" + }, + "peerDependencies": { + "postcss": "^8.2.14" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", + "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-remove-scroll": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz", + "integrity": "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==", + "license": "MIT", + "dependencies": { + "react-remove-scroll-bar": "^2.3.7", + "react-style-singleton": "^2.2.3", + "tslib": "^2.1.0", + "use-callback-ref": "^1.3.3", + "use-sidecar": "^1.1.3" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/react-remove-scroll-bar": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz", + "integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==", + "license": "MIT", + "dependencies": { + "react-style-singleton": "^2.2.2", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/react-router": { + "version": "6.30.3", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.3.tgz", + "integrity": "sha512-XRnlbKMTmktBkjCLE8/XcZFlnHvr2Ltdr1eJX4idL55/9BbORzyZEaIkBFDhFGCEWBBItsVrDxwx3gnisMitdw==", + "license": "MIT", + "dependencies": { + "@remix-run/router": "1.23.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8" + } + }, + "node_modules/react-router-dom": { + "version": "6.30.3", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.3.tgz", + "integrity": "sha512-pxPcv1AczD4vso7G4Z3TKcvlxK7g7TNt3/FNGMhfqyntocvYKj+GCatfigGDjbLozC4baguJ0ReCigoDJXb0ag==", + "license": "MIT", + "dependencies": { + "@remix-run/router": "1.23.2", + "react-router": "6.30.3" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8", + "react-dom": ">=16.8" + } + }, + "node_modules/react-style-singleton": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz", + "integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==", + "license": "MIT", + "dependencies": { + "get-nonce": "^1.0.0", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^2.3.0" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.12", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz", + "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rolldown": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0.tgz", + "integrity": "sha512-yD986aXDESFGS95spT1LAv0jssywP4npMEjmMHyN2/5+eE8qQJUype2AaKkRiLgBgyD0LFlubwAht7VmY8rGoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.129.0", + "@rolldown/pluginutils": "1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.0.0", + "@rolldown/binding-darwin-arm64": "1.0.0", + "@rolldown/binding-darwin-x64": "1.0.0", + "@rolldown/binding-freebsd-x64": "1.0.0", + "@rolldown/binding-linux-arm-gnueabihf": "1.0.0", + "@rolldown/binding-linux-arm64-gnu": "1.0.0", + "@rolldown/binding-linux-arm64-musl": "1.0.0", + "@rolldown/binding-linux-ppc64-gnu": "1.0.0", + "@rolldown/binding-linux-s390x-gnu": "1.0.0", + "@rolldown/binding-linux-x64-gnu": "1.0.0", + "@rolldown/binding-linux-x64-musl": "1.0.0", + "@rolldown/binding-openharmony-arm64": "1.0.0", + "@rolldown/binding-wasm32-wasi": "1.0.0", + "@rolldown/binding-win32-arm64-msvc": "1.0.0", + "@rolldown/binding-win32-x64-msvc": "1.0.0" + } + }, + "node_modules/rolldown/node_modules/@rolldown/pluginutils": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0.tgz", + "integrity": "sha512-aKs/3GSWyV0mrhNmt/96/Z3yczC3yvrzYATCiCXQebBsGyYzjNdUphRVLeJQ67ySKVXRfMxt2lm12pmXvbPFQQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/sonner": { + "version": "1.7.4", + "resolved": "https://registry.npmjs.org/sonner/-/sonner-1.7.4.tgz", + "integrity": "sha512-DIS8z4PfJRbIyfVFDVnK9rO3eYDtse4Omcm6bt0oEr5/jtLgysmjuBl1frJ9E/EQZrFmKx2A8m/s5s9CRXIzhw==", + "license": "MIT", + "peerDependencies": { + "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", + "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sucrase": { + "version": "3.35.1", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz", + "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.2", + "commander": "^4.0.0", + "lines-and-columns": "^1.1.6", + "mz": "^2.7.0", + "pirates": "^4.0.1", + "tinyglobby": "^0.2.11", + "ts-interface-checker": "^0.1.9" + }, + "bin": { + "sucrase": "bin/sucrase", + "sucrase-node": "bin/sucrase-node" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/supports-color": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-10.2.2.tgz", + "integrity": "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tailwind-merge": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.5.0.tgz", + "integrity": "sha512-I8K9wewnVDkL1NTGoqWmVEIlUcB9gFriAEkXkfCjX5ib8ezGxtR3xD7iZIxrfArjEsH7F1CHD4RFUtxefdqV/A==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/dcastil" + } + }, + "node_modules/tailwindcss": { + "version": "3.4.19", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz", + "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@alloc/quick-lru": "^5.2.0", + "arg": "^5.0.2", + "chokidar": "^3.6.0", + "didyoumean": "^1.2.2", + "dlv": "^1.1.3", + "fast-glob": "^3.3.2", + "glob-parent": "^6.0.2", + "is-glob": "^4.0.3", + "jiti": "^1.21.7", + "lilconfig": "^3.1.3", + "micromatch": "^4.0.8", + "normalize-path": "^3.0.0", + "object-hash": "^3.0.0", + "picocolors": "^1.1.1", + "postcss": "^8.4.47", + "postcss-import": "^15.1.0", + "postcss-js": "^4.0.1", + "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0", + "postcss-nested": "^6.2.0", + "postcss-selector-parser": "^6.1.2", + "resolve": "^1.22.8", + "sucrase": "^3.35.0" + }, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tailwindcss-animate": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz", + "integrity": "sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "tailwindcss": ">=3.0.0 || insiders" + } + }, + "node_modules/thenify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0" + } + }, + "node_modules/thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "thenify": ">= 3.1.0 < 4" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", + "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinyglobby/node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/tinyglobby/node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/ts-interface-checker": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/type-fest": { + "version": "4.41.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz", + "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js-replace": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/uri-js-replace/-/uri-js-replace-1.0.1.tgz", + "integrity": "sha512-W+C9NWNLFOoBI2QWDp4UT9pv65r2w5Cx+3sTYFvtMdDBxkKt1syCqsUdSFAChbEe1uK5TfS04wt/nGwmaeIQ0g==", + "dev": true, + "license": "MIT" + }, + "node_modules/use-callback-ref": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz", + "integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/use-sidecar": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz", + "integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==", + "license": "MIT", + "dependencies": { + "detect-node-es": "^1.1.0", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@types/react": "*", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true, + "license": "MIT" + }, + "node_modules/vite": { + "version": "8.0.12", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.12.tgz", + "integrity": "sha512-w2dDofOWv2QB09ZITZBsvKTVAlYvPR4IAmrY/v0ir9KvLs0xybR7i48wxhM1/oyBWO34wPns+bPGw5ZrZqDpZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "lightningcss": "^1.32.0", + "picomatch": "^4.0.4", + "postcss": "^8.5.14", + "rolldown": "1.0.0", + "tinyglobby": "^0.2.16" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.1.18", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite/node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/yaml-ast-parser": { + "version": "0.0.43", + "resolved": "https://registry.npmjs.org/yaml-ast-parser/-/yaml-ast-parser-0.0.43.tgz", + "integrity": "sha512-2PTINUwsRqSd+s8XxKaJWQlUuEMHJQyEuh2edBbW8KNJz0SJPwUSD2zRWqezFEdN7IzAgeuYHFUCF7o8zRdZ0A==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + } + } +} diff --git a/server/dashboard/package.json b/server/dashboard/package.json new file mode 100644 index 0000000..a869d46 --- /dev/null +++ b/server/dashboard/package.json @@ -0,0 +1,50 @@ +{ + "name": "cix-dashboard", + "version": "0.1.0", + "private": true, + "type": "module", + "description": "Embedded operator dashboard for cix-server. Built with Vite, served by Go via embed.FS at /dashboard.", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "preview": "vite preview", + "gen:api": "openapi-typescript ../../doc/openapi.yaml -o src/api/generated.ts", + "typecheck": "tsc --noEmit", + "lint": "tsc --noEmit" + }, + "dependencies": { + "@radix-ui/react-dialog": "^1.1.6", + "@radix-ui/react-dropdown-menu": "^2.1.6", + "@radix-ui/react-label": "^2.1.2", + "@radix-ui/react-radio-group": "^1.3.8", + "@radix-ui/react-scroll-area": "^1.2.10", + "@radix-ui/react-select": "^2.2.6", + "@radix-ui/react-slider": "^1.3.6", + "@radix-ui/react-slot": "^1.2.4", + "@radix-ui/react-switch": "^1.2.6", + "@radix-ui/react-tabs": "^1.1.13", + "@radix-ui/react-tooltip": "^1.2.8", + "@tanstack/react-query": "^5.66.0", + "class-variance-authority": "^0.7.1", + "clsx": "^2.1.1", + "lucide-react": "^0.475.0", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "react-router-dom": "^6.28.0", + "sonner": "^1.7.4", + "tailwind-merge": "^3.0.1" + }, + "devDependencies": { + "@types/node": "^22.13.0", + "@types/react": "^18.3.18", + "@types/react-dom": "^18.3.5", + "@vitejs/plugin-react": "^4.3.4", + "autoprefixer": "^10.4.20", + "openapi-typescript": "^7.5.2", + "postcss": "^8.5.1", + "tailwindcss": "^3.4.17", + "tailwindcss-animate": "^1.0.7", + "typescript": "^5.7.3", + "vite": "^8.0.12" + } +} diff --git a/server/dashboard/postcss.config.js b/server/dashboard/postcss.config.js new file mode 100644 index 0000000..2aa7205 --- /dev/null +++ b/server/dashboard/postcss.config.js @@ -0,0 +1,6 @@ +export default { + plugins: { + tailwindcss: {}, + autoprefixer: {}, + }, +}; diff --git a/server/dashboard/src/api/client.ts b/server/dashboard/src/api/client.ts new file mode 100644 index 0000000..8035316 --- /dev/null +++ b/server/dashboard/src/api/client.ts @@ -0,0 +1,111 @@ +// Lightweight fetch wrapper used by every TanStack Query call. +// +// Two contracts the rest of the app relies on: +// +// 1. Cookie-based auth: requests are sent with `credentials: 'same-origin'` +// so the HttpOnly `cix_session` cookie set by /api/v1/auth/login flows +// automatically. No tokens in localStorage; no Authorization header. +// +// 2. Error normalisation: any non-2xx response is translated into an +// `ApiError` whose `.detail` mirrors the FastAPI-style {"detail": "..."} +// payload our handlers always emit. Callers can `instanceof ApiError` +// and check `.status === 401` to drive auth redirects. + +const API_PREFIX = '/api/v1'; + +export class ApiError extends Error { + status: number; + detail: string; + constructor(status: number, detail: string) { + super(`HTTP ${status}: ${detail}`); + this.name = 'ApiError'; + this.status = status; + this.detail = detail; + } +} + +export interface RequestOptions { + method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'; + /** Plain object — serialized as JSON. */ + body?: unknown; + /** Extra query-string params; values are stringified. */ + query?: Record; + /** Cancel signal from React Query. */ + signal?: AbortSignal; +} + +function buildUrl(path: string, query?: RequestOptions['query']): string { + // Path always starts with `/auth/...` etc. The /api/v1 prefix is added here + // so individual call sites stay short and won't drift from the OpenAPI spec. + const base = path.startsWith('/api/') ? path : `${API_PREFIX}${path}`; + if (!query) return base; + const params = new URLSearchParams(); + for (const [k, v] of Object.entries(query)) { + if (v === undefined || v === null) continue; + params.set(k, String(v)); + } + const qs = params.toString(); + return qs ? `${base}?${qs}` : base; +} + +async function readDetail(res: Response): Promise { + try { + const data = (await res.clone().json()) as { detail?: unknown }; + if (data && typeof data.detail === 'string') return data.detail; + } catch { + // fall through — non-JSON body + } + try { + const txt = await res.text(); + return txt || res.statusText || `HTTP ${res.status}`; + } catch { + return res.statusText || `HTTP ${res.status}`; + } +} + +export async function request( + path: string, + opts: RequestOptions = {} +): Promise { + const { method = 'GET', body, query, signal } = opts; + + const init: RequestInit = { + method, + credentials: 'same-origin', + headers: { Accept: 'application/json' }, + signal, + }; + + if (body !== undefined) { + init.headers = { + ...(init.headers as Record), + 'Content-Type': 'application/json', + }; + init.body = JSON.stringify(body); + } + + const res = await fetch(buildUrl(path, query), init); + + if (!res.ok) { + throw new ApiError(res.status, await readDetail(res)); + } + + // 204 No Content + empty body for DELETEs. + if (res.status === 204) return undefined as T; + const ctype = res.headers.get('content-type') || ''; + if (!ctype.includes('application/json')) return undefined as T; + return (await res.json()) as T; +} + +export const api = { + get: (path: string, opts?: Omit) => + request(path, { ...opts, method: 'GET' }), + post: (path: string, body?: unknown, opts?: Omit) => + request(path, { ...opts, method: 'POST', body }), + patch: (path: string, body?: unknown, opts?: Omit) => + request(path, { ...opts, method: 'PATCH', body }), + put: (path: string, body?: unknown, opts?: Omit) => + request(path, { ...opts, method: 'PUT', body }), + delete: (path: string, opts?: Omit) => + request(path, { ...opts, method: 'DELETE' }), +}; diff --git a/server/dashboard/src/api/types.ts b/server/dashboard/src/api/types.ts new file mode 100644 index 0000000..f79accf --- /dev/null +++ b/server/dashboard/src/api/types.ts @@ -0,0 +1,66 @@ +// Hand-written re-exports of the OpenAPI schemas the dashboard actually uses. +// +// The full generated `./generated.ts` is produced by `npm run gen:api` and is +// gitignored — this file gives us stable, named imports without leaking +// `components['schemas']['User']` syntax into every component. Add a new +// alias here when the dashboard starts consuming a new schema. + +import type { components } from './generated'; + +export type Role = 'admin' | 'viewer'; + +export type User = components['schemas']['User']; +export type UserWithStats = components['schemas']['UserWithStats']; +export type Session = components['schemas']['Session']; +export type ApiKey = components['schemas']['ApiKey']; +export type ApiKeyCreated = components['schemas']['ApiKeyCreated']; +export type ApiKeyListResponse = components['schemas']['ApiKeyListResponse']; + +export type Project = components['schemas']['Project']; +export type ProjectSummary = components['schemas']['ProjectSummary']; +export type ProjectStats = components['schemas']['ProjectStats']; +export type ProjectSettings = components['schemas']['ProjectSettings']; +export type ProjectListResponse = components['schemas']['ProjectListResponse']; +export type DirEntry = components['schemas']['DirEntry']; +export type SymbolEntry = components['schemas']['SymbolEntry']; + +export type SemanticSearchRequest = components['schemas']['SemanticSearchRequest']; +export type SemanticSearchResponse = components['schemas']['SemanticSearchResponse']; +export type FileGroupResult = components['schemas']['FileGroupResult']; +export type FileMatch = components['schemas']['FileMatch']; +export type NestedHit = components['schemas']['NestedHit']; + +export type SymbolSearchRequest = components['schemas']['SymbolSearchRequest']; +export type SymbolSearchResponse = components['schemas']['SymbolSearchResponse']; +export type SymbolResultItem = components['schemas']['SymbolResultItem']; + +export type DefinitionRequest = components['schemas']['DefinitionRequest']; +export type DefinitionResponse = components['schemas']['DefinitionResponse']; +export type DefinitionItem = components['schemas']['DefinitionItem']; + +export type ReferenceRequest = components['schemas']['ReferenceRequest']; +export type ReferenceResponse = components['schemas']['ReferenceResponse']; +export type ReferenceItem = components['schemas']['ReferenceItem']; + +export type FileSearchRequest = components['schemas']['FileSearchRequest']; +export type FileSearchResponse = components['schemas']['FileSearchResponse']; +export type FileResultItem = components['schemas']['FileResultItem']; + +export type LoginRequest = components['schemas']['LoginRequest']; +export type LoginResponse = components['schemas']['LoginResponse']; +export type MeResponse = components['schemas']['MeResponse']; +export type ChangePasswordRequest = components['schemas']['ChangePasswordRequest']; +export type CreateUserRequest = components['schemas']['CreateUserRequest']; +export type UpdateUserRequest = components['schemas']['UpdateUserRequest']; +export type UserListResponse = components['schemas']['UserListResponse']; +export type CreateApiKeyRequest = components['schemas']['CreateApiKeyRequest']; +export type SessionListResponse = components['schemas']['SessionListResponse']; +export type BootstrapStatusResponse = components['schemas']['BootstrapStatusResponse']; + +export type RuntimeConfig = components['schemas']['RuntimeConfig']; +export type RuntimeConfigUpdate = components['schemas']['RuntimeConfigUpdate']; +export type RuntimeConfigRecommended = components['schemas']['RuntimeConfigRecommended']; +export type SidecarStatus = components['schemas']['SidecarStatus']; +export type ModelEntry = components['schemas']['ModelEntry']; +export type ModelList = components['schemas']['ModelList']; +export type RestartAccepted = components['schemas']['RestartAccepted']; diff --git a/server/dashboard/src/app/App.tsx b/server/dashboard/src/app/App.tsx new file mode 100644 index 0000000..260549b --- /dev/null +++ b/server/dashboard/src/app/App.tsx @@ -0,0 +1,75 @@ +import { Loader2 } from 'lucide-react'; +import { Navigate, Route, Routes } from 'react-router-dom'; +import { useAuth } from '@/auth/useAuth'; +import BootstrapNeededPage from '@/auth/BootstrapNeededPage'; +import ChangePasswordPage from '@/auth/ChangePasswordPage'; +import LoginPage from '@/auth/LoginPage'; +import { MODULES } from '@/modules/registry'; +import { Shell } from './Shell'; + +// Top-level auth + route gate. Three states branch off here: +// - bootstrap not done → BootstrapNeededPage (no other route works) +// - logged out → LoginPage (no Shell, no nav) +// - must change password → ChangePasswordPage (no Shell, no nav) +// - logged in & happy → Shell + module routes +// +// Module routes are derived from the registry — no manual entries +// per feature. Each module owns its `path` (relative to /dashboard) and +// renders whatever it likes inside. +export default function App() { + const { loading, needsBootstrap, user, mustChangePassword } = useAuth(); + + if (loading) { + return ( +
+ + Loading… +
+ ); + } + + if (needsBootstrap) return ; + + if (!user) { + return ( + + } /> + } /> + + ); + } + + if (mustChangePassword) { + return ( + + } /> + } /> + + ); + } + + // Authenticated + ready — render every registered module under the Shell. + // A module whose role gate excludes the current user simply has no + // mounted, so a deep link to it 404s back to /. + const visible = MODULES.filter((m) => { + if (!m.requiredRole) return true; + if (m.requiredRole === 'viewer') return true; + return user.role === 'admin'; + }); + + return ( + + + {visible.map((m) => { + // Modules can own a sub-tree by defining their own routes inside + // their element; we mount with a trailing wildcard so they get + // them on `//*`. + const mountPath = m.path === '/' ? '/*' : `${m.path}/*`; + const Element = m.element; + return } />; + })} + } /> + + + ); +} diff --git a/server/dashboard/src/app/Footer.tsx b/server/dashboard/src/app/Footer.tsx new file mode 100644 index 0000000..f772808 --- /dev/null +++ b/server/dashboard/src/app/Footer.tsx @@ -0,0 +1,73 @@ +import { Link } from 'react-router-dom'; +import { useServerStatus } from '@/lib/useServerStatus'; +import { useAuth } from '@/auth/useAuth'; +import { cn } from '@/lib/cn'; + +// Footer spans the full width below the sidebar + main pane. Reads +// from the shared /status query (polled every 30 s) — server version +// on the left, llama sidecar liveness dot on the right. The "llama" +// label links to /server (admin-only page); viewers see plain text +// since the route isn't mounted for them. +export function Footer() { + const { data, isLoading } = useServerStatus(); + const { user } = useAuth(); + const version = data?.server_version ?? 'dev'; + const alive = data?.model_loaded === true; + const isAdmin = user?.role === 'admin'; + + const dotClass = isLoading + ? 'bg-muted-foreground/40' + : alive + ? 'bg-emerald-500' + : 'bg-red-500'; + const dotTitle = isLoading + ? 'Checking sidecar status…' + : alive + ? 'Sidecar is alive' + : 'Sidecar is not responding'; + + const indicator = ( + <> + + llama + + ); + + return ( + + ); +} diff --git a/server/dashboard/src/app/Shell.tsx b/server/dashboard/src/app/Shell.tsx new file mode 100644 index 0000000..782e8e7 --- /dev/null +++ b/server/dashboard/src/app/Shell.tsx @@ -0,0 +1,24 @@ +import type { ReactNode } from 'react'; +import { Sidebar } from './Sidebar'; +import { Footer } from './Footer'; +import { UpdateBanner } from './UpdateBanner'; + +// Three-row layout: sidebar + main on top, footer spanning the full +// width on the bottom. min-h-0 on the inner row is required so that +//
's overflow-y-auto honors the footer's height when content +// grows tall. UpdateBanner sits above the main row so it spans the +// full width when a newer server release is available. +export function Shell({ children }: { children: ReactNode }) { + return ( +
+ +
+ +
+
{children}
+
+
+
+
+ ); +} diff --git a/server/dashboard/src/app/Sidebar.tsx b/server/dashboard/src/app/Sidebar.tsx new file mode 100644 index 0000000..6a1241e --- /dev/null +++ b/server/dashboard/src/app/Sidebar.tsx @@ -0,0 +1,76 @@ +import { LogOut } from 'lucide-react'; +import { NavLink } from 'react-router-dom'; +import { useAuth } from '@/auth/useAuth'; +import { Button } from '@/ui/button'; +import { cn } from '@/lib/cn'; +import { MODULES } from '@/modules/registry'; + +// Sidebar is rendered from the module registry, filtered by the current +// user's role. A module without `requiredRole` is always visible; a module +// requiring `admin` is hidden from viewers. +// +// New features show up in the sidebar automatically once registered — no +// edits to this component are needed when a module is added. +export function Sidebar() { + const { user, logout } = useAuth(); + const role = user?.role ?? 'viewer'; + + const visible = MODULES.filter((m) => { + if (!m.requiredRole) return true; + if (m.requiredRole === 'viewer') return true; + return role === 'admin'; + }); + + return ( + + ); +} diff --git a/server/dashboard/src/app/ThemeProvider.tsx b/server/dashboard/src/app/ThemeProvider.tsx new file mode 100644 index 0000000..f6e1028 --- /dev/null +++ b/server/dashboard/src/app/ThemeProvider.tsx @@ -0,0 +1,64 @@ +import { + createContext, + useCallback, + useContext, + useEffect, + useMemo, + useState, + type ReactNode, +} from 'react'; +import { + applyResolvedTheme, + readStoredTheme, + resolveTheme, + writeStoredTheme, + type ResolvedTheme, + type ThemeMode, +} from '@/lib/theme'; + +interface ThemeContextValue { + mode: ThemeMode; + resolved: ResolvedTheme; + setMode: (mode: ThemeMode) => void; +} + +const ThemeContext = createContext(null); + +export function ThemeProvider({ children }: { children: ReactNode }) { + const [mode, setModeState] = useState(() => readStoredTheme()); + const [resolved, setResolved] = useState(() => resolveTheme(mode)); + + // Apply class + persist whenever the mode changes. Includes a listener on + // `(prefers-color-scheme: dark)` for the 'system' mode so OS toggles flip + // the UI live without a reload. + useEffect(() => { + const next = resolveTheme(mode); + setResolved(next); + applyResolvedTheme(next); + + if (mode !== 'system') return; + const mql = window.matchMedia('(prefers-color-scheme: dark)'); + const handler = () => { + const r = mql.matches ? 'dark' : 'light'; + setResolved(r); + applyResolvedTheme(r); + }; + mql.addEventListener('change', handler); + return () => mql.removeEventListener('change', handler); + }, [mode]); + + const setMode = useCallback((next: ThemeMode) => { + writeStoredTheme(next); + setModeState(next); + }, []); + + const value = useMemo(() => ({ mode, resolved, setMode }), [mode, resolved, setMode]); + + return {children}; +} + +export function useTheme(): ThemeContextValue { + const ctx = useContext(ThemeContext); + if (!ctx) throw new Error('useTheme must be used inside '); + return ctx; +} diff --git a/server/dashboard/src/app/UpdateBanner.tsx b/server/dashboard/src/app/UpdateBanner.tsx new file mode 100644 index 0000000..0d06776 --- /dev/null +++ b/server/dashboard/src/app/UpdateBanner.tsx @@ -0,0 +1,78 @@ +import { useEffect, useState } from 'react'; +import { ArrowUpCircle, X } from 'lucide-react'; +import { useServerStatus } from '@/lib/useServerStatus'; +import { cn } from '@/lib/cn'; + +const dismissKey = (version: string) => `cix.update-dismissed.${version}`; + +// UpdateBanner renders at the top of the dashboard shell when the +// server-side version checker reports a newer `server/v*` release on +// GitHub. Dismissals are namespaced by the latest version, so dismissing +// 0.6.0 silences the banner only until 0.6.1 ships. +export function UpdateBanner() { + const { data } = useServerStatus(); + const latest = data?.latest_version ?? null; + const updateAvailable = data?.update_available === true && !!latest; + + const [dismissed, setDismissed] = useState(false); + + // Re-evaluate the localStorage flag whenever the latest version changes + // — a fresh release should re-show the banner even within an open tab. + useEffect(() => { + if (!latest) { + setDismissed(false); + return; + } + setDismissed(localStorage.getItem(dismissKey(latest)) === '1'); + }, [latest]); + + if (!updateAvailable || dismissed || !latest) return null; + + const onDismiss = () => { + localStorage.setItem(dismissKey(latest), '1'); + setDismissed(true); + }; + + return ( +
+ +
+ cix-server v{latest} is available + {data?.server_version ? ( + <> (you're running v{data.server_version}) + ) : null} + {data?.release_url ? ( + <> + {' — '} + + release notes + + + ) : null} +
+ +
+ ); +} diff --git a/server/dashboard/src/app/providers.tsx b/server/dashboard/src/app/providers.tsx new file mode 100644 index 0000000..ab3a324 --- /dev/null +++ b/server/dashboard/src/app/providers.tsx @@ -0,0 +1,51 @@ +import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; +import { useState, type ReactNode } from 'react'; +import { Toaster } from '@/ui/sonner'; +import { TooltipProvider } from '@/ui/tooltip'; +import { AuthProvider } from '@/auth/AuthProvider'; +import { ApiError } from '@/api/client'; +import { ThemeProvider } from './ThemeProvider'; + +// One place to wire app-level providers — order matters: +// 1. QueryClient: needed before AuthProvider, which uses useQuery for /me. +// 2. AuthProvider: hooks the whole app to the current session. +// 3. Toaster: rendered last so toasts paint above everything else. +export function AppProviders({ children }: { children: ReactNode }) { + // Lazy-init so a fast refresh doesn't lose in-flight queries. + const [client] = useState( + () => + new QueryClient({ + defaultOptions: { + queries: { + staleTime: 30_000, + gcTime: 5 * 60_000, + refetchOnWindowFocus: false, + // Default retry: 3 fast retries, but not on auth errors — those + // mean the cookie is gone, retrying just delays the redirect. + retry: (failureCount, error) => { + if (error instanceof ApiError && (error.status === 401 || error.status === 403)) { + return false; + } + return failureCount < 2; + }, + }, + mutations: { + // Mutations should never be auto-retried; the user clicked once, + // surface the failure once. + retry: false, + }, + }, + }) + ); + + return ( + + + + {children} + + + + + ); +} diff --git a/server/dashboard/src/auth/AuthProvider.tsx b/server/dashboard/src/auth/AuthProvider.tsx new file mode 100644 index 0000000..e793dfa --- /dev/null +++ b/server/dashboard/src/auth/AuthProvider.tsx @@ -0,0 +1,110 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { createContext, useCallback, useMemo, type ReactNode } from 'react'; +import { ApiError, api } from '@/api/client'; +import type { BootstrapStatusResponse, LoginRequest, LoginResponse, MeResponse, User } from '@/api/types'; + +// Shape exposed to components — kept narrow on purpose. Use `useAuth` to +// consume; `AuthProvider` is the only place that touches the underlying +// queries directly. +export interface AuthContextValue { + /** True while we're still figuring out the initial auth state. */ + loading: boolean; + /** True until the operator has done the first-run bootstrap. */ + needsBootstrap: boolean; + /** Currently authenticated user, or null when logged out. */ + user: User | null; + /** When true, the user must change their password before reaching the app. */ + mustChangePassword: boolean; + /** Performs the login flow + warms /me. Throws ApiError on failure. */ + login: (req: LoginRequest) => Promise; + /** Performs server-side logout + clears cached /me. */ + logout: () => Promise; + /** Re-fetches /me — call after the user changes their password. */ + refresh: () => Promise; +} + +export const AuthContext = createContext(null); + +// Two queries drive the auth state machine: +// +// 1. /auth/bootstrap-status — public; tells us whether *any* user exists. +// If `needs_bootstrap === true`, the dashboard renders the +// BootstrapNeededPage instead of the login form. +// 2. /auth/me — requires a session cookie. 401 means logged out; +// anything else is treated as an outage and surfaces the error. +export function AuthProvider({ children }: { children: ReactNode }) { + const qc = useQueryClient(); + + const bootstrap = useQuery({ + queryKey: ['auth', 'bootstrap-status'], + queryFn: () => api.get('/auth/bootstrap-status'), + staleTime: Infinity, + retry: false, + }); + + const me = useQuery({ + queryKey: ['auth', 'me'], + queryFn: async () => { + try { + return await api.get('/auth/me'); + } catch (err) { + if (err instanceof ApiError && err.status === 401) return null; + throw err; + } + }, + enabled: bootstrap.data?.needs_bootstrap === false, + staleTime: 60_000, + retry: false, + }); + + const loginMutation = useMutation({ + mutationFn: (req: LoginRequest) => api.post('/auth/login', req), + onSuccess: () => { + // /auth/me has a slightly richer envelope than /auth/login (carries + // auth_method); re-fetching is simpler than constructing a partial. + void qc.invalidateQueries({ queryKey: ['auth', 'me'] }); + }, + }); + + const logoutMutation = useMutation({ + mutationFn: () => api.post('/auth/logout'), + onSettled: () => { + qc.setQueryData(['auth', 'me'], null); + qc.removeQueries({ queryKey: ['auth', 'me'] }); + }, + }); + + const login = useCallback( + async (req: LoginRequest) => { + await loginMutation.mutateAsync(req); + }, + [loginMutation] + ); + + const logout = useCallback(async () => { + try { + await logoutMutation.mutateAsync(); + } catch { + // logout endpoint can fail if the cookie is already gone — that's fine + } + }, [logoutMutation]); + + const refresh = useCallback(async () => { + await qc.invalidateQueries({ queryKey: ['auth', 'me'] }); + }, [qc]); + + const value = useMemo( + () => ({ + loading: bootstrap.isLoading || (bootstrap.data?.needs_bootstrap === false && me.isLoading), + needsBootstrap: bootstrap.data?.needs_bootstrap ?? false, + user: me.data?.user ?? null, + mustChangePassword: me.data?.user?.must_change_password ?? false, + login, + logout, + refresh, + }), + [bootstrap.isLoading, bootstrap.data, me.isLoading, me.data, login, logout, refresh] + ); + + return {children}; +} diff --git a/server/dashboard/src/auth/BootstrapNeededPage.tsx b/server/dashboard/src/auth/BootstrapNeededPage.tsx new file mode 100644 index 0000000..e4a8fc3 --- /dev/null +++ b/server/dashboard/src/auth/BootstrapNeededPage.tsx @@ -0,0 +1,39 @@ +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; + +// Shown when /auth/bootstrap-status reports `needs_bootstrap: true` — +// i.e. the database has no users and the operator hasn't supplied the +// bootstrap admin env vars. There's nothing the visitor can do from the +// browser; this page exists to explain what to set on the server. +export default function BootstrapNeededPage() { + return ( +
+
+
+
Server not configured
+
+ cix-server has no users yet. An administrator must seed the first account before the dashboard becomes available. +
+
+ + + How to bootstrap the first admin + +

+ Restart the server with both of these environment variables set: +

+ 
+{`CIX_BOOTSTRAP_ADMIN_EMAIL=admin@example.com \\
+CIX_BOOTSTRAP_ADMIN_PASSWORD='change-me-on-first-login' \\
+./cix-server`}
+
+

+ On first login the admin will be required to change the + password. After that, both env vars are ignored on subsequent + starts. +

+ + +
+
+ ); +} diff --git a/server/dashboard/src/auth/ChangePasswordPage.tsx b/server/dashboard/src/auth/ChangePasswordPage.tsx new file mode 100644 index 0000000..30e72a1 --- /dev/null +++ b/server/dashboard/src/auth/ChangePasswordPage.tsx @@ -0,0 +1,115 @@ +import { useState, type FormEvent } from 'react'; +import { ApiError, api } from '@/api/client'; +import type { ChangePasswordRequest } from '@/api/types'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { toast } from '@/ui/sonner'; +import { useAuth } from './useAuth'; + +// Forced password-change page — reached either right after a bootstrap +// admin first logs in, or after an admin invite. Server-side: a successful +// POST /auth/change-password ALSO revokes every other session for this +// user, so we log out and bounce back to /login on success. +export default function ChangePasswordPage() { + const { logout } = useAuth(); + const [current, setCurrent] = useState(''); + const [next, setNext] = useState(''); + const [confirm, setConfirm] = useState(''); + const [submitting, setSubmitting] = useState(false); + const [error, setError] = useState(null); + + async function onSubmit(e: FormEvent) { + e.preventDefault(); + setError(null); + if (next !== confirm) { + setError('New password and confirmation must match.'); + return; + } + if (next.length < 8) { + setError('New password must be at least 8 characters.'); + return; + } + setSubmitting(true); + try { + const req: ChangePasswordRequest = { current_password: current, new_password: next }; + await api.post('/auth/change-password', req); + toast.success('Password updated. Please sign in with your new password.'); + // Server already invalidated this session — calling logout cleans up + // the cookie + clears cached /me so App.tsx falls back to LoginPage. + await logout(); + } catch (err) { + setError(err instanceof ApiError ? err.detail : 'Unexpected error. Try again.'); + } finally { + setSubmitting(false); + } + } + + return ( +
+
+
+
Change your password
+
+ For security, you must set a new password before continuing. +
+
+ +
+
+ + setCurrent(e.target.value)} + disabled={submitting} + /> +
+ +
+ + setNext(e.target.value)} + disabled={submitting} + /> +
+ +
+ + setConfirm(e.target.value)} + disabled={submitting} + /> +
+ + {error && ( + + Could not update password + {error} + + )} + + +
+
+
+ ); +} diff --git a/server/dashboard/src/auth/LoginPage.tsx b/server/dashboard/src/auth/LoginPage.tsx new file mode 100644 index 0000000..62f1e0f --- /dev/null +++ b/server/dashboard/src/auth/LoginPage.tsx @@ -0,0 +1,87 @@ +import { useState, type FormEvent } from 'react'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { useAuth } from './useAuth'; + +// Standalone full-page login form. Lives outside the Shell so the sidebar +// doesn't peek through. Successful login transitions the auth state and +// the parent App routes the user to /change-password or / accordingly. +export default function LoginPage() { + const { login } = useAuth(); + const [email, setEmail] = useState(''); + const [password, setPassword] = useState(''); + const [submitting, setSubmitting] = useState(false); + const [error, setError] = useState(null); + + async function onSubmit(e: FormEvent) { + e.preventDefault(); + setError(null); + setSubmitting(true); + try { + await login({ email, password }); + } catch (err) { + const detail = + err instanceof ApiError ? err.detail : 'Could not reach server. Try again.'; + setError(detail); + } finally { + setSubmitting(false); + } + } + + return ( +
+
+
+
cix dashboard
+
Sign in to continue
+
+ +
+
+ + setEmail(e.target.value)} + disabled={submitting} + /> +
+ +
+ + setPassword(e.target.value)} + disabled={submitting} + /> +
+ + {error && ( + + Login failed + {error} + + )} + + +
+ +

+ CLI users authenticate with API keys, not this form. +

+
+
+ ); +} diff --git a/server/dashboard/src/auth/useAuth.ts b/server/dashboard/src/auth/useAuth.ts new file mode 100644 index 0000000..fe530c4 --- /dev/null +++ b/server/dashboard/src/auth/useAuth.ts @@ -0,0 +1,13 @@ +import { useContext } from 'react'; +import { AuthContext, type AuthContextValue } from './AuthProvider'; + +// Hook for components to read the current auth state. Throws when used +// outside — that's a developer mistake, not a runtime +// condition we'd want to silently fall through. +export function useAuth(): AuthContextValue { + const ctx = useContext(AuthContext); + if (!ctx) { + throw new Error('useAuth must be used within '); + } + return ctx; +} diff --git a/server/dashboard/src/index.css b/server/dashboard/src/index.css new file mode 100644 index 0000000..5703ce5 --- /dev/null +++ b/server/dashboard/src/index.css @@ -0,0 +1,63 @@ +@tailwind base; +@tailwind components; +@tailwind utilities; + +/* shadcn/ui design tokens — neutral baseColor, Notion-like palette. + * Light is the default; .dark variants live alongside for the toggle that + * lands in PR-D. Keep both in sync when adjusting. */ +@layer base { + :root { + --background: 0 0% 100%; + --foreground: 0 0% 9%; + --card: 0 0% 100%; + --card-foreground: 0 0% 9%; + --popover: 0 0% 100%; + --popover-foreground: 0 0% 9%; + --primary: 0 0% 9%; + --primary-foreground: 0 0% 98%; + --secondary: 0 0% 96%; + --secondary-foreground: 0 0% 9%; + --muted: 0 0% 96%; + --muted-foreground: 0 0% 45%; + --accent: 0 0% 96%; + --accent-foreground: 0 0% 9%; + --destructive: 0 72% 51%; + --destructive-foreground: 0 0% 98%; + --border: 0 0% 90%; + --input: 0 0% 90%; + --ring: 0 0% 9%; + --radius: 0.5rem; + } + + .dark { + --background: 0 0% 7%; + --foreground: 0 0% 95%; + --card: 0 0% 9%; + --card-foreground: 0 0% 95%; + --popover: 0 0% 9%; + --popover-foreground: 0 0% 95%; + --primary: 0 0% 95%; + --primary-foreground: 0 0% 9%; + --secondary: 0 0% 14%; + --secondary-foreground: 0 0% 95%; + --muted: 0 0% 14%; + --muted-foreground: 0 0% 60%; + --accent: 0 0% 14%; + --accent-foreground: 0 0% 95%; + --destructive: 0 62% 45%; + --destructive-foreground: 0 0% 95%; + --border: 0 0% 18%; + --input: 0 0% 18%; + --ring: 0 0% 80%; + } +} + +@layer base { + * { + @apply border-border; + } + body { + @apply bg-background text-foreground; + font-feature-settings: 'rlig' 1, 'calt' 1; + } +} diff --git a/server/dashboard/src/lib/cn.ts b/server/dashboard/src/lib/cn.ts new file mode 100644 index 0000000..00a0be5 --- /dev/null +++ b/server/dashboard/src/lib/cn.ts @@ -0,0 +1,9 @@ +import { clsx, type ClassValue } from 'clsx'; +import { twMerge } from 'tailwind-merge'; + +// Standard shadcn helper — clsx for conditional classes + tailwind-merge to +// resolve conflicts (e.g. "px-2 px-4" → "px-4"). Used everywhere instead of +// raw className concatenation. +export function cn(...inputs: ClassValue[]): string { + return twMerge(clsx(inputs)); +} diff --git a/server/dashboard/src/lib/editorPreference.ts b/server/dashboard/src/lib/editorPreference.ts new file mode 100644 index 0000000..9cd5f4a --- /dev/null +++ b/server/dashboard/src/lib/editorPreference.ts @@ -0,0 +1,56 @@ +// Editor protocol preference. Persisted in localStorage; consumed by every +// "Open in editor" call site (currently search ResultSnippet). The default +// 'cursor' matches the prior hardcoded behaviour so users without a stored +// preference see no behaviour change. + +export type EditorProtocol = 'cursor' | 'vscode' | 'none'; + +export const EDITOR_STORAGE_KEY = 'cix.editor.protocol'; + +const VALID: ReadonlySet = new Set(['cursor', 'vscode', 'none']); + +export function getEditorPreference(): EditorProtocol { + if (typeof window === 'undefined') return 'cursor'; + try { + const v = window.localStorage.getItem(EDITOR_STORAGE_KEY); + if (v && VALID.has(v as EditorProtocol)) return v as EditorProtocol; + } catch { + /* localStorage may throw in privacy mode */ + } + return 'cursor'; +} + +export function setEditorPreference(p: EditorProtocol): void { + if (typeof window === 'undefined') return; + try { + window.localStorage.setItem(EDITOR_STORAGE_KEY, p); + } catch { + /* swallow — preference will reset on reload */ + } +} + +// CURSOR_FALLBACK_DELAY_MS — Cursor's URL handler usually takes ~100ms to +// pull focus on macOS. We give it 250ms before falling back to VS Code, +// which is long enough that a successful Cursor handle pre-empts the +// fallback navigation, and short enough that users without Cursor barely +// see a delay. +const CURSOR_FALLBACK_DELAY_MS = 250; + +export function openInEditor(absolutePath: string, line?: number): void { + const pref = getEditorPreference(); + if (pref === 'none') return; + + const suffix = typeof line === 'number' ? `:${line}` : ''; + const cursorURL = `cursor://file/${absolutePath}${suffix}`; + const vscodeURL = `vscode://file/${absolutePath}${suffix}`; + + if (pref === 'vscode') { + window.location.href = vscodeURL; + return; + } + // 'cursor' — try Cursor first, fall back to VS Code if no handler claims focus. + window.location.href = cursorURL; + window.setTimeout(() => { + window.location.href = vscodeURL; + }, CURSOR_FALLBACK_DELAY_MS); +} diff --git a/server/dashboard/src/lib/formatDate.ts b/server/dashboard/src/lib/formatDate.ts new file mode 100644 index 0000000..2c13d85 --- /dev/null +++ b/server/dashboard/src/lib/formatDate.ts @@ -0,0 +1,54 @@ +// Centralised date formatters so the whole UI stays consistent. +// +// All cix-server APIs emit RFC3339 strings (Go time.Time JSON default) or +// `null` for never-touched fields like `last_used_at`. Helpers here accept +// `string | null | undefined` to keep call sites concise. + +const DATE_FMT = new Intl.DateTimeFormat(undefined, { + year: 'numeric', + month: 'short', + day: 'numeric', +}); + +const TIME_FMT = new Intl.DateTimeFormat(undefined, { + hour: '2-digit', + minute: '2-digit', +}); + +export function formatDate(iso: string | null | undefined): string { + if (!iso) return '—'; + const d = new Date(iso); + if (Number.isNaN(d.getTime())) return iso; + return DATE_FMT.format(d); +} + +export function formatDateTime(iso: string | null | undefined): string { + if (!iso) return '—'; + const d = new Date(iso); + if (Number.isNaN(d.getTime())) return iso; + return `${DATE_FMT.format(d)}, ${TIME_FMT.format(d)}`; +} + +const RTF = new Intl.RelativeTimeFormat(undefined, { numeric: 'auto' }); + +const STEPS: Array<[Intl.RelativeTimeFormatUnit, number]> = [ + ['year', 60 * 60 * 24 * 365], + ['month', 60 * 60 * 24 * 30], + ['day', 60 * 60 * 24], + ['hour', 60 * 60], + ['minute', 60], + ['second', 1], +]; + +export function formatRelative(iso: string | null | undefined): string { + if (!iso) return 'never'; + const then = new Date(iso).getTime(); + if (Number.isNaN(then)) return iso; + const seconds = Math.round((then - Date.now()) / 1000); + for (const [unit, secs] of STEPS) { + if (Math.abs(seconds) >= secs || unit === 'second') { + return RTF.format(Math.round(seconds / secs), unit); + } + } + return 'just now'; +} diff --git a/server/dashboard/src/lib/theme.ts b/server/dashboard/src/lib/theme.ts new file mode 100644 index 0000000..bb4cff9 --- /dev/null +++ b/server/dashboard/src/lib/theme.ts @@ -0,0 +1,46 @@ +// Theme storage + system-preference resolution. Mirrors the inline script +// in index.html — keep the storage key + values in sync with that script +// (otherwise the anti-flash hint and the React state diverge on first paint). + +export type ThemeMode = 'light' | 'dark' | 'system'; +export type ResolvedTheme = 'light' | 'dark'; + +export const THEME_STORAGE_KEY = 'cix.theme'; + +const VALID_MODES: ReadonlySet = new Set(['light', 'dark', 'system']); + +export function readStoredTheme(): ThemeMode { + if (typeof window === 'undefined') return 'system'; + try { + const v = window.localStorage.getItem(THEME_STORAGE_KEY); + if (v && VALID_MODES.has(v as ThemeMode)) return v as ThemeMode; + } catch { + /* localStorage may throw in privacy mode */ + } + return 'system'; +} + +export function writeStoredTheme(mode: ThemeMode): void { + if (typeof window === 'undefined') return; + try { + window.localStorage.setItem(THEME_STORAGE_KEY, mode); + } catch { + /* swallow — theme will reset on reload */ + } +} + +export function resolveSystemTheme(): ResolvedTheme { + if (typeof window === 'undefined' || !window.matchMedia) return 'light'; + return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'; +} + +export function resolveTheme(mode: ThemeMode): ResolvedTheme { + return mode === 'system' ? resolveSystemTheme() : mode; +} + +export function applyResolvedTheme(resolved: ResolvedTheme): void { + if (typeof document === 'undefined') return; + const root = document.documentElement; + if (resolved === 'dark') root.classList.add('dark'); + else root.classList.remove('dark'); +} diff --git a/server/dashboard/src/lib/useServerStatus.ts b/server/dashboard/src/lib/useServerStatus.ts new file mode 100644 index 0000000..049bbce --- /dev/null +++ b/server/dashboard/src/lib/useServerStatus.ts @@ -0,0 +1,42 @@ +import { useQuery } from '@tanstack/react-query'; +import { api } from '@/api/client'; + +interface StatusPayload { + server_version: string; + embedding_model: string; + model_loaded: boolean; + // Version-check fields are present only when the server has the + // versioncheck service wired (see CIX_VERSION_CHECK_ENABLED). + update_available?: boolean; + latest_version?: string | null; + release_url?: string | null; + version_check?: { + enabled: boolean; + checked_at?: string | null; + error?: string | null; + }; +} + +// useServerStatus polls /api/v1/status every 30 seconds. The footer +// reads server_version + model_loaded; the Projects drift indicator +// reads embedding_model. /status is auth-only (not admin-only) so +// viewers also see the footer indicator. model_loaded is set by an +// active Ready(ctx) ping, so it tracks actual sidecar liveness. +// +// queryKey is kept as ['runtime-model'] because server/hooks.ts +// invalidates that key after a sidecar restart to refresh drift +// immediately. +export function useServerStatus() { + return useQuery({ + queryKey: ['runtime-model'], + queryFn: ({ signal }) => api.get('/status', { signal }), + refetchInterval: 30_000, + refetchIntervalInBackground: false, + staleTime: 30_000, + }); +} + +export function useRuntimeModel() { + const { data } = useServerStatus(); + return data?.embedding_model ?? ''; +} diff --git a/server/dashboard/src/main.tsx b/server/dashboard/src/main.tsx new file mode 100644 index 0000000..f42e509 --- /dev/null +++ b/server/dashboard/src/main.tsx @@ -0,0 +1,22 @@ +import { StrictMode } from 'react'; +import { createRoot } from 'react-dom/client'; +import { BrowserRouter } from 'react-router-dom'; +import App from './app/App.tsx'; +import { AppProviders } from './app/providers.tsx'; +import './index.css'; + +const root = document.getElementById('root'); +if (!root) throw new Error('cix-dashboard: #root not found in index.html'); + +// React Router lives at /dashboard so all in-app paths are relative to that +// prefix. The Go server returns the same index.html for any /dashboard/* +// URL so a deep refresh still boots the SPA, then BrowserRouter takes over. +createRoot(root).render( + + + + + + + +); diff --git a/server/dashboard/src/modules/api-keys/ApiKeysPage.tsx b/server/dashboard/src/modules/api-keys/ApiKeysPage.tsx new file mode 100644 index 0000000..c75a52f --- /dev/null +++ b/server/dashboard/src/modules/api-keys/ApiKeysPage.tsx @@ -0,0 +1,101 @@ +import { useMemo, useState } from 'react'; +import { AlertCircle, KeyRound } from 'lucide-react'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Skeleton } from '@/ui/skeleton'; +import { Tabs, TabsList, TabsTrigger } from '@/ui/tabs'; +import { useAuth } from '@/auth/useAuth'; +import { ApiKeyTable } from './components/ApiKeyTable'; +import { CreateApiKeyDialog } from './components/CreateApiKeyDialog'; +import { useAllApiKeys, useMyApiKeys } from './hooks'; + +type Mode = 'mine' | 'all'; + +export default function ApiKeysPage() { + const { user } = useAuth(); + const isAdmin = user?.role === 'admin'; + const [mode, setMode] = useState('mine'); + + const mine = useMyApiKeys(); + // Only fetch the All bucket when admin actively switches to it — avoids + // a wasted request and a redundant refetch on viewers (server would 403). + const all = useAllApiKeys(isAdmin && mode === 'all'); + + const active = mode === 'all' && isAdmin ? all : mine; + const keys = active.data?.api_keys ?? []; + + const ownerEmailLookup = useMemo(() => { + // The Owner column would ideally show emails, but the api-keys endpoint + // returns owner_user_id only. Resolving emails would need /admin/users — + // skipping that JOIN here keeps this page lean. Render a short id slice + // until a follow-up adds the lookup. Self-key is highlighted via + // canRevoke ownership so the audit trail still works. + return (id: string) => + id === user?.id ? user.email : undefined; + }, [user?.id, user?.email]); + + return ( +
+
+
+

API keys

+

+ Bearer tokens for CLI / SDK access. Created here, revoked here. +

+
+ +
+ + {isAdmin ? ( + setMode(v as Mode)}> + + My keys + All keys (admin) + + + ) : null} + + {active.isLoading ? ( +
+ {Array.from({ length: 4 }).map((_, i) => ( + + ))} +
+ ) : active.error ? ( + + + Failed to load API keys + + {active.error instanceof ApiError ? active.error.detail : String(active.error)} + + + ) : keys.length === 0 ? ( + + ) : ( + isAdmin || k.owner_user_id === user?.id} + /> + )} +
+ ); +} + +function EmptyState({ mode, isAdmin }: { mode: Mode; isAdmin: boolean }) { + return ( +
+ +
+

+ {mode === 'all' && isAdmin ? 'No API keys exist yet' : 'You have no API keys yet'} +

+

+ Create one to authenticate the cix{' '} + CLI from a workstation. +

+
+
+ ); +} diff --git a/server/dashboard/src/modules/api-keys/components/ApiKeyTable.tsx b/server/dashboard/src/modules/api-keys/components/ApiKeyTable.tsx new file mode 100644 index 0000000..482e6a9 --- /dev/null +++ b/server/dashboard/src/modules/api-keys/components/ApiKeyTable.tsx @@ -0,0 +1,87 @@ +import type { ApiKey } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { + Table, + TableBody, + TableCell, + TableHead, + TableHeader, + TableRow, +} from '@/ui/table'; +import { cn } from '@/lib/cn'; +import { formatDateTime, formatRelative } from '@/lib/formatDate'; +import { RevokeApiKeyDialog } from './RevokeApiKeyDialog'; + +interface Props { + keys: ApiKey[]; + /** Owner column appears in admin "All keys" mode. */ + showOwner?: boolean; + /** Maps owner_user_id → email for the Owner column. Omit when showOwner is false. */ + ownerEmail?: (id: string) => string | undefined; + /** Whether the current viewer can revoke a row. Server enforces too. */ + canRevoke: (key: ApiKey) => boolean; +} + +export function ApiKeyTable({ keys, showOwner = false, ownerEmail, canRevoke }: Props) { + return ( +
+ + + + Name + Prefix + {showOwner ? Owner : null} + Created + Last used + Last IP + Actions + + + + {keys.map((k) => { + const revoked = Boolean(k.revoked); + return ( + + +
+ {k.name} + {revoked ? revoked : null} +
+ + {k.prefix}… + {showOwner ? ( + + {ownerEmail?.(k.owner_user_id) ?? k.owner_user_id.slice(0, 8)} + + ) : null} + + {formatRelative(k.created_at)} + + + {formatRelative(k.last_used_at)} + + + {k.last_used_ip ?? '—'} + + + {revoked || !canRevoke(k) ? null : ( + + )} + + + ); + })} + +
+
+ ); +} diff --git a/server/dashboard/src/modules/api-keys/components/CreateApiKeyDialog.tsx b/server/dashboard/src/modules/api-keys/components/CreateApiKeyDialog.tsx new file mode 100644 index 0000000..4b56de6 --- /dev/null +++ b/server/dashboard/src/modules/api-keys/components/CreateApiKeyDialog.tsx @@ -0,0 +1,242 @@ +import { useEffect, useRef, useState } from 'react'; +import { Check, Copy, Loader2, KeyRound, AlertTriangle } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from '@/ui/dialog'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { useCreateApiKey } from '../hooks'; + +// Last-resort copy when the async Clipboard API isn't available — happens +// on plain HTTP deploys (non-localhost) and inside some embedded webviews. +// document.execCommand('copy') is deprecated but universally implemented as +// of 2026; keeping it as a fallback turns "no way to copy" into "always works". +function legacyCopy(text: string): boolean { + if (typeof document === 'undefined') return false; + const ta = document.createElement('textarea'); + ta.value = text; + ta.setAttribute('readonly', ''); + ta.style.position = 'fixed'; + ta.style.opacity = '0'; + document.body.appendChild(ta); + ta.focus(); + ta.select(); + let ok = false; + try { + ok = document.execCommand('copy'); + } catch { + ok = false; + } + document.body.removeChild(ta); + return ok; +} + +// Two-stage dialog: collect a name, then reveal the freshly minted key once. +// Once revealed, the dialog refuses outside-click and Escape — accidental +// dismissal would lose the unrecoverable secret. Only the explicit "I've +// saved it" / X button can close it. +export function CreateApiKeyDialog() { + const [open, setOpen] = useState(false); + const [name, setName] = useState(''); + const [revealed, setRevealed] = useState(null); + const [copied, setCopied] = useState(false); + const inputRef = useRef(null); + const create = useCreateApiKey(); + + // Auto-select the revealed key as soon as it appears so users can ⌘C + // immediately if the Copy button doesn't work in their context. + useEffect(() => { + if (revealed && inputRef.current) { + inputRef.current.focus(); + inputRef.current.select(); + } + }, [revealed]); + + function reset() { + setName(''); + setRevealed(null); + setCopied(false); + create.reset(); + } + + async function onCreate() { + const trimmed = name.trim(); + if (!trimmed) return; + try { + const out = await create.mutateAsync({ name: trimmed }); + setRevealed(out.full_key); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Failed to create API key', { description: detail }); + } + } + + async function copyToClipboard() { + if (!revealed) return; + // navigator.clipboard requires a secure context (HTTPS or localhost). On + // bare-IP / HTTP deploys it throws — fall back to document.execCommand + // through a transient textarea so users still get one-click copy. + try { + if (window.isSecureContext && navigator.clipboard?.writeText) { + await navigator.clipboard.writeText(revealed); + } else { + if (!legacyCopy(revealed)) throw new Error('legacy copy failed'); + } + setCopied(true); + window.setTimeout(() => setCopied(false), 2000); + } catch { + toast.error('Could not copy automatically.', { + description: 'Click the field, ⌘A / Ctrl-A to select, then copy.', + }); + } + } + + return ( + { + // Once a key is revealed, only the explicit "I've saved it" button + // (or close-X) may dismiss the dialog. Outside-click and Escape are + // blocked at the DialogContent layer below; we still gate state-resets + // here so a sibling dismiss path can't wipe the key silently. + if (!next && revealed) return; + setOpen(next); + if (!next) reset(); + }} + > + + + + { + if (revealed) e.preventDefault(); + }} + onEscapeKeyDown={(e) => { + if (revealed) e.preventDefault(); + }} + onInteractOutside={(e) => { + if (revealed) e.preventDefault(); + }} + > + {revealed ? ( + <> + + API key created + + Copy and store this key now. You will not be able to view it again. + + + + + Save it before closing + + The full value is shown exactly once. We store only a SHA-256 + hash; if you lose it you must revoke and create a new key. + + +
+ +
+ {/* readonly Input + select-all-on-focus is the most reliable + fallback when navigator.clipboard is unavailable (e.g. HTTP + deploys without a secure context). User can always ⌘A → ⌘C. */} + e.currentTarget.select()} + onClick={(e) => e.currentTarget.select()} + /> + +
+

+ Click the field to select all, then ⌘C / Ctrl-C if the Copy + button is blocked by your browser. +

+
+ + + + + ) : ( + <> + + Create API key + + Generate a long-lived bearer token for CLI / SDK use. The full key + is shown once and never stored in plaintext. + + +
+ + setName(e.target.value)} + placeholder="e.g. ci-bot, laptop, jenkins" + autoFocus + onKeyDown={(e) => { + if (e.key === 'Enter') { + e.preventDefault(); + void onCreate(); + } + }} + /> +
+ + + + + + )} + + + ); +} diff --git a/server/dashboard/src/modules/api-keys/components/RevokeApiKeyDialog.tsx b/server/dashboard/src/modules/api-keys/components/RevokeApiKeyDialog.tsx new file mode 100644 index 0000000..db4b5e2 --- /dev/null +++ b/server/dashboard/src/modules/api-keys/components/RevokeApiKeyDialog.tsx @@ -0,0 +1,73 @@ +import { useState } from 'react'; +import { Loader2, Trash2 } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from '@/ui/dialog'; +import { useRevokeApiKey } from '../hooks'; + +export function RevokeApiKeyDialog({ + id, + name, + prefix, +}: { + id: string; + name: string; + prefix: string; +}) { + const [open, setOpen] = useState(false); + const revoke = useRevokeApiKey(); + + async function onConfirm() { + try { + await revoke.mutateAsync(id); + toast.success('API key revoked', { description: name }); + setOpen(false); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Failed to revoke key', { description: detail }); + } + } + + return ( + + + + + + + Revoke this API key? + + Any client using {prefix}… ({name}) + will start receiving 401 immediately. The audit row stays in the + database but the key cannot authenticate again. + + + + + + + + + ); +} diff --git a/server/dashboard/src/modules/api-keys/hooks.ts b/server/dashboard/src/modules/api-keys/hooks.ts new file mode 100644 index 0000000..02e0e96 --- /dev/null +++ b/server/dashboard/src/modules/api-keys/hooks.ts @@ -0,0 +1,53 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { + ApiKeyCreated, + ApiKeyListResponse, + CreateApiKeyRequest, +} from '@/api/types'; + +// Owned-keys vs admin-only "all keys" view share an endpoint differentiated +// by the `?owner=all` query param. Two cache buckets so an admin toggling +// between the views doesn't see a stale slice from the other. +export const apiKeyKeys = { + mine: ['apikeys', 'mine'] as const, + all: ['apikeys', 'all'] as const, +}; + +export function useMyApiKeys() { + return useQuery({ + queryKey: apiKeyKeys.mine, + queryFn: ({ signal }) => api.get('/api-keys', { signal }), + }); +} + +export function useAllApiKeys(enabled: boolean) { + return useQuery({ + queryKey: apiKeyKeys.all, + queryFn: ({ signal }) => + api.get('/api-keys', { signal, query: { owner: 'all' } }), + enabled, + }); +} + +export function useCreateApiKey() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (body: CreateApiKeyRequest) => api.post('/api-keys', body), + onSuccess: () => { + qc.invalidateQueries({ queryKey: apiKeyKeys.mine }); + qc.invalidateQueries({ queryKey: apiKeyKeys.all }); + }, + }); +} + +export function useRevokeApiKey() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (id: string) => api.delete(`/api-keys/${id}`), + onSuccess: () => { + qc.invalidateQueries({ queryKey: apiKeyKeys.mine }); + qc.invalidateQueries({ queryKey: apiKeyKeys.all }); + }, + }); +} diff --git a/server/dashboard/src/modules/api-keys/index.ts b/server/dashboard/src/modules/api-keys/index.ts new file mode 100644 index 0000000..a83d94e --- /dev/null +++ b/server/dashboard/src/modules/api-keys/index.ts @@ -0,0 +1,12 @@ +import { KeyRound } from 'lucide-react'; +import type { Module } from '../types'; +import ApiKeysPage from './ApiKeysPage'; + +export const ApiKeysModule: Module = { + id: 'api-keys', + label: 'API Keys', + icon: KeyRound, + path: '/api-keys', + element: ApiKeysPage, + weight: 30, +}; diff --git a/server/dashboard/src/modules/home/HomePage.tsx b/server/dashboard/src/modules/home/HomePage.tsx new file mode 100644 index 0000000..e8511dd --- /dev/null +++ b/server/dashboard/src/modules/home/HomePage.tsx @@ -0,0 +1,120 @@ +import { NavLink } from 'react-router-dom'; +import { useAuth } from '@/auth/useAuth'; +import { useServerStatus } from '@/lib/useServerStatus'; +import { Card, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { cn } from '@/lib/cn'; +import { MODULES } from '../registry'; + +// One-line pitch per module — kept here (not on the Module type) so the +// sidebar stays terse and only the landing page carries the prose. +const DESCRIPTIONS: Record = { + projects: + 'Browse indexed repositories, inspect stats, copy reindex commands, and watch for stale-model drift.', + search: + 'Five modes — semantic, symbols, references, definitions, files — across every project from one bar.', + 'api-keys': + 'Mint long-lived API keys for CLI / CI use, scope them to a role, revoke at any time.', + users: 'Invite teammates, set roles, reset passwords, and audit access.', + settings: 'Personal preferences — theme, default editor, change password.', + server: + 'Tune the embedding model and llama-server runtime, restart the sidecar without dropping into SSH.', +}; + +export default function HomePage() { + const { user } = useAuth(); + const role = user?.role ?? 'viewer'; + const { data: status } = useServerStatus(); + + const cards = MODULES.filter((m) => m.id !== 'home').filter((m) => { + if (!m.requiredRole) return true; + if (m.requiredRole === 'viewer') return true; + return role === 'admin'; + }); + + return ( +
+
+

+ Welcome back{user?.email ? `, ${user.email}` : ''} +

+

+ The cix dashboard — semantic code search, project management, and runtime control. +

+
+ + {status && ( +
+ + + +
+ )} + +
+

Modules

+
+ {cards.map((m) => { + const Icon = m.icon; + return ( + + + +
+ + {m.label} +
+ {DESCRIPTIONS[m.id] ?? ''} + + + + ); + })} +
+
+ +

+ Prefer the terminal? cix --help{' '} + does everything the dashboard does, plus reindex, watch, and bulk operations. +

+
+ ); +} + +function StatusStat({ + label, + value, + mono, + tone, +}: { + label: string; + value: string; + mono?: boolean; + tone?: 'ok' | 'warn'; +}) { + return ( +
+
{label}
+
+ {value} +
+
+ ); +} diff --git a/server/dashboard/src/modules/home/index.ts b/server/dashboard/src/modules/home/index.ts new file mode 100644 index 0000000..1b94f96 --- /dev/null +++ b/server/dashboard/src/modules/home/index.ts @@ -0,0 +1,15 @@ +import { Home } from 'lucide-react'; +import type { Module } from '../types'; +import HomePage from './HomePage'; + +// Landing page for /dashboard/. Renders a status strip + cards for every +// module the user can see, driven by the registry — new features show up +// here automatically. +export const HomeModule: Module = { + id: 'home', + label: 'Home', + icon: Home, + path: '/', + element: HomePage, + weight: 0, +}; diff --git a/server/dashboard/src/modules/projects/ProjectDetailPage.tsx b/server/dashboard/src/modules/projects/ProjectDetailPage.tsx new file mode 100644 index 0000000..6a475f1 --- /dev/null +++ b/server/dashboard/src/modules/projects/ProjectDetailPage.tsx @@ -0,0 +1,229 @@ +import { AlertCircle, AlertTriangle, ArrowLeft, Search } from 'lucide-react'; +import { Link, useParams } from 'react-router-dom'; +import { ApiError } from '@/api/client'; +import type { Project } from '@/api/types'; +import { useAuth } from '@/auth/useAuth'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Badge } from '@/ui/badge'; +import { Button } from '@/ui/button'; +import { Card, CardContent } from '@/ui/card'; +import { Skeleton } from '@/ui/skeleton'; +import { formatDateTime, formatRelative } from '@/lib/formatDate'; +import { useRuntimeModel } from '@/lib/useServerStatus'; +import { DeleteProjectDialog } from './components/DeleteProjectDialog'; +import { ProjectInfoCard } from './components/ProjectInfoCard'; +import { useProject, useProjectSummary } from './hooks'; + +const STATUS_VARIANT: Record = { + created: 'outline', + indexing: 'secondary', + indexed: 'default', + error: 'destructive', +}; + +export function ProjectDetailPage() { + const { id } = useParams<{ id: string }>(); + const { user } = useAuth(); + const isAdmin = user?.role === 'admin'; + const project = useProject(id); + const summary = useProjectSummary(id); + const currentModel = useRuntimeModel(); + + if (project.isLoading) return ; + if (project.error || !project.data) { + return ( + + + Project not found + + {project.error instanceof ApiError ? project.error.detail : 'Unknown error'} + +
+ +
+ + ); + } + + const p = project.data; + const s = summary.data; + const drift = !!p.indexed_with_model && !!currentModel && p.indexed_with_model !== currentModel; + + return ( +
+
+ +
+ +
+
+ + {p.status} + + {p.languages.slice(0, 6).map((l) => ( + + {l} + + ))} +
+

+ {p.host_path} +

+
+ Hash: {p.path_hash} + Created {formatRelative(p.created_at)} + + {p.last_indexed_at + ? `Indexed ${formatRelative(p.last_indexed_at)} (${formatDateTime(p.last_indexed_at)})` + : 'Never indexed'} + +
+
+ + {isAdmin ? ( + + ) : null} +
+
+ + {drift ? ( + + + Indexed with a stale embedding model + +
+ This project's vectors were produced under{' '} + {p.indexed_with_model}, + but the sidecar is currently running{' '} + {currentModel}. + Search results may be incorrect or empty until the project is reindexed. +
+
+ Reindex from your terminal:{' '} + cix reindex {p.host_path} +
+ + + ) : null} + +
+ + + + +
+ + + +
+
+

Top directories

+ {summary.isLoading ? ( + + ) : !s || s.top_directories.length === 0 ? ( +

No directories yet.

+ ) : ( + + + {s.top_directories.map((d) => ( +
+ {d.path} + + {d.file_count.toLocaleString()} {d.file_count === 1 ? 'file' : 'files'} + +
+ ))} + + + )} +
+ +
+

Recent symbols

+ {summary.isLoading ? ( + + ) : !s || s.recent_symbols.length === 0 ? ( +

No symbols indexed yet.

+ ) : ( + + + {s.recent_symbols.slice(0, 12).map((sym, i) => ( +
+ + {sym.kind} + +
+
{sym.name}
+
+ {sym.file_path} +
+
+ {sym.language} +
+ ))} + + + )} +
+
+ + + Reindexing + + Indexing reads files from the local filesystem and is driven by the CLI. Run{' '} + cix reindex for a one-shot + rescan, or keep cix watch{' '} + running for automatic updates on file change. + + +
+ ); +} + +function StatCard({ label, value, sub }: { label: string; value: number; sub?: string }) { + return ( + + +
{label}
+
{value.toLocaleString()}
+ {sub ?
{sub}
: null} + + + ); +} + +function DetailSkeleton() { + return ( +
+ + +
+ {Array.from({ length: 4 }).map((_, i) => ( + + ))} +
+
+ + +
+
+ ); +} diff --git a/server/dashboard/src/modules/projects/ProjectsListPage.tsx b/server/dashboard/src/modules/projects/ProjectsListPage.tsx new file mode 100644 index 0000000..97bfc5d --- /dev/null +++ b/server/dashboard/src/modules/projects/ProjectsListPage.tsx @@ -0,0 +1,61 @@ +import { AlertCircle, FolderPlus } from 'lucide-react'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Skeleton } from '@/ui/skeleton'; +import { ApiError } from '@/api/client'; +import { ProjectCard } from './components/ProjectCard'; +import { useProjects } from './hooks'; + +export function ProjectsListPage() { + const { data, error, isLoading } = useProjects(); + + return ( +
+
+

Projects

+

+ {data ? `${data.total} indexed ${data.total === 1 ? 'project' : 'projects'}` : ' '} +

+
+ + {isLoading ? ( +
+ {Array.from({ length: 6 }).map((_, i) => ( + + ))} +
+ ) : error ? ( + + + Failed to load projects + + {error instanceof ApiError ? error.detail : String(error)} + + + ) : !data || data.projects.length === 0 ? ( + + ) : ( +
+ {data.projects.map((p) => ( + + ))} +
+ )} +
+ ); +} + +function EmptyState() { + return ( +
+ +
+

No projects yet

+

+ Register a project from the CLI with{' '} + cix init <path>. + A GitHub source will land here in a future PR. +

+
+
+ ); +} diff --git a/server/dashboard/src/modules/projects/ProjectsPage.tsx b/server/dashboard/src/modules/projects/ProjectsPage.tsx new file mode 100644 index 0000000..77017f5 --- /dev/null +++ b/server/dashboard/src/modules/projects/ProjectsPage.tsx @@ -0,0 +1,12 @@ +import { Route, Routes } from 'react-router-dom'; +import { ProjectsListPage } from './ProjectsListPage'; +import { ProjectDetailPage } from './ProjectDetailPage'; + +export default function ProjectsPage() { + return ( + + } /> + } /> + + ); +} diff --git a/server/dashboard/src/modules/projects/components/DeleteProjectDialog.tsx b/server/dashboard/src/modules/projects/components/DeleteProjectDialog.tsx new file mode 100644 index 0000000..4ec7305 --- /dev/null +++ b/server/dashboard/src/modules/projects/components/DeleteProjectDialog.tsx @@ -0,0 +1,72 @@ +import { useState } from 'react'; +import { Loader2, Trash2 } from 'lucide-react'; +import { useNavigate } from 'react-router-dom'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from '@/ui/dialog'; +import { useDeleteProject } from '../hooks'; + +export function DeleteProjectDialog({ + hash, + hostPath, + redirectAfter = false, +}: { + hash: string; + hostPath: string; + redirectAfter?: boolean; +}) { + const [open, setOpen] = useState(false); + const del = useDeleteProject(); + const navigate = useNavigate(); + + async function onConfirm() { + try { + await del.mutateAsync(hash); + toast.success('Project deleted', { description: hostPath }); + setOpen(false); + if (redirectAfter) navigate('/projects'); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Failed to delete project', { description: detail }); + } + } + + return ( + + + + + + + Delete this project? + + This removes the project record and all indexed chunks, symbols, and references for{' '} + {hostPath}. The files on disk are + not touched. This cannot be undone. + + + + + + + + + ); +} diff --git a/server/dashboard/src/modules/projects/components/ProjectCard.tsx b/server/dashboard/src/modules/projects/components/ProjectCard.tsx new file mode 100644 index 0000000..4b17b5e --- /dev/null +++ b/server/dashboard/src/modules/projects/components/ProjectCard.tsx @@ -0,0 +1,90 @@ +import { Link } from 'react-router-dom'; +import { AlertTriangle, ChevronRight, Database, FileText } from 'lucide-react'; +import type { Project } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { Card, CardContent } from '@/ui/card'; +import { formatRelative } from '@/lib/formatDate'; +import { useRuntimeModel } from '@/lib/useServerStatus'; + +function basename(p: string): string { + const parts = p.replace(/\/+$/, '').split('/'); + return parts[parts.length - 1] || p; +} + +const STATUS_VARIANT: Record = { + created: 'outline', + indexing: 'secondary', + indexed: 'default', + error: 'destructive', +}; + +export function ProjectCard({ project }: { project: Project }) { + const currentModel = useRuntimeModel(); + // Drift = the project was indexed under a different model than the one + // the sidecar is running right now. NULL indexed_with_model is a legacy + // row from before drift tracking landed — not drift, just unknown. + const drift = + !!project.indexed_with_model && + !!currentModel && + project.indexed_with_model !== currentModel; + + return ( + + + +
+
+
+ {basename(project.host_path)} +
+
+ {project.host_path} +
+
+ +
+
+ + {project.status} + + {drift ? ( + + + Stale model + + ) : null} + {project.languages.slice(0, 4).map((l) => ( + + {l} + + ))} + {project.languages.length > 4 ? ( + +{project.languages.length - 4} + ) : null} +
+
+ + + {project.stats.indexed_files.toLocaleString()} files + + + + {project.stats.total_symbols.toLocaleString()} symbols + + + {project.last_indexed_at + ? `Indexed ${formatRelative(project.last_indexed_at)}` + : 'Never indexed'} + +
+ + + + ); +} diff --git a/server/dashboard/src/modules/projects/components/ProjectInfoCard.tsx b/server/dashboard/src/modules/projects/components/ProjectInfoCard.tsx new file mode 100644 index 0000000..84f4ec5 --- /dev/null +++ b/server/dashboard/src/modules/projects/components/ProjectInfoCard.tsx @@ -0,0 +1,90 @@ +import type { Project } from '@/api/types'; +import { Card, CardContent, CardHeader, CardTitle } from '@/ui/card'; +import { formatDateTime, formatRelative } from '@/lib/formatDate'; + +function formatBytes(bytes?: number | null): string { + if (!bytes || bytes <= 0) return '—'; + const units = ['B', 'KB', 'MB', 'GB', 'TB']; + let i = 0; + let v = bytes; + while (v >= 1024 && i < units.length - 1) { + v /= 1024; + i++; + } + return `${v.toFixed(v < 10 ? 1 : 0)} ${units[i]}`; +} + +// ProjectInfoCard surfaces metadata that would otherwise require SSH'ing +// onto the box: which embedding model produced the vectors, where the +// SQLite + chromem-go state for this project lives, on-disk sizes. +// Storage fields are nullable — embeddings-disabled servers don't have +// resolvable paths and we want to render gracefully rather than show "0 B". +export function ProjectInfoCard({ project }: { project: Project }) { + return ( + + + Storage & index info + + +
+ + {project.indexed_with_model ? ( + {project.indexed_with_model} + ) : ( + Unknown (indexed before drift tracking landed) + )} + + + {project.last_indexed_at ? ( + <> + {formatRelative(project.last_indexed_at)}{' '} + ({formatDateTime(project.last_indexed_at)}) + + ) : ( + Never + )} + + +
+ {project.sqlite_path ? ( + {project.sqlite_path} + ) : ( + Not available + )} + {project.sqlite_size_bytes ? ( +
{formatBytes(project.sqlite_size_bytes)}
+ ) : null} +
+ + +
+ {project.chroma_path ? ( + {project.chroma_path} + ) : ( + Not available + )} + {project.chroma_size_bytes ? ( +
{formatBytes(project.chroma_size_bytes)}
+ ) : null} +
+ + + {project.stats.total_chunks.toLocaleString()} + + + {project.stats.total_symbols.toLocaleString()} + +
+ + + ); +} + +function Row({ label, children }: { label: string; children: React.ReactNode }) { + return ( + <> +
{label}
+
{children}
+ + ); +} diff --git a/server/dashboard/src/modules/projects/hooks.ts b/server/dashboard/src/modules/projects/hooks.ts new file mode 100644 index 0000000..10a0ca1 --- /dev/null +++ b/server/dashboard/src/modules/projects/hooks.ts @@ -0,0 +1,50 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { + Project, + ProjectListResponse, + ProjectSummary, +} from '@/api/types'; + +export const projectKeys = { + all: ['projects'] as const, + detail: (hash: string) => ['projects', hash] as const, + summary: (hash: string) => ['projects', hash, 'summary'] as const, +}; + +export function useProjects() { + return useQuery({ + queryKey: projectKeys.all, + queryFn: ({ signal }) => api.get('/projects', { signal }), + }); +} + +export function useProject(hash: string | undefined) { + return useQuery({ + queryKey: hash ? projectKeys.detail(hash) : ['projects', 'unknown'], + queryFn: ({ signal }) => api.get(`/projects/${hash}`, { signal }), + enabled: Boolean(hash), + }); +} + +export function useProjectSummary(hash: string | undefined) { + return useQuery({ + queryKey: hash ? projectKeys.summary(hash) : ['projects', 'unknown', 'summary'], + queryFn: ({ signal }) => api.get(`/projects/${hash}/summary`, { signal }), + enabled: Boolean(hash), + }); +} + +export function useDeleteProject() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (hash: string) => api.delete(`/projects/${hash}`), + onSuccess: () => qc.invalidateQueries({ queryKey: projectKeys.all }), + }); +} + +// NOTE: a "Reindex" button is intentionally absent. The server's three-phase +// indexing protocol (begin → files → finish) requires a producer with filesystem +// access to upload file contents. That is the CLI's job (`cix reindex` / +// `cix watch`). The browser cannot drive this — it has no local filesystem. +// The detail page surfaces this expectation in copy. diff --git a/server/dashboard/src/modules/projects/index.ts b/server/dashboard/src/modules/projects/index.ts new file mode 100644 index 0000000..afd42a3 --- /dev/null +++ b/server/dashboard/src/modules/projects/index.ts @@ -0,0 +1,12 @@ +import { Folder } from 'lucide-react'; +import type { Module } from '../types'; +import ProjectsPage from './ProjectsPage'; + +export const ProjectsModule: Module = { + id: 'projects', + label: 'Projects', + icon: Folder, + path: '/projects', + element: ProjectsPage, + weight: 10, +}; diff --git a/server/dashboard/src/modules/registry.ts b/server/dashboard/src/modules/registry.ts new file mode 100644 index 0000000..0f6b6fe --- /dev/null +++ b/server/dashboard/src/modules/registry.ts @@ -0,0 +1,21 @@ +import { ApiKeysModule } from './api-keys'; +import { HomeModule } from './home'; +import { ProjectsModule } from './projects'; +import { SearchModule } from './search'; +import { ServerModule } from './server'; +import { SettingsModule } from './settings'; +import { UsersModule } from './users'; +import type { Module } from './types'; + +// Static registry of every dashboard feature. Order in the sidebar is +// determined by `weight` (default 100). PR-D adds API Keys, Users, Settings. +// PR-E adds Server (admin-only runtime config + sidecar lifecycle). +export const MODULES: Module[] = [ + HomeModule, + ProjectsModule, + SearchModule, + ApiKeysModule, + UsersModule, + SettingsModule, + ServerModule, +].sort((a, b) => (a.weight ?? 100) - (b.weight ?? 100)); diff --git a/server/dashboard/src/modules/search/SearchPage.tsx b/server/dashboard/src/modules/search/SearchPage.tsx new file mode 100644 index 0000000..5299448 --- /dev/null +++ b/server/dashboard/src/modules/search/SearchPage.tsx @@ -0,0 +1,450 @@ +import { useEffect, useMemo, useState } from 'react'; +import { useSearchParams } from 'react-router-dom'; +import { AlertCircle, FileQuestion, Search as SearchIcon } from 'lucide-react'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Badge } from '@/ui/badge'; +import { Card, CardContent } from '@/ui/card'; +import { Skeleton } from '@/ui/skeleton'; +import { Tabs, TabsList, TabsTrigger } from '@/ui/tabs'; +import { SearchInput } from './components/SearchInput'; +import { + LimitInput, + LanguagesInput, + MinScoreSlider, + ModeSpecificHelp, + ProjectPicker, +} from './components/Filters'; +import { ResultFileCard } from './components/ResultFileCard'; +import { OpenInEditorButton } from './components/ResultSnippet'; +import { + SEARCH_MODES, + type SearchMode, + useDefinitions, + useFileSearch, + useReferences, + useSemanticSearch, + useSymbolSearch, +} from './hooks'; + +const MODE_IDS = SEARCH_MODES.map((m) => m.id) as readonly SearchMode[]; + +function isMode(value: string | null): value is SearchMode { + return value !== null && (MODE_IDS as readonly string[]).includes(value); +} + +export default function SearchPage() { + const [params, setParams] = useSearchParams(); + const mode = isMode(params.get('mode')) ? (params.get('mode') as SearchMode) : 'semantic'; + const projectHash = params.get('project') ?? undefined; + const queryParam = params.get('q') ?? ''; + const [draft, setDraft] = useState(queryParam); + + // Debounce: input → URL after 250ms idle. Enter on the form bypasses this + // via `commitQuery(draft)`. + useEffect(() => { + const id = setTimeout(() => { + if (draft === queryParam) return; + const next = new URLSearchParams(params); + if (draft.trim()) next.set('q', draft); + else next.delete('q'); + setParams(next, { replace: true }); + }, 250); + return () => clearTimeout(id); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [draft]); + + // Sync local draft if URL changes externally (e.g. user pastes a link). + useEffect(() => { + setDraft(queryParam); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [queryParam]); + + function commitQuery(value: string) { + const v = value.trim(); + const next = new URLSearchParams(params); + if (v) next.set('q', v); + else next.delete('q'); + setParams(next, { replace: true }); + } + + function setMode(next: SearchMode) { + const p = new URLSearchParams(params); + p.set('mode', next); + setParams(p, { replace: true }); + } + function setProject(hash: string) { + const p = new URLSearchParams(params); + p.set('project', hash); + setParams(p, { replace: true }); + } + + return ( +
+
+

Search

+

+ Semantic, symbol, and path search across your indexed projects. +

+
+ + + + + setMode(v as SearchMode)}> + + {SEARCH_MODES.map((m) => ( + + {m.label} + + ))} + + + + + + +
+ + +
+
+ ); +} + +function placeholderFor(mode: SearchMode): string { + switch (mode) { + case 'semantic': + return 'e.g. "JWT validation middleware" or "retry with backoff"'; + case 'symbols': + return 'Symbol name (substring)'; + case 'definitions': + case 'references': + return 'Exact symbol name'; + case 'files': + return 'File path substring'; + } +} + +function ModeFilters({ + mode, + params, + setParams, +}: { + mode: SearchMode; + params: URLSearchParams; + setParams: ReturnType[1]; +}) { + const limit = Number(params.get('limit') ?? defaultLimit(mode)); + const minScore = Number(params.get('min_score') ?? '0.4'); + const langs = params.get('langs') ?? ''; + + function update(key: string, value: string | undefined) { + const p = new URLSearchParams(params); + if (value === undefined || value === '') p.delete(key); + else p.set(key, value); + setParams(p, { replace: true }); + } + + return ( +
+

Filters

+ update('limit', String(v))} /> + {mode === 'semantic' ? ( + <> + update('min_score', v.toFixed(2))} /> + update('langs', v)} /> + + ) : null} +
+ ); +} + +function defaultLimit(mode: SearchMode): number { + switch (mode) { + case 'references': + return 50; + case 'symbols': + case 'files': + return 20; + default: + return 10; + } +} + +function ResultsArea({ + mode, + projectHash, + query, + params, +}: { + mode: SearchMode; + projectHash: string | undefined; + query: string; + params: URLSearchParams; +}) { + if (!projectHash) { + return ; + } + if (query.trim().length < 2) { + return ; + } + switch (mode) { + case 'semantic': + return ; + case 'symbols': + return ; + case 'definitions': + return ; + case 'references': + return ; + case 'files': + return ; + } +} + +type ResultProps = { + projectHash: string; + query: string; + params: URLSearchParams; +}; + +function SemanticResults({ projectHash, query, params }: ResultProps) { + const limit = Number(params.get('limit') ?? '10'); + const minScore = Number(params.get('min_score') ?? '0.4'); + const langs = (params.get('langs') ?? '').split(',').map((s) => s.trim()).filter(Boolean); + const body = useMemo( + () => ({ + query, + limit, + min_score: minScore, + languages: langs.length > 0 ? langs : undefined, + }), + [query, limit, minScore, langs.join(',')], + ); + const q = useSemanticSearch(projectHash, body); + + if (q.isLoading) return ; + if (q.error) return ; + if (!q.data || q.data.results.length === 0) return ; + + return ( +
+ + {q.data.results.map((g) => ( + + ))} +
+ ); +} + +function SymbolResults({ projectHash, query, params }: ResultProps) { + const limit = Number(params.get('limit') ?? '20'); + const body = useMemo(() => ({ query, limit }), [query, limit]); + const q = useSymbolSearch(projectHash, body); + + if (q.isLoading) return ; + if (q.error) return ; + if (!q.data || q.data.results.length === 0) return ; + + return ( +
+ + + + {q.data.results.map((s, i) => ( +
+ + {s.kind} + +
+
{s.name}
+
+ {s.file_path}:{s.line} +
+
+ {s.language} + +
+ ))} + + +
+ ); +} + +function DefinitionResults({ projectHash, query, params }: ResultProps) { + const limit = Number(params.get('limit') ?? '10'); + const body = useMemo(() => ({ symbol: query, limit }), [query, limit]); + const q = useDefinitions(projectHash, body); + + if (q.isLoading) return ; + if (q.error) return ; + if (!q.data || q.data.results.length === 0) return ; + + return ( +
+ + + + {q.data.results.map((d, i) => ( +
+ + {d.kind} + +
+
{d.name}
+
+ {d.file_path}:{d.line} +
+ {d.signature ? ( +
+ {d.signature} +
+ ) : null} +
+ {d.language} + +
+ ))} + + +
+ ); +} + +function ReferenceResults({ projectHash, query, params }: ResultProps) { + const limit = Number(params.get('limit') ?? '50'); + const body = useMemo(() => ({ symbol: query, limit }), [query, limit]); + const q = useReferences(projectHash, body); + + if (q.isLoading) return ; + if (q.error) return ; + if (!q.data || q.data.results.length === 0) return ; + + return ( +
+ + + + {q.data.results.map((r, i) => ( +
+ + L{r.start_line} + + + {r.file_path} + + {r.language} + +
+ ))} + + +
+ ); +} + +function FileResults({ projectHash, query, params }: ResultProps) { + const limit = Number(params.get('limit') ?? '20'); + const body = useMemo(() => ({ query, limit }), [query, limit]); + const q = useFileSearch(projectHash, body); + + if (q.isLoading) return ; + if (q.error) return ; + if (!q.data || q.data.results.length === 0) return ; + + return ( +
+ + + + {q.data.results.map((f, i) => ( +
+ + {f.file_path} + + {f.language ? ( + {f.language} + ) : null} + +
+ ))} + + +
+ ); +} + +function ResultsMeta({ total, timeMs }: { total: number; timeMs?: number }) { + return ( +
+ {total} {total === 1 ? 'result' : 'results'} + {typeof timeMs === 'number' ? ` · ${timeMs.toFixed(1)} ms` : ''} +
+ ); +} + +function ResultsSkeleton() { + return ( +
+ {Array.from({ length: 4 }).map((_, i) => ( + + ))} +
+ ); +} + +function ResultsError({ error }: { error: unknown }) { + return ( + + + Search failed + + {error instanceof ApiError ? error.detail : String(error)} + + + ); +} + +function NoResultsCard() { + return ( + + + +

No matches

+

+ Try a different query, lower the minimum score, or pick a different mode. +

+ + + ); +} + +function PromptCard({ + icon: Icon, + title, +}: { + icon: typeof SearchIcon; + title: string; +}) { + return ( + + + +

{title}

+ + + ); +} diff --git a/server/dashboard/src/modules/search/components/Filters.tsx b/server/dashboard/src/modules/search/components/Filters.tsx new file mode 100644 index 0000000..45182fe --- /dev/null +++ b/server/dashboard/src/modules/search/components/Filters.tsx @@ -0,0 +1,142 @@ +import { Loader2 } from 'lucide-react'; +import { useProjects } from '@/modules/projects/hooks'; +import { Label } from '@/ui/label'; +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from '@/ui/select'; +import { Slider } from '@/ui/slider'; +import { Input } from '@/ui/input'; +import type { SearchMode } from '../hooks'; + +export function ProjectPicker({ + value, + onChange, +}: { + value: string | undefined; + onChange: (hash: string) => void; +}) { + const { data, isLoading } = useProjects(); + const projects = data?.projects ?? []; + + return ( +
+ + +
+ ); +} + +export function MinScoreSlider({ + value, + onChange, +}: { + value: number; + onChange: (v: number) => void; +}) { + return ( +
+
+ + {value.toFixed(2)} +
+ onChange(v)} + /> +
+ ); +} + +export function LimitInput({ + value, + onChange, + max = 100, +}: { + value: number; + onChange: (v: number) => void; + max?: number; +}) { + return ( +
+ + { + const n = Number(e.target.value); + if (Number.isFinite(n)) onChange(Math.max(1, Math.min(max, Math.round(n)))); + }} + className="h-9" + /> +
+ ); +} + +export function LanguagesInput({ + value, + onChange, +}: { + value: string; + onChange: (v: string) => void; +}) { + return ( +
+ + onChange(e.target.value)} + className="h-9" + /> +

Comma-separated. Leave empty for all.

+
+ ); +} + +export function ModeSpecificHelp({ mode }: { mode: SearchMode }) { + const messages: Record = { + semantic: 'Ask in natural language ("JWT validation", "retry with exponential backoff").', + symbols: 'Substring match against symbol names.', + definitions: 'Exact symbol name. Optional kind/file filters.', + references: 'Exact symbol name. Returns every callsite.', + files: 'Substring match against file paths.', + }; + return

{messages[mode]}

; +} diff --git a/server/dashboard/src/modules/search/components/ResultFileCard.tsx b/server/dashboard/src/modules/search/components/ResultFileCard.tsx new file mode 100644 index 0000000..ee84095 --- /dev/null +++ b/server/dashboard/src/modules/search/components/ResultFileCard.tsx @@ -0,0 +1,65 @@ +import { useState } from 'react'; +import { ChevronDown, ChevronRight } from 'lucide-react'; +import type { FileGroupResult } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { Card, CardContent } from '@/ui/card'; +import { cn } from '@/lib/cn'; +import { OpenInEditorButton, ResultSnippet } from './ResultSnippet'; + +export function ResultFileCard({ + group, + defaultOpen = true, +}: { + group: FileGroupResult; + defaultOpen?: boolean; +}) { + const [open, setOpen] = useState(defaultOpen); + const matchCount = group.matches.length; + + return ( + + + + {open ? ( +
+ {group.matches.map((m, i) => ( + + ))} +
+ ) : null} + + + ); +} diff --git a/server/dashboard/src/modules/search/components/ResultSnippet.tsx b/server/dashboard/src/modules/search/components/ResultSnippet.tsx new file mode 100644 index 0000000..33f38fb --- /dev/null +++ b/server/dashboard/src/modules/search/components/ResultSnippet.tsx @@ -0,0 +1,96 @@ +import { ExternalLink } from 'lucide-react'; +import type { FileMatch, NestedHit } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { Button } from '@/ui/button'; +import { cn } from '@/lib/cn'; +import { openInEditor } from '@/lib/editorPreference'; + +export function ResultSnippet({ + filePath, + match, +}: { + filePath: string; + match: FileMatch; +}) { + const lines = match.content.split('\n'); + return ( +
+
+ + L{match.start_line} + {match.end_line !== match.start_line ? `–${match.end_line}` : ''} + + {match.symbol_name ? ( + {match.symbol_name} + ) : null} + + {match.chunk_type} + + + {match.score.toFixed(2)} + + +
+ 
+        
+          {lines.map((line, i) => (
+            

+              
+                {match.start_line + i}
+              
+              {line || ' '}
+            

+          ))}
+        
+
+ {match.nested_hits && match.nested_hits.length > 0 ? ( + + ) : null} +
+ ); +} + +function NestedHitsList({ hits }: { hits: NestedHit[] }) { + return ( +
+
Also matches:
+
    + {hits.map((h, i) => ( +
  • + + L{h.start_line} + {h.end_line !== h.start_line ? `–${h.end_line}` : ''} + + {h.symbol_name ? {h.symbol_name} : null} + ({h.chunk_type}) + {h.score.toFixed(2)} +
    • + ))} +
+
+ ); +} + +export function OpenInEditorButton({ + path, + line, + className, +}: { + path: string; + line?: number; + className?: string; +}) { + return ( + + ); +} diff --git a/server/dashboard/src/modules/search/components/SearchInput.tsx b/server/dashboard/src/modules/search/components/SearchInput.tsx new file mode 100644 index 0000000..1d94774 --- /dev/null +++ b/server/dashboard/src/modules/search/components/SearchInput.tsx @@ -0,0 +1,60 @@ +import { useEffect, useRef } from 'react'; +import { Search as SearchIcon } from 'lucide-react'; +import { Input } from '@/ui/input'; +import { cn } from '@/lib/cn'; + +export function SearchInput({ + value, + onChange, + onSubmit, + placeholder = 'Search…', + className, +}: { + value: string; + onChange: (v: string) => void; + /** Fired on Enter — bypasses debounce and commits immediately. */ + onSubmit?: (v: string) => void; + placeholder?: string; + className?: string; +}) { + const ref = useRef(null); + + // ⌘K / Ctrl+K focuses the search input from anywhere on the page. + useEffect(() => { + function onKey(e: KeyboardEvent) { + const isMac = navigator.platform.toLowerCase().includes('mac'); + const cmd = isMac ? e.metaKey : e.ctrlKey; + if (cmd && e.key === 'k') { + e.preventDefault(); + ref.current?.focus(); + ref.current?.select(); + } + } + window.addEventListener('keydown', onKey); + return () => window.removeEventListener('keydown', onKey); + }, []); + + return ( +
{ + e.preventDefault(); + onSubmit?.(value); + }} + > + + onChange(e.target.value)} + className="h-10 pl-9 pr-12" + /> + + ⌘K + + + ); +} diff --git a/server/dashboard/src/modules/search/hooks.ts b/server/dashboard/src/modules/search/hooks.ts new file mode 100644 index 0000000..351c0aa --- /dev/null +++ b/server/dashboard/src/modules/search/hooks.ts @@ -0,0 +1,90 @@ +import { useQuery } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { + DefinitionRequest, + DefinitionResponse, + FileSearchRequest, + FileSearchResponse, + ReferenceRequest, + ReferenceResponse, + SemanticSearchRequest, + SemanticSearchResponse, + SymbolSearchRequest, + SymbolSearchResponse, +} from '@/api/types'; + +export type SearchMode = 'semantic' | 'symbols' | 'definitions' | 'references' | 'files'; + +export const SEARCH_MODES: { id: SearchMode; label: string; description: string }[] = [ + { id: 'semantic', label: 'Semantic', description: 'Vector search: ask in natural language.' }, + { id: 'symbols', label: 'Symbols', description: 'Find symbols by name (substring match).' }, + { id: 'definitions', label: 'Definitions', description: 'Where is this symbol defined?' }, + { id: 'references', label: 'References', description: 'Where is this symbol used?' }, + { id: 'files', label: 'Files', description: 'Find files by path substring.' }, +]; + +const baseKey = ['search'] as const; + +function searchEnabled(query: string) { + return query.trim().length >= 2; +} + +export function useSemanticSearch( + projectHash: string | undefined, + body: SemanticSearchRequest +) { + return useQuery({ + queryKey: [...baseKey, 'semantic', projectHash, body], + queryFn: ({ signal }) => + api.post(`/projects/${projectHash}/search`, body, { signal }), + enabled: Boolean(projectHash) && searchEnabled(body.query), + }); +} + +export function useSymbolSearch( + projectHash: string | undefined, + body: SymbolSearchRequest +) { + return useQuery({ + queryKey: [...baseKey, 'symbols', projectHash, body], + queryFn: ({ signal }) => + api.post(`/projects/${projectHash}/search/symbols`, body, { signal }), + enabled: Boolean(projectHash) && searchEnabled(body.query), + }); +} + +export function useDefinitions( + projectHash: string | undefined, + body: DefinitionRequest +) { + return useQuery({ + queryKey: [...baseKey, 'definitions', projectHash, body], + queryFn: ({ signal }) => + api.post(`/projects/${projectHash}/search/definitions`, body, { signal }), + enabled: Boolean(projectHash) && searchEnabled(body.symbol), + }); +} + +export function useReferences( + projectHash: string | undefined, + body: ReferenceRequest +) { + return useQuery({ + queryKey: [...baseKey, 'references', projectHash, body], + queryFn: ({ signal }) => + api.post(`/projects/${projectHash}/search/references`, body, { signal }), + enabled: Boolean(projectHash) && searchEnabled(body.symbol), + }); +} + +export function useFileSearch( + projectHash: string | undefined, + body: FileSearchRequest +) { + return useQuery({ + queryKey: [...baseKey, 'files', projectHash, body], + queryFn: ({ signal }) => + api.post(`/projects/${projectHash}/search/files`, body, { signal }), + enabled: Boolean(projectHash) && searchEnabled(body.query), + }); +} diff --git a/server/dashboard/src/modules/search/index.ts b/server/dashboard/src/modules/search/index.ts new file mode 100644 index 0000000..c305c29 --- /dev/null +++ b/server/dashboard/src/modules/search/index.ts @@ -0,0 +1,12 @@ +import { Search } from 'lucide-react'; +import type { Module } from '../types'; +import SearchPage from './SearchPage'; + +export const SearchModule: Module = { + id: 'search', + label: 'Search', + icon: Search, + path: '/search', + element: SearchPage, + weight: 20, +}; diff --git a/server/dashboard/src/modules/server/ServerPage.tsx b/server/dashboard/src/modules/server/ServerPage.tsx new file mode 100644 index 0000000..8481ae7 --- /dev/null +++ b/server/dashboard/src/modules/server/ServerPage.tsx @@ -0,0 +1,196 @@ +import { useEffect, useMemo, useState } from 'react'; +import { AlertCircle, Loader2, Save } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import type { RuntimeConfig, RuntimeConfigUpdate } from '@/api/types'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { Skeleton } from '@/ui/skeleton'; +import { useRestartSidecar, useRuntimeConfig, useSidecarStatus, useUpdateRuntimeConfig } from './hooks'; +import { EmbeddingModelSection } from './sections/EmbeddingModelSection'; +import { RuntimeParamsSection } from './sections/RuntimeParamsSection'; +import { SidecarSection } from './sections/SidecarSection'; +import { AdvancedSection } from './sections/AdvancedSection'; +import { SaveAndRestartDialog } from './components/SaveAndRestartDialog'; + +interface Draft { + embedding_model: string; + llama_ctx_size: number; + llama_n_gpu_layers: number; + llama_n_threads: number; + max_embedding_concurrency: number; + llama_batch_size: number; +} + +function configToDraft(c: RuntimeConfig): Draft { + return { + embedding_model: c.embedding_model, + llama_ctx_size: c.llama_ctx_size, + llama_n_gpu_layers: c.llama_n_gpu_layers, + llama_n_threads: c.llama_n_threads, + max_embedding_concurrency: c.max_embedding_concurrency, + llama_batch_size: c.llama_batch_size, + }; +} + +// diffPatch produces (a) the partial PUT body containing only changed +// fields and (b) the human-readable changes list the confirm dialog renders. +function diffPatch(c: RuntimeConfig, d: Draft): { patch: RuntimeConfigUpdate; changes: Array<{ field: string; from: string; to: string }> } { + const patch: RuntimeConfigUpdate = {}; + const changes: Array<{ field: string; from: string; to: string }> = []; + if (d.embedding_model !== c.embedding_model) { + patch.embedding_model = d.embedding_model; + changes.push({ field: 'embedding_model', from: c.embedding_model, to: d.embedding_model }); + } + for (const k of [ + 'llama_ctx_size', + 'llama_n_gpu_layers', + 'llama_n_threads', + 'max_embedding_concurrency', + 'llama_batch_size', + ] as const) { + if (d[k] !== c[k]) { + patch[k] = d[k]; + changes.push({ field: k, from: String(c[k]), to: String(d[k]) }); + } + } + return { patch, changes }; +} + +export default function ServerPage() { + const cfg = useRuntimeConfig(); + const status = useSidecarStatus(); + const update = useUpdateRuntimeConfig(); + const restart = useRestartSidecar(); + + const [draft, setDraft] = useState(null); + const [confirmOpen, setConfirmOpen] = useState(false); + + // Initialise / reset draft whenever the server-side config changes from + // under us (initial fetch, optimistic refresh after save). + useEffect(() => { + if (cfg.data) setDraft(configToDraft(cfg.data)); + }, [cfg.data]); + + const dirty = useMemo(() => { + if (!cfg.data || !draft) return false; + return diffPatch(cfg.data, draft).changes.length > 0; + }, [cfg.data, draft]); + + if (cfg.isLoading || !draft) { + return ( +
+
+

Server

+

Embedding model, indexing parameters, sidecar lifecycle.

+
+ + +
+ ); + } + + if (cfg.error || !cfg.data) { + return ( + + + Could not load runtime config + {cfg.error instanceof ApiError ? cfg.error.detail : String(cfg.error)} + + ); + } + + const disabled = status.data?.state === 'disabled'; + const { changes } = diffPatch(cfg.data, draft); + + async function onConfirm() { + if (!cfg.data || !draft) return; + const { patch } = diffPatch(cfg.data, draft); + try { + // Step 1 — write overrides to DB. The mutation also refreshes the + // cache so the form's "DB" pills appear before the restart fires. + if (Object.keys(patch).length > 0) { + await update.mutateAsync(patch); + } + // Step 2 — kick a sidecar restart so the new model / flags load. + await restart.mutateAsync(); + setConfirmOpen(false); + toast.success('Configuration saved', { + description: 'Sidecar is restarting — watch the Sidecar card for status.', + }); + } catch (e) { + const detail = e instanceof ApiError ? e.detail : String(e); + toast.error('Save & Restart failed', { description: detail }); + } + } + + const isPending = update.isPending || restart.isPending; + + return ( +
+
+
+

Server

+

+ Embedding model, indexing parameters, sidecar lifecycle. Saved + overrides land in the database and are reapplied on the next + sidecar restart — env vars stay as bootstrap defaults. +

+
+ +
+ + {disabled ? ( + + + Embeddings disabled at boot + + The server was started with CIX_EMBEDDINGS_ENABLED=false. + Restart the server with the env var set to true to + enable runtime config + the sidecar. + + + ) : null} + + setDraft({ ...draft, embedding_model: v })} + /> + + setDraft({ ...draft, llama_ctx_size: n })} + onDraftGpuLayers={(n) => setDraft({ ...draft, llama_n_gpu_layers: n })} + onDraftThreads={(n) => setDraft({ ...draft, llama_n_threads: n })} + /> + + + + setDraft({ ...draft, max_embedding_concurrency: n })} + onDraftBatch={(n) => setDraft({ ...draft, llama_batch_size: n })} + /> + + (!isPending ? setConfirmOpen(next) : null)} + onConfirm={onConfirm} + isPending={isPending} + changes={changes} + /> +
+ ); +} diff --git a/server/dashboard/src/modules/server/components/SaveAndRestartDialog.tsx b/server/dashboard/src/modules/server/components/SaveAndRestartDialog.tsx new file mode 100644 index 0000000..59ddc65 --- /dev/null +++ b/server/dashboard/src/modules/server/components/SaveAndRestartDialog.tsx @@ -0,0 +1,72 @@ +import { Loader2 } from 'lucide-react'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, +} from '@/ui/dialog'; + +interface Props { + open: boolean; + onOpenChange: (next: boolean) => void; + onConfirm: () => void; + isPending: boolean; + // Per-field summary the dialog renders so the admin sees exactly what + // they're about to apply before the sidecar gets killed. + changes: Array<{ field: string; from: string; to: string }>; +} + +// SaveAndRestartDialog confirms a runtime-config save that will trigger an +// embedding-sidecar restart. Active indexing batches will fail mid-call — +// not a quiet operation — so we always require explicit confirm before the +// PUT + restart cascade fires. +export function SaveAndRestartDialog({ + open, + onOpenChange, + onConfirm, + isPending, + changes, +}: Props) { + return ( + + + + Apply config and restart sidecar? + + Saving will write the overrides to the database, then drain the + embedding queue (up to 30s) and restart llama-server. Indexing + batches in flight at restart time will fail — re-run{' '} + cix reindex{' '} + for affected projects. + + + {changes.length > 0 ? ( +
    + {changes.map((c) => ( +
  • + {c.field}: + {c.from} + → + {c.to} +
    • + ))} +
+ ) : ( +

No field changes — restart only.

+ )} + + + + + + + ); +} diff --git a/server/dashboard/src/modules/server/components/SidecarStateBadge.tsx b/server/dashboard/src/modules/server/components/SidecarStateBadge.tsx new file mode 100644 index 0000000..f2c33fc --- /dev/null +++ b/server/dashboard/src/modules/server/components/SidecarStateBadge.tsx @@ -0,0 +1,18 @@ +import { Badge } from '@/ui/badge'; + +const VARIANT: Record = { + running: 'default', + starting: 'secondary', + restarting: 'secondary', + failed: 'destructive', + disabled: 'outline', +}; + +export function SidecarStateBadge({ state }: { state?: string }) { + if (!state) return null; + return ( + + {state} + + ); +} diff --git a/server/dashboard/src/modules/server/components/SourcePill.tsx b/server/dashboard/src/modules/server/components/SourcePill.tsx new file mode 100644 index 0000000..3df85ed --- /dev/null +++ b/server/dashboard/src/modules/server/components/SourcePill.tsx @@ -0,0 +1,27 @@ +import { Badge } from '@/ui/badge'; + +const VARIANT: Record = { + db: 'default', + env: 'secondary', + recommended: 'outline', +}; + +const LABEL: Record = { + db: 'DB', + env: 'Env', + recommended: 'Default', +}; + +// SourcePill renders a tiny "DB" / "Env" / "Default" tag next to a runtime +// config field, telling the admin where the currently-effective value came +// from. "DB" means the dashboard saved an override; "Env" means the operator +// set CIX_* at boot; "Default" means we're falling through to the hardcoded +// recommended value. +export function SourcePill({ source }: { source?: string }) { + if (!source) return null; + return ( + + {LABEL[source] ?? source} + + ); +} diff --git a/server/dashboard/src/modules/server/hooks.ts b/server/dashboard/src/modules/server/hooks.ts new file mode 100644 index 0000000..fb1e715 --- /dev/null +++ b/server/dashboard/src/modules/server/hooks.ts @@ -0,0 +1,79 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { + ModelList, + RestartAccepted, + RuntimeConfig, + RuntimeConfigUpdate, + SidecarStatus, +} from '@/api/types'; + +export const serverKeys = { + runtimeConfig: ['server', 'runtime-config'] as const, + sidecarStatus: ['server', 'sidecar-status'] as const, + models: ['server', 'models'] as const, +}; + +export function useRuntimeConfig() { + return useQuery({ + queryKey: serverKeys.runtimeConfig, + queryFn: ({ signal }) => api.get('/admin/runtime-config', { signal }), + }); +} + +export function useUpdateRuntimeConfig() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (patch: RuntimeConfigUpdate) => + api.put('/admin/runtime-config', patch), + onSuccess: (data) => { + // Replace the cached value so the form switches to "DB"-sourced + // pills before the dashboard issues the restart call. + qc.setQueryData(serverKeys.runtimeConfig, data); + }, + }); +} + +export function useSidecarStatus() { + return useQuery({ + queryKey: serverKeys.sidecarStatus, + queryFn: ({ signal }) => api.get('/admin/sidecar/status', { signal }), + // Poll every second whenever a restart is in flight; otherwise back off + // to 5s — the status almost never changes outside of admin actions and + // we don't want to thrash on idle dashboards. + refetchInterval: (q) => { + const data = q.state.data as SidecarStatus | undefined; + if (!data) return 2_000; + if (data.restart_in_flight || data.state === 'starting' || data.state === 'restarting') { + return 1_000; + } + return 5_000; + }, + refetchIntervalInBackground: false, + }); +} + +export function useRestartSidecar() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: () => api.post('/admin/sidecar/restart'), + onSettled: () => { + // Force a status refetch immediately so the UI flips to "restarting" + // without waiting for the next poll tick. Also invalidate the cached + // runtime model — drift indicators on Projects depend on it being + // current after a model swap. + qc.invalidateQueries({ queryKey: serverKeys.sidecarStatus }); + qc.invalidateQueries({ queryKey: ['runtime-model'] }); + }, + }); +} + +export function useGGUFModels() { + return useQuery({ + queryKey: serverKeys.models, + queryFn: ({ signal }) => api.get('/admin/models', { signal }), + // Cache aggressively: GGUFs only change when the operator runs + // `cix init` or manually drops a file in the cache. + staleTime: 60_000, + }); +} diff --git a/server/dashboard/src/modules/server/index.ts b/server/dashboard/src/modules/server/index.ts new file mode 100644 index 0000000..1c9da80 --- /dev/null +++ b/server/dashboard/src/modules/server/index.ts @@ -0,0 +1,13 @@ +import { ServerCog } from 'lucide-react'; +import type { Module } from '../types'; +import ServerPage from './ServerPage'; + +export const ServerModule: Module = { + id: 'server', + label: 'Server', + icon: ServerCog, + path: '/server', + element: ServerPage, + requiredRole: 'admin', + weight: 60, +}; diff --git a/server/dashboard/src/modules/server/sections/AdvancedSection.tsx b/server/dashboard/src/modules/server/sections/AdvancedSection.tsx new file mode 100644 index 0000000..1854ea7 --- /dev/null +++ b/server/dashboard/src/modules/server/sections/AdvancedSection.tsx @@ -0,0 +1,97 @@ +import { useId } from 'react'; +import type { RuntimeConfig } from '@/api/types'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { SourcePill } from '../components/SourcePill'; + +interface Props { + config?: RuntimeConfig; + draftConcurrency: number; + draftBatch: number; + onDraftConcurrency: (n: number) => void; + onDraftBatch: (n: number) => void; +} + +// AdvancedSection: throughput-tuning fields most operators won't touch. +// Wrapped in a native
so the form stays light by default — Radix +// Collapsible isn't installed and the plain HTML element is good enough. +export function AdvancedSection({ + config, + draftConcurrency, + draftBatch, + onDraftConcurrency, + onDraftBatch, +}: Props) { + const concId = useId(); + const batchId = useId(); + const rec = config?.recommended; + const src = config?.source; + + return ( + + + Advanced + Throughput tuning. Leave at recommended unless you have a specific reason. + + +
+ + Show advanced tunables + +
+
+
+ + +
+ { + const n = parseInt(e.target.value, 10); + onDraftConcurrency(Number.isFinite(n) ? n : 0); + }} + className="max-w-xs" + /> +

+ Concurrent /v1/embeddings calls allowed against the sidecar. 1 = strictly sequential. + Recommended: {rec?.max_embedding_concurrency ?? 1}. +

+
+ +
+
+ + +
+ { + const n = parseInt(e.target.value, 10); + onDraftBatch(Number.isFinite(n) ? n : 0); + }} + className="max-w-xs" + /> +

+ Logical batch passed to llama-server (-b). 0 = match context window. + Recommended: {rec?.llama_batch_size ?? 'ctx'}. +

+
+
+
+ + + ); +} diff --git a/server/dashboard/src/modules/server/sections/EmbeddingModelSection.tsx b/server/dashboard/src/modules/server/sections/EmbeddingModelSection.tsx new file mode 100644 index 0000000..8d6cb18 --- /dev/null +++ b/server/dashboard/src/modules/server/sections/EmbeddingModelSection.tsx @@ -0,0 +1,210 @@ +import { useEffect, useId, useState } from 'react'; +import { AlertTriangle } from 'lucide-react'; +import type { ModelEntry, RuntimeConfig } from '@/api/types'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { RadioGroup, RadioGroupItem } from '@/ui/radio-group'; +import { Skeleton } from '@/ui/skeleton'; +import { useGGUFModels } from '../hooks'; +import { SourcePill } from '../components/SourcePill'; + +interface Props { + config?: RuntimeConfig; + draftModel: string; + onDraftChange: (next: string) => void; +} + +type Mode = 'repo' | 'path'; + +function isAbsPath(v: string): boolean { + // POSIX-only check is enough — the server is Linux/macOS for the + // foreseeable future. Windows path support would need an additional + // drive-letter test (`/^[a-zA-Z]:[\\/]/.test(v)`). + return v.startsWith('/'); +} + +function formatSize(bytes: number): string { + if (!Number.isFinite(bytes) || bytes <= 0) return '—'; + const units = ['B', 'KB', 'MB', 'GB']; + let i = 0; + let v = bytes; + while (v >= 1024 && i < units.length - 1) { + v /= 1024; + i++; + } + return `${v.toFixed(v < 10 ? 1 : 0)} ${units[i]}`; +} + +// EmbeddingModelSection lets the admin pick exactly one model source: +// 1. "HuggingFace repo" — selects from cix's own GGUF cache (or types +// a repo ID for first-use download). Active = repo mode. +// 2. "Local file path" — points at an absolute .gguf path on the host. +// Active = path mode. +// +// The two inputs are mutually exclusive. Switching modes resets the draft +// to a sensible default for the new mode (recommended repo / empty path) +// so the parent component never holds a half-typed cross-mode value. +export function EmbeddingModelSection({ config, draftModel, onDraftChange }: Props) { + const repoSelectId = useId(); + const repoInputId = useId(); + const pathInputId = useId(); + + const [mode, setMode] = useState(() => (isAbsPath(draftModel) ? 'path' : 'repo')); + + // Sync mode if the draft is changed from the outside (initial fetch, + // optimistic refresh after save). Without this the radio would lie + // after the parent updates draftModel from a server-reload. + useEffect(() => { + setMode(isAbsPath(draftModel) ? 'path' : 'repo'); + }, [draftModel]); + + const models = useGGUFModels(); + const cached: ModelEntry[] = models.data?.models ?? []; + const cacheDir = models.data?.cache_dir ?? ''; + const matched = cached.find((m) => m.id === draftModel); + + function switchTo(next: Mode) { + if (next === mode) return; + setMode(next); + if (next === 'repo') { + // Switching out of path → restore a sensible repo default so the + // form doesn't show an absolute path under the disabled path input. + onDraftChange(config?.recommended?.embedding_model ?? ''); + } else { + // Switching into path → clear the field so the user types a fresh + // absolute path. Empty string is invalid, save button stays disabled + // until they enter something. + onDraftChange(''); + } + } + + return ( + + + + Embedding model + + + + Pick one source. Saving triggers a sidecar restart so the new + weights load before any further embedding. + + + + switchTo(v as Mode)} + className="grid grid-cols-1 gap-2 sm:grid-cols-2" + > + + + + + {/* Repo mode: dropdown when cache has entries, free-text input either way. */} +
+ {models.isLoading ? ( + + ) : cached.length > 0 ? ( +
+ + + {cacheDir ? ( +

+ Scanned {cacheDir} +

+ ) : null} +
+ ) : ( + + + No cached repos + + {cacheDir + ? <>Nothing under {cacheDir}. Type a repo ID below — first save will download to cache. + : <>No cache directory reported. Type a repo ID below or switch to "Local file path" if the model lives outside cix.} + + + )} + +
+ + onDraftChange(e.target.value)} + placeholder="awhiteside/CodeRankEmbed-Q8_0-GGUF" + disabled={mode !== 'repo'} + className="font-mono text-xs" + /> + {config?.recommended ? ( +

+ Recommended: {config.recommended.embedding_model} +

+ ) : null} +
+
+ + {/* Path mode: single absolute-path input. */} +
+ + onDraftChange(e.target.value)} + placeholder="/Users/me/.cache/huggingface/hub/.../coderankembed-q8_0.gguf" + disabled={mode !== 'path'} + className="font-mono text-xs" + /> +

+ File must be readable by the cix-server process. The path is used as-is — cix will not copy it into its cache. +

+
+ + + ); +} + +function ModeOption({ value, label, hint }: { value: Mode; label: string; hint: string }) { + const id = useId(); + return ( + + ); +} diff --git a/server/dashboard/src/modules/server/sections/RuntimeParamsSection.tsx b/server/dashboard/src/modules/server/sections/RuntimeParamsSection.tsx new file mode 100644 index 0000000..ac8fb5e --- /dev/null +++ b/server/dashboard/src/modules/server/sections/RuntimeParamsSection.tsx @@ -0,0 +1,115 @@ +import { useId } from 'react'; +import type { RuntimeConfig } from '@/api/types'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { SourcePill } from '../components/SourcePill'; + +interface NumberFieldProps { + field: string; + label: string; + hint: string; + value: number; + recommended?: number; + source?: string; + onChange: (next: number) => void; + min?: number; +} + +function NumberField({ field, label, hint, value, recommended, source, onChange, min = 0 }: NumberFieldProps) { + const id = useId(); + return ( +
+
+ + +
+ { + const n = parseInt(e.target.value, 10); + onChange(Number.isFinite(n) ? n : 0); + }} + className="max-w-xs" + /> +

+ {hint} + {recommended !== undefined ? <> Recommended: {recommended}. : null} +

+
+ ); +} + +interface Props { + config?: RuntimeConfig; + draftCtx: number; + draftGpuLayers: number; + draftThreads: number; + onDraftCtx: (n: number) => void; + onDraftGpuLayers: (n: number) => void; + onDraftThreads: (n: number) => void; +} + +// RuntimeParamsSection: ctx, n_gpu_layers, n_threads form. n_gpu_layers +// allows -1 (Metal/CUDA all-layers sentinel) so we deliberately do NOT +// clamp to >= 0 in the input. +export function RuntimeParamsSection({ + config, + draftCtx, + draftGpuLayers, + draftThreads, + onDraftCtx, + onDraftGpuLayers, + onDraftThreads, +}: Props) { + const rec = config?.recommended; + const src = config?.source; + return ( + + + Runtime parameters + + Tunables passed to llama-server on every (re)start. Leaving a field + at zero falls back to env / recommended on the next save. + + + + + + + + + ); +} diff --git a/server/dashboard/src/modules/server/sections/SidecarSection.tsx b/server/dashboard/src/modules/server/sections/SidecarSection.tsx new file mode 100644 index 0000000..499b33d --- /dev/null +++ b/server/dashboard/src/modules/server/sections/SidecarSection.tsx @@ -0,0 +1,133 @@ +import { useState } from 'react'; +import { Loader2, RefreshCw } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, +} from '@/ui/dialog'; +import { useRestartSidecar, useSidecarStatus } from '../hooks'; +import { SidecarStateBadge } from '../components/SidecarStateBadge'; + +function formatUptime(seconds?: number): string { + if (!seconds || seconds <= 0) return '—'; + const h = Math.floor(seconds / 3600); + const m = Math.floor((seconds % 3600) / 60); + const s = seconds % 60; + if (h > 0) return `${h}h ${m}m`; + if (m > 0) return `${m}m ${s}s`; + return `${s}s`; +} + +// SidecarSection renders the live llama-server status (PID, uptime, ready, +// model, last error) plus a "Restart sidecar" button. Used when an admin +// changes a runtime-config field that needs the new weights / flags to +// take effect, OR for opportunistic recovery when the sidecar got stuck. +export function SidecarSection() { + const status = useSidecarStatus(); + const restart = useRestartSidecar(); + const [confirm, setConfirm] = useState(false); + + const data = status.data; + const restarting = data?.restart_in_flight || data?.state === 'restarting'; + + return ( + + + + Sidecar + + + + The llama-server child process embedding chunks for this index. + Restart re-spawns with the latest runtime config. + + + + {data?.last_error ? ( + + Sidecar reported an error + {data.last_error} + + ) : null} + +
+ + + + +
+ +
+ +
+ + + (!restart.isPending ? setConfirm(next) : null)}> + + + Restart llama-server? + + Drains the embedding queue (up to 30s) and respawns. Active + indexing batches will fail mid-call and need to be re-driven by + the operator (cix reindex). + + + + + + + + + + ); +} + +function Field({ label, value, mono }: { label: string; value: string; mono?: boolean }) { + return ( +
+
{label}
+
+ {value} +
+
+ ); +} diff --git a/server/dashboard/src/modules/settings/SettingsPage.tsx b/server/dashboard/src/modules/settings/SettingsPage.tsx new file mode 100644 index 0000000..3092764 --- /dev/null +++ b/server/dashboard/src/modules/settings/SettingsPage.tsx @@ -0,0 +1,22 @@ +import { EditorSection } from './sections/EditorSection'; +import { ProfileSection } from './sections/ProfileSection'; +import { SessionsSection } from './sections/SessionsSection'; +import { ThemeSection } from './sections/ThemeSection'; + +export default function SettingsPage() { + return ( +
+
+

Settings

+

+ Account, sessions, and personal UI preferences. +

+
+ + + + + +
+ ); +} diff --git a/server/dashboard/src/modules/settings/components/ChangePasswordForm.tsx b/server/dashboard/src/modules/settings/components/ChangePasswordForm.tsx new file mode 100644 index 0000000..5be0e5b --- /dev/null +++ b/server/dashboard/src/modules/settings/components/ChangePasswordForm.tsx @@ -0,0 +1,102 @@ +import { useState, type FormEvent } from 'react'; +import { Loader2 } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { useAuth } from '@/auth/useAuth'; +import { useChangePassword } from '../hooks'; + +// Settings-page password change. Server invalidates sibling sessions and +// keeps the current cookie alive — but to make the cookie consistent with +// the new password we still log out + bounce to /login afterwards. +export function ChangePasswordForm() { + const { logout } = useAuth(); + const change = useChangePassword(); + const [current, setCurrent] = useState(''); + const [next, setNext] = useState(''); + const [confirm, setConfirm] = useState(''); + const [error, setError] = useState(null); + + async function onSubmit(e: FormEvent) { + e.preventDefault(); + setError(null); + if (next !== confirm) { + setError('New password and confirmation must match.'); + return; + } + if (next.length < 8) { + setError('New password must be at least 8 characters.'); + return; + } + try { + await change.mutateAsync({ current_password: current, new_password: next }); + toast.success('Password updated', { + description: 'Please sign in again with your new password.', + }); + await logout(); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : 'Unexpected error. Try again.'; + setError(detail); + } + } + + return ( +
+
+
+ + setCurrent(e.target.value)} + disabled={change.isPending} + /> +
+
+ + setNext(e.target.value)} + disabled={change.isPending} + /> +
+
+ + setConfirm(e.target.value)} + disabled={change.isPending} + /> +
+
+ {error ? ( + + Could not update password + {error} + + ) : null} +
+ +
+
+ ); +} diff --git a/server/dashboard/src/modules/settings/components/SessionRow.tsx b/server/dashboard/src/modules/settings/components/SessionRow.tsx new file mode 100644 index 0000000..eadf6ca --- /dev/null +++ b/server/dashboard/src/modules/settings/components/SessionRow.tsx @@ -0,0 +1,88 @@ +import { Loader2, LogOut } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import type { Session } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { Button } from '@/ui/button'; +import { TableCell, TableRow } from '@/ui/table'; +import { Tooltip, TooltipContent, TooltipTrigger } from '@/ui/tooltip'; +import { formatDateTime, formatRelative } from '@/lib/formatDate'; +import { useDeleteSession } from '../hooks'; + +export function SessionRow({ session }: { session: Session }) { + const del = useDeleteSession(); + const ua = session.last_seen_ua ?? '—'; + + async function onSignOut() { + try { + await del.mutateAsync(session.id); + toast.success('Session ended'); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Could not end session', { description: detail }); + } + } + + return ( + + + {formatRelative(session.created_at)} + + + {formatRelative(session.last_seen_at)} + + + {session.last_seen_ip ?? '—'} + + + + + {ua} + + {ua} + + + + {session.is_current ? current : null} + + + {session.is_current ? ( + + + + + + + + This is your current session. Use the sidebar Sign out to end it. + + + ) : ( + + )} + + + ); +} diff --git a/server/dashboard/src/modules/settings/hooks.ts b/server/dashboard/src/modules/settings/hooks.ts new file mode 100644 index 0000000..54dcdce --- /dev/null +++ b/server/dashboard/src/modules/settings/hooks.ts @@ -0,0 +1,32 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { ChangePasswordRequest, SessionListResponse } from '@/api/types'; + +export const settingsKeys = { + sessions: ['auth', 'sessions'] as const, +}; + +export function useMySessions() { + return useQuery({ + queryKey: settingsKeys.sessions, + queryFn: ({ signal }) => api.get('/auth/sessions', { signal }), + }); +} + +export function useDeleteSession() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (id: string) => api.delete(`/auth/sessions/${id}`), + onSuccess: () => qc.invalidateQueries({ queryKey: settingsKeys.sessions }), + }); +} + +// Change-password — no useQueryClient invalidation; the caller is expected +// to logout immediately afterwards (server already revoked sibling sessions +// for us, only the current one survives, and we want a fresh login anyway). +export function useChangePassword() { + return useMutation({ + mutationFn: (body: ChangePasswordRequest) => + api.post('/auth/change-password', body), + }); +} diff --git a/server/dashboard/src/modules/settings/index.ts b/server/dashboard/src/modules/settings/index.ts new file mode 100644 index 0000000..66d77ee --- /dev/null +++ b/server/dashboard/src/modules/settings/index.ts @@ -0,0 +1,12 @@ +import { Settings as SettingsIcon } from 'lucide-react'; +import type { Module } from '../types'; +import SettingsPage from './SettingsPage'; + +export const SettingsModule: Module = { + id: 'settings', + label: 'Settings', + icon: SettingsIcon, + path: '/settings', + element: SettingsPage, + weight: 50, +}; diff --git a/server/dashboard/src/modules/settings/sections/EditorSection.tsx b/server/dashboard/src/modules/settings/sections/EditorSection.tsx new file mode 100644 index 0000000..0f1122b --- /dev/null +++ b/server/dashboard/src/modules/settings/sections/EditorSection.tsx @@ -0,0 +1,71 @@ +import { useState } from 'react'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Label } from '@/ui/label'; +import { RadioGroup, RadioGroupItem } from '@/ui/radio-group'; +import { + getEditorPreference, + setEditorPreference, + type EditorProtocol, +} from '@/lib/editorPreference'; + +const OPTIONS: ReadonlyArray<{ + value: EditorProtocol; + label: string; + hint: string; +}> = [ + { + value: 'cursor', + label: 'Cursor (default)', + hint: 'Opens cursor:// — falls back to VS Code if Cursor is not installed.', + }, + { + value: 'vscode', + label: 'VS Code', + hint: 'Opens vscode:// directly.', + }, + { + value: 'none', + label: 'Disabled', + hint: 'The Open in editor button does nothing.', + }, +]; + +export function EditorSection() { + const [pref, setPref] = useState(() => getEditorPreference()); + + function onChange(next: EditorProtocol) { + setPref(next); + setEditorPreference(next); + } + + return ( + + + Open in editor + + What happens when you click the Open icon next to a search result. + Stored locally — applies to this browser only. + + + + onChange(v as EditorProtocol)} + className="space-y-3" + > + {OPTIONS.map((o) => ( +
+ +
+ +

{o.hint}

+
+
+ ))} + + + + ); +} diff --git a/server/dashboard/src/modules/settings/sections/ProfileSection.tsx b/server/dashboard/src/modules/settings/sections/ProfileSection.tsx new file mode 100644 index 0000000..d23e989 --- /dev/null +++ b/server/dashboard/src/modules/settings/sections/ProfileSection.tsx @@ -0,0 +1,30 @@ +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { useAuth } from '@/auth/useAuth'; +import { ChangePasswordForm } from '../components/ChangePasswordForm'; + +export function ProfileSection() { + const { user } = useAuth(); + return ( + + + Profile + Account email + password. + + +
+ + Email + + {user?.email ?? '—'} + + Role: {user?.role ?? 'unknown'} + +
+
+

Change password

+ +
+ + + ); +} diff --git a/server/dashboard/src/modules/settings/sections/SessionsSection.tsx b/server/dashboard/src/modules/settings/sections/SessionsSection.tsx new file mode 100644 index 0000000..e453cbf --- /dev/null +++ b/server/dashboard/src/modules/settings/sections/SessionsSection.tsx @@ -0,0 +1,69 @@ +import { AlertCircle } from 'lucide-react'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Skeleton } from '@/ui/skeleton'; +import { + Table, + TableBody, + TableHead, + TableHeader, + TableRow, +} from '@/ui/table'; +import { SessionRow } from '../components/SessionRow'; +import { useMySessions } from '../hooks'; + +export function SessionsSection() { + const { data, error, isLoading } = useMySessions(); + + return ( + + + Active sessions + + Browsers signed in to your account. Sign out of any session you + don’t recognise. + + + + {isLoading ? ( +
+ {Array.from({ length: 2 }).map((_, i) => ( + + ))} +
+ ) : error ? ( + + + Failed to load sessions + + {error instanceof ApiError ? error.detail : String(error)} + + + ) : !data || data.sessions.length === 0 ? ( +

No active sessions.

+ ) : ( +
+ + + + Started + Last seen + IP + User agent + + Actions + + + + {data.sessions.map((s) => ( + + ))} + +
+
+ )} + + + ); +} diff --git a/server/dashboard/src/modules/settings/sections/ThemeSection.tsx b/server/dashboard/src/modules/settings/sections/ThemeSection.tsx new file mode 100644 index 0000000..6b8da72 --- /dev/null +++ b/server/dashboard/src/modules/settings/sections/ThemeSection.tsx @@ -0,0 +1,50 @@ +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/ui/card'; +import { Label } from '@/ui/label'; +import { RadioGroup, RadioGroupItem } from '@/ui/radio-group'; +import { useTheme } from '@/app/ThemeProvider'; +import type { ThemeMode } from '@/lib/theme'; + +const OPTIONS: ReadonlyArray<{ value: ThemeMode; label: string; hint: string }> = [ + { value: 'light', label: 'Light', hint: 'Always use the light theme.' }, + { value: 'dark', label: 'Dark', hint: 'Always use the dark theme.' }, + { + value: 'system', + label: 'System', + hint: 'Follow the OS-level prefers-color-scheme setting.', + }, +]; + +export function ThemeSection() { + const { mode, resolved, setMode } = useTheme(); + + return ( + + + Theme + + Currently rendering in {resolved}{' '} + mode. Stored locally — applies to this browser only. + + + + setMode(v as ThemeMode)} + className="space-y-3" + > + {OPTIONS.map((o) => ( +
+ +
+ +

{o.hint}

+
+
+ ))} + + + + ); +} diff --git a/server/dashboard/src/modules/types.ts b/server/dashboard/src/modules/types.ts new file mode 100644 index 0000000..03c3143 --- /dev/null +++ b/server/dashboard/src/modules/types.ts @@ -0,0 +1,25 @@ +import type { ComponentType, SVGProps } from 'react'; +import type { Role } from '@/api/types'; + +// A `Module` is a self-contained dashboard feature: its own folder under +// `src/modules//` with an `index.ts` that exports a `Module` constant. +// +// Sidebar + router both consume the registry — adding a new feature is +// "create folder, register the module" and nothing else. See +// `dashboard/README.md` for the full style guide. +export interface Module { + /** Stable kebab-case identifier — also used as the React key in the sidebar. */ + id: string; + /** Human-facing label shown in the sidebar. */ + label: string; + /** Sidebar icon — must accept `className`. lucide-react icons satisfy this. */ + icon: ComponentType>; + /** Path relative to the `/dashboard` basename (must start with `/`). */ + path: string; + /** Top-level page rendered for this module. Owns its own internal routes. */ + element: ComponentType; + /** Minimum role required to *see* this module in the sidebar. Default: viewer. */ + requiredRole?: Role; + /** Sort order in the sidebar — lower comes first. Default: 100. */ + weight?: number; +} diff --git a/server/dashboard/src/modules/users/UsersPage.tsx b/server/dashboard/src/modules/users/UsersPage.tsx new file mode 100644 index 0000000..0a2a573 --- /dev/null +++ b/server/dashboard/src/modules/users/UsersPage.tsx @@ -0,0 +1,60 @@ +import { AlertCircle, Users as UsersIcon } from 'lucide-react'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription, AlertTitle } from '@/ui/alert'; +import { Skeleton } from '@/ui/skeleton'; +import { useAuth } from '@/auth/useAuth'; +import { InviteUserDialog } from './components/InviteUserDialog'; +import { UsersTable } from './components/UsersTable'; +import { useUsers } from './hooks'; + +export default function UsersPage() { + const { user } = useAuth(); + const { data, error, isLoading } = useUsers(); + + return ( +
+
+
+

Users

+

+ {data ? `${data.total} ${data.total === 1 ? 'user' : 'users'}` : ' '} +

+
+ +
+ + {isLoading ? ( +
+ {Array.from({ length: 4 }).map((_, i) => ( + + ))} +
+ ) : error ? ( + + + Failed to load users + + {error instanceof ApiError ? error.detail : String(error)} + + + ) : !data || data.users.length === 0 ? ( + + ) : ( + + )} +
+ ); +} + +function EmptyState() { + return ( +
+ +

No users yet

+

+ Invite the first teammate to share dashboard access. Bootstrap admin + always counts — if you can read this, your account is in the list. +

+
+ ); +} diff --git a/server/dashboard/src/modules/users/components/DeleteUserDialog.tsx b/server/dashboard/src/modules/users/components/DeleteUserDialog.tsx new file mode 100644 index 0000000..8057a72 --- /dev/null +++ b/server/dashboard/src/modules/users/components/DeleteUserDialog.tsx @@ -0,0 +1,104 @@ +import { useState } from 'react'; +import { Loader2, Trash2 } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from '@/ui/dialog'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { useDeleteUser } from '../hooks'; + +// Two-factor confirm: typing the email avoids accidental destructive clicks +// in a list of similar-looking rows. Server cascade-deletes sessions + keys. +export function DeleteUserDialog({ + userId, + email, +}: { + userId: string; + email: string; +}) { + const [open, setOpen] = useState(false); + const [typed, setTyped] = useState(''); + const del = useDeleteUser(); + + function reset() { + setTyped(''); + del.reset(); + } + + async function onConfirm() { + if (typed.trim() !== email) return; + try { + await del.mutateAsync(userId); + toast.success('User deleted', { description: email }); + setOpen(false); + reset(); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Failed to delete user', { description: detail }); + } + } + + return ( + { + setOpen(next); + if (!next) reset(); + }} + > + + + + + + Delete user? + + Permanently removes {email}{' '} + and cascades all their sessions and API keys. This cannot be undone. + + +
+ + setTyped(e.target.value)} + placeholder={email} + autoComplete="off" + /> +
+ + + + + + + ); +} diff --git a/server/dashboard/src/modules/users/components/DisableUserButton.tsx b/server/dashboard/src/modules/users/components/DisableUserButton.tsx new file mode 100644 index 0000000..a512faf --- /dev/null +++ b/server/dashboard/src/modules/users/components/DisableUserButton.tsx @@ -0,0 +1,48 @@ +import { Loader2, ShieldOff, ShieldCheck } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Button } from '@/ui/button'; +import { useUpdateUser } from '../hooks'; + +// One-click toggle. Server's last-admin guard kicks in for the disable path. +export function DisableUserButton({ + userId, + disabled, +}: { + userId: string; + /** Current disabled state on the user record. */ + disabled: boolean; +}) { + const update = useUpdateUser(); + + async function onToggle() { + try { + await update.mutateAsync({ id: userId, body: { disabled: !disabled } }); + toast.success(disabled ? 'User re-enabled' : 'User disabled'); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error(disabled ? 'Could not enable user' : 'Could not disable user', { + description: detail, + }); + } + } + + return ( + + ); +} diff --git a/server/dashboard/src/modules/users/components/InviteUserDialog.tsx b/server/dashboard/src/modules/users/components/InviteUserDialog.tsx new file mode 100644 index 0000000..458df94 --- /dev/null +++ b/server/dashboard/src/modules/users/components/InviteUserDialog.tsx @@ -0,0 +1,151 @@ +import { useState } from 'react'; +import { Loader2, UserPlus } from 'lucide-react'; +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { Alert, AlertDescription } from '@/ui/alert'; +import { Button } from '@/ui/button'; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, + DialogTrigger, +} from '@/ui/dialog'; +import { Input } from '@/ui/input'; +import { Label } from '@/ui/label'; +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from '@/ui/select'; +import type { Role } from '@/api/types'; +import { useCreateUser } from '../hooks'; + +// Invite-only flow: admin sets the initial password and shares it out-of-band. +// The new user is forced to change it on first login (server sets +// must_change_password=true). Field minimums (≥8 chars) mirror the server. +export function InviteUserDialog() { + const [open, setOpen] = useState(false); + const [email, setEmail] = useState(''); + const [role, setRole] = useState('viewer'); + const [pw, setPw] = useState(''); + const create = useCreateUser(); + + function reset() { + setEmail(''); + setRole('viewer'); + setPw(''); + create.reset(); + } + + async function onSubmit() { + const trimmedEmail = email.trim(); + if (!trimmedEmail || pw.length < 8) return; + try { + await create.mutateAsync({ + email: trimmedEmail, + role, + initial_password: pw, + }); + toast.success('User created', { + description: `Share the initial password with ${trimmedEmail}. They will be required to change it on first login.`, + }); + setOpen(false); + reset(); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Failed to invite user', { description: detail }); + } + } + + return ( + { + setOpen(next); + if (!next) reset(); + }} + > + + + + + + Invite user + + Creates a user with an initial password you set. The user is forced + to change it on first login. + + + +
+
+ + setEmail(e.target.value)} + placeholder="user@example.com" + /> +
+
+ + +
+
+ + setPw(e.target.value)} + placeholder="At least 8 characters" + /> +

+ Shown once. Share via your team’s preferred secure channel. +

+
+ + + The user’s account will be flagged{' '} + must_change_password; + they cannot use the system until they pick a new password. + + +
+ + + + + + + + ); +} diff --git a/server/dashboard/src/modules/users/components/UserRoleSelect.tsx b/server/dashboard/src/modules/users/components/UserRoleSelect.tsx new file mode 100644 index 0000000..18de764 --- /dev/null +++ b/server/dashboard/src/modules/users/components/UserRoleSelect.tsx @@ -0,0 +1,52 @@ +import { toast } from 'sonner'; +import { ApiError } from '@/api/client'; +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from '@/ui/select'; +import type { Role } from '@/api/types'; +import { useUpdateUser } from '../hooks'; + +// Inline role-edit. The server enforces the last-admin guard — if it returns +// 409 we just surface the toast and the next refetch resets the value. +export function UserRoleSelect({ + userId, + role, + disabled = false, +}: { + userId: string; + role: Role; + disabled?: boolean; +}) { + const update = useUpdateUser(); + + async function onChange(next: Role) { + if (next === role) return; + try { + await update.mutateAsync({ id: userId, body: { role: next } }); + toast.success('Role updated', { description: `Now ${next}` }); + } catch (err) { + const detail = err instanceof ApiError ? err.detail : String(err); + toast.error('Could not update role', { description: detail }); + } + } + + return ( + + ); +} diff --git a/server/dashboard/src/modules/users/components/UsersTable.tsx b/server/dashboard/src/modules/users/components/UsersTable.tsx new file mode 100644 index 0000000..592ef00 --- /dev/null +++ b/server/dashboard/src/modules/users/components/UsersTable.tsx @@ -0,0 +1,95 @@ +import type { UserWithStats } from '@/api/types'; +import { Badge } from '@/ui/badge'; +import { + Table, + TableBody, + TableCell, + TableHead, + TableHeader, + TableRow, +} from '@/ui/table'; +import { cn } from '@/lib/cn'; +import { formatDateTime, formatRelative } from '@/lib/formatDate'; +import { DeleteUserDialog } from './DeleteUserDialog'; +import { DisableUserButton } from './DisableUserButton'; +import { UserRoleSelect } from './UserRoleSelect'; + +export function UsersTable({ + users, + currentUserId, +}: { + users: UserWithStats[]; + currentUserId: string | undefined; +}) { + return ( +
+ + + + Email + Role + Created + Last login + Sessions + API keys + Status + Actions + + + + {users.map((u) => { + const isSelf = u.id === currentUserId; + return ( + + +
+ {u.email} + {isSelf ? You : null} +
+ + + + + + {formatRelative(u.created_at)} + + + {formatRelative(u.last_login_at)} + + + {u.active_sessions_count} + + + {u.api_keys_count} + + + {u.disabled ? ( + disabled + ) : ( + active + )} + + +
+ {isSelf ? null : ( + <> + + + + )} +
+ + + ); + })} + +
+
+ ); +} diff --git a/server/dashboard/src/modules/users/hooks.ts b/server/dashboard/src/modules/users/hooks.ts new file mode 100644 index 0000000..d8baab6 --- /dev/null +++ b/server/dashboard/src/modules/users/hooks.ts @@ -0,0 +1,44 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'; +import { api } from '@/api/client'; +import type { + CreateUserRequest, + UpdateUserRequest, + User, + UserListResponse, +} from '@/api/types'; + +export const userKeys = { + all: ['users'] as const, +}; + +export function useUsers() { + return useQuery({ + queryKey: userKeys.all, + queryFn: ({ signal }) => api.get('/admin/users', { signal }), + }); +} + +export function useCreateUser() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (body: CreateUserRequest) => api.post('/admin/users', body), + onSuccess: () => qc.invalidateQueries({ queryKey: userKeys.all }), + }); +} + +export function useUpdateUser() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: ({ id, body }: { id: string; body: UpdateUserRequest }) => + api.patch(`/admin/users/${id}`, body), + onSuccess: () => qc.invalidateQueries({ queryKey: userKeys.all }), + }); +} + +export function useDeleteUser() { + const qc = useQueryClient(); + return useMutation({ + mutationFn: (id: string) => api.delete(`/admin/users/${id}`), + onSuccess: () => qc.invalidateQueries({ queryKey: userKeys.all }), + }); +} diff --git a/server/dashboard/src/modules/users/index.ts b/server/dashboard/src/modules/users/index.ts new file mode 100644 index 0000000..4352e82 --- /dev/null +++ b/server/dashboard/src/modules/users/index.ts @@ -0,0 +1,13 @@ +import { Users } from 'lucide-react'; +import type { Module } from '../types'; +import UsersPage from './UsersPage'; + +export const UsersModule: Module = { + id: 'users', + label: 'Users', + icon: Users, + path: '/users', + element: UsersPage, + requiredRole: 'admin', + weight: 40, +}; diff --git a/server/dashboard/src/ui/alert.tsx b/server/dashboard/src/ui/alert.tsx new file mode 100644 index 0000000..2f7b5c8 --- /dev/null +++ b/server/dashboard/src/ui/alert.tsx @@ -0,0 +1,52 @@ +import { cva, type VariantProps } from 'class-variance-authority'; +import { forwardRef, type HTMLAttributes } from 'react'; +import { cn } from '@/lib/cn'; + +const alertVariants = cva( + 'relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground [&>svg~*]:pl-7', + { + variants: { + variant: { + default: 'bg-background text-foreground', + destructive: + 'border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive', + }, + }, + defaultVariants: { variant: 'default' }, + } +); + +export const Alert = forwardRef< + HTMLDivElement, + HTMLAttributes & VariantProps +>(({ className, variant, ...props }, ref) => ( +
+)); +Alert.displayName = 'Alert'; + +export const AlertTitle = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +AlertTitle.displayName = 'AlertTitle'; + +export const AlertDescription = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +AlertDescription.displayName = 'AlertDescription'; diff --git a/server/dashboard/src/ui/badge.tsx b/server/dashboard/src/ui/badge.tsx new file mode 100644 index 0000000..d7fbe4b --- /dev/null +++ b/server/dashboard/src/ui/badge.tsx @@ -0,0 +1,36 @@ +import * as React from "react" +import { cva, type VariantProps } from "class-variance-authority" + +import { cn } from "@/lib/cn" + +const badgeVariants = cva( + "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", + { + variants: { + variant: { + default: + "border-transparent bg-primary text-primary-foreground hover:bg-primary/80", + secondary: + "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80", + destructive: + "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80", + outline: "text-foreground", + }, + }, + defaultVariants: { + variant: "default", + }, + } +) + +export interface BadgeProps + extends React.HTMLAttributes, + VariantProps {} + +function Badge({ className, variant, ...props }: BadgeProps) { + return ( +
+ ) +} + +export { Badge, badgeVariants } diff --git a/server/dashboard/src/ui/button.tsx b/server/dashboard/src/ui/button.tsx new file mode 100644 index 0000000..577eb63 --- /dev/null +++ b/server/dashboard/src/ui/button.tsx @@ -0,0 +1,55 @@ +import { Slot } from '@radix-ui/react-slot'; +import { cva, type VariantProps } from 'class-variance-authority'; +import { forwardRef, type ButtonHTMLAttributes } from 'react'; +import { cn } from '@/lib/cn'; + +const buttonVariants = cva( + 'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0', + { + variants: { + variant: { + default: 'bg-primary text-primary-foreground hover:bg-primary/90', + destructive: + 'bg-destructive text-destructive-foreground hover:bg-destructive/90', + outline: + 'border border-input bg-background hover:bg-accent hover:text-accent-foreground', + secondary: + 'bg-secondary text-secondary-foreground hover:bg-secondary/80', + ghost: 'hover:bg-accent hover:text-accent-foreground', + link: 'text-primary underline-offset-4 hover:underline', + }, + size: { + default: 'h-9 px-4 py-2', + sm: 'h-8 rounded-md px-3 text-xs', + lg: 'h-10 rounded-md px-6', + icon: 'h-9 w-9', + }, + }, + defaultVariants: { + variant: 'default', + size: 'default', + }, + } +); + +export interface ButtonProps + extends ButtonHTMLAttributes, + VariantProps { + asChild?: boolean; +} + +export const Button = forwardRef( + ({ className, variant, size, asChild = false, ...props }, ref) => { + const Comp = asChild ? Slot : 'button'; + return ( + + ); + } +); +Button.displayName = 'Button'; + +export { buttonVariants }; diff --git a/server/dashboard/src/ui/card.tsx b/server/dashboard/src/ui/card.tsx new file mode 100644 index 0000000..a03423f --- /dev/null +++ b/server/dashboard/src/ui/card.tsx @@ -0,0 +1,52 @@ +import { forwardRef, type HTMLAttributes } from 'react'; +import { cn } from '@/lib/cn'; + +export const Card = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +Card.displayName = 'Card'; + +export const CardHeader = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +CardHeader.displayName = 'CardHeader'; + +export const CardTitle = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +CardTitle.displayName = 'CardTitle'; + +export const CardDescription = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +CardDescription.displayName = 'CardDescription'; + +export const CardContent = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +CardContent.displayName = 'CardContent'; + +export const CardFooter = forwardRef>( + ({ className, ...props }, ref) => ( +
+ ) +); +CardFooter.displayName = 'CardFooter'; diff --git a/server/dashboard/src/ui/dialog.tsx b/server/dashboard/src/ui/dialog.tsx new file mode 100644 index 0000000..b4e6616 --- /dev/null +++ b/server/dashboard/src/ui/dialog.tsx @@ -0,0 +1,93 @@ +import * as DialogPrimitive from '@radix-ui/react-dialog'; +import { X } from 'lucide-react'; +import { + forwardRef, + type ComponentPropsWithoutRef, + type ElementRef, + type HTMLAttributes, +} from 'react'; +import { cn } from '@/lib/cn'; + +export const Dialog = DialogPrimitive.Root; +export const DialogTrigger = DialogPrimitive.Trigger; +export const DialogPortal = DialogPrimitive.Portal; +export const DialogClose = DialogPrimitive.Close; + +export const DialogOverlay = forwardRef< + ElementRef, + ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)); +DialogOverlay.displayName = DialogPrimitive.Overlay.displayName; + +export const DialogContent = forwardRef< + ElementRef, + ComponentPropsWithoutRef +>(({ className, children, ...props }, ref) => ( + + + + {children} + + + Close + + + +)); +DialogContent.displayName = DialogPrimitive.Content.displayName; + +export const DialogHeader = ({ className, ...props }: HTMLAttributes) => ( +
+); +DialogHeader.displayName = 'DialogHeader'; + +export const DialogFooter = ({ className, ...props }: HTMLAttributes) => ( +
+); +DialogFooter.displayName = 'DialogFooter'; + +export const DialogTitle = forwardRef< + ElementRef, + ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)); +DialogTitle.displayName = DialogPrimitive.Title.displayName; + +export const DialogDescription = forwardRef< + ElementRef, + ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)); +DialogDescription.displayName = DialogPrimitive.Description.displayName; diff --git a/server/dashboard/src/ui/input.tsx b/server/dashboard/src/ui/input.tsx new file mode 100644 index 0000000..05b78c3 --- /dev/null +++ b/server/dashboard/src/ui/input.tsx @@ -0,0 +1,17 @@ +import { forwardRef, type InputHTMLAttributes } from 'react'; +import { cn } from '@/lib/cn'; + +export const Input = forwardRef>( + ({ className, type, ...props }, ref) => ( + + ) +); +Input.displayName = 'Input'; diff --git a/server/dashboard/src/ui/label.tsx b/server/dashboard/src/ui/label.tsx new file mode 100644 index 0000000..2a98d66 --- /dev/null +++ b/server/dashboard/src/ui/label.tsx @@ -0,0 +1,18 @@ +import * as LabelPrimitive from '@radix-ui/react-label'; +import { forwardRef, type ComponentPropsWithoutRef, type ElementRef } from 'react'; +import { cn } from '@/lib/cn'; + +export const Label = forwardRef< + ElementRef, + ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)); +Label.displayName = LabelPrimitive.Root.displayName; diff --git a/server/dashboard/src/ui/radio-group.tsx b/server/dashboard/src/ui/radio-group.tsx new file mode 100644 index 0000000..571a487 --- /dev/null +++ b/server/dashboard/src/ui/radio-group.tsx @@ -0,0 +1,42 @@ +import * as React from "react" +import * as RadioGroupPrimitive from "@radix-ui/react-radio-group" +import { Circle } from "lucide-react" + +import { cn } from "@/lib/cn" + +const RadioGroup = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => { + return ( + + ) +}) +RadioGroup.displayName = RadioGroupPrimitive.Root.displayName + +const RadioGroupItem = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => { + return ( + + + + + + ) +}) +RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName + +export { RadioGroup, RadioGroupItem } diff --git a/server/dashboard/src/ui/scroll-area.tsx b/server/dashboard/src/ui/scroll-area.tsx new file mode 100644 index 0000000..f099c02 --- /dev/null +++ b/server/dashboard/src/ui/scroll-area.tsx @@ -0,0 +1,46 @@ +import * as React from "react" +import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area" + +import { cn } from "@/lib/cn" + +const ScrollArea = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, children, ...props }, ref) => ( + + + {children} + + + + +)) +ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName + +const ScrollBar = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, orientation = "vertical", ...props }, ref) => ( + + + +)) +ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName + +export { ScrollArea, ScrollBar } diff --git a/server/dashboard/src/ui/select.tsx b/server/dashboard/src/ui/select.tsx new file mode 100644 index 0000000..1f7778c --- /dev/null +++ b/server/dashboard/src/ui/select.tsx @@ -0,0 +1,158 @@ +import * as React from "react" +import * as SelectPrimitive from "@radix-ui/react-select" +import { Check, ChevronDown, ChevronUp } from "lucide-react" + +import { cn } from "@/lib/cn" + +const Select = SelectPrimitive.Root + +const SelectGroup = SelectPrimitive.Group + +const SelectValue = SelectPrimitive.Value + +const SelectTrigger = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, children, ...props }, ref) => ( + span]:line-clamp-1", + className + )} + {...props} + > + {children} + + + + +)) +SelectTrigger.displayName = SelectPrimitive.Trigger.displayName + +const SelectScrollUpButton = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + + + +)) +SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName + +const SelectScrollDownButton = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + + + +)) +SelectScrollDownButton.displayName = + SelectPrimitive.ScrollDownButton.displayName + +const SelectContent = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, children, position = "popper", ...props }, ref) => ( + + + + + {children} + + + + +)) +SelectContent.displayName = SelectPrimitive.Content.displayName + +const SelectLabel = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)) +SelectLabel.displayName = SelectPrimitive.Label.displayName + +const SelectItem = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, children, ...props }, ref) => ( + + + + + + + + {children} + +)) +SelectItem.displayName = SelectPrimitive.Item.displayName + +const SelectSeparator = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)) +SelectSeparator.displayName = SelectPrimitive.Separator.displayName + +export { + Select, + SelectGroup, + SelectValue, + SelectTrigger, + SelectContent, + SelectLabel, + SelectItem, + SelectSeparator, + SelectScrollUpButton, + SelectScrollDownButton, +} diff --git a/server/dashboard/src/ui/skeleton.tsx b/server/dashboard/src/ui/skeleton.tsx new file mode 100644 index 0000000..67dc9fc --- /dev/null +++ b/server/dashboard/src/ui/skeleton.tsx @@ -0,0 +1,15 @@ +import { cn } from "@/lib/cn" + +function Skeleton({ + className, + ...props +}: React.HTMLAttributes) { + return ( +
+ ) +} + +export { Skeleton } diff --git a/server/dashboard/src/ui/slider.tsx b/server/dashboard/src/ui/slider.tsx new file mode 100644 index 0000000..ed0d360 --- /dev/null +++ b/server/dashboard/src/ui/slider.tsx @@ -0,0 +1,28 @@ +"use client" + +import * as React from "react" +import * as SliderPrimitive from "@radix-ui/react-slider" + +import { cn } from "@/lib/cn" + +const Slider = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + + + + + + +)) +Slider.displayName = SliderPrimitive.Root.displayName + +export { Slider } diff --git a/server/dashboard/src/ui/sonner.tsx b/server/dashboard/src/ui/sonner.tsx new file mode 100644 index 0000000..6dc40e9 --- /dev/null +++ b/server/dashboard/src/ui/sonner.tsx @@ -0,0 +1,20 @@ +import { Toaster as SonnerToaster } from 'sonner'; + +// Thin wrapper so the rest of the app imports `Toaster` from `@/ui/sonner` +// instead of pulling sonner directly. Keeps swap potential trivial. +export function Toaster() { + return ( + + ); +} + +export { toast } from 'sonner'; diff --git a/server/dashboard/src/ui/switch.tsx b/server/dashboard/src/ui/switch.tsx new file mode 100644 index 0000000..ad88818 --- /dev/null +++ b/server/dashboard/src/ui/switch.tsx @@ -0,0 +1,29 @@ +"use client" + +import * as React from "react" +import * as SwitchPrimitives from "@radix-ui/react-switch" + +import { cn } from "@/lib/cn" + +const Switch = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + + + +)) +Switch.displayName = SwitchPrimitives.Root.displayName + +export { Switch } diff --git a/server/dashboard/src/ui/table.tsx b/server/dashboard/src/ui/table.tsx new file mode 100644 index 0000000..3699604 --- /dev/null +++ b/server/dashboard/src/ui/table.tsx @@ -0,0 +1,117 @@ +import * as React from "react" + +import { cn } from "@/lib/cn" + +const Table = React.forwardRef< + HTMLTableElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( +
+ + +)) +Table.displayName = "Table" + +const TableHeader = React.forwardRef< + HTMLTableSectionElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( + +)) +TableHeader.displayName = "TableHeader" + +const TableBody = React.forwardRef< + HTMLTableSectionElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( + +)) +TableBody.displayName = "TableBody" + +const TableFooter = React.forwardRef< + HTMLTableSectionElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( + tr]:last:border-b-0", + className + )} + {...props} + /> +)) +TableFooter.displayName = "TableFooter" + +const TableRow = React.forwardRef< + HTMLTableRowElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( + +)) +TableRow.displayName = "TableRow" + +const TableHead = React.forwardRef< + HTMLTableCellElement, + React.ThHTMLAttributes +>(({ className, ...props }, ref) => ( + \n"},cC.thead_close=function(){return"\n"},cC.tbody_open=function(){return"\n"},cC.tbody_close=function(){return"\n"},cC.tr_open=function(){return""},cC.tr_close=function(){return"\n"},cC.th_open=function(s,o){var i=s[o];return""},cC.th_close=function(){return""},cC.td_open=function(s,o){var i=s[o];return""},cC.td_close=function(){return""},cC.strong_open=function(){return""},cC.strong_close=function(){return""},cC.em_open=function(){return""},cC.em_close=function(){return""},cC.del_open=function(){return""},cC.del_close=function(){return""},cC.ins_open=function(){return""},cC.ins_close=function(){return""},cC.mark_open=function(){return""},cC.mark_close=function(){return""},cC.sub=function(s,o){return""+escapeHtml(s[o].content)+""},cC.sup=function(s,o){return""+escapeHtml(s[o].content)+""},cC.hardbreak=function(s,o,i){return i.xhtmlOut?"
\n":"
\n"},cC.softbreak=function(s,o,i){return i.breaks?i.xhtmlOut?"
\n":"
\n":"\n"},cC.text=function(s,o){return escapeHtml(s[o].content)},cC.htmlblock=function(s,o){return s[o].content},cC.htmltag=function(s,o){return s[o].content},cC.abbr_open=function(s,o){return''},cC.abbr_close=function(){return""},cC.footnote_ref=function(s,o){var i=Number(s[o].id+1).toString(),u="fnref"+i;return s[o].subId>0&&(u+=":"+s[o].subId),'['+i+"]"},cC.footnote_block_open=function(s,o,i){return(i.xhtmlOut?'
\n':'
\n')+'
\n
    \n'},cC.footnote_block_close=function(){return"
\n
\n"},cC.footnote_open=function(s,o){return'
  • '},cC.footnote_close=function(){return"
    • \n"},cC.footnote_anchor=function(s,o){var i="fnref"+Number(s[o].id+1).toString();return s[o].subId>0&&(i+=":"+s[o].subId),' ↩'},cC.dl_open=function(){return"
    \n"},cC.dt_open=function(){return"
    "},cC.dd_open=function(){return"
    "},cC.dl_close=function(){return"
    \n"},cC.dt_close=function(){return"\n"},cC.dd_close=function(){return"\n"};var uC=cC.getBreak=function getBreak(s,o){return(o=nextToken(s,o))1)break;if(41===i&&--u<0)break;o++}return w!==o&&(_=unescapeMd(s.src.slice(w,o)),!!s.parser.validateLink(_)&&(s.linkContent=_,s.pos=o,!0))}function parseLinkTitle(s,o){var i,u=o,_=s.posMax,w=s.src.charCodeAt(o);if(34!==w&&39!==w&&40!==w)return!1;for(o++,40===w&&(w=41);o<_;){if((i=s.src.charCodeAt(o))===w)return s.pos=o+1,s.linkContent=unescapeMd(s.src.slice(u+1,o)),!0;92===i&&o+1<_?o+=2:o++}return!1}function normalizeReference(s){return s.trim().replace(/\s+/g," ").toUpperCase()}function parseReference(s,o,i,u){var _,w,x,C,j,L,B,$,V;if(91!==s.charCodeAt(0))return-1;if(-1===s.indexOf("]:"))return-1;if((w=parseLinkLabel(_=new StateInline(s,o,i,u,[]),0))<0||58!==s.charCodeAt(w+1))return-1;for(C=_.posMax,x=w+2;x=s.length)&&!yC.test(s[o])}function replaceAt(s,o,i){return s.substr(0,o)+i+s.substr(o+1)}var vC=[["block",function block(s){s.inlineMode?s.tokens.push({type:"inline",content:s.src.replace(/\n/g," ").trim(),level:0,lines:[0,1],children:[]}):s.block.parse(s.src,s.options,s.env,s.tokens)}],["abbr",function abbr(s){var o,i,u,_,w=s.tokens;if(!s.inlineMode)for(o=1,i=w.length-1;o0?x[o].count:1,u=0;u<_;u++)s.tokens.push({type:"footnote_anchor",id:o,subId:u,level:B});w&&s.tokens.push(w),s.tokens.push({type:"footnote_close",level:--B})}s.tokens.push({type:"footnote_block_close",level:--B})}}],["abbr2",function abbr2(s){var o,i,u,_,w,x,C,j,L,B,$,V,U=s.tokens;if(s.env.abbreviations)for(s.env.abbrRegExp||(V="(^|["+pC.split("").map(regEscape).join("")+"])("+Object.keys(s.env.abbreviations).map((function(s){return s.substr(1)})).sort((function(s,o){return o.length-s.length})).map(regEscape).join("|")+")($|["+pC.split("").map(regEscape).join("")+"])",s.env.abbrRegExp=new RegExp(V,"g")),B=s.env.abbrRegExp,i=0,u=U.length;i=0;o--)if("text"===(w=_[o]).type){for(j=0,x=w.content,B.lastIndex=0,L=w.level,C=[];$=B.exec(x);)B.lastIndex>j&&C.push({type:"text",content:x.slice(j,$.index+$[1].length),level:L}),C.push({type:"abbr_open",title:s.env.abbreviations[":"+$[2]],level:L++}),C.push({type:"text",content:$[2],level:L}),C.push({type:"abbr_close",level:--L}),j=B.lastIndex-$[3].length;C.length&&(j=0;w--)if("inline"===s.tokens[w].type)for(o=(_=s.tokens[w].children).length-1;o>=0;o--)"text"===(i=_[o]).type&&(u=replaceScopedAbbr(u=i.content),hC.test(u)&&(u=u.replace(/\+-/g,"±").replace(/\.{2,}/g,"…").replace(/([?!])…/g,"$1..").replace(/([?!]){4,}/g,"$1$1$1").replace(/,{2,}/g,",").replace(/(^|[^-])---([^-]|$)/gm,"$1—$2").replace(/(^|\s)--(\s|$)/gm,"$1–$2").replace(/(^|[^-\s])--([^-\s]|$)/gm,"$1–$2")),i.content=u)}],["smartquotes",function smartquotes(s){var o,i,u,_,w,x,C,j,L,B,$,V,U,z,Y,Z,ee;if(s.options.typographer)for(ee=[],Y=s.tokens.length-1;Y>=0;Y--)if("inline"===s.tokens[Y].type)for(Z=s.tokens[Y].children,ee.length=0,o=0;o=0&&!(ee[U].level<=C);U--);ee.length=U+1,w=0,x=(u=i.content).length;e:for(;w=0&&(B=ee[U],!(ee[U].level=(_=s.eMarks[o])||42!==(i=s.src.charCodeAt(u++))&&45!==i&&43!==i||u<_&&32!==s.src.charCodeAt(u)?-1:u}function skipOrderedListMarker(s,o){var i,u=s.bMarks[o]+s.tShift[o],_=s.eMarks[o];if(u+1>=_)return-1;if((i=s.src.charCodeAt(u++))<48||i>57)return-1;for(;;){if(u>=_)return-1;if(!((i=s.src.charCodeAt(u++))>=48&&i<=57)){if(41===i||46===i)break;return-1}}return u<_&&32!==s.src.charCodeAt(u)?-1:u}Core.prototype.process=function(s){var o,i,u;for(o=0,i=(u=this.ruler.getRules("")).length;o=this.eMarks[s]},StateBlock.prototype.skipEmptyLines=function skipEmptyLines(s){for(var o=this.lineMax;si;)if(o!==this.src.charCodeAt(--s))return s+1;return s},StateBlock.prototype.getLines=function getLines(s,o,i,u){var _,w,x,C,j,L=s;if(s>=o)return"";if(L+1===o)return w=this.bMarks[L]+Math.min(this.tShift[L],i),x=u?this.eMarks[L]+1:this.eMarks[L],this.src.slice(w,x);for(C=new Array(o-s),_=0;Li&&(j=i),j<0&&(j=0),w=this.bMarks[L]+j,x=L+1]/,EC=/^<\/([a-zA-Z]{1,15})[\s>]/;function index_browser_getLine(s,o){var i=s.bMarks[o]+s.blkIndent,u=s.eMarks[o];return s.src.substr(i,u-i)}function skipMarker(s,o){var i,u,_=s.bMarks[o]+s.tShift[o],w=s.eMarks[o];return _>=w||126!==(u=s.src.charCodeAt(_++))&&58!==u||_===(i=s.skipSpaces(_))||i>=w?-1:i}var wC=[["code",function code(s,o,i){var u,_;if(s.tShift[o]-s.blkIndent<4)return!1;for(_=u=o+1;u=4))break;_=++u}return s.line=u,s.tokens.push({type:"code",content:s.getLines(o,_,4+s.blkIndent,!0),block:!0,lines:[o,s.line],level:s.level}),!0}],["fences",function fences(s,o,i,u){var _,w,x,C,j,L=!1,B=s.bMarks[o]+s.tShift[o],$=s.eMarks[o];if(B+3>$)return!1;if(126!==(_=s.src.charCodeAt(B))&&96!==_)return!1;if(j=B,(w=(B=s.skipChars(B,_))-j)<3)return!1;if((x=s.src.slice(B,$).trim()).indexOf("`")>=0)return!1;if(u)return!0;for(C=o;!(++C>=i)&&!((B=j=s.bMarks[C]+s.tShift[C])<($=s.eMarks[C])&&s.tShift[C]=4||(B=s.skipChars(B,_))-jZ)return!1;if(62!==s.src.charCodeAt(Y++))return!1;if(s.level>=s.options.maxNesting)return!1;if(u)return!0;for(32===s.src.charCodeAt(Y)&&Y++,j=s.blkIndent,s.blkIndent=0,C=[s.bMarks[o]],s.bMarks[o]=Y,w=(Y=Y=Z,x=[s.tShift[o]],s.tShift[o]=Y-s.bMarks[o],$=s.parser.ruler.getRules("blockquote"),_=o+1;_=(Z=s.eMarks[_]));_++)if(62!==s.src.charCodeAt(Y++)){if(w)break;for(z=!1,V=0,U=$.length;V=Z,x.push(s.tShift[_]),s.tShift[_]=Y-s.bMarks[_];for(L=s.parentType,s.parentType="blockquote",s.tokens.push({type:"blockquote_open",lines:B=[o,0],level:s.level++}),s.parser.tokenize(s,o,_),s.tokens.push({type:"blockquote_close",level:--s.level}),s.parentType=L,B[1]=s.line,V=0;Vj)return!1;if(42!==(_=s.src.charCodeAt(C++))&&45!==_&&95!==_)return!1;for(w=1;C=0)Y=!0;else{if(!(($=skipBulletListMarker(s,o))>=0))return!1;Y=!1}if(s.level>=s.options.maxNesting)return!1;if(z=s.src.charCodeAt($-1),u)return!0;for(ee=s.tokens.length,Y?(B=s.bMarks[o]+s.tShift[o],U=Number(s.src.substr(B,$-B-1)),s.tokens.push({type:"ordered_list_open",order:U,lines:ae=[o,0],level:s.level++})):s.tokens.push({type:"bullet_list_open",lines:ae=[o,0],level:s.level++}),_=o,ie=!1,ce=s.parser.ruler.getRules("list");!(!(_=s.eMarks[_]?1:Z-$)>4&&(V=1),V<1&&(V=1),w=$-s.bMarks[_]+V,s.tokens.push({type:"list_item_open",lines:le=[o,0],level:s.level++}),C=s.blkIndent,j=s.tight,x=s.tShift[o],L=s.parentType,s.tShift[o]=Z-s.bMarks[o],s.blkIndent=w,s.tight=!0,s.parentType="list",s.parser.tokenize(s,o,i,!0),s.tight&&!ie||(ye=!1),ie=s.line-o>1&&s.isEmpty(s.line-1),s.blkIndent=C,s.tShift[o]=x,s.tight=j,s.parentType=L,s.tokens.push({type:"list_item_close",level:--s.level}),_=o=s.line,le[1]=_,Z=s.bMarks[o],_>=i)||s.isEmpty(_)||s.tShift[_]B)return!1;if(91!==s.src.charCodeAt(L))return!1;if(94!==s.src.charCodeAt(L+1))return!1;if(s.level>=s.options.maxNesting)return!1;for(C=L+2;C=B||58!==s.src.charCodeAt(++C))&&(u||(C++,s.env.footnotes||(s.env.footnotes={}),s.env.footnotes.refs||(s.env.footnotes.refs={}),j=s.src.slice(L+2,C-2),s.env.footnotes.refs[":"+j]=-1,s.tokens.push({type:"footnote_reference_open",label:j,level:s.level++}),_=s.bMarks[o],w=s.tShift[o],x=s.parentType,s.tShift[o]=s.skipSpaces(C)-C,s.bMarks[o]=C,s.blkIndent+=4,s.parentType="footnote",s.tShift[o]=j)return!1;if(35!==(_=s.src.charCodeAt(C))||C>=j)return!1;for(w=1,_=s.src.charCodeAt(++C);35===_&&C6||CC&&32===s.src.charCodeAt(x-1)&&(j=x),s.line=o+1,s.tokens.push({type:"heading_open",hLevel:w,lines:[o,s.line],level:s.level}),C=i)&&(!(s.tShift[x]3)&&(!((_=s.bMarks[x]+s.tShift[x])>=(w=s.eMarks[x]))&&((45===(u=s.src.charCodeAt(_))||61===u)&&(_=s.skipChars(_,u),!((_=s.skipSpaces(_))3||C+2>=j)return!1;if(60!==s.src.charCodeAt(C))return!1;if(33===(_=s.src.charCodeAt(C+1))||63===_){if(u)return!0}else{if(47!==_&&!function isLetter$1(s){var o=32|s;return o>=97&&o<=122}(_))return!1;if(47===_){if(!(w=s.src.slice(C,j).match(EC)))return!1}else if(!(w=s.src.slice(C,j).match(_C)))return!1;if(!0!==bC[w[1].toLowerCase()])return!1;if(u)return!0}for(x=o+1;xi)return!1;if(j=o+1,s.tShift[j]=s.eMarks[j])return!1;if(124!==(_=s.src.charCodeAt(x))&&45!==_&&58!==_)return!1;if(w=index_browser_getLine(s,o+1),!/^[-:| ]+$/.test(w))return!1;if((L=w.split("|"))<=2)return!1;for($=[],C=0;C=0;if(B=o+1,s.isEmpty(B)&&++B>i)return!1;if(s.tShift[B]=s.options.maxNesting)return!1;L=s.tokens.length,s.tokens.push({type:"dl_open",lines:j=[o,0],level:s.level++}),x=o,w=B;e:for(;;){for(ee=!0,Z=!1,s.tokens.push({type:"dt_open",lines:[x,x],level:s.level++}),s.tokens.push({type:"inline",content:s.getLines(x,x+1,s.blkIndent,!1).trim(),level:s.level+1,lines:[x,x],children:[]}),s.tokens.push({type:"dt_close",level:--s.level});;){if(s.tokens.push({type:"dd_open",lines:C=[B,0],level:s.level++}),Y=s.tight,V=s.ddIndent,$=s.blkIndent,z=s.tShift[w],U=s.parentType,s.blkIndent=s.ddIndent=s.tShift[w]+2,s.tShift[w]=_-s.bMarks[w],s.tight=!0,s.parentType="deflist",s.parser.tokenize(s,w,i,!0),s.tight&&!Z||(ee=!1),Z=s.line-w>1&&s.isEmpty(s.line-1),s.tShift[w]=z,s.tight=Y,s.parentType=U,s.blkIndent=$,s.ddIndent=V,s.tokens.push({type:"dd_close",level:--s.level}),C[1]=B=s.line,B>=i)break e;if(s.tShift[B]=i)break;if(x=B,s.isEmpty(x))break;if(s.tShift[x]=i)break;if(s.isEmpty(w)&&w++,w>=i)break;if(s.tShift[w]3)){for(_=!1,w=0,x=C.length;w=i))&&!(s.tShift[x]=0&&(s=s.replace(SC,(function(o,i){var u;return 10===s.charCodeAt(i)?(w=i+1,x=0,o):(u=" ".slice((i-w-x)%4),x=i-w+1,u)}))),_=new StateBlock(s,this,o,i,u),this.tokenize(_,_.line,_.lineMax)};for(var CC=[],OC=0;OC<256;OC++)CC.push(0);function isAlphaNum(s){return s>=48&&s<=57||s>=65&&s<=90||s>=97&&s<=122}function scanDelims(s,o){var i,u,_,w=o,x=!0,C=!0,j=s.posMax,L=s.src.charCodeAt(o);for(i=o>0?s.src.charCodeAt(o-1):-1;w=j&&(x=!1),(_=w-o)>=4?x=C=!1:(32!==(u=w?@[]^_`{|}~-".split("").forEach((function(s){CC[s.charCodeAt(0)]=1}));var AC=/\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g;var jC=/\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g;var IC=["coap","doi","javascript","aaa","aaas","about","acap","cap","cid","crid","data","dav","dict","dns","file","ftp","geo","go","gopher","h323","http","https","iax","icap","im","imap","info","ipp","iris","iris.beep","iris.xpc","iris.xpcs","iris.lwz","ldap","mailto","mid","msrp","msrps","mtqp","mupdate","news","nfs","ni","nih","nntp","opaquelocktoken","pop","pres","rtsp","service","session","shttp","sieve","sip","sips","sms","snmp","soap.beep","soap.beeps","tag","tel","telnet","tftp","thismessage","tn3270","tip","tv","urn","vemmi","ws","wss","xcon","xcon-userid","xmlrpc.beep","xmlrpc.beeps","xmpp","z39.50r","z39.50s","adiumxtra","afp","afs","aim","apt","attachment","aw","beshare","bitcoin","bolo","callto","chrome","chrome-extension","com-eventbrite-attendee","content","cvs","dlna-playsingle","dlna-playcontainer","dtn","dvb","ed2k","facetime","feed","finger","fish","gg","git","gizmoproject","gtalk","hcp","icon","ipn","irc","irc6","ircs","itms","jar","jms","keyparc","lastfm","ldaps","magnet","maps","market","message","mms","ms-help","msnim","mumble","mvn","notes","oid","palm","paparazzi","platform","proxy","psyc","query","res","resource","rmi","rsync","rtmp","secondlife","sftp","sgn","skype","smb","soldat","spotify","ssh","steam","svn","teamspeak","things","udp","unreal","ut2004","ventrilo","view-source","webcal","wtai","wyciwyg","xfire","xri","ymsgr"],PC=/^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/,MC=/^<([a-zA-Z.\-]{1,25}):([^<>\x00-\x20]*)>/;function replace$1(s,o){return s=s.source,o=o||"",function self(i,u){return i?(u=u.source||u,s=s.replace(i,u),self):new RegExp(s,o)}}var TC=replace$1(/(?:unquoted|single_quoted|double_quoted)/)("unquoted",/[^"'=<>`\x00-\x20]+/)("single_quoted",/'[^']*'/)("double_quoted",/"[^"]*"/)(),NC=replace$1(/(?:\s+attr_name(?:\s*=\s*attr_value)?)/)("attr_name",/[a-zA-Z_:][a-zA-Z0-9:._-]*/)("attr_value",TC)(),RC=replace$1(/<[A-Za-z][A-Za-z0-9]*attribute*\s*\/?>/)("attribute",NC)(),DC=replace$1(/^(?:open_tag|close_tag|comment|processing|declaration|cdata)/)("open_tag",RC)("close_tag",/<\/[A-Za-z][A-Za-z0-9]*\s*>/)("comment",/|/)("processing",/<[?].*?[?]>/)("declaration",/]*>/)("cdata",//)();var LC=/^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i,BC=/^&([a-z][a-z0-9]{1,31});/i;var FC=[["text",function index_browser_text(s,o){for(var i=s.pos;i=0&&32===s.pending.charCodeAt(i))if(i>=1&&32===s.pending.charCodeAt(i-1)){for(var w=i-2;w>=0;w--)if(32!==s.pending.charCodeAt(w)){s.pending=s.pending.substring(0,w+1);break}s.push({type:"hardbreak",level:s.level})}else s.pending=s.pending.slice(0,-1),s.push({type:"softbreak",level:s.level});else s.push({type:"softbreak",level:s.level});for(_++;_=C)return!1;if(126!==s.src.charCodeAt(j+1))return!1;if(s.level>=s.options.maxNesting)return!1;if(w=j>0?s.src.charCodeAt(j-1):-1,x=s.src.charCodeAt(j+2),126===w)return!1;if(126===x)return!1;if(32===x||10===x)return!1;for(u=j+2;uj+3)return s.pos+=u-j,o||(s.pending+=s.src.slice(j,u)),!0;for(s.pos=j+2,_=1;s.pos+1=C)return!1;if(43!==s.src.charCodeAt(j+1))return!1;if(s.level>=s.options.maxNesting)return!1;if(w=j>0?s.src.charCodeAt(j-1):-1,x=s.src.charCodeAt(j+2),43===w)return!1;if(43===x)return!1;if(32===x||10===x)return!1;for(u=j+2;u=C)return!1;if(61!==s.src.charCodeAt(j+1))return!1;if(s.level>=s.options.maxNesting)return!1;if(w=j>0?s.src.charCodeAt(j-1):-1,x=s.src.charCodeAt(j+2),61===w)return!1;if(61===x)return!1;if(32===x||10===x)return!1;for(u=j+2;u=s.options.maxNesting)return!1;for(s.pos=B+i,C=[i];s.pos=_)return!1;if(s.level>=s.options.maxNesting)return!1;for(s.pos=w+1;s.pos<_;){if(126===s.src.charCodeAt(s.pos)){i=!0;break}s.parser.skipToken(s)}return i&&w+1!==s.pos?(u=s.src.slice(w+1,s.pos)).match(/(^|[^\\])(\\\\)*\s/)?(s.pos=w,!1):(s.posMax=s.pos,s.pos=w+1,o||s.push({type:"sub",level:s.level,content:u.replace(AC,"$1")}),s.pos=s.posMax+1,s.posMax=_,!0):(s.pos=w,!1)}],["sup",function sup(s,o){var i,u,_=s.posMax,w=s.pos;if(94!==s.src.charCodeAt(w))return!1;if(o)return!1;if(w+2>=_)return!1;if(s.level>=s.options.maxNesting)return!1;for(s.pos=w+1;s.pos<_;){if(94===s.src.charCodeAt(s.pos)){i=!0;break}s.parser.skipToken(s)}return i&&w+1!==s.pos?(u=s.src.slice(w+1,s.pos)).match(/(^|[^\\])(\\\\)*\s/)?(s.pos=w,!1):(s.posMax=s.pos,s.pos=w+1,o||s.push({type:"sup",level:s.level,content:u.replace(jC,"$1")}),s.pos=s.posMax+1,s.posMax=_,!0):(s.pos=w,!1)}],["links",function links(s,o){var i,u,_,w,x,C,j,L,B=!1,$=s.pos,V=s.posMax,U=s.pos,z=s.src.charCodeAt(U);if(33===z&&(B=!0,z=s.src.charCodeAt(++U)),91!==z)return!1;if(s.level>=s.options.maxNesting)return!1;if(i=U+1,(u=parseLinkLabel(s,U))<0)return!1;if((C=u+1)=V)return!1;for(U=C,parseLinkDestination(s,C)?(w=s.linkContent,C=s.pos):w="",U=C;C=V||41!==s.src.charCodeAt(C))return s.pos=$,!1;C++}else{if(s.linkLevel>0)return!1;for(;C=0?_=s.src.slice(U,C++):C=U-1),_||(void 0===_&&(C=u+1),_=s.src.slice(i,u)),!(j=s.env.references[normalizeReference(_)]))return s.pos=$,!1;w=j.href,x=j.title}return o||(s.pos=i,s.posMax=u,B?s.push({type:"image",src:w,title:x,alt:s.src.substr(i,u-i),level:s.level}):(s.push({type:"link_open",href:w,title:x,level:s.level++}),s.linkLevel++,s.parser.tokenize(s),s.linkLevel--,s.push({type:"link_close",level:--s.level}))),s.pos=C,s.posMax=V,!0}],["footnote_inline",function footnote_inline(s,o){var i,u,_,w,x=s.posMax,C=s.pos;return!(C+2>=x)&&(94===s.src.charCodeAt(C)&&(91===s.src.charCodeAt(C+1)&&(!(s.level>=s.options.maxNesting)&&(i=C+2,!((u=parseLinkLabel(s,C+1))<0)&&(o||(s.env.footnotes||(s.env.footnotes={}),s.env.footnotes.list||(s.env.footnotes.list=[]),_=s.env.footnotes.list.length,s.pos=i,s.posMax=u,s.push({type:"footnote_ref",id:_,level:s.level}),s.linkLevel++,w=s.tokens.length,s.parser.tokenize(s),s.env.footnotes.list[_]={tokens:s.tokens.splice(w)},s.linkLevel--),s.pos=u+1,s.posMax=x,!0)))))}],["footnote_ref",function footnote_ref(s,o){var i,u,_,w,x=s.posMax,C=s.pos;if(C+3>x)return!1;if(!s.env.footnotes||!s.env.footnotes.refs)return!1;if(91!==s.src.charCodeAt(C))return!1;if(94!==s.src.charCodeAt(C+1))return!1;if(s.level>=s.options.maxNesting)return!1;for(u=C+2;u=x)&&(u++,i=s.src.slice(C+2,u-1),void 0!==s.env.footnotes.refs[":"+i]&&(o||(s.env.footnotes.list||(s.env.footnotes.list=[]),s.env.footnotes.refs[":"+i]<0?(_=s.env.footnotes.list.length,s.env.footnotes.list[_]={label:i,count:0},s.env.footnotes.refs[":"+i]=_):_=s.env.footnotes.refs[":"+i],w=s.env.footnotes.list[_].count,s.env.footnotes.list[_].count++,s.push({type:"footnote_ref",id:_,subId:w,level:s.level})),s.pos=u,s.posMax=x,!0)))}],["autolink",function autolink(s,o){var i,u,_,w,x,C=s.pos;return 60===s.src.charCodeAt(C)&&(!((i=s.src.slice(C)).indexOf(">")<0)&&((u=i.match(MC))?!(IC.indexOf(u[1].toLowerCase())<0)&&(x=normalizeLink(w=u[0].slice(1,-1)),!!s.parser.validateLink(w)&&(o||(s.push({type:"link_open",href:x,level:s.level}),s.push({type:"text",content:w,level:s.level+1}),s.push({type:"link_close",level:s.level})),s.pos+=u[0].length,!0)):!!(_=i.match(PC))&&(x=normalizeLink("mailto:"+(w=_[0].slice(1,-1))),!!s.parser.validateLink(x)&&(o||(s.push({type:"link_open",href:x,level:s.level}),s.push({type:"text",content:w,level:s.level+1}),s.push({type:"link_close",level:s.level})),s.pos+=_[0].length,!0))))}],["htmltag",function htmltag(s,o){var i,u,_,w=s.pos;return!!s.options.html&&(_=s.posMax,!(60!==s.src.charCodeAt(w)||w+2>=_)&&(!(33!==(i=s.src.charCodeAt(w+1))&&63!==i&&47!==i&&!function isLetter$2(s){var o=32|s;return o>=97&&o<=122}(i))&&(!!(u=s.src.slice(w).match(DC))&&(o||s.push({type:"htmltag",content:s.src.slice(w,w+u[0].length),level:s.level}),s.pos+=u[0].length,!0))))}],["entity",function entity(s,o){var i,u,_=s.pos,w=s.posMax;if(38!==s.src.charCodeAt(_))return!1;if(_+10)s.pos=i;else{for(o=0;o<_;o++)if(u[o](s,!0))return void s.cacheSet(w,s.pos);s.pos++,s.cacheSet(w,s.pos)}},ParserInline.prototype.tokenize=function(s){for(var o,i,u=this.ruler.getRules(""),_=u.length,w=s.posMax;s.pos=w)break}else s.pending+=s.src[s.pos++]}s.pending&&s.pushPending()},ParserInline.prototype.parse=function(s,o,i,u){var _=new StateInline(s,this,o,i,u);this.tokenize(_)};var qC={default:{options:{html:!1,xhtmlOut:!1,breaks:!1,langPrefix:"language-",linkTarget:"",typographer:!1,quotes:"“”‘’",highlight:null,maxNesting:20},components:{core:{rules:["block","inline","references","replacements","smartquotes","references","abbr2","footnote_tail"]},block:{rules:["blockquote","code","fences","footnote","heading","hr","htmlblock","lheading","list","paragraph","table"]},inline:{rules:["autolink","backticks","del","emphasis","entity","escape","footnote_ref","htmltag","links","newline","text"]}}},full:{options:{html:!1,xhtmlOut:!1,breaks:!1,langPrefix:"language-",linkTarget:"",typographer:!1,quotes:"“”‘’",highlight:null,maxNesting:20},components:{core:{},block:{},inline:{}}},commonmark:{options:{html:!0,xhtmlOut:!0,breaks:!1,langPrefix:"language-",linkTarget:"",typographer:!1,quotes:"“”‘’",highlight:null,maxNesting:20},components:{core:{rules:["block","inline","references","abbr2"]},block:{rules:["blockquote","code","fences","heading","hr","htmlblock","lheading","list","paragraph"]},inline:{rules:["autolink","backticks","emphasis","entity","escape","htmltag","links","newline","text"]}}}};function StateCore(s,o,i){this.src=o,this.env=i,this.options=s.options,this.tokens=[],this.inlineMode=!1,this.inline=s.inline,this.block=s.block,this.renderer=s.renderer,this.typographer=s.typographer}function Remarkable(s,o){"string"!=typeof s&&(o=s,s="default"),o&&null!=o.linkify&&console.warn("linkify option is removed. Use linkify plugin instead:\n\nimport Remarkable from 'remarkable';\nimport linkify from 'remarkable/linkify';\nnew Remarkable().use(linkify)\n"),this.inline=new ParserInline,this.block=new ParserBlock,this.core=new Core,this.renderer=new Renderer,this.ruler=new Ruler,this.options={},this.configure(qC[s]),this.set(o||{})}Remarkable.prototype.set=function(s){index_browser_assign(this.options,s)},Remarkable.prototype.configure=function(s){var o=this;if(!s)throw new Error("Wrong `remarkable` preset, check name/content");s.options&&o.set(s.options),s.components&&Object.keys(s.components).forEach((function(i){s.components[i].rules&&o[i].ruler.enable(s.components[i].rules,!0)}))},Remarkable.prototype.use=function(s,o){return s(this,o),this},Remarkable.prototype.parse=function(s,o){var i=new StateCore(this,s,o);return this.core.process(i),i.tokens},Remarkable.prototype.render=function(s,o){return o=o||{},this.renderer.render(this.parse(s,o),this.options,o)},Remarkable.prototype.parseInline=function(s,o){var i=new StateCore(this,s,o);return i.inlineMode=!0,this.core.process(i),i.tokens},Remarkable.prototype.renderInline=function(s,o){return o=o||{},this.renderer.render(this.parseInline(s,o),this.options,o)};function indexOf(s,o){if(Array.prototype.indexOf)return s.indexOf(o);for(var i=0,u=s.length;i=0;i--)!0===o(s[i])&&s.splice(i,1)}function throwUnhandledCaseError(s){throw new Error("Unhandled case for value: '".concat(s,"'"))}var $C=function(){function HtmlTag(s){void 0===s&&(s={}),this.tagName="",this.attrs={},this.innerHTML="",this.whitespaceRegex=/\s+/,this.tagName=s.tagName||"",this.attrs=s.attrs||{},this.innerHTML=s.innerHtml||s.innerHTML||""}return HtmlTag.prototype.setTagName=function(s){return this.tagName=s,this},HtmlTag.prototype.getTagName=function(){return this.tagName||""},HtmlTag.prototype.setAttr=function(s,o){return this.getAttrs()[s]=o,this},HtmlTag.prototype.getAttr=function(s){return this.getAttrs()[s]},HtmlTag.prototype.setAttrs=function(s){return Object.assign(this.getAttrs(),s),this},HtmlTag.prototype.getAttrs=function(){return this.attrs||(this.attrs={})},HtmlTag.prototype.setClass=function(s){return this.setAttr("class",s)},HtmlTag.prototype.addClass=function(s){for(var o,i=this.getClass(),u=this.whitespaceRegex,_=i?i.split(u):[],w=s.split(u);o=w.shift();)-1===indexOf(_,o)&&_.push(o);return this.getAttrs().class=_.join(" "),this},HtmlTag.prototype.removeClass=function(s){for(var o,i=this.getClass(),u=this.whitespaceRegex,_=i?i.split(u):[],w=s.split(u);_.length&&(o=w.shift());){var x=indexOf(_,o);-1!==x&&_.splice(x,1)}return this.getAttrs().class=_.join(" "),this},HtmlTag.prototype.getClass=function(){return this.getAttrs().class||""},HtmlTag.prototype.hasClass=function(s){return-1!==(" "+this.getClass()+" ").indexOf(" "+s+" ")},HtmlTag.prototype.setInnerHTML=function(s){return this.innerHTML=s,this},HtmlTag.prototype.setInnerHtml=function(s){return this.setInnerHTML(s)},HtmlTag.prototype.getInnerHTML=function(){return this.innerHTML||""},HtmlTag.prototype.getInnerHtml=function(){return this.getInnerHTML()},HtmlTag.prototype.toAnchorString=function(){var s=this.getTagName(),o=this.buildAttrsStr();return["<",s,o=o?" "+o:"",">",this.getInnerHtml(),""].join("")},HtmlTag.prototype.buildAttrsStr=function(){if(!this.attrs)return"";var s=this.getAttrs(),o=[];for(var i in s)s.hasOwnProperty(i)&&o.push(i+'="'+s[i]+'"');return o.join(" ")},HtmlTag}();var VC=function(){function AnchorTagBuilder(s){void 0===s&&(s={}),this.newWindow=!1,this.truncate={},this.className="",this.newWindow=s.newWindow||!1,this.truncate=s.truncate||{},this.className=s.className||""}return AnchorTagBuilder.prototype.build=function(s){return new $C({tagName:"a",attrs:this.createAttrs(s),innerHtml:this.processAnchorText(s.getAnchorText())})},AnchorTagBuilder.prototype.createAttrs=function(s){var o={href:s.getAnchorHref()},i=this.createCssClass(s);return i&&(o.class=i),this.newWindow&&(o.target="_blank",o.rel="noopener noreferrer"),this.truncate&&this.truncate.length&&this.truncate.length=w)return x.host.length==o?(x.host.substr(0,o-_)+i).substr(0,w+u):buildSegment(j,w).substr(0,w+u);var L="";if(x.path&&(L+="/"+x.path),x.query&&(L+="?"+x.query),L){if((j+L).length>=w)return(j+L).length==o?(j+L).substr(0,o):(j+buildSegment(L,w-j.length)).substr(0,w+u);j+=L}if(x.fragment){var B="#"+x.fragment;if((j+B).length>=w)return(j+B).length==o?(j+B).substr(0,o):(j+buildSegment(B,w-j.length)).substr(0,w+u);j+=B}if(x.scheme&&x.host){var $=x.scheme+"://";if((j+$).length0&&(V=j.substr(-1*Math.floor(w/2))),(j.substr(0,Math.ceil(w/2))+i+V).substr(0,w+u)}(s,i):"middle"===u?function truncateMiddle(s,o,i){if(s.length<=o)return s;var u,_;null==i?(i="…",u=8,_=3):(u=i.length,_=i.length);var w=o-_,x="";return w>0&&(x=s.substr(-1*Math.floor(w/2))),(s.substr(0,Math.ceil(w/2))+i+x).substr(0,w+u)}(s,i):function truncateEnd(s,o,i){return function ellipsis(s,o,i){var u;return s.length>o&&(null==i?(i="…",u=3):u=i.length,s=s.substring(0,o-u)+i),s}(s,o,i)}(s,i)},AnchorTagBuilder}(),UC=function(){function Match(s){this.__jsduckDummyDocProp=null,this.matchedText="",this.offset=0,this.tagBuilder=s.tagBuilder,this.matchedText=s.matchedText,this.offset=s.offset}return Match.prototype.getMatchedText=function(){return this.matchedText},Match.prototype.setOffset=function(s){this.offset=s},Match.prototype.getOffset=function(){return this.offset},Match.prototype.getCssClassSuffixes=function(){return[this.getType()]},Match.prototype.buildTag=function(){return this.tagBuilder.build(this)},Match}(),extendStatics=function(s,o){return extendStatics=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(s,o){s.__proto__=o}||function(s,o){for(var i in o)Object.prototype.hasOwnProperty.call(o,i)&&(s[i]=o[i])},extendStatics(s,o)};function tslib_es6_extends(s,o){if("function"!=typeof o&&null!==o)throw new TypeError("Class extends value "+String(o)+" is not a constructor or null");function __(){this.constructor=s}extendStatics(s,o),s.prototype=null===o?Object.create(o):(__.prototype=o.prototype,new __)}var __assign=function(){return __assign=Object.assign||function __assign(s){for(var o,i=1,u=arguments.length;i-1},UrlMatchValidator.isValidUriScheme=function(s){var o=s.match(this.uriSchemeRegex),i=o&&o[0].toLowerCase();return"javascript:"!==i&&"vbscript:"!==i},UrlMatchValidator.urlMatchDoesNotHaveProtocolOrDot=function(s,o){return!(!s||o&&this.hasFullProtocolRegex.test(o)||-1!==s.indexOf("."))},UrlMatchValidator.urlMatchDoesNotHaveAtLeastOneWordChar=function(s,o){return!(!s||!o)&&(!this.hasFullProtocolRegex.test(o)&&!this.hasWordCharAfterProtocolRegex.test(s))},UrlMatchValidator.hasFullProtocolRegex=/^[A-Za-z][-.+A-Za-z0-9]*:\/\//,UrlMatchValidator.uriSchemeRegex=/^[A-Za-z][-.+A-Za-z0-9]*:/,UrlMatchValidator.hasWordCharAfterProtocolRegex=new RegExp(":[^\\s]*?["+nO+"]"),UrlMatchValidator.ipRegex=/[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?(:[0-9]*)?\/?$/,UrlMatchValidator}(),vO=(zC=new RegExp("[/?#](?:["+aO+"\\-+&@#/%=~_()|'$*\\[\\]{}?!:,.;^✓]*["+aO+"\\-+&@#/%=~_()|'$*\\[\\]{}✓])?"),new RegExp(["(?:","(",/(?:[A-Za-z][-.+A-Za-z0-9]{0,63}:(?![A-Za-z][-.+A-Za-z0-9]{0,63}:\/\/)(?!\d+\/?)(?:\/\/)?)/.source,getDomainNameStr(2),")","|","(","(//)?",/(?:www\.)/.source,getDomainNameStr(6),")","|","(","(//)?",getDomainNameStr(10)+"\\.",hO.source,"(?![-"+iO+"])",")",")","(?::[0-9]+)?","(?:"+zC.source+")?"].join(""),"gi")),bO=new RegExp("["+aO+"]"),_O=function(s){function UrlMatcher(o){var i=s.call(this,o)||this;return i.stripPrefix={scheme:!0,www:!0},i.stripTrailingSlash=!0,i.decodePercentEncoding=!0,i.matcherRegex=vO,i.wordCharRegExp=bO,i.stripPrefix=o.stripPrefix,i.stripTrailingSlash=o.stripTrailingSlash,i.decodePercentEncoding=o.decodePercentEncoding,i}return tslib_es6_extends(UrlMatcher,s),UrlMatcher.prototype.parseMatches=function(s){for(var o,i=this.matcherRegex,u=this.stripPrefix,_=this.stripTrailingSlash,w=this.decodePercentEncoding,x=this.tagBuilder,C=[],_loop_1=function(){var i=o[0],L=o[1],B=o[4],$=o[5],V=o[9],U=o.index,z=$||V,Y=s.charAt(U-1);if(!yO.isValid(i,L))return"continue";if(U>0&&"@"===Y)return"continue";if(U>0&&z&&j.wordCharRegExp.test(Y))return"continue";if(/\?$/.test(i)&&(i=i.substr(0,i.length-1)),j.matchHasUnbalancedClosingParen(i))i=i.substr(0,i.length-1);else{var Z=j.matchHasInvalidCharAfterTld(i,L);Z>-1&&(i=i.substr(0,Z))}var ee=["http://","https://"].find((function(s){return!!L&&-1!==L.indexOf(s)}));if(ee){var ie=i.indexOf(ee);i=i.substr(ie),L=L.substr(ie),U+=ie}var ae=L?"scheme":B?"www":"tld",le=!!L;C.push(new GC({tagBuilder:x,matchedText:i,offset:U,urlMatchType:ae,url:i,protocolUrlMatch:le,protocolRelativeMatch:!!z,stripPrefix:u,stripTrailingSlash:_,decodePercentEncoding:w}))},j=this;null!==(o=i.exec(s));)_loop_1();return C},UrlMatcher.prototype.matchHasUnbalancedClosingParen=function(s){var o,i=s.charAt(s.length-1);if(")"===i)o="(";else if("]"===i)o="[";else{if("}"!==i)return!1;o="{"}for(var u=0,_=0,w=s.length-1;_-1&&w-x<=140){var _=s.slice(x,w),C=new KC({tagBuilder:o,matchedText:_,offset:x,serviceName:i,hashtag:_.slice(1)});u.push(C)}}},HashtagMatcher}(YC),SO=["twitter","facebook","instagram","tiktok"],xO=new RegExp("".concat(/(?:(?:(?:(\+)?\d{1,3}[-\040.]?)?\(?\d{3}\)?[-\040.]?\d{3}[-\040.]?\d{4})|(?:(\+)(?:9[976]\d|8[987530]\d|6[987]\d|5[90]\d|42\d|3[875]\d|2[98654321]\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|4[987654310]|3[9643210]|2[70]|7|1)[-\040.]?(?:\d[-\040.]?){6,12}\d+))([,;]+[0-9]+#?)*/.source,"|").concat(/(0([1-9]{1}-?[1-9]\d{3}|[1-9]{2}-?\d{3}|[1-9]{2}\d{1}-?\d{2}|[1-9]{2}\d{2}-?\d{1})-?\d{4}|0[789]0-?\d{4}-?\d{4}|050-?\d{4}-?\d{4})/.source),"g"),kO=function(s){function PhoneMatcher(){var o=null!==s&&s.apply(this,arguments)||this;return o.matcherRegex=xO,o}return tslib_es6_extends(PhoneMatcher,s),PhoneMatcher.prototype.parseMatches=function(s){for(var o,i=this.matcherRegex,u=this.tagBuilder,_=[];null!==(o=i.exec(s));){var w=o[0],x=w.replace(/[^0-9,;#]/g,""),C=!(!o[1]&&!o[2]),j=0==o.index?"":s.substr(o.index-1,1),L=s.substr(o.index+w.length,1),B=!j.match(/\d/)&&!L.match(/\d/);this.testMatch(o[3])&&this.testMatch(w)&&B&&_.push(new JC({tagBuilder:u,matchedText:w,offset:o.index,number:x,plusSign:C}))}return _},PhoneMatcher.prototype.testMatch=function(s){return QC.test(s)},PhoneMatcher}(YC),CO=new RegExp("@[_".concat(aO,"]{1,50}(?![_").concat(aO,"])"),"g"),OO=new RegExp("@[_.".concat(aO,"]{1,30}(?![_").concat(aO,"])"),"g"),AO=new RegExp("@[-_.".concat(aO,"]{1,50}(?![-_").concat(aO,"])"),"g"),jO=new RegExp("@[_.".concat(aO,"]{1,23}[_").concat(aO,"](?![_").concat(aO,"])"),"g"),IO=new RegExp("[^"+aO+"]"),PO=function(s){function MentionMatcher(o){var i=s.call(this,o)||this;return i.serviceName="twitter",i.matcherRegexes={twitter:CO,instagram:OO,soundcloud:AO,tiktok:jO},i.nonWordCharRegex=IO,i.serviceName=o.serviceName,i}return tslib_es6_extends(MentionMatcher,s),MentionMatcher.prototype.parseMatches=function(s){var o,i=this.serviceName,u=this.matcherRegexes[this.serviceName],_=this.nonWordCharRegex,w=this.tagBuilder,x=[];if(!u)return x;for(;null!==(o=u.exec(s));){var C=o.index,j=s.charAt(C-1);if(0===C||_.test(j)){var L=o[0].replace(/\.+$/g,""),B=L.slice(1);x.push(new HC({tagBuilder:w,matchedText:L,offset:C,serviceName:i,mention:B}))}}return x},MentionMatcher}(YC);function parseHtml(s,o){for(var i=o.onOpenTag,u=o.onCloseTag,_=o.onText,w=o.onComment,x=o.onDoctype,C=new MO,j=0,L=s.length,B=0,$=0,V=C;j"===s?(V=new MO(__assign(__assign({},V),{name:captureTagName()})),emitTagAndPreviousTextNode()):XC.test(s)||ZC.test(s)||":"===s||resetToDataState()}function stateEndTagOpen(s){">"===s?resetToDataState():XC.test(s)?B=3:resetToDataState()}function stateBeforeAttributeName(s){eO.test(s)||("/"===s?B=12:">"===s?emitTagAndPreviousTextNode():"<"===s?startNewTag():"="===s||tO.test(s)||rO.test(s)?resetToDataState():B=5)}function stateAttributeName(s){eO.test(s)?B=6:"/"===s?B=12:"="===s?B=7:">"===s?emitTagAndPreviousTextNode():"<"===s?startNewTag():tO.test(s)&&resetToDataState()}function stateAfterAttributeName(s){eO.test(s)||("/"===s?B=12:"="===s?B=7:">"===s?emitTagAndPreviousTextNode():"<"===s?startNewTag():tO.test(s)?resetToDataState():B=5)}function stateBeforeAttributeValue(s){eO.test(s)||('"'===s?B=8:"'"===s?B=9:/[>=`]/.test(s)?resetToDataState():"<"===s?startNewTag():B=10)}function stateAttributeValueDoubleQuoted(s){'"'===s&&(B=11)}function stateAttributeValueSingleQuoted(s){"'"===s&&(B=11)}function stateAttributeValueUnquoted(s){eO.test(s)?B=4:">"===s?emitTagAndPreviousTextNode():"<"===s&&startNewTag()}function stateAfterAttributeValueQuoted(s){eO.test(s)?B=4:"/"===s?B=12:">"===s?emitTagAndPreviousTextNode():"<"===s?startNewTag():(B=4,function reconsumeCurrentCharacter(){j--}())}function stateSelfClosingStartTag(s){">"===s?(V=new MO(__assign(__assign({},V),{isClosing:!0})),emitTagAndPreviousTextNode()):B=4}function stateMarkupDeclarationOpen(o){"--"===s.substr(j,2)?(j+=2,V=new MO(__assign(__assign({},V),{type:"comment"})),B=14):"DOCTYPE"===s.substr(j,7).toUpperCase()?(j+=7,V=new MO(__assign(__assign({},V),{type:"doctype"})),B=20):resetToDataState()}function stateCommentStart(s){"-"===s?B=15:">"===s?resetToDataState():B=16}function stateCommentStartDash(s){"-"===s?B=18:">"===s?resetToDataState():B=16}function stateComment(s){"-"===s&&(B=17)}function stateCommentEndDash(s){B="-"===s?18:16}function stateCommentEnd(s){">"===s?emitTagAndPreviousTextNode():"!"===s?B=19:"-"===s||(B=16)}function stateCommentEndBang(s){"-"===s?B=17:">"===s?emitTagAndPreviousTextNode():B=16}function stateDoctype(s){">"===s?emitTagAndPreviousTextNode():"<"===s&&startNewTag()}function resetToDataState(){B=0,V=C}function startNewTag(){B=1,V=new MO({idx:j})}function emitTagAndPreviousTextNode(){var o=s.slice($,V.idx);o&&_(o,$),"comment"===V.type?w(V.idx):"doctype"===V.type?x(V.idx):(V.isOpening&&i(V.name,V.idx),V.isClosing&&u(V.name,V.idx)),resetToDataState(),$=j+1}function captureTagName(){var o=V.idx+(V.isClosing?2:1);return s.slice(o,j).toLowerCase()}$=0&&u++},onText:function(s,i){if(0===u){var w=function splitAndCapture(s,o){if(!o.global)throw new Error("`splitRegex` must have the 'g' flag set");for(var i,u=[],_=0;i=o.exec(s);)u.push(s.substring(_,i.index)),u.push(i[0]),_=i.index+i[0].length;return u.push(s.substring(_)),u}(s,/( | |<|<|>|>|"|"|')/gi),x=i;w.forEach((function(s,i){if(i%2==0){var u=o.parseText(s,x);_.push.apply(_,u)}x+=s.length}))}},onCloseTag:function(s){i.indexOf(s)>=0&&(u=Math.max(u-1,0))},onComment:function(s){},onDoctype:function(s){}}),_=this.compactMatches(_),_=this.removeUnwantedMatches(_)},Autolinker.prototype.compactMatches=function(s){s.sort((function(s,o){return s.getOffset()-o.getOffset()}));for(var o=0;o_?o:o+1;s.splice(x,1);continue}if(s[o+1].getOffset()/g,">"));for(var o=this.parse(s),i=[],u=0,_=0,w=o.length;_\s]/i.test(s)}function isLinkClose(s){return/^<\/a\s*>/i.test(s)}function createLinkifier(){var s=[],o=new NO({stripPrefix:!1,url:!0,email:!0,replaceFn:function(o){switch(o.getType()){case"url":s.push({text:o.matchedText,url:o.getUrl()});break;case"email":s.push({text:o.matchedText,url:"mailto:"+o.getEmail().replace(/^mailto:/i,"")})}return!1}});return{links:s,autolinker:o}}function parseTokens(s){var o,i,u,_,w,x,C,j,L,B,$,V,U,z=s.tokens,Y=null;for(i=0,u=z.length;i=0;o--)if("link_close"!==(w=_[o]).type){if("htmltag"===w.type&&(isLinkOpen(w.content)&&$>0&&$--,isLinkClose(w.content)&&$++),!($>0)&&"text"===w.type&&RO.test(w.content)){if(Y||(V=(Y=createLinkifier()).links,U=Y.autolinker),x=w.content,V.length=0,U.link(x),!V.length)continue;for(C=[],B=w.level,j=0;j({useUnsafeMarkdown:!1})}){if("string"!=typeof s)return null;const u=new Remarkable({html:!0,typographer:!0,breaks:!0,linkTarget:"_blank"}).use(linkify);u.core.ruler.disable(["replacements","smartquotes"]);const{useUnsafeMarkdown:_}=i(),w=u.render(s),x=sanitizer(w,{useUnsafeMarkdown:_});return s&&w&&x?Pe.createElement("div",{className:Hn()(o,"markdown"),dangerouslySetInnerHTML:{__html:x}}):null};function sanitizer(s,{useUnsafeMarkdown:o=!1}={}){const i=o,u=o?[]:["style","class"];return o&&!sanitizer.hasWarnedAboutDeprecation&&(console.warn("useUnsafeMarkdown display configuration parameter is deprecated since >3.26.0 and will be removed in v4.0.0."),sanitizer.hasWarnedAboutDeprecation=!0),LO().sanitize(s,{ADD_ATTR:["target"],FORBID_TAGS:["style","form"],ALLOW_DATA_ATTR:i,FORBID_ATTR:u})}sanitizer.hasWarnedAboutDeprecation=!1;class BaseLayout extends Pe.Component{render(){const{errSelectors:s,specSelectors:o,getComponent:i}=this.props,u=i("SvgAssets"),_=i("InfoContainer",!0),w=i("VersionPragmaFilter"),x=i("operations",!0),C=i("Models",!0),j=i("Webhooks",!0),L=i("Row"),B=i("Col"),$=i("errors",!0),V=i("ServersContainer",!0),U=i("SchemesContainer",!0),z=i("AuthorizeBtnContainer",!0),Y=i("FilterContainer",!0),Z=o.isSwagger2(),ee=o.isOAS3(),ie=o.isOAS31(),ae=!o.specStr(),le=o.loadingStatus();let ce=null;if("loading"===le&&(ce=Pe.createElement("div",{className:"info"},Pe.createElement("div",{className:"loading-container"},Pe.createElement("div",{className:"loading"})))),"failed"===le&&(ce=Pe.createElement("div",{className:"info"},Pe.createElement("div",{className:"loading-container"},Pe.createElement("h4",{className:"title"},"Failed to load API definition."),Pe.createElement($,null)))),"failedConfig"===le){const o=s.lastError(),i=o?o.get("message"):"";ce=Pe.createElement("div",{className:"info failed-config"},Pe.createElement("div",{className:"loading-container"},Pe.createElement("h4",{className:"title"},"Failed to load remote configuration."),Pe.createElement("p",null,i)))}if(!ce&&ae&&(ce=Pe.createElement("h4",null,"No API definition provided.")),ce)return Pe.createElement("div",{className:"swagger-ui"},Pe.createElement("div",{className:"loading-container"},ce));const pe=o.servers(),de=o.schemes(),fe=pe&&pe.size,ye=de&&de.size,be=!!o.securityDefinitions();return Pe.createElement("div",{className:"swagger-ui"},Pe.createElement(u,null),Pe.createElement(w,{isSwagger2:Z,isOAS3:ee,alsoShow:Pe.createElement($,null)},Pe.createElement($,null),Pe.createElement(L,{className:"information-container"},Pe.createElement(B,{mobile:12},Pe.createElement(_,null))),fe||ye||be?Pe.createElement("div",{className:"scheme-container"},Pe.createElement(B,{className:"schemes wrapper",mobile:12},fe||ye?Pe.createElement("div",{className:"schemes-server-container"},fe?Pe.createElement(V,null):null,ye?Pe.createElement(U,null):null):null,be?Pe.createElement(z,null):null)):null,Pe.createElement(Y,null),Pe.createElement(L,null,Pe.createElement(B,{mobile:12,desktop:12},Pe.createElement(x,null))),ie&&Pe.createElement(L,{className:"webhooks-container"},Pe.createElement(B,{mobile:12,desktop:12},Pe.createElement(j,null))),Pe.createElement(L,null,Pe.createElement(B,{mobile:12,desktop:12},Pe.createElement(C,null)))))}}const core_components=()=>({components:{App:fk,authorizationPopup:AuthorizationPopup,authorizeBtn:AuthorizeBtn,AuthorizeBtnContainer,authorizeOperationBtn:AuthorizeOperationBtn,auths:Auths,AuthItem:auth_item_Auths,authError:AuthError,oauth2:Oauth2,apiKeyAuth:ApiKeyAuth,basicAuth:BasicAuth,clear:Clear,liveResponse:LiveResponse,InitializedInput,info:qk,InfoContainer,InfoUrl,InfoBasePath,Contact:Vk,License:zk,JumpToPath,CopyToClipboardBtn,onlineValidatorBadge:OnlineValidatorBadge,operations:Operations,operation:operation_Operation,OperationSummary,OperationSummaryMethod,OperationSummaryPath,responses:responses_Responses,response:response_Response,ResponseExtension:response_extension,responseBody:ResponseBody,parameters:Parameters,parameterRow:ParameterRow,execute:Execute,headers:headers_Headers,errors:Errors,contentType:ContentType,overview:Overview,footer:Footer,FilterContainer,ParamBody,curl:Curl,Property:property,TryItOutButton,Markdown:BO,BaseLayout,VersionPragmaFilter,VersionStamp:version_stamp,OperationExt:operation_extensions,OperationExtRow:operation_extension_row,ParameterExt:parameter_extension,ParameterIncludeEmpty,OperationTag,OperationContainer,OpenAPIVersion:openapi_version,DeepLink:deep_link,SvgAssets:svg_assets,Example:example_Example,ExamplesSelect,ExamplesSelectValueRetainer}}),form_components=()=>({components:{...ye}}),base=()=>[configsPlugin,util,logs,view,view_legacy,plugins_spec,err,icons,plugins_layout,json_schema_5,json_schema_5_samples,core_components,form_components,swagger_client,auth,downloadUrlPlugin,deep_linking,filter,on_complete,plugins_request_snippets,syntax_highlighting,versions,safe_render()],FO=(0,qe.Map)();function onlyOAS3(s){return(o,i)=>(...u)=>{if(i.getSystem().specSelectors.isOAS3()){const o=s(...u);return"function"==typeof o?o(i):o}return o(...u)}}const qO=onlyOAS3(Ss()(null)),$O=onlyOAS3(((s,o)=>s=>s.getSystem().specSelectors.findSchema(o))),VO=onlyOAS3((()=>s=>{const o=s.getSystem().specSelectors.specJson().getIn(["components","schemas"]);return qe.Map.isMap(o)?o:FO})),UO=onlyOAS3((()=>s=>s.getSystem().specSelectors.specJson().hasIn(["servers",0]))),zO=onlyOAS3(Ut(Ms,(s=>s.getIn(["components","securitySchemes"])||null))),wrap_selectors_validOperationMethods=(s,o)=>(i,...u)=>o.specSelectors.isOAS3()?o.oas3Selectors.validOperationMethods():s(...u),WO=qO,KO=qO,HO=qO,JO=qO,GO=qO;const YO=function wrap_selectors_onlyOAS3(s){return(o,i)=>(...u)=>{if(i.getSystem().specSelectors.isOAS3()){let o=i.getState().getIn(["spec","resolvedSubtrees","components","securitySchemes"]);return s(i,o,...u)}return o(...u)}}(Ut((s=>s),(({specSelectors:s})=>s.securityDefinitions()),((s,o)=>{let i=(0,qe.List)();return o?(o.entrySeq().forEach((([s,o])=>{const u=o.get("type");if("oauth2"===u&&o.get("flows").entrySeq().forEach((([u,_])=>{let w=(0,qe.fromJS)({flow:u,authorizationUrl:_.get("authorizationUrl"),tokenUrl:_.get("tokenUrl"),scopes:_.get("scopes"),type:o.get("type"),description:o.get("description")});i=i.push(new qe.Map({[s]:w.filter((s=>void 0!==s))}))})),"http"!==u&&"apiKey"!==u||(i=i.push(new qe.Map({[s]:o}))),"openIdConnect"===u&&o.get("openIdConnectData")){let u=o.get("openIdConnectData");(u.get("grant_types_supported")||["authorization_code","implicit"]).forEach((_=>{let w=u.get("scopes_supported")&&u.get("scopes_supported").reduce(((s,o)=>s.set(o,"")),new qe.Map),x=(0,qe.fromJS)({flow:_,authorizationUrl:u.get("authorization_endpoint"),tokenUrl:u.get("token_endpoint"),scopes:w,type:"oauth2",openIdConnectUrl:o.get("openIdConnectUrl")});i=i.push(new qe.Map({[s]:x.filter((s=>void 0!==s))}))}))}})),i):i})));function OAS3ComponentWrapFactory(s){return(o,i)=>u=>"function"==typeof i.specSelectors?.isOAS3?i.specSelectors.isOAS3()?Pe.createElement(s,Rn()({},u,i,{Ori:o})):Pe.createElement(o,u):(console.warn("OAS3 wrapper: couldn't get spec"),null)}const XO=(0,qe.Map)(),selectors_isSwagger2=()=>s=>function isSwagger2(s){const o=s.get("swagger");return"string"==typeof o&&"2.0"===o}(s.getSystem().specSelectors.specJson()),selectors_isOAS30=()=>s=>function isOAS30(s){const o=s.get("openapi");return"string"==typeof o&&/^3\.0\.([0123])(?:-rc[012])?$/.test(o)}(s.getSystem().specSelectors.specJson()),selectors_isOAS3=()=>s=>s.getSystem().specSelectors.isOAS30();function selectors_onlyOAS3(s){return(o,...i)=>u=>{if(u.specSelectors.isOAS3()){const _=s(o,...i);return"function"==typeof _?_(u):_}return null}}const ZO=selectors_onlyOAS3((()=>s=>s.specSelectors.specJson().get("servers",XO))),findSchema=(s,o)=>{const i=s.getIn(["resolvedSubtrees","components","schemas",o],null),u=s.getIn(["json","components","schemas",o],null);return i||u||null},QO=selectors_onlyOAS3(((s,{callbacks:o,specPath:i})=>s=>{const u=s.specSelectors.validOperationMethods();return qe.Map.isMap(o)?o.reduce(((s,o,_)=>{if(!qe.Map.isMap(o))return s;const w=o.reduce(((s,o,w)=>{if(!qe.Map.isMap(o))return s;const x=o.entrySeq().filter((([s])=>u.includes(s))).map((([s,o])=>({operation:(0,qe.Map)({operation:o}),method:s,path:w,callbackName:_,specPath:i.concat([_,w,s])})));return s.concat(x)}),(0,qe.List)());return s.concat(w)}),(0,qe.List)()).groupBy((s=>s.callbackName)).map((s=>s.toArray())).toObject():{}})),callbacks=({callbacks:s,specPath:o,specSelectors:i,getComponent:u})=>{const _=i.callbacksOperations({callbacks:s,specPath:o}),w=Object.keys(_),x=u("OperationContainer",!0);return 0===w.length?Pe.createElement("span",null,"No callbacks"):Pe.createElement("div",null,w.map((s=>Pe.createElement("div",{key:`${s}`},Pe.createElement("h2",null,s),_[s].map((o=>Pe.createElement(x,{key:`${s}-${o.path}-${o.method}`,op:o.operation,tag:"callbacks",method:o.method,path:o.path,specPath:o.specPath,allowTryItOut:!1})))))))},getDefaultRequestBodyValue=(s,o,i,u)=>{const _=s.getIn(["content",o])??(0,qe.OrderedMap)(),w=_.get("schema",(0,qe.OrderedMap)()).toJS(),x=void 0!==_.get("examples"),C=_.get("example"),j=x?_.getIn(["examples",i,"value"]):C;return stringify(u.getSampleSchema(w,o,{includeWriteOnly:!0},j))},components_request_body=({userHasEditedBody:s,requestBody:o,requestBodyValue:i,requestBodyInclusionSetting:u,requestBodyErrors:_,getComponent:w,getConfigs:x,specSelectors:C,fn:j,contentType:L,isExecute:B,specPath:$,onChange:V,onChangeIncludeEmpty:U,activeExamplesKey:z,updateActiveExamplesKey:Y,setRetainRequestBodyValueFlag:Z})=>{const handleFile=s=>{V(s.target.files[0])},setIsIncludedOptions=s=>{let o={key:s,shouldDispatchInit:!1,defaultValue:!0};return"no value"===u.get(s,"no value")&&(o.shouldDispatchInit=!0),o},ee=w("Markdown",!0),ie=w("modelExample"),ae=w("RequestBodyEditor"),le=w("HighlightCode",!0),ce=w("ExamplesSelectValueRetainer"),pe=w("Example"),de=w("ParameterIncludeEmpty"),{showCommonExtensions:fe}=x(),ye=o?.get("description")??null,be=o?.get("content")??new qe.OrderedMap;L=L||be.keySeq().first()||"";const _e=be.get(L)??(0,qe.OrderedMap)(),we=_e.get("schema",(0,qe.OrderedMap)()),Se=_e.get("examples",null),xe=Se?.map(((s,i)=>{const u=s?.get("value",null);return u&&(s=s.set("value",getDefaultRequestBodyValue(o,L,i,j),u)),s}));if(_=qe.List.isList(_)?_:(0,qe.List)(),!_e.size)return null;const Te="object"===_e.getIn(["schema","type"]),Re="binary"===_e.getIn(["schema","format"]),$e="base64"===_e.getIn(["schema","format"]);if("application/octet-stream"===L||0===L.indexOf("image/")||0===L.indexOf("audio/")||0===L.indexOf("video/")||Re||$e){const s=w("Input");return B?Pe.createElement(s,{type:"file",onChange:handleFile}):Pe.createElement("i",null,"Example values are not available for ",Pe.createElement("code",null,L)," media types.")}if(Te&&("application/x-www-form-urlencoded"===L||0===L.indexOf("multipart/"))&&we.get("properties",(0,qe.OrderedMap)()).size>0){const s=w("JsonSchemaForm"),o=w("ParameterExt"),x=we.get("properties",(0,qe.OrderedMap)());return i=qe.Map.isMap(i)?i:(0,qe.OrderedMap)(),Pe.createElement("div",{className:"table-container"},ye&&Pe.createElement(ee,{source:ye}),Pe.createElement("table",null,Pe.createElement("tbody",null,qe.Map.isMap(x)&&x.entrySeq().map((([x,C])=>{if(C.get("readOnly"))return;const L=C.get("oneOf")?.get(0)?.toJS(),$=C.get("anyOf")?.get(0)?.toJS();C=(0,qe.fromJS)(j.mergeJsonSchema(C.toJS(),L??$??{}));let z=fe?getCommonExtensions(C):null;const Y=we.get("required",(0,qe.List)()).includes(x),Z=C.get("type"),ie=C.get("format"),ae=C.get("description"),le=i.getIn([x,"value"]),ce=i.getIn([x,"errors"])||_,pe=u.get(x)||!1;let ye=j.getSampleSchema(C,!1,{includeWriteOnly:!0});!1===ye&&(ye="false"),0===ye&&(ye="0"),"string"!=typeof ye&&"object"===Z&&(ye=stringify(ye)),"string"==typeof ye&&"array"===Z&&(ye=JSON.parse(ye));const be="string"===Z&&("binary"===ie||"base64"===ie);return Pe.createElement("tr",{key:x,className:"parameters","data-property-name":x},Pe.createElement("td",{className:"parameters-col_name"},Pe.createElement("div",{className:Y?"parameter__name required":"parameter__name"},x,Y?Pe.createElement("span",null," *"):null),Pe.createElement("div",{className:"parameter__type"},Z,ie&&Pe.createElement("span",{className:"prop-format"},"($",ie,")"),fe&&z.size?z.entrySeq().map((([s,i])=>Pe.createElement(o,{key:`${s}-${i}`,xKey:s,xVal:i}))):null),Pe.createElement("div",{className:"parameter__deprecated"},C.get("deprecated")?"deprecated":null)),Pe.createElement("td",{className:"parameters-col_description"},Pe.createElement(ee,{source:ae}),B?Pe.createElement("div",null,Pe.createElement(s,{fn:j,dispatchInitialValue:!be,schema:C,description:x,getComponent:w,value:void 0===le?ye:le,required:Y,errors:ce,onChange:s=>{V(s,[x])}}),Y?null:Pe.createElement(de,{onChange:s=>U(x,s),isIncluded:pe,isIncludedOptions:setIsIncludedOptions(x),isDisabled:Array.isArray(le)?0!==le.length:!isEmptyValue(le)})):null))})))))}const ze=getDefaultRequestBodyValue(o,L,z,j);let We=null;return getKnownSyntaxHighlighterLanguage(ze)&&(We="json"),Pe.createElement("div",null,ye&&Pe.createElement(ee,{source:ye}),xe?Pe.createElement(ce,{userHasEditedBody:s,examples:xe,currentKey:z,currentUserInputValue:i,onSelect:s=>{Y(s)},updateValue:V,defaultToFirstExample:!0,getComponent:w,setRetainRequestBodyValueFlag:Z}):null,B?Pe.createElement("div",null,Pe.createElement(ae,{value:i,errors:_,defaultValue:ze,onChange:V,getComponent:w})):Pe.createElement(ie,{getComponent:w,getConfigs:x,specSelectors:C,expandDepth:1,isExecute:B,schema:_e.get("schema"),specPath:$.push("content",L),example:Pe.createElement(le,{className:"body-param__example",language:We},stringify(i)||ze),includeWriteOnly:!0}),xe?Pe.createElement(pe,{example:xe.get(z),getComponent:w,getConfigs:x}):null)};class operation_link_OperationLink extends Pe.Component{render(){const{link:s,name:o,getComponent:i}=this.props,u=i("Markdown",!0);let _=s.get("operationId")||s.get("operationRef"),w=s.get("parameters")&&s.get("parameters").toJS(),x=s.get("description");return Pe.createElement("div",{className:"operation-link"},Pe.createElement("div",{className:"description"},Pe.createElement("b",null,Pe.createElement("code",null,o)),x?Pe.createElement(u,{source:x}):null),Pe.createElement("pre",null,"Operation `",_,"`",Pe.createElement("br",null),Pe.createElement("br",null),"Parameters ",function padString(s,o){if("string"!=typeof o)return"";return o.split("\n").map(((o,i)=>i>0?Array(s+1).join(" ")+o:o)).join("\n")}(0,JSON.stringify(w,null,2))||"{}",Pe.createElement("br",null)))}}const eA=operation_link_OperationLink,components_servers=({servers:s,currentServer:o,setSelectedServer:i,setServerVariableValue:u,getServerVariable:_,getEffectiveServerValue:w})=>{const x=(s.find((s=>s.get("url")===o))||(0,qe.OrderedMap)()).get("variables")||(0,qe.OrderedMap)(),C=0!==x.size;(0,Pe.useEffect)((()=>{o||i(s.first()?.get("url"))}),[]),(0,Pe.useEffect)((()=>{const _=s.find((s=>s.get("url")===o));if(!_)return void i(s.first().get("url"));(_.get("variables")||(0,qe.OrderedMap)()).map(((s,i)=>{u({server:o,key:i,val:s.get("default")||""})}))}),[o,s]);const j=(0,Pe.useCallback)((s=>{i(s.target.value)}),[i]),L=(0,Pe.useCallback)((s=>{const i=s.target.getAttribute("data-variable"),_=s.target.value;u({server:o,key:i,val:_})}),[u,o]);return Pe.createElement("div",{className:"servers"},Pe.createElement("label",{htmlFor:"servers"},Pe.createElement("select",{onChange:j,value:o,id:"servers"},s.valueSeq().map((s=>Pe.createElement("option",{value:s.get("url"),key:s.get("url")},s.get("url"),s.get("description")&&` - ${s.get("description")}`))).toArray())),C&&Pe.createElement("div",null,Pe.createElement("div",{className:"computed-url"},"Computed URL:",Pe.createElement("code",null,w(o))),Pe.createElement("h4",null,"Server variables"),Pe.createElement("table",null,Pe.createElement("tbody",null,x.entrySeq().map((([s,i])=>Pe.createElement("tr",{key:s},Pe.createElement("td",null,s),Pe.createElement("td",null,i.get("enum")?Pe.createElement("select",{"data-variable":s,onChange:L},i.get("enum").map((i=>Pe.createElement("option",{selected:i===_(o,s),key:i,value:i},i)))):Pe.createElement("input",{type:"text",value:_(o,s)||"",onChange:L,"data-variable":s})))))))))};class ServersContainer extends Pe.Component{render(){const{specSelectors:s,oas3Selectors:o,oas3Actions:i,getComponent:u}=this.props,_=s.servers(),w=u("Servers");return _&&_.size?Pe.createElement("div",null,Pe.createElement("span",{className:"servers-title"},"Servers"),Pe.createElement(w,{servers:_,currentServer:o.selectedServer(),setSelectedServer:i.setSelectedServer,setServerVariableValue:i.setServerVariableValue,getServerVariable:o.serverVariableValue,getEffectiveServerValue:o.serverEffectiveValue})):null}}const tA=Function.prototype;class RequestBodyEditor extends Pe.PureComponent{static defaultProps={onChange:tA,userHasEditedBody:!1};constructor(s,o){super(s,o),this.state={value:stringify(s.value)||s.defaultValue},s.onChange(s.value)}applyDefaultValue=s=>{const{onChange:o,defaultValue:i}=s||this.props;return this.setState({value:i}),o(i)};onChange=s=>{this.props.onChange(stringify(s))};onDomChange=s=>{const o=s.target.value;this.setState({value:o},(()=>this.onChange(o)))};UNSAFE_componentWillReceiveProps(s){this.props.value!==s.value&&s.value!==this.state.value&&this.setState({value:stringify(s.value)}),!s.value&&s.defaultValue&&this.state.value&&this.applyDefaultValue(s)}render(){let{getComponent:s,errors:o}=this.props,{value:i}=this.state,u=o.size>0;const _=s("TextArea");return Pe.createElement("div",{className:"body-param"},Pe.createElement(_,{className:Hn()("body-param__text",{invalid:u}),title:o.size?o.join(", "):"",value:i,onChange:this.onDomChange}))}}class HttpAuth extends Pe.Component{constructor(s,o){super(s,o);let{name:i,schema:u}=this.props,_=this.getValue();this.state={name:i,schema:u,value:_}}getValue(){let{name:s,authorized:o}=this.props;return o&&o.getIn([s,"value"])}onChange=s=>{let{onChange:o}=this.props,{value:i,name:u}=s.target,_=Object.assign({},this.state.value);u?_[u]=i:_=i,this.setState({value:_},(()=>o(this.state)))};render(){let{schema:s,getComponent:o,errSelectors:i,name:u}=this.props;const _=o("Input"),w=o("Row"),x=o("Col"),C=o("authError"),j=o("Markdown",!0),L=o("JumpToPath",!0),B=(s.get("scheme")||"").toLowerCase();let $=this.getValue(),V=i.allErrors().filter((s=>s.get("authId")===u));if("basic"===B){let o=$?$.get("username"):null;return Pe.createElement("div",null,Pe.createElement("h4",null,Pe.createElement("code",null,u||s.get("name")),"  (http, Basic)",Pe.createElement(L,{path:["securityDefinitions",u]})),o&&Pe.createElement("h6",null,"Authorized"),Pe.createElement(w,null,Pe.createElement(j,{source:s.get("description")})),Pe.createElement(w,null,Pe.createElement("label",{htmlFor:"auth-basic-username"},"Username:"),o?Pe.createElement("code",null," ",o," "):Pe.createElement(x,null,Pe.createElement(_,{id:"auth-basic-username",type:"text",required:"required",name:"username","aria-label":"auth-basic-username",onChange:this.onChange,autoFocus:!0}))),Pe.createElement(w,null,Pe.createElement("label",{htmlFor:"auth-basic-password"},"Password:"),o?Pe.createElement("code",null," ****** "):Pe.createElement(x,null,Pe.createElement(_,{id:"auth-basic-password",autoComplete:"new-password",name:"password",type:"password","aria-label":"auth-basic-password",onChange:this.onChange}))),V.valueSeq().map(((s,o)=>Pe.createElement(C,{error:s,key:o}))))}return"bearer"===B?Pe.createElement("div",null,Pe.createElement("h4",null,Pe.createElement("code",null,u||s.get("name")),"  (http, Bearer)",Pe.createElement(L,{path:["securityDefinitions",u]})),$&&Pe.createElement("h6",null,"Authorized"),Pe.createElement(w,null,Pe.createElement(j,{source:s.get("description")})),Pe.createElement(w,null,Pe.createElement("label",{htmlFor:"auth-bearer-value"},"Value:"),$?Pe.createElement("code",null," ****** "):Pe.createElement(x,null,Pe.createElement(_,{id:"auth-bearer-value",type:"text","aria-label":"auth-bearer-value",onChange:this.onChange,autoFocus:!0}))),V.valueSeq().map(((s,o)=>Pe.createElement(C,{error:s,key:o})))):Pe.createElement("div",null,Pe.createElement("em",null,Pe.createElement("b",null,u)," HTTP authentication: unsupported scheme ",`'${B}'`))}}class operation_servers_OperationServers extends Pe.Component{setSelectedServer=s=>{const{path:o,method:i}=this.props;return this.forceUpdate(),this.props.setSelectedServer(s,`${o}:${i}`)};setServerVariableValue=s=>{const{path:o,method:i}=this.props;return this.forceUpdate(),this.props.setServerVariableValue({...s,namespace:`${o}:${i}`})};getSelectedServer=()=>{const{path:s,method:o}=this.props;return this.props.getSelectedServer(`${s}:${o}`)};getServerVariable=(s,o)=>{const{path:i,method:u}=this.props;return this.props.getServerVariable({namespace:`${i}:${u}`,server:s},o)};getEffectiveServerValue=s=>{const{path:o,method:i}=this.props;return this.props.getEffectiveServerValue({server:s,namespace:`${o}:${i}`})};render(){const{operationServers:s,pathServers:o,getComponent:i}=this.props;if(!s&&!o)return null;const u=i("Servers"),_=s||o,w=s?"operation":"path";return Pe.createElement("div",{className:"opblock-section operation-servers"},Pe.createElement("div",{className:"opblock-section-header"},Pe.createElement("div",{className:"tab-header"},Pe.createElement("h4",{className:"opblock-title"},"Servers"))),Pe.createElement("div",{className:"opblock-description-wrapper"},Pe.createElement("h4",{className:"message"},"These ",w,"-level options override the global server options."),Pe.createElement(u,{servers:_,currentServer:this.getSelectedServer(),setSelectedServer:this.setSelectedServer,setServerVariableValue:this.setServerVariableValue,getServerVariable:this.getServerVariable,getEffectiveServerValue:this.getEffectiveServerValue})))}}const rA={Callbacks:callbacks,HttpAuth,RequestBody:components_request_body,Servers:components_servers,ServersContainer,RequestBodyEditor,OperationServers:operation_servers_OperationServers,operationLink:eA},nA=new Remarkable("commonmark");nA.block.ruler.enable(["table"]),nA.set({linkTarget:"_blank"});const sA=OAS3ComponentWrapFactory((({source:s,className:o="",getConfigs:i=()=>({useUnsafeMarkdown:!1})})=>{if("string"!=typeof s)return null;if(s){const{useUnsafeMarkdown:u}=i(),_=sanitizer(nA.render(s),{useUnsafeMarkdown:u});let w;return"string"==typeof _&&(w=_.trim()),Pe.createElement("div",{dangerouslySetInnerHTML:{__html:w},className:Hn()(o,"renderedMarkdown")})}return null})),oA=OAS3ComponentWrapFactory((({Ori:s,...o})=>{const{schema:i,getComponent:u,errSelectors:_,authorized:w,onAuthChange:x,name:C}=o,j=u("HttpAuth");return"http"===i.get("type")?Pe.createElement(j,{key:C,schema:i,name:C,errSelectors:_,authorized:w,getComponent:u,onChange:x}):Pe.createElement(s,o)})),iA=OAS3ComponentWrapFactory(OnlineValidatorBadge);class ModelComponent extends Pe.Component{render(){let{getConfigs:s,schema:o,Ori:i}=this.props,u=["model-box"],_=null;return!0===o.get("deprecated")&&(u.push("deprecated"),_=Pe.createElement("span",{className:"model-deprecated-warning"},"Deprecated:")),Pe.createElement("div",{className:u.join(" ")},_,Pe.createElement(i,Rn()({},this.props,{getConfigs:s,depth:1,expandDepth:this.props.expandDepth||0})))}}const aA=OAS3ComponentWrapFactory(ModelComponent),lA=OAS3ComponentWrapFactory((({Ori:s,...o})=>{const{schema:i,getComponent:u,errors:_,onChange:w}=o,x=i&&i.get?i.get("format"):null,C=i&&i.get?i.get("type"):null,j=u("Input");return C&&"string"===C&&x&&("binary"===x||"base64"===x)?Pe.createElement(j,{type:"file",className:_.length?"invalid":"",title:_.length?_:"",onChange:s=>{w(s.target.files[0])},disabled:s.isDisabled}):Pe.createElement(s,o)})),cA={Markdown:sA,AuthItem:oA,OpenAPIVersion:function OAS30ComponentWrapFactory(s){return(o,i)=>u=>"function"==typeof i.specSelectors?.isOAS30?i.specSelectors.isOAS30()?Pe.createElement(s,Rn()({},u,i,{Ori:o})):Pe.createElement(o,u):(console.warn("OAS30 wrapper: couldn't get spec"),null)}((s=>{const{Ori:o}=s;return Pe.createElement(o,{oasVersion:"3.0"})})),JsonSchema_string:lA,model:aA,onlineValidatorBadge:iA},uA="oas3_set_servers",pA="oas3_set_request_body_value",hA="oas3_set_request_body_retain_flag",dA="oas3_set_request_body_inclusion",fA="oas3_set_active_examples_member",mA="oas3_set_request_content_type",gA="oas3_set_response_content_type",yA="oas3_set_server_variable_value",vA="oas3_set_request_body_validate_error",bA="oas3_clear_request_body_validate_error",_A="oas3_clear_request_body_value";function setSelectedServer(s,o){return{type:uA,payload:{selectedServerUrl:s,namespace:o}}}function setRequestBodyValue({value:s,pathMethod:o}){return{type:pA,payload:{value:s,pathMethod:o}}}const setRetainRequestBodyValueFlag=({value:s,pathMethod:o})=>({type:hA,payload:{value:s,pathMethod:o}});function setRequestBodyInclusion({value:s,pathMethod:o,name:i}){return{type:dA,payload:{value:s,pathMethod:o,name:i}}}function setActiveExamplesMember({name:s,pathMethod:o,contextType:i,contextName:u}){return{type:fA,payload:{name:s,pathMethod:o,contextType:i,contextName:u}}}function setRequestContentType({value:s,pathMethod:o}){return{type:mA,payload:{value:s,pathMethod:o}}}function setResponseContentType({value:s,path:o,method:i}){return{type:gA,payload:{value:s,path:o,method:i}}}function setServerVariableValue({server:s,namespace:o,key:i,val:u}){return{type:yA,payload:{server:s,namespace:o,key:i,val:u}}}const setRequestBodyValidateError=({path:s,method:o,validationErrors:i})=>({type:vA,payload:{path:s,method:o,validationErrors:i}}),clearRequestBodyValidateError=({path:s,method:o})=>({type:bA,payload:{path:s,method:o}}),initRequestBodyValidateError=({pathMethod:s})=>({type:bA,payload:{path:s[0],method:s[1]}}),clearRequestBodyValue=({pathMethod:s})=>({type:_A,payload:{pathMethod:s}});var EA=__webpack_require__(60680),wA=__webpack_require__.n(EA);const oas3_selectors_onlyOAS3=s=>(o,...i)=>u=>{if(u.getSystem().specSelectors.isOAS3()){const _=s(o,...i);return"function"==typeof _?_(u):_}return null};const SA=oas3_selectors_onlyOAS3(((s,o)=>{const i=o?[o,"selectedServer"]:["selectedServer"];return s.getIn(i)||""})),xA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"bodyValue"])||null)),kA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"retainBodyValue"])||!1)),selectDefaultRequestBodyValue=(s,o,i)=>s=>{const{oas3Selectors:u,specSelectors:_,fn:w}=s.getSystem();if(_.isOAS3()){const s=u.requestContentType(o,i);if(s)return getDefaultRequestBodyValue(_.specResolvedSubtree(["paths",o,i,"requestBody"]),s,u.activeExamplesMember(o,i,"requestBody","requestBody"),w)}return null},CA=oas3_selectors_onlyOAS3(((s,o,i)=>s=>{const{oas3Selectors:u,specSelectors:_,fn:w}=s;let x=!1;const C=u.requestContentType(o,i);let j=u.requestBodyValue(o,i);const L=_.specResolvedSubtree(["paths",o,i,"requestBody"]);if(!L)return!1;if(qe.Map.isMap(j)&&(j=stringify(j.mapEntries((s=>qe.Map.isMap(s[1])?[s[0],s[1].get("value")]:s)).toJS())),qe.List.isList(j)&&(j=stringify(j)),C){const s=getDefaultRequestBodyValue(L,C,u.activeExamplesMember(o,i,"requestBody","requestBody"),w);x=!!j&&j!==s}return x})),OA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"bodyInclusion"])||(0,qe.Map)())),AA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"errors"])||null)),jA=oas3_selectors_onlyOAS3(((s,o,i,u,_)=>s.getIn(["examples",o,i,u,_,"activeExample"])||null)),IA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"requestContentType"])||null)),PA=oas3_selectors_onlyOAS3(((s,o,i)=>s.getIn(["requestData",o,i,"responseContentType"])||null)),MA=oas3_selectors_onlyOAS3(((s,o,i)=>{let u;if("string"!=typeof o){const{server:s,namespace:_}=o;u=_?[_,"serverVariableValues",s,i]:["serverVariableValues",s,i]}else{u=["serverVariableValues",o,i]}return s.getIn(u)||null})),TA=oas3_selectors_onlyOAS3(((s,o)=>{let i;if("string"!=typeof o){const{server:s,namespace:u}=o;i=u?[u,"serverVariableValues",s]:["serverVariableValues",s]}else{i=["serverVariableValues",o]}return s.getIn(i)||(0,qe.OrderedMap)()})),NA=oas3_selectors_onlyOAS3(((s,o)=>{var i,u;if("string"!=typeof o){const{server:_,namespace:w}=o;u=_,i=w?s.getIn([w,"serverVariableValues",u]):s.getIn(["serverVariableValues",u])}else u=o,i=s.getIn(["serverVariableValues",u]);i=i||(0,qe.OrderedMap)();let _=u;return i.map(((s,o)=>{_=_.replace(new RegExp(`{${wA()(o)}}`,"g"),s)})),_})),RA=function validateRequestBodyIsRequired(s){return(...o)=>i=>{const u=i.getSystem().specSelectors.specJson();let _=[...o][1]||[];return!u.getIn(["paths",..._,"requestBody","required"])||s(...o)}}(((s,o)=>((s,o)=>(o=o||[],!!s.getIn(["requestData",...o,"bodyValue"])))(s,o))),validateShallowRequired=(s,{oas3RequiredRequestBodyContentType:o,oas3RequestContentType:i,oas3RequestBodyValue:u})=>{let _=[];if(!qe.Map.isMap(u))return _;let w=[];return Object.keys(o.requestContentType).forEach((s=>{if(s===i){o.requestContentType[s].forEach((s=>{w.indexOf(s)<0&&w.push(s)}))}})),w.forEach((s=>{u.getIn([s,"value"])||_.push(s)})),_},DA=Ss()(["get","put","post","delete","options","head","patch","trace"]),LA={[uA]:(s,{payload:{selectedServerUrl:o,namespace:i}})=>{const u=i?[i,"selectedServer"]:["selectedServer"];return s.setIn(u,o)},[pA]:(s,{payload:{value:o,pathMethod:i}})=>{let[u,_]=i;if(!qe.Map.isMap(o))return s.setIn(["requestData",u,_,"bodyValue"],o);let w,x=s.getIn(["requestData",u,_,"bodyValue"])||(0,qe.Map)();qe.Map.isMap(x)||(x=(0,qe.Map)());const[...C]=o.keys();return C.forEach((s=>{let i=o.getIn([s]);x.has(s)&&qe.Map.isMap(i)||(w=x.setIn([s,"value"],i))})),s.setIn(["requestData",u,_,"bodyValue"],w)},[hA]:(s,{payload:{value:o,pathMethod:i}})=>{let[u,_]=i;return s.setIn(["requestData",u,_,"retainBodyValue"],o)},[dA]:(s,{payload:{value:o,pathMethod:i,name:u}})=>{let[_,w]=i;return s.setIn(["requestData",_,w,"bodyInclusion",u],o)},[fA]:(s,{payload:{name:o,pathMethod:i,contextType:u,contextName:_}})=>{let[w,x]=i;return s.setIn(["examples",w,x,u,_,"activeExample"],o)},[mA]:(s,{payload:{value:o,pathMethod:i}})=>{let[u,_]=i;return s.setIn(["requestData",u,_,"requestContentType"],o)},[gA]:(s,{payload:{value:o,path:i,method:u}})=>s.setIn(["requestData",i,u,"responseContentType"],o),[yA]:(s,{payload:{server:o,namespace:i,key:u,val:_}})=>{const w=i?[i,"serverVariableValues",o,u]:["serverVariableValues",o,u];return s.setIn(w,_)},[vA]:(s,{payload:{path:o,method:i,validationErrors:u}})=>{let _=[];if(_.push("Required field is not provided"),u.missingBodyValue)return s.setIn(["requestData",o,i,"errors"],(0,qe.fromJS)(_));if(u.missingRequiredKeys&&u.missingRequiredKeys.length>0){const{missingRequiredKeys:w}=u;return s.updateIn(["requestData",o,i,"bodyValue"],(0,qe.fromJS)({}),(s=>w.reduce(((s,o)=>s.setIn([o,"errors"],(0,qe.fromJS)(_))),s)))}return console.warn("unexpected result: SET_REQUEST_BODY_VALIDATE_ERROR"),s},[bA]:(s,{payload:{path:o,method:i}})=>{const u=s.getIn(["requestData",o,i,"bodyValue"]);if(!qe.Map.isMap(u))return s.setIn(["requestData",o,i,"errors"],(0,qe.fromJS)([]));const[..._]=u.keys();return _?s.updateIn(["requestData",o,i,"bodyValue"],(0,qe.fromJS)({}),(s=>_.reduce(((s,o)=>s.setIn([o,"errors"],(0,qe.fromJS)([]))),s))):s},[_A]:(s,{payload:{pathMethod:o}})=>{let[i,u]=o;const _=s.getIn(["requestData",i,u,"bodyValue"]);return _?qe.Map.isMap(_)?s.setIn(["requestData",i,u,"bodyValue"],(0,qe.Map)()):s.setIn(["requestData",i,u,"bodyValue"],""):s}};function oas3(){return{components:rA,wrapComponents:cA,statePlugins:{spec:{wrapSelectors:be,selectors:we},auth:{wrapSelectors:_e},oas3:{actions:{...Se},reducers:LA,selectors:{...xe}}}}}const webhooks=({specSelectors:s,getComponent:o})=>{const i=s.selectWebhooksOperations(),u=Object.keys(i),_=o("OperationContainer",!0);return 0===u.length?null:Pe.createElement("div",{className:"webhooks"},Pe.createElement("h2",null,"Webhooks"),u.map((s=>Pe.createElement("div",{key:`${s}-webhook`},i[s].map((o=>Pe.createElement(_,{key:`${s}-${o.method}-webhook`,op:o.operation,tag:"webhooks",method:o.method,path:s,specPath:(0,qe.List)(o.specPath),allowTryItOut:!1})))))))},oas31_components_license=({getComponent:s,specSelectors:o})=>{const i=o.selectLicenseNameField(),u=o.selectLicenseUrl(),_=s("Link");return Pe.createElement("div",{className:"info__license"},u?Pe.createElement("div",{className:"info__license__url"},Pe.createElement(_,{target:"_blank",href:sanitizeUrl(u)},i)):Pe.createElement("span",null,i))},oas31_components_contact=({getComponent:s,specSelectors:o})=>{const i=o.selectContactNameField(),u=o.selectContactUrl(),_=o.selectContactEmailField(),w=s("Link");return Pe.createElement("div",{className:"info__contact"},u&&Pe.createElement("div",null,Pe.createElement(w,{href:sanitizeUrl(u),target:"_blank"},i," - Website")),_&&Pe.createElement(w,{href:sanitizeUrl(`mailto:${_}`)},u?`Send email to ${i}`:`Contact ${i}`))},oas31_components_info=({getComponent:s,specSelectors:o})=>{const i=o.version(),u=o.url(),_=o.basePath(),w=o.host(),x=o.selectInfoSummaryField(),C=o.selectInfoDescriptionField(),j=o.selectInfoTitleField(),L=o.selectInfoTermsOfServiceUrl(),B=o.selectExternalDocsUrl(),$=o.selectExternalDocsDescriptionField(),V=o.contact(),U=o.license(),z=s("Markdown",!0),Y=s("Link"),Z=s("VersionStamp"),ee=s("OpenAPIVersion"),ie=s("InfoUrl"),ae=s("InfoBasePath"),le=s("License",!0),ce=s("Contact",!0),pe=s("JsonSchemaDialect",!0);return Pe.createElement("div",{className:"info"},Pe.createElement("hgroup",{className:"main"},Pe.createElement("h2",{className:"title"},j,Pe.createElement("span",null,i&&Pe.createElement(Z,{version:i}),Pe.createElement(ee,{oasVersion:"3.1"}))),(w||_)&&Pe.createElement(ae,{host:w,basePath:_}),u&&Pe.createElement(ie,{getComponent:s,url:u})),x&&Pe.createElement("p",{className:"info__summary"},x),Pe.createElement("div",{className:"info__description description"},Pe.createElement(z,{source:C})),L&&Pe.createElement("div",{className:"info__tos"},Pe.createElement(Y,{target:"_blank",href:sanitizeUrl(L)},"Terms of service")),V.size>0&&Pe.createElement(ce,null),U.size>0&&Pe.createElement(le,null),B&&Pe.createElement(Y,{className:"info__extdocs",target:"_blank",href:sanitizeUrl(B)},$||B),Pe.createElement(pe,null))},json_schema_dialect=({getComponent:s,specSelectors:o})=>{const i=o.selectJsonSchemaDialectField(),u=o.selectJsonSchemaDialectDefault(),_=s("Link");return Pe.createElement(Pe.Fragment,null,i&&i===u&&Pe.createElement("p",{className:"info__jsonschemadialect"},"JSON Schema dialect:"," ",Pe.createElement(_,{target:"_blank",href:sanitizeUrl(i)},i)),i&&i!==u&&Pe.createElement("div",{className:"error-wrapper"},Pe.createElement("div",{className:"no-margin"},Pe.createElement("div",{className:"errors"},Pe.createElement("div",{className:"errors-wrapper"},Pe.createElement("h4",{className:"center"},"Warning"),Pe.createElement("p",{className:"message"},Pe.createElement("strong",null,"OpenAPI.jsonSchemaDialect")," field contains a value different from the default value of"," ",Pe.createElement(_,{target:"_blank",href:u},u),". Values different from the default one are currently not supported. Please either omit the field or provide it with the default value."))))))},version_pragma_filter=({bypass:s,isSwagger2:o,isOAS3:i,isOAS31:u,alsoShow:_,children:w})=>s?Pe.createElement("div",null,w):o&&(i||u)?Pe.createElement("div",{className:"version-pragma"},_,Pe.createElement("div",{className:"version-pragma__message version-pragma__message--ambiguous"},Pe.createElement("div",null,Pe.createElement("h3",null,"Unable to render this definition"),Pe.createElement("p",null,Pe.createElement("code",null,"swagger")," and ",Pe.createElement("code",null,"openapi")," fields cannot be present in the same Swagger or OpenAPI definition. Please remove one of the fields."),Pe.createElement("p",null,"Supported version fields are ",Pe.createElement("code",null,'swagger: "2.0"')," and those that match ",Pe.createElement("code",null,"openapi: 3.x.y")," (for example,"," ",Pe.createElement("code",null,"openapi: 3.1.0"),").")))):o||i||u?Pe.createElement("div",null,w):Pe.createElement("div",{className:"version-pragma"},_,Pe.createElement("div",{className:"version-pragma__message version-pragma__message--missing"},Pe.createElement("div",null,Pe.createElement("h3",null,"Unable to render this definition"),Pe.createElement("p",null,"The provided definition does not specify a valid version field."),Pe.createElement("p",null,"Please indicate a valid Swagger or OpenAPI version field. Supported version fields are ",Pe.createElement("code",null,'swagger: "2.0"')," and those that match ",Pe.createElement("code",null,"openapi: 3.x.y")," (for example,"," ",Pe.createElement("code",null,"openapi: 3.1.0"),").")))),getModelName=s=>"string"==typeof s&&s.includes("#/components/schemas/")?(s=>{const o=s.replace(/~1/g,"/").replace(/~0/g,"~");try{return decodeURIComponent(o)}catch{return o}})(s.replace(/^.*#\/components\/schemas\//,"")):null,BA=(0,Pe.forwardRef)((({schema:s,getComponent:o,onToggle:i=()=>{}},u)=>{const _=o("JSONSchema202012"),w=getModelName(s.get("$$ref")),x=(0,Pe.useCallback)(((s,o)=>{i(w,o)}),[w,i]);return Pe.createElement(_,{name:w,schema:s.toJS(),ref:u,onExpand:x})})),FA=BA,models=({specActions:s,specSelectors:o,layoutSelectors:i,layoutActions:u,getComponent:_,getConfigs:w,fn:x})=>{const C=o.selectSchemas(),j=Object.keys(C).length>0,L=["components","schemas"],{docExpansion:B,defaultModelsExpandDepth:$}=w(),V=$>0&&"none"!==B,U=i.isShown(L,V),z=_("Collapse"),Y=_("JSONSchema202012"),Z=_("ArrowUpIcon"),ee=_("ArrowDownIcon"),{getTitle:ie}=x.jsonSchema202012.useFn();(0,Pe.useEffect)((()=>{const i=U&&$>1,u=null!=o.specResolvedSubtree(L);i&&!u&&s.requestResolvedSubtree(L)}),[U,$]);const ae=(0,Pe.useCallback)((()=>{u.show(L,!U)}),[U]),le=(0,Pe.useCallback)((s=>{null!==s&&u.readyToScroll(L,s)}),[]),handleJSONSchema202012Ref=s=>o=>{null!==o&&u.readyToScroll([...L,s],o)},handleJSONSchema202012Expand=i=>(u,_)=>{if(_){const u=[...L,i];null!=o.specResolvedSubtree(u)||s.requestResolvedSubtree([...L,i])}};return!j||$<0?null:Pe.createElement("section",{className:Hn()("models",{"is-open":U}),ref:le},Pe.createElement("h4",null,Pe.createElement("button",{"aria-expanded":U,className:"models-control",onClick:ae},Pe.createElement("span",null,"Schemas"),U?Pe.createElement(Z,null):Pe.createElement(ee,null))),Pe.createElement(z,{isOpened:U},Object.entries(C).map((([s,o])=>{const i=ie(o,{lookup:"basic"})||s;return Pe.createElement(Y,{key:s,ref:handleJSONSchema202012Ref(s),schema:o,name:i,onExpand:handleJSONSchema202012Expand(s)})}))))},mutual_tls_auth=({schema:s,getComponent:o})=>{const i=o("JumpToPath",!0);return Pe.createElement("div",null,Pe.createElement("h4",null,s.get("name")," (mutualTLS)"," ",Pe.createElement(i,{path:["securityDefinitions",s.get("name")]})),Pe.createElement("p",null,"Mutual TLS is required by this API/Operation. Certificates are managed via your Operating System and/or your browser."),Pe.createElement("p",null,s.get("description")))};class auths_Auths extends Pe.Component{constructor(s,o){super(s,o),this.state={}}onAuthChange=s=>{let{name:o}=s;this.setState({[o]:s})};submitAuth=s=>{s.preventDefault();let{authActions:o}=this.props;o.authorizeWithPersistOption(this.state)};logoutClick=s=>{s.preventDefault();let{authActions:o,definitions:i}=this.props,u=i.map(((s,o)=>o)).toArray();this.setState(u.reduce(((s,o)=>(s[o]="",s)),{})),o.logoutWithPersistOption(u)};close=s=>{s.preventDefault();let{authActions:o}=this.props;o.showDefinitions(!1)};render(){let{definitions:s,getComponent:o,authSelectors:i,errSelectors:u}=this.props;const _=o("AuthItem"),w=o("oauth2",!0),x=o("Button"),C=i.authorized(),j=s.filter(((s,o)=>!!C.get(o))),L=s.filter((s=>"oauth2"!==s.get("type")&&"mutualTLS"!==s.get("type"))),B=s.filter((s=>"oauth2"===s.get("type"))),$=s.filter((s=>"mutualTLS"===s.get("type")));return Pe.createElement("div",{className:"auth-container"},L.size>0&&Pe.createElement("form",{onSubmit:this.submitAuth},L.map(((s,i)=>Pe.createElement(_,{key:i,schema:s,name:i,getComponent:o,onAuthChange:this.onAuthChange,authorized:C,errSelectors:u}))).toArray(),Pe.createElement("div",{className:"auth-btn-wrapper"},L.size===j.size?Pe.createElement(x,{className:"btn modal-btn auth",onClick:this.logoutClick,"aria-label":"Remove authorization"},"Logout"):Pe.createElement(x,{type:"submit",className:"btn modal-btn auth authorize","aria-label":"Apply credentials"},"Authorize"),Pe.createElement(x,{className:"btn modal-btn auth btn-done",onClick:this.close},"Close"))),B.size>0?Pe.createElement("div",null,Pe.createElement("div",{className:"scope-def"},Pe.createElement("p",null,"Scopes are used to grant an application different levels of access to data on behalf of the end user. Each API may declare one or more scopes."),Pe.createElement("p",null,"API requires the following scopes. Select which ones you want to grant to Swagger UI.")),s.filter((s=>"oauth2"===s.get("type"))).map(((s,o)=>Pe.createElement("div",{key:o},Pe.createElement(w,{authorized:C,schema:s,name:o})))).toArray()):null,$.size>0&&Pe.createElement("div",null,$.map(((s,i)=>Pe.createElement(_,{key:i,schema:s,name:i,getComponent:o,onAuthChange:this.onAuthChange,authorized:C,errSelectors:u}))).toArray()))}}const qA=auths_Auths,isOAS31=s=>{const o=s.get("openapi");return"string"==typeof o&&/^3\.1\.(?:[1-9]\d*|0)$/.test(o)},fn_createOnlyOAS31Selector=s=>(o,...i)=>u=>{if(u.getSystem().specSelectors.isOAS31()){const _=s(o,...i);return"function"==typeof _?_(u):_}return null},createOnlyOAS31SelectorWrapper=s=>(o,i)=>(u,..._)=>{if(i.getSystem().specSelectors.isOAS31()){const w=s(u,..._);return"function"==typeof w?w(o,i):w}return o(..._)},fn_createSystemSelector=s=>(o,...i)=>u=>{const _=s(o,u,...i);return"function"==typeof _?_(u):_},createOnlyOAS31ComponentWrapper=s=>(o,i)=>u=>i.specSelectors.isOAS31()?Pe.createElement(s,Rn()({},u,{originalComponent:o,getSystem:i.getSystem})):Pe.createElement(o,u),$A=createOnlyOAS31ComponentWrapper((({getSystem:s})=>{const o=s().getComponent("OAS31License",!0);return Pe.createElement(o,null)})),VA=createOnlyOAS31ComponentWrapper((({getSystem:s})=>{const o=s().getComponent("OAS31Contact",!0);return Pe.createElement(o,null)})),UA=createOnlyOAS31ComponentWrapper((({getSystem:s})=>{const o=s().getComponent("OAS31Info",!0);return Pe.createElement(o,null)})),zA=createOnlyOAS31ComponentWrapper((({getSystem:s,...o})=>{const i=s(),{getComponent:u,fn:_,getConfigs:w}=i,x=w(),C=u("OAS31Model"),j=u("JSONSchema202012"),L=u("JSONSchema202012Keyword$schema"),B=u("JSONSchema202012Keyword$vocabulary"),$=u("JSONSchema202012Keyword$id"),V=u("JSONSchema202012Keyword$anchor"),U=u("JSONSchema202012Keyword$dynamicAnchor"),z=u("JSONSchema202012Keyword$ref"),Y=u("JSONSchema202012Keyword$dynamicRef"),Z=u("JSONSchema202012Keyword$defs"),ee=u("JSONSchema202012Keyword$comment"),ie=u("JSONSchema202012KeywordAllOf"),ae=u("JSONSchema202012KeywordAnyOf"),le=u("JSONSchema202012KeywordOneOf"),ce=u("JSONSchema202012KeywordNot"),pe=u("JSONSchema202012KeywordIf"),de=u("JSONSchema202012KeywordThen"),fe=u("JSONSchema202012KeywordElse"),ye=u("JSONSchema202012KeywordDependentSchemas"),be=u("JSONSchema202012KeywordPrefixItems"),_e=u("JSONSchema202012KeywordItems"),we=u("JSONSchema202012KeywordContains"),Se=u("JSONSchema202012KeywordProperties"),xe=u("JSONSchema202012KeywordPatternProperties"),Te=u("JSONSchema202012KeywordAdditionalProperties"),Re=u("JSONSchema202012KeywordPropertyNames"),qe=u("JSONSchema202012KeywordUnevaluatedItems"),$e=u("JSONSchema202012KeywordUnevaluatedProperties"),ze=u("JSONSchema202012KeywordType"),We=u("JSONSchema202012KeywordEnum"),He=u("JSONSchema202012KeywordConst"),Ye=u("JSONSchema202012KeywordConstraint"),Xe=u("JSONSchema202012KeywordDependentRequired"),Qe=u("JSONSchema202012KeywordContentSchema"),et=u("JSONSchema202012KeywordTitle"),tt=u("JSONSchema202012KeywordDescription"),rt=u("JSONSchema202012KeywordDefault"),nt=u("JSONSchema202012KeywordDeprecated"),st=u("JSONSchema202012KeywordReadOnly"),ot=u("JSONSchema202012KeywordWriteOnly"),it=u("JSONSchema202012Accordion"),at=u("JSONSchema202012ExpandDeepButton"),lt=u("JSONSchema202012ChevronRightIcon"),ct=u("withJSONSchema202012Context")(C,{config:{default$schema:"https://spec.openapis.org/oas/3.1/dialect/base",defaultExpandedLevels:x.defaultModelExpandDepth,includeReadOnly:Boolean(o.includeReadOnly),includeWriteOnly:Boolean(o.includeWriteOnly)},components:{JSONSchema:j,Keyword$schema:L,Keyword$vocabulary:B,Keyword$id:$,Keyword$anchor:V,Keyword$dynamicAnchor:U,Keyword$ref:z,Keyword$dynamicRef:Y,Keyword$defs:Z,Keyword$comment:ee,KeywordAllOf:ie,KeywordAnyOf:ae,KeywordOneOf:le,KeywordNot:ce,KeywordIf:pe,KeywordThen:de,KeywordElse:fe,KeywordDependentSchemas:ye,KeywordPrefixItems:be,KeywordItems:_e,KeywordContains:we,KeywordProperties:Se,KeywordPatternProperties:xe,KeywordAdditionalProperties:Te,KeywordPropertyNames:Re,KeywordUnevaluatedItems:qe,KeywordUnevaluatedProperties:$e,KeywordType:ze,KeywordEnum:We,KeywordConst:He,KeywordConstraint:Ye,KeywordDependentRequired:Xe,KeywordContentSchema:Qe,KeywordTitle:et,KeywordDescription:tt,KeywordDefault:rt,KeywordDeprecated:nt,KeywordReadOnly:st,KeywordWriteOnly:ot,Accordion:it,ExpandDeepButton:at,ChevronRightIcon:lt},fn:{upperFirst:_.upperFirst,isExpandable:_.jsonSchema202012.isExpandable,getProperties:_.jsonSchema202012.getProperties}});return Pe.createElement(ct,o)})),WA=zA,KA=createOnlyOAS31ComponentWrapper((({getSystem:s})=>{const{getComponent:o,fn:i,getConfigs:u}=s(),_=u();if(KA.ModelsWithJSONSchemaContext)return Pe.createElement(KA.ModelsWithJSONSchemaContext,null);const w=o("OAS31Models",!0),x=o("JSONSchema202012"),C=o("JSONSchema202012Keyword$schema"),j=o("JSONSchema202012Keyword$vocabulary"),L=o("JSONSchema202012Keyword$id"),B=o("JSONSchema202012Keyword$anchor"),$=o("JSONSchema202012Keyword$dynamicAnchor"),V=o("JSONSchema202012Keyword$ref"),U=o("JSONSchema202012Keyword$dynamicRef"),z=o("JSONSchema202012Keyword$defs"),Y=o("JSONSchema202012Keyword$comment"),Z=o("JSONSchema202012KeywordAllOf"),ee=o("JSONSchema202012KeywordAnyOf"),ie=o("JSONSchema202012KeywordOneOf"),ae=o("JSONSchema202012KeywordNot"),le=o("JSONSchema202012KeywordIf"),ce=o("JSONSchema202012KeywordThen"),pe=o("JSONSchema202012KeywordElse"),de=o("JSONSchema202012KeywordDependentSchemas"),fe=o("JSONSchema202012KeywordPrefixItems"),ye=o("JSONSchema202012KeywordItems"),be=o("JSONSchema202012KeywordContains"),_e=o("JSONSchema202012KeywordProperties"),we=o("JSONSchema202012KeywordPatternProperties"),Se=o("JSONSchema202012KeywordAdditionalProperties"),xe=o("JSONSchema202012KeywordPropertyNames"),Te=o("JSONSchema202012KeywordUnevaluatedItems"),Re=o("JSONSchema202012KeywordUnevaluatedProperties"),qe=o("JSONSchema202012KeywordType"),$e=o("JSONSchema202012KeywordEnum"),ze=o("JSONSchema202012KeywordConst"),We=o("JSONSchema202012KeywordConstraint"),He=o("JSONSchema202012KeywordDependentRequired"),Ye=o("JSONSchema202012KeywordContentSchema"),Xe=o("JSONSchema202012KeywordTitle"),Qe=o("JSONSchema202012KeywordDescription"),et=o("JSONSchema202012KeywordDefault"),tt=o("JSONSchema202012KeywordDeprecated"),rt=o("JSONSchema202012KeywordReadOnly"),nt=o("JSONSchema202012KeywordWriteOnly"),st=o("JSONSchema202012Accordion"),ot=o("JSONSchema202012ExpandDeepButton"),it=o("JSONSchema202012ChevronRightIcon"),at=o("withJSONSchema202012Context");return KA.ModelsWithJSONSchemaContext=at(w,{config:{default$schema:"https://spec.openapis.org/oas/3.1/dialect/base",defaultExpandedLevels:_.defaultModelsExpandDepth-1,includeReadOnly:!0,includeWriteOnly:!0},components:{JSONSchema:x,Keyword$schema:C,Keyword$vocabulary:j,Keyword$id:L,Keyword$anchor:B,Keyword$dynamicAnchor:$,Keyword$ref:V,Keyword$dynamicRef:U,Keyword$defs:z,Keyword$comment:Y,KeywordAllOf:Z,KeywordAnyOf:ee,KeywordOneOf:ie,KeywordNot:ae,KeywordIf:le,KeywordThen:ce,KeywordElse:pe,KeywordDependentSchemas:de,KeywordPrefixItems:fe,KeywordItems:ye,KeywordContains:be,KeywordProperties:_e,KeywordPatternProperties:we,KeywordAdditionalProperties:Se,KeywordPropertyNames:xe,KeywordUnevaluatedItems:Te,KeywordUnevaluatedProperties:Re,KeywordType:qe,KeywordEnum:$e,KeywordConst:ze,KeywordConstraint:We,KeywordDependentRequired:He,KeywordContentSchema:Ye,KeywordTitle:Xe,KeywordDescription:Qe,KeywordDefault:et,KeywordDeprecated:tt,KeywordReadOnly:rt,KeywordWriteOnly:nt,Accordion:st,ExpandDeepButton:ot,ChevronRightIcon:it},fn:{upperFirst:i.upperFirst,isExpandable:i.jsonSchema202012.isExpandable,getProperties:i.jsonSchema202012.getProperties}}),Pe.createElement(KA.ModelsWithJSONSchemaContext,null)}));KA.ModelsWithJSONSchemaContext=null;const HA=KA,wrap_components_version_pragma_filter=(s,o)=>s=>{const i=o.specSelectors.isOAS31(),u=o.getComponent("OAS31VersionPragmaFilter");return Pe.createElement(u,Rn()({isOAS31:i},s))},JA=createOnlyOAS31ComponentWrapper((({originalComponent:s,...o})=>{const{getComponent:i,schema:u}=o,_=i("MutualTLSAuth",!0);return"mutualTLS"===u.get("type")?Pe.createElement(_,{schema:u}):Pe.createElement(s,o)})),GA=JA,YA=createOnlyOAS31ComponentWrapper((({getSystem:s,...o})=>{const i=s().getComponent("OAS31Auths",!0);return Pe.createElement(i,o)})),XA=(0,qe.Map)(),ZA=Ut(((s,o)=>o.specSelectors.specJson()),isOAS31),selectors_webhooks=()=>s=>{const o=s.specSelectors.specJson().get("webhooks");return qe.Map.isMap(o)?o:XA},QA=Ut([(s,o)=>o.specSelectors.webhooks(),(s,o)=>o.specSelectors.validOperationMethods(),(s,o)=>o.specSelectors.specResolvedSubtree(["webhooks"])],((s,o)=>s.reduce(((s,i,u)=>{if(!qe.Map.isMap(i))return s;const _=i.entrySeq().filter((([s])=>o.includes(s))).map((([s,o])=>({operation:(0,qe.Map)({operation:o}),method:s,path:u,specPath:["webhooks",u,s]})));return s.concat(_)}),(0,qe.List)()).groupBy((s=>s.path)).map((s=>s.toArray())).toObject())),selectors_license=()=>s=>{const o=s.specSelectors.info().get("license");return qe.Map.isMap(o)?o:XA},selectLicenseNameField=()=>s=>s.specSelectors.license().get("name","License"),selectLicenseUrlField=()=>s=>s.specSelectors.license().get("url"),ej=Ut([(s,o)=>o.specSelectors.url(),(s,o)=>o.oas3Selectors.selectedServer(),(s,o)=>o.specSelectors.selectLicenseUrlField()],((s,o,i)=>{if(i)return safeBuildUrl(i,s,{selectedServer:o})})),selectLicenseIdentifierField=()=>s=>s.specSelectors.license().get("identifier"),selectors_contact=()=>s=>{const o=s.specSelectors.info().get("contact");return qe.Map.isMap(o)?o:XA},selectContactNameField=()=>s=>s.specSelectors.contact().get("name","the developer"),selectContactEmailField=()=>s=>s.specSelectors.contact().get("email"),selectContactUrlField=()=>s=>s.specSelectors.contact().get("url"),fj=Ut([(s,o)=>o.specSelectors.url(),(s,o)=>o.oas3Selectors.selectedServer(),(s,o)=>o.specSelectors.selectContactUrlField()],((s,o,i)=>{if(i)return safeBuildUrl(i,s,{selectedServer:o})})),selectInfoTitleField=()=>s=>s.specSelectors.info().get("title"),selectInfoSummaryField=()=>s=>s.specSelectors.info().get("summary"),selectInfoDescriptionField=()=>s=>s.specSelectors.info().get("description"),selectInfoTermsOfServiceField=()=>s=>s.specSelectors.info().get("termsOfService"),mj=Ut([(s,o)=>o.specSelectors.url(),(s,o)=>o.oas3Selectors.selectedServer(),(s,o)=>o.specSelectors.selectInfoTermsOfServiceField()],((s,o,i)=>{if(i)return safeBuildUrl(i,s,{selectedServer:o})})),selectExternalDocsDescriptionField=()=>s=>s.specSelectors.externalDocs().get("description"),selectExternalDocsUrlField=()=>s=>s.specSelectors.externalDocs().get("url"),_j=Ut([(s,o)=>o.specSelectors.url(),(s,o)=>o.oas3Selectors.selectedServer(),(s,o)=>o.specSelectors.selectExternalDocsUrlField()],((s,o,i)=>{if(i)return safeBuildUrl(i,s,{selectedServer:o})})),selectJsonSchemaDialectField=()=>s=>s.specSelectors.specJson().get("jsonSchemaDialect"),selectJsonSchemaDialectDefault=()=>"https://spec.openapis.org/oas/3.1/dialect/base",Cj=Ut(((s,o)=>o.specSelectors.definitions()),((s,o)=>o.specSelectors.specResolvedSubtree(["components","schemas"])),((s,o)=>qe.Map.isMap(s)?qe.Map.isMap(o)?Object.entries(s.toJS()).reduce(((s,[i,u])=>{const _=o.get(i);return s[i]=_?.toJS()||u,s}),{}):s.toJS():{})),wrap_selectors_isOAS3=(s,o)=>(i,...u)=>o.specSelectors.isOAS31()||s(...u),Aj=createOnlyOAS31SelectorWrapper((()=>(s,o)=>o.oas31Selectors.selectLicenseUrl())),Nj=createOnlyOAS31SelectorWrapper((()=>(s,o)=>{const i=o.specSelectors.securityDefinitions();let u=s();return i?(i.entrySeq().forEach((([s,o])=>{"mutualTLS"===o.get("type")&&(u=u.push(new qe.Map({[s]:o})))})),u):u})),Bj=Ut([(s,o)=>o.specSelectors.url(),(s,o)=>o.oas3Selectors.selectedServer(),(s,o)=>o.specSelectors.selectLicenseUrlField(),(s,o)=>o.specSelectors.selectLicenseIdentifierField()],((s,o,i,u)=>i?safeBuildUrl(i,s,{selectedServer:o}):u?`https://spdx.org/licenses/${u}.html`:void 0)),keywords_Example=({schema:s,getSystem:o})=>{const{fn:i}=o(),{hasKeyword:u,stringify:_}=i.jsonSchema202012.useFn();return u(s,"example")?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--example"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"Example"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--const"},_(s.example))):null},keywords_Xml=({schema:s,getSystem:o})=>{const i=s?.xml||{},{fn:u,getComponent:_}=o(),{useIsExpandedDeeply:w,useComponent:x}=u.jsonSchema202012,C=w(),j=!!(i.name||i.namespace||i.prefix),[L,B]=(0,Pe.useState)(C),[$,V]=(0,Pe.useState)(!1),U=x("Accordion"),z=x("ExpandDeepButton"),Y=_("JSONSchema202012DeepExpansionContext")(),Z=(0,Pe.useCallback)((()=>{B((s=>!s))}),[]),ee=(0,Pe.useCallback)(((s,o)=>{B(o),V(o)}),[]);return 0===Object.keys(i).length?null:Pe.createElement(Y.Provider,{value:$},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--xml"},j?Pe.createElement(Pe.Fragment,null,Pe.createElement(U,{expanded:L,onChange:Z},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"XML")),Pe.createElement(z,{expanded:L,onClick:ee})):Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"XML"),!0===i.attribute&&Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--muted"},"attribute"),!0===i.wrapped&&Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--muted"},"wrapped"),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!L})},L&&Pe.createElement(Pe.Fragment,null,i.name&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"name"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},i.name))),i.namespace&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement("div",{className:"json-schema-2020-12-keyword"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"namespace"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},i.namespace))),i.prefix&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement("div",{className:"json-schema-2020-12-keyword"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"prefix"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},i.prefix)))))))},Discriminator_DiscriminatorMapping=({discriminator:s})=>{const o=s?.mapping||{};return 0===Object.keys(o).length?null:Object.entries(o).map((([s,o])=>Pe.createElement("div",{key:`${s}-${o}`,className:"json-schema-2020-12-keyword"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},s),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},o))))},keywords_Discriminator_Discriminator=({schema:s,getSystem:o})=>{const i=s?.discriminator||{},{fn:u,getComponent:_}=o(),{useIsExpandedDeeply:w,useComponent:x}=u.jsonSchema202012,C=w(),j=!!i.mapping,[L,B]=(0,Pe.useState)(C),[$,V]=(0,Pe.useState)(!1),U=x("Accordion"),z=x("ExpandDeepButton"),Y=_("JSONSchema202012DeepExpansionContext")(),Z=(0,Pe.useCallback)((()=>{B((s=>!s))}),[]),ee=(0,Pe.useCallback)(((s,o)=>{B(o),V(o)}),[]);return 0===Object.keys(i).length?null:Pe.createElement(Y.Provider,{value:$},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--discriminator"},j?Pe.createElement(Pe.Fragment,null,Pe.createElement(U,{expanded:L,onChange:Z},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"Discriminator")),Pe.createElement(z,{expanded:L,onClick:ee})):Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"Discriminator"),i.propertyName&&Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--muted"},i.propertyName),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!L})},L&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement(Discriminator_DiscriminatorMapping,{discriminator:i})))))},keywords_ExternalDocs=({schema:s,getSystem:o})=>{const i=s?.externalDocs||{},{fn:u,getComponent:_}=o(),{useIsExpandedDeeply:w,useComponent:x}=u.jsonSchema202012,C=w(),j=!(!i.description&&!i.url),[L,B]=(0,Pe.useState)(C),[$,V]=(0,Pe.useState)(!1),U=x("Accordion"),z=x("ExpandDeepButton"),Y=_("JSONSchema202012KeywordDescription"),Z=_("Link"),ee=_("JSONSchema202012DeepExpansionContext")(),ie=(0,Pe.useCallback)((()=>{B((s=>!s))}),[]),ae=(0,Pe.useCallback)(((s,o)=>{B(o),V(o)}),[]);return 0===Object.keys(i).length?null:Pe.createElement(ee.Provider,{value:$},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--externalDocs"},j?Pe.createElement(Pe.Fragment,null,Pe.createElement(U,{expanded:L,onChange:ie},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"External documentation")),Pe.createElement(z,{expanded:L,onClick:ae})):Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"External documentation"),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!L})},L&&Pe.createElement(Pe.Fragment,null,i.description&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement(Y,{schema:i,getSystem:o})),i.url&&Pe.createElement("li",{className:"json-schema-2020-12-property"},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"url"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},Pe.createElement(Z,{target:"_blank",href:sanitizeUrl(i.url)},i.url))))))))},keywords_Description=({schema:s,getSystem:o})=>{if(!s?.description)return null;const{getComponent:i}=o(),u=i("Markdown");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--description"},Pe.createElement("div",{className:"json-schema-2020-12-core-keyword__value json-schema-2020-12-core-keyword__value--secondary"},Pe.createElement(u,{source:s.description})))},$j=createOnlyOAS31ComponentWrapper(keywords_Description),zj=createOnlyOAS31ComponentWrapper((({schema:s,getSystem:o,originalComponent:i})=>{const{getComponent:u}=o(),_=u("JSONSchema202012KeywordDiscriminator"),w=u("JSONSchema202012KeywordXml"),x=u("JSONSchema202012KeywordExample"),C=u("JSONSchema202012KeywordExternalDocs");return Pe.createElement(Pe.Fragment,null,Pe.createElement(i,{schema:s}),Pe.createElement(_,{schema:s,getSystem:o}),Pe.createElement(w,{schema:s,getSystem:o}),Pe.createElement(C,{schema:s,getSystem:o}),Pe.createElement(x,{schema:s,getSystem:o}))})),Kj=zj,keywords_Properties=({schema:s,getSystem:o})=>{const{fn:i}=o(),{useComponent:u}=i.jsonSchema202012,{getDependentRequired:_,getProperties:w}=i.jsonSchema202012.useFn(),x=i.jsonSchema202012.useConfig(),C=Array.isArray(s?.required)?s.required:[],j=u("JSONSchema"),L=w(s,x);return 0===Object.keys(L).length?null:Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--properties"},Pe.createElement("ul",null,Object.entries(L).map((([o,i])=>{const u=C.includes(o),w=_(o,s);return Pe.createElement("li",{key:o,className:Hn()("json-schema-2020-12-property",{"json-schema-2020-12-property--required":u})},Pe.createElement(j,{name:o,schema:i,dependentRequired:w}))}))))},Jj=createOnlyOAS31ComponentWrapper(keywords_Properties),getProperties=(s,{includeReadOnly:o,includeWriteOnly:i})=>{if(!s?.properties)return{};const u=Object.entries(s.properties).filter((([,s])=>(!(!0===s?.readOnly)||o)&&(!(!0===s?.writeOnly)||i)));return Object.fromEntries(u)};const Gj=function oas31_after_load_afterLoad({fn:s,getSystem:o}){if(s.jsonSchema202012){const i=((s,o)=>{const{fn:i}=o();if("function"!=typeof s)return null;const{hasKeyword:u}=i.jsonSchema202012;return o=>s(o)||u(o,"example")||o?.xml||o?.discriminator||o?.externalDocs})(s.jsonSchema202012.isExpandable,o);Object.assign(this.fn.jsonSchema202012,{isExpandable:i,getProperties})}if("function"==typeof s.sampleFromSchema&&s.jsonSchema202012){const i=((s,o)=>{const{fn:i,specSelectors:u}=o;return Object.fromEntries(Object.entries(s).map((([s,o])=>{const _=i[s];return[s,(...s)=>u.isOAS31()?o(...s):"function"==typeof _?_(...s):void 0]})))})({sampleFromSchema:s.jsonSchema202012.sampleFromSchema,sampleFromSchemaGeneric:s.jsonSchema202012.sampleFromSchemaGeneric,createXMLExample:s.jsonSchema202012.createXMLExample,memoizedSampleFromSchema:s.jsonSchema202012.memoizedSampleFromSchema,memoizedCreateXMLExample:s.jsonSchema202012.memoizedCreateXMLExample,getJsonSampleSchema:s.jsonSchema202012.getJsonSampleSchema,getYamlSampleSchema:s.jsonSchema202012.getYamlSampleSchema,getXmlSampleSchema:s.jsonSchema202012.getXmlSampleSchema,getSampleSchema:s.jsonSchema202012.getSampleSchema,mergeJsonSchema:s.jsonSchema202012.mergeJsonSchema},o());Object.assign(this.fn,i)}},oas31=({fn:s})=>{const o=s.createSystemSelector||fn_createSystemSelector,i=s.createOnlyOAS31Selector||fn_createOnlyOAS31Selector;return{afterLoad:Gj,fn:{isOAS31,createSystemSelector:fn_createSystemSelector,createOnlyOAS31Selector:fn_createOnlyOAS31Selector},components:{Webhooks:webhooks,JsonSchemaDialect:json_schema_dialect,MutualTLSAuth:mutual_tls_auth,OAS31Info:oas31_components_info,OAS31License:oas31_components_license,OAS31Contact:oas31_components_contact,OAS31VersionPragmaFilter:version_pragma_filter,OAS31Model:FA,OAS31Models:models,OAS31Auths:qA,JSONSchema202012KeywordExample:keywords_Example,JSONSchema202012KeywordXml:keywords_Xml,JSONSchema202012KeywordDiscriminator:keywords_Discriminator_Discriminator,JSONSchema202012KeywordExternalDocs:keywords_ExternalDocs},wrapComponents:{InfoContainer:UA,License:$A,Contact:VA,VersionPragmaFilter:wrap_components_version_pragma_filter,Model:WA,Models:HA,AuthItem:GA,auths:YA,JSONSchema202012KeywordDescription:$j,JSONSchema202012KeywordDefault:Kj,JSONSchema202012KeywordProperties:Jj},statePlugins:{auth:{wrapSelectors:{definitionsToAuthorize:Nj}},spec:{selectors:{isOAS31:o(ZA),license:selectors_license,selectLicenseNameField,selectLicenseUrlField,selectLicenseIdentifierField:i(selectLicenseIdentifierField),selectLicenseUrl:o(ej),contact:selectors_contact,selectContactNameField,selectContactEmailField,selectContactUrlField,selectContactUrl:o(fj),selectInfoTitleField,selectInfoSummaryField:i(selectInfoSummaryField),selectInfoDescriptionField,selectInfoTermsOfServiceField,selectInfoTermsOfServiceUrl:o(mj),selectExternalDocsDescriptionField,selectExternalDocsUrlField,selectExternalDocsUrl:o(_j),webhooks:i(selectors_webhooks),selectWebhooksOperations:i(o(QA)),selectJsonSchemaDialectField,selectJsonSchemaDialectDefault,selectSchemas:o(Cj)},wrapSelectors:{isOAS3:wrap_selectors_isOAS3,selectLicenseUrl:Aj}},oas31:{selectors:{selectLicenseUrl:i(o(Bj))}}}}},Xj=ts().object,eI=ts().bool,tI=(ts().oneOfType([Xj,eI]),(0,Pe.createContext)(null));tI.displayName="JSONSchemaContext";const rI=(0,Pe.createContext)(0);rI.displayName="JSONSchemaLevelContext";const nI=(0,Pe.createContext)(!1);nI.displayName="JSONSchemaDeepExpansionContext";const sI=(0,Pe.createContext)(new Set),useConfig=()=>{const{config:s}=(0,Pe.useContext)(tI);return s},useComponent=s=>{const{components:o}=(0,Pe.useContext)(tI);return o[s]||null},useFn=(s=void 0)=>{const{fn:o}=(0,Pe.useContext)(tI);return void 0!==s?o[s]:o},useLevel=()=>{const s=(0,Pe.useContext)(rI);return[s,s+1]},useIsExpanded=()=>{const[s]=useLevel(),{defaultExpandedLevels:o}=useConfig();return o-s>0},useIsExpandedDeeply=()=>(0,Pe.useContext)(nI),useRenderedSchemas=(s=void 0)=>{if(void 0===s)return(0,Pe.useContext)(sI);const o=(0,Pe.useContext)(sI);return new Set([...o,s])},oI=(0,Pe.forwardRef)((({schema:s,name:o="",dependentRequired:i=[],onExpand:u=()=>{}},_)=>{const w=useFn(),x=useIsExpanded(),C=useIsExpandedDeeply(),[j,L]=(0,Pe.useState)(x||C),[B,$]=(0,Pe.useState)(C),[V,U]=useLevel(),z=(()=>{const[s]=useLevel();return s>0})(),Y=w.isExpandable(s)||i.length>0,Z=(s=>useRenderedSchemas().has(s))(s),ee=useRenderedSchemas(s),ie=w.stringifyConstraints(s),ae=useComponent("Accordion"),le=useComponent("Keyword$schema"),ce=useComponent("Keyword$vocabulary"),pe=useComponent("Keyword$id"),de=useComponent("Keyword$anchor"),fe=useComponent("Keyword$dynamicAnchor"),ye=useComponent("Keyword$ref"),be=useComponent("Keyword$dynamicRef"),_e=useComponent("Keyword$defs"),we=useComponent("Keyword$comment"),Se=useComponent("KeywordAllOf"),xe=useComponent("KeywordAnyOf"),Te=useComponent("KeywordOneOf"),Re=useComponent("KeywordNot"),qe=useComponent("KeywordIf"),$e=useComponent("KeywordThen"),ze=useComponent("KeywordElse"),We=useComponent("KeywordDependentSchemas"),He=useComponent("KeywordPrefixItems"),Ye=useComponent("KeywordItems"),Xe=useComponent("KeywordContains"),Qe=useComponent("KeywordProperties"),et=useComponent("KeywordPatternProperties"),tt=useComponent("KeywordAdditionalProperties"),rt=useComponent("KeywordPropertyNames"),nt=useComponent("KeywordUnevaluatedItems"),st=useComponent("KeywordUnevaluatedProperties"),ot=useComponent("KeywordType"),it=useComponent("KeywordEnum"),at=useComponent("KeywordConst"),lt=useComponent("KeywordConstraint"),ct=useComponent("KeywordDependentRequired"),ut=useComponent("KeywordContentSchema"),pt=useComponent("KeywordTitle"),ht=useComponent("KeywordDescription"),dt=useComponent("KeywordDefault"),mt=useComponent("KeywordDeprecated"),gt=useComponent("KeywordReadOnly"),yt=useComponent("KeywordWriteOnly"),vt=useComponent("ExpandDeepButton");(0,Pe.useEffect)((()=>{$(C)}),[C]),(0,Pe.useEffect)((()=>{$(B)}),[B]);const bt=(0,Pe.useCallback)(((s,o)=>{L(o),!o&&$(!1),u(s,o,!1)}),[u]),_t=(0,Pe.useCallback)(((s,o)=>{L(o),$(o),u(s,o,!0)}),[u]);return Pe.createElement(rI.Provider,{value:U},Pe.createElement(nI.Provider,{value:B},Pe.createElement(sI.Provider,{value:ee},Pe.createElement("article",{ref:_,"data-json-schema-level":V,className:Hn()("json-schema-2020-12",{"json-schema-2020-12--embedded":z,"json-schema-2020-12--circular":Z})},Pe.createElement("div",{className:"json-schema-2020-12-head"},Y&&!Z?Pe.createElement(Pe.Fragment,null,Pe.createElement(ae,{expanded:j,onChange:bt},Pe.createElement(pt,{title:o,schema:s})),Pe.createElement(vt,{expanded:j,onClick:_t})):Pe.createElement(pt,{title:o,schema:s}),Pe.createElement(mt,{schema:s}),Pe.createElement(gt,{schema:s}),Pe.createElement(yt,{schema:s}),Pe.createElement(ot,{schema:s,isCircular:Z}),ie.length>0&&ie.map((s=>Pe.createElement(lt,{key:`${s.scope}-${s.value}`,constraint:s})))),Pe.createElement("div",{className:Hn()("json-schema-2020-12-body",{"json-schema-2020-12-body--collapsed":!j})},j&&Pe.createElement(Pe.Fragment,null,Pe.createElement(ht,{schema:s}),!Z&&Y&&Pe.createElement(Pe.Fragment,null,Pe.createElement(Qe,{schema:s}),Pe.createElement(et,{schema:s}),Pe.createElement(tt,{schema:s}),Pe.createElement(st,{schema:s}),Pe.createElement(rt,{schema:s}),Pe.createElement(Se,{schema:s}),Pe.createElement(xe,{schema:s}),Pe.createElement(Te,{schema:s}),Pe.createElement(Re,{schema:s}),Pe.createElement(qe,{schema:s}),Pe.createElement($e,{schema:s}),Pe.createElement(ze,{schema:s}),Pe.createElement(We,{schema:s}),Pe.createElement(He,{schema:s}),Pe.createElement(Ye,{schema:s}),Pe.createElement(nt,{schema:s}),Pe.createElement(Xe,{schema:s}),Pe.createElement(ut,{schema:s})),Pe.createElement(it,{schema:s}),Pe.createElement(at,{schema:s}),Pe.createElement(ct,{schema:s,dependentRequired:i}),Pe.createElement(dt,{schema:s}),Pe.createElement(le,{schema:s}),Pe.createElement(ce,{schema:s}),Pe.createElement(pe,{schema:s}),Pe.createElement(de,{schema:s}),Pe.createElement(fe,{schema:s}),Pe.createElement(ye,{schema:s}),!Z&&Y&&Pe.createElement(_e,{schema:s}),Pe.createElement(be,{schema:s}),Pe.createElement(we,{schema:s})))))))})),iI=oI,keywords_$schema=({schema:s})=>s?.$schema?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$schema"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$schema"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$schema)):null,$vocabulary_$vocabulary=({schema:s})=>{const o=useIsExpanded(),i=useIsExpandedDeeply(),[u,_]=(0,Pe.useState)(o||i),w=useComponent("Accordion"),x=(0,Pe.useCallback)((()=>{_((s=>!s))}),[]);return s?.$vocabulary?"object"!=typeof s.$vocabulary?null:Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$vocabulary"},Pe.createElement(w,{expanded:u,onChange:x},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$vocabulary")),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",null,u&&Object.entries(s.$vocabulary).map((([s,o])=>Pe.createElement("li",{key:s,className:Hn()("json-schema-2020-12-$vocabulary-uri",{"json-schema-2020-12-$vocabulary-uri--disabled":!o})},Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s)))))):null},keywords_$id=({schema:s})=>s?.$id?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$id"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$id"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$id)):null,keywords_$anchor=({schema:s})=>s?.$anchor?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$anchor"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$anchor"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$anchor)):null,keywords_$dynamicAnchor=({schema:s})=>s?.$dynamicAnchor?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$dynamicAnchor"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$dynamicAnchor"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$dynamicAnchor)):null,keywords_$ref=({schema:s})=>s?.$ref?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$ref"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$ref"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$ref)):null,keywords_$dynamicRef=({schema:s})=>s?.$dynamicRef?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$dynamicRef"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$dynamicRef"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$dynamicRef)):null,keywords_$defs=({schema:s})=>{const o=s?.$defs||{},i=useIsExpanded(),u=useIsExpandedDeeply(),[_,w]=(0,Pe.useState)(i||u),[x,C]=(0,Pe.useState)(!1),j=useComponent("Accordion"),L=useComponent("ExpandDeepButton"),B=useComponent("JSONSchema"),$=(0,Pe.useCallback)((()=>{w((s=>!s))}),[]),V=(0,Pe.useCallback)(((s,o)=>{w(o),C(o)}),[]);return 0===Object.keys(o).length?null:Pe.createElement(nI.Provider,{value:x},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$defs"},Pe.createElement(j,{expanded:_,onChange:$},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$defs")),Pe.createElement(L,{expanded:_,onClick:V}),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!_})},_&&Pe.createElement(Pe.Fragment,null,Object.entries(o).map((([s,o])=>Pe.createElement("li",{key:s,className:"json-schema-2020-12-property"},Pe.createElement(B,{name:s,schema:o}))))))))},keywords_$comment=({schema:s})=>s?.$comment?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--$comment"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--secondary"},"$comment"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--secondary"},s.$comment)):null,keywords_AllOf=({schema:s})=>{const o=s?.allOf||[],i=useFn(),u=useIsExpanded(),_=useIsExpandedDeeply(),[w,x]=(0,Pe.useState)(u||_),[C,j]=(0,Pe.useState)(!1),L=useComponent("Accordion"),B=useComponent("ExpandDeepButton"),$=useComponent("JSONSchema"),V=useComponent("KeywordType"),U=(0,Pe.useCallback)((()=>{x((s=>!s))}),[]),z=(0,Pe.useCallback)(((s,o)=>{x(o),j(o)}),[]);return Array.isArray(o)&&0!==o.length?Pe.createElement(nI.Provider,{value:C},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--allOf"},Pe.createElement(L,{expanded:w,onChange:U},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"All of")),Pe.createElement(B,{expanded:w,onClick:z}),Pe.createElement(V,{schema:{allOf:o}}),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!w})},w&&Pe.createElement(Pe.Fragment,null,o.map(((s,o)=>Pe.createElement("li",{key:`#${o}`,className:"json-schema-2020-12-property"},Pe.createElement($,{name:`#${o} ${i.getTitle(s)}`,schema:s})))))))):null},keywords_AnyOf=({schema:s})=>{const o=s?.anyOf||[],i=useFn(),u=useIsExpanded(),_=useIsExpandedDeeply(),[w,x]=(0,Pe.useState)(u||_),[C,j]=(0,Pe.useState)(!1),L=useComponent("Accordion"),B=useComponent("ExpandDeepButton"),$=useComponent("JSONSchema"),V=useComponent("KeywordType"),U=(0,Pe.useCallback)((()=>{x((s=>!s))}),[]),z=(0,Pe.useCallback)(((s,o)=>{x(o),j(o)}),[]);return Array.isArray(o)&&0!==o.length?Pe.createElement(nI.Provider,{value:C},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--anyOf"},Pe.createElement(L,{expanded:w,onChange:U},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Any of")),Pe.createElement(B,{expanded:w,onClick:z}),Pe.createElement(V,{schema:{anyOf:o}}),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!w})},w&&Pe.createElement(Pe.Fragment,null,o.map(((s,o)=>Pe.createElement("li",{key:`#${o}`,className:"json-schema-2020-12-property"},Pe.createElement($,{name:`#${o} ${i.getTitle(s)}`,schema:s})))))))):null},keywords_OneOf=({schema:s})=>{const o=s?.oneOf||[],i=useFn(),u=useIsExpanded(),_=useIsExpandedDeeply(),[w,x]=(0,Pe.useState)(u||_),[C,j]=(0,Pe.useState)(!1),L=useComponent("Accordion"),B=useComponent("ExpandDeepButton"),$=useComponent("JSONSchema"),V=useComponent("KeywordType"),U=(0,Pe.useCallback)((()=>{x((s=>!s))}),[]),z=(0,Pe.useCallback)(((s,o)=>{x(o),j(o)}),[]);return Array.isArray(o)&&0!==o.length?Pe.createElement(nI.Provider,{value:C},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--oneOf"},Pe.createElement(L,{expanded:w,onChange:U},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"One of")),Pe.createElement(B,{expanded:w,onClick:z}),Pe.createElement(V,{schema:{oneOf:o}}),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!w})},w&&Pe.createElement(Pe.Fragment,null,o.map(((s,o)=>Pe.createElement("li",{key:`#${o}`,className:"json-schema-2020-12-property"},Pe.createElement($,{name:`#${o} ${i.getTitle(s)}`,schema:s})))))))):null},keywords_Not=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"not"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Not");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--not"},Pe.createElement(i,{name:u,schema:s.not}))},keywords_If=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"if"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"If");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--if"},Pe.createElement(i,{name:u,schema:s.if}))},keywords_Then=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"then"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Then");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--then"},Pe.createElement(i,{name:u,schema:s.then}))},keywords_Else=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"else"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Else");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--if"},Pe.createElement(i,{name:u,schema:s.else}))},keywords_DependentSchemas=({schema:s})=>{const o=s?.dependentSchemas||[],i=useIsExpanded(),u=useIsExpandedDeeply(),[_,w]=(0,Pe.useState)(i||u),[x,C]=(0,Pe.useState)(!1),j=useComponent("Accordion"),L=useComponent("ExpandDeepButton"),B=useComponent("JSONSchema"),$=(0,Pe.useCallback)((()=>{w((s=>!s))}),[]),V=(0,Pe.useCallback)(((s,o)=>{w(o),C(o)}),[]);return"object"!=typeof o||0===Object.keys(o).length?null:Pe.createElement(nI.Provider,{value:x},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--dependentSchemas"},Pe.createElement(j,{expanded:_,onChange:$},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Dependent schemas")),Pe.createElement(L,{expanded:_,onClick:V}),Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"object"),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!_})},_&&Pe.createElement(Pe.Fragment,null,Object.entries(o).map((([s,o])=>Pe.createElement("li",{key:s,className:"json-schema-2020-12-property"},Pe.createElement(B,{name:s,schema:o}))))))))},keywords_PrefixItems=({schema:s})=>{const o=s?.prefixItems||[],i=useFn(),u=useIsExpanded(),_=useIsExpandedDeeply(),[w,x]=(0,Pe.useState)(u||_),[C,j]=(0,Pe.useState)(!1),L=useComponent("Accordion"),B=useComponent("ExpandDeepButton"),$=useComponent("JSONSchema"),V=useComponent("KeywordType"),U=(0,Pe.useCallback)((()=>{x((s=>!s))}),[]),z=(0,Pe.useCallback)(((s,o)=>{x(o),j(o)}),[]);return Array.isArray(o)&&0!==o.length?Pe.createElement(nI.Provider,{value:C},Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--prefixItems"},Pe.createElement(L,{expanded:w,onChange:U},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Prefix items")),Pe.createElement(B,{expanded:w,onClick:z}),Pe.createElement(V,{schema:{prefixItems:o}}),Pe.createElement("ul",{className:Hn()("json-schema-2020-12-keyword__children",{"json-schema-2020-12-keyword__children--collapsed":!w})},w&&Pe.createElement(Pe.Fragment,null,o.map(((s,o)=>Pe.createElement("li",{key:`#${o}`,className:"json-schema-2020-12-property"},Pe.createElement($,{name:`#${o} ${i.getTitle(s)}`,schema:s})))))))):null},keywords_Items=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"items"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Items");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--items"},Pe.createElement(i,{name:u,schema:s.items}))},keywords_Contains=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"contains"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Contains");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--contains"},Pe.createElement(i,{name:u,schema:s.contains}))},keywords_Properties_Properties=({schema:s})=>{const o=useFn(),i=s?.properties||{},u=Array.isArray(s?.required)?s.required:[],_=useComponent("JSONSchema");return 0===Object.keys(i).length?null:Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--properties"},Pe.createElement("ul",null,Object.entries(i).map((([i,w])=>{const x=u.includes(i),C=o.getDependentRequired(i,s);return Pe.createElement("li",{key:i,className:Hn()("json-schema-2020-12-property",{"json-schema-2020-12-property--required":x})},Pe.createElement(_,{name:i,schema:w,dependentRequired:C}))}))))},PatternProperties_PatternProperties=({schema:s})=>{const o=s?.patternProperties||{},i=useComponent("JSONSchema");return 0===Object.keys(o).length?null:Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--patternProperties"},Pe.createElement("ul",null,Object.entries(o).map((([s,o])=>Pe.createElement("li",{key:s,className:"json-schema-2020-12-property"},Pe.createElement(i,{name:s,schema:o}))))))},keywords_AdditionalProperties=({schema:s})=>{const o=useFn(),{additionalProperties:i}=s,u=useComponent("JSONSchema");if(!o.hasKeyword(s,"additionalProperties"))return null;const _=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Additional properties");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--additionalProperties"},!0===i?Pe.createElement(Pe.Fragment,null,_,Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"allowed")):!1===i?Pe.createElement(Pe.Fragment,null,_,Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},"forbidden")):Pe.createElement(u,{name:_,schema:i}))},keywords_PropertyNames=({schema:s})=>{const o=useFn(),{propertyNames:i}=s,u=useComponent("JSONSchema"),_=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Property names");return o.hasKeyword(s,"propertyNames")?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--propertyNames"},Pe.createElement(u,{name:_,schema:i})):null},keywords_UnevaluatedItems=({schema:s})=>{const o=useFn(),{unevaluatedItems:i}=s,u=useComponent("JSONSchema");if(!o.hasKeyword(s,"unevaluatedItems"))return null;const _=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Unevaluated items");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--unevaluatedItems"},Pe.createElement(u,{name:_,schema:i}))},keywords_UnevaluatedProperties=({schema:s})=>{const o=useFn(),{unevaluatedProperties:i}=s,u=useComponent("JSONSchema");if(!o.hasKeyword(s,"unevaluatedProperties"))return null;const _=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Unevaluated properties");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--unevaluatedProperties"},Pe.createElement(u,{name:_,schema:i}))},keywords_Type=({schema:s,isCircular:o=!1})=>{const i=useFn().getType(s),u=o?" [circular]":"";return Pe.createElement("strong",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--primary"},`${i}${u}`)},Enum_Enum=({schema:s})=>{const o=useFn();return Array.isArray(s?.enum)?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--enum"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Allowed values"),Pe.createElement("ul",null,s.enum.map((s=>{const i=o.stringify(s);return Pe.createElement("li",{key:i},Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--const"},i))})))):null},keywords_Const=({schema:s})=>{const o=useFn();return o.hasKeyword(s,"const")?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--const"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Const"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--const"},o.stringify(s.const))):null},Constraint=({constraint:s})=>Pe.createElement("span",{className:`json-schema-2020-12__constraint json-schema-2020-12__constraint--${s.scope}`},s.value),aI=Pe.memo(Constraint),DependentRequired_DependentRequired=({dependentRequired:s})=>0===s.length?null:Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--dependentRequired"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Required when defined"),Pe.createElement("ul",null,s.map((s=>Pe.createElement("li",{key:s},Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--warning"},s)))))),keywords_ContentSchema=({schema:s})=>{const o=useFn(),i=useComponent("JSONSchema");if(!o.hasKeyword(s,"contentSchema"))return null;const u=Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Content schema");return Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--contentSchema"},Pe.createElement(i,{name:u,schema:s.contentSchema}))},Title_Title=({title:s="",schema:o})=>{const i=useFn(),u=s||i.getTitle(o);return u?Pe.createElement("div",{className:"json-schema-2020-12__title"},u):null},keywords_Description_Description=({schema:s})=>s?.description?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--description"},Pe.createElement("div",{className:"json-schema-2020-12-core-keyword__value json-schema-2020-12-core-keyword__value--secondary"},s.description)):null,keywords_Default=({schema:s})=>{const o=useFn();return o.hasKeyword(s,"default")?Pe.createElement("div",{className:"json-schema-2020-12-keyword json-schema-2020-12-keyword--default"},Pe.createElement("span",{className:"json-schema-2020-12-keyword__name json-schema-2020-12-keyword__name--primary"},"Default"),Pe.createElement("span",{className:"json-schema-2020-12-keyword__value json-schema-2020-12-keyword__value--const"},o.stringify(s.default))):null},keywords_Deprecated=({schema:s})=>!0!==s?.deprecated?null:Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--warning"},"deprecated"),keywords_ReadOnly=({schema:s})=>!0!==s?.readOnly?null:Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--muted"},"read-only"),keywords_WriteOnly=({schema:s})=>!0!==s?.writeOnly?null:Pe.createElement("span",{className:"json-schema-2020-12__attribute json-schema-2020-12__attribute--muted"},"write-only"),Accordion_Accordion=({expanded:s=!1,children:o,onChange:i})=>{const u=useComponent("ChevronRightIcon"),_=(0,Pe.useCallback)((o=>{i(o,!s)}),[s,i]);return Pe.createElement("button",{type:"button",className:"json-schema-2020-12-accordion",onClick:_},Pe.createElement("div",{className:"json-schema-2020-12-accordion__children"},o),Pe.createElement("span",{className:Hn()("json-schema-2020-12-accordion__icon",{"json-schema-2020-12-accordion__icon--expanded":s,"json-schema-2020-12-accordion__icon--collapsed":!s})},Pe.createElement(u,null)))},ExpandDeepButton_ExpandDeepButton=({expanded:s,onClick:o})=>{const i=(0,Pe.useCallback)((i=>{o(i,!s)}),[s,o]);return Pe.createElement("button",{type:"button",className:"json-schema-2020-12-expand-deep-button",onClick:i},s?"Collapse all":"Expand all")},icons_ChevronRight=()=>Pe.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",width:"24",height:"24",viewBox:"0 0 24 24"},Pe.createElement("path",{d:"M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"})),fn_upperFirst=s=>"string"==typeof s?`${s.charAt(0).toUpperCase()}${s.slice(1)}`:s,getTitle=(s,{lookup:o="extended"}={})=>{const i=useFn();if(null!=s?.title)return i.upperFirst(String(s.title));if("extended"===o){if(null!=s?.$anchor)return i.upperFirst(String(s.$anchor));if(null!=s?.$id)return String(s.$id)}return""},getType=(s,o=new WeakSet)=>{const i=useFn();if(null==s)return"any";if(i.isBooleanJSONSchema(s))return s?"any":"never";if("object"!=typeof s)return"any";if(o.has(s))return"any";o.add(s);const{type:u,prefixItems:_,items:w}=s,getArrayType=()=>{if(Array.isArray(_)){const s=_.map((s=>getType(s,o))),i=w?getType(w,o):"any";return`array<[${s.join(", ")}], ${i}>`}if(w){return`array<${getType(w,o)}>`}return"array"};if(s.not&&"any"===getType(s.not))return"never";const handleCombiningKeywords=(i,u)=>{if(Array.isArray(s[i])){return`(${s[i].map((s=>getType(s,o))).join(u)})`}return null},x=[Array.isArray(u)?u.map((s=>"array"===s?getArrayType():s)).join(" | "):"array"===u?getArrayType():["null","boolean","object","array","number","integer","string"].includes(u)?u:(()=>{if(Object.hasOwn(s,"prefixItems")||Object.hasOwn(s,"items")||Object.hasOwn(s,"contains"))return getArrayType();if(Object.hasOwn(s,"properties")||Object.hasOwn(s,"additionalProperties")||Object.hasOwn(s,"patternProperties"))return"object";if(["int32","int64"].includes(s.format))return"integer";if(["float","double"].includes(s.format))return"number";if(Object.hasOwn(s,"minimum")||Object.hasOwn(s,"maximum")||Object.hasOwn(s,"exclusiveMinimum")||Object.hasOwn(s,"exclusiveMaximum")||Object.hasOwn(s,"multipleOf"))return"number | integer";if(Object.hasOwn(s,"pattern")||Object.hasOwn(s,"format")||Object.hasOwn(s,"minLength")||Object.hasOwn(s,"maxLength"))return"string";if(void 0!==s.const){if(null===s.const)return"null";if("boolean"==typeof s.const)return"boolean";if("number"==typeof s.const)return Number.isInteger(s.const)?"integer":"number";if("string"==typeof s.const)return"string";if(Array.isArray(s.const))return"array";if("object"==typeof s.const)return"object"}return null})(),handleCombiningKeywords("oneOf"," | "),handleCombiningKeywords("anyOf"," | "),handleCombiningKeywords("allOf"," & ")].filter(Boolean).join(" | ");return o.delete(s),x||"any"},isBooleanJSONSchema=s=>"boolean"==typeof s,hasKeyword=(s,o)=>null!==s&&"object"==typeof s&&Object.hasOwn(s,o),isExpandable=s=>{const o=useFn();return s?.$schema||s?.$vocabulary||s?.$id||s?.$anchor||s?.$dynamicAnchor||s?.$ref||s?.$dynamicRef||s?.$defs||s?.$comment||s?.allOf||s?.anyOf||s?.oneOf||o.hasKeyword(s,"not")||o.hasKeyword(s,"if")||o.hasKeyword(s,"then")||o.hasKeyword(s,"else")||s?.dependentSchemas||s?.prefixItems||o.hasKeyword(s,"items")||o.hasKeyword(s,"contains")||s?.properties||s?.patternProperties||o.hasKeyword(s,"additionalProperties")||o.hasKeyword(s,"propertyNames")||o.hasKeyword(s,"unevaluatedItems")||o.hasKeyword(s,"unevaluatedProperties")||s?.description||s?.enum||o.hasKeyword(s,"const")||o.hasKeyword(s,"contentSchema")||o.hasKeyword(s,"default")},fn_stringify=s=>null===s||["number","bigint","boolean"].includes(typeof s)?String(s):Array.isArray(s)?`[${s.map(fn_stringify).join(", ")}]`:JSON.stringify(s),stringifyConstraintRange=(s,o,i)=>{const u="number"==typeof o,_="number"==typeof i;return u&&_?o===i?`${o} ${s}`:`[${o}, ${i}] ${s}`:u?`>= ${o} ${s}`:_?`<= ${i} ${s}`:null},stringifyConstraints=s=>{const o=[],i=(s=>{if("number"!=typeof s?.multipleOf)return null;if(s.multipleOf<=0)return null;if(1===s.multipleOf)return null;const{multipleOf:o}=s;if(Number.isInteger(o))return`multiple of ${o}`;const i=10**o.toString().split(".")[1].length;return`multiple of ${o*i}/${i}`})(s);null!==i&&o.push({scope:"number",value:i});const u=(s=>{const o=s?.minimum,i=s?.maximum,u=s?.exclusiveMinimum,_=s?.exclusiveMaximum,w="number"==typeof o,x="number"==typeof i,C="number"==typeof u,j="number"==typeof _,L=C&&(!w||o_);if((w||C)&&(x||j))return`${L?"(":"["}${L?u:o}, ${B?_:i}${B?")":"]"}`;if(w||C)return`${L?">":"≥"} ${L?u:o}`;if(x||j)return`${B?"<":"≤"} ${B?_:i}`;return null})(s);null!==u&&o.push({scope:"number",value:u}),s?.format&&o.push({scope:"string",value:s.format});const _=stringifyConstraintRange("characters",s?.minLength,s?.maxLength);null!==_&&o.push({scope:"string",value:_}),s?.pattern&&o.push({scope:"string",value:`matches ${s?.pattern}`}),s?.contentMediaType&&o.push({scope:"string",value:`media type: ${s.contentMediaType}`}),s?.contentEncoding&&o.push({scope:"string",value:`encoding: ${s.contentEncoding}`});const w=stringifyConstraintRange(s?.hasUniqueItems?"unique items":"items",s?.minItems,s?.maxItems);null!==w&&o.push({scope:"array",value:w});const x=stringifyConstraintRange("contained items",s?.minContains,s?.maxContains);null!==x&&o.push({scope:"array",value:x});const C=stringifyConstraintRange("properties",s?.minProperties,s?.maxProperties);return null!==C&&o.push({scope:"object",value:C}),o},getDependentRequired=(s,o)=>o?.dependentRequired?Array.from(Object.entries(o.dependentRequired).reduce(((o,[i,u])=>Array.isArray(u)&&u.includes(s)?(o.add(i),o):o),new Set)):[],withJSONSchemaContext=(s,o={})=>{const i={components:{JSONSchema:iI,Keyword$schema:keywords_$schema,Keyword$vocabulary:$vocabulary_$vocabulary,Keyword$id:keywords_$id,Keyword$anchor:keywords_$anchor,Keyword$dynamicAnchor:keywords_$dynamicAnchor,Keyword$ref:keywords_$ref,Keyword$dynamicRef:keywords_$dynamicRef,Keyword$defs:keywords_$defs,Keyword$comment:keywords_$comment,KeywordAllOf:keywords_AllOf,KeywordAnyOf:keywords_AnyOf,KeywordOneOf:keywords_OneOf,KeywordNot:keywords_Not,KeywordIf:keywords_If,KeywordThen:keywords_Then,KeywordElse:keywords_Else,KeywordDependentSchemas:keywords_DependentSchemas,KeywordPrefixItems:keywords_PrefixItems,KeywordItems:keywords_Items,KeywordContains:keywords_Contains,KeywordProperties:keywords_Properties_Properties,KeywordPatternProperties:PatternProperties_PatternProperties,KeywordAdditionalProperties:keywords_AdditionalProperties,KeywordPropertyNames:keywords_PropertyNames,KeywordUnevaluatedItems:keywords_UnevaluatedItems,KeywordUnevaluatedProperties:keywords_UnevaluatedProperties,KeywordType:keywords_Type,KeywordEnum:Enum_Enum,KeywordConst:keywords_Const,KeywordConstraint:aI,KeywordDependentRequired:DependentRequired_DependentRequired,KeywordContentSchema:keywords_ContentSchema,KeywordTitle:Title_Title,KeywordDescription:keywords_Description_Description,KeywordDefault:keywords_Default,KeywordDeprecated:keywords_Deprecated,KeywordReadOnly:keywords_ReadOnly,KeywordWriteOnly:keywords_WriteOnly,Accordion:Accordion_Accordion,ExpandDeepButton:ExpandDeepButton_ExpandDeepButton,ChevronRightIcon:icons_ChevronRight,...o.components},config:{default$schema:"https://json-schema.org/draft/2020-12/schema",defaultExpandedLevels:0,...o.config},fn:{upperFirst:fn_upperFirst,getTitle,getType,isBooleanJSONSchema,hasKeyword,isExpandable,stringify:fn_stringify,stringifyConstraints,getDependentRequired,...o.fn}},HOC=o=>Pe.createElement(tI.Provider,{value:i},Pe.createElement(s,o));return HOC.contexts={JSONSchemaContext:tI},HOC.displayName=s.displayName,HOC},json_schema_2020_12=()=>({components:{JSONSchema202012:iI,JSONSchema202012Keyword$schema:keywords_$schema,JSONSchema202012Keyword$vocabulary:$vocabulary_$vocabulary,JSONSchema202012Keyword$id:keywords_$id,JSONSchema202012Keyword$anchor:keywords_$anchor,JSONSchema202012Keyword$dynamicAnchor:keywords_$dynamicAnchor,JSONSchema202012Keyword$ref:keywords_$ref,JSONSchema202012Keyword$dynamicRef:keywords_$dynamicRef,JSONSchema202012Keyword$defs:keywords_$defs,JSONSchema202012Keyword$comment:keywords_$comment,JSONSchema202012KeywordAllOf:keywords_AllOf,JSONSchema202012KeywordAnyOf:keywords_AnyOf,JSONSchema202012KeywordOneOf:keywords_OneOf,JSONSchema202012KeywordNot:keywords_Not,JSONSchema202012KeywordIf:keywords_If,JSONSchema202012KeywordThen:keywords_Then,JSONSchema202012KeywordElse:keywords_Else,JSONSchema202012KeywordDependentSchemas:keywords_DependentSchemas,JSONSchema202012KeywordPrefixItems:keywords_PrefixItems,JSONSchema202012KeywordItems:keywords_Items,JSONSchema202012KeywordContains:keywords_Contains,JSONSchema202012KeywordProperties:keywords_Properties_Properties,JSONSchema202012KeywordPatternProperties:PatternProperties_PatternProperties,JSONSchema202012KeywordAdditionalProperties:keywords_AdditionalProperties,JSONSchema202012KeywordPropertyNames:keywords_PropertyNames,JSONSchema202012KeywordUnevaluatedItems:keywords_UnevaluatedItems,JSONSchema202012KeywordUnevaluatedProperties:keywords_UnevaluatedProperties,JSONSchema202012KeywordType:keywords_Type,JSONSchema202012KeywordEnum:Enum_Enum,JSONSchema202012KeywordConst:keywords_Const,JSONSchema202012KeywordConstraint:aI,JSONSchema202012KeywordDependentRequired:DependentRequired_DependentRequired,JSONSchema202012KeywordContentSchema:keywords_ContentSchema,JSONSchema202012KeywordTitle:Title_Title,JSONSchema202012KeywordDescription:keywords_Description_Description,JSONSchema202012KeywordDefault:keywords_Default,JSONSchema202012KeywordDeprecated:keywords_Deprecated,JSONSchema202012KeywordReadOnly:keywords_ReadOnly,JSONSchema202012KeywordWriteOnly:keywords_WriteOnly,JSONSchema202012Accordion:Accordion_Accordion,JSONSchema202012ExpandDeepButton:ExpandDeepButton_ExpandDeepButton,JSONSchema202012ChevronRightIcon:icons_ChevronRight,withJSONSchema202012Context:withJSONSchemaContext,JSONSchema202012DeepExpansionContext:()=>nI},fn:{upperFirst:fn_upperFirst,jsonSchema202012:{isExpandable,hasKeyword,useFn,useConfig,useComponent,useIsExpandedDeeply}}});var lI=__webpack_require__(11331),cI=__webpack_require__.n(lI);const array=(s,{sample:o})=>((s,o={})=>{const{minItems:i,maxItems:u,uniqueItems:_}=o,{contains:w,minContains:x,maxContains:C}=o;let j=[...s];if(null!=w&&"object"==typeof w){if(Number.isInteger(x)&&x>1){const s=j.at(0);for(let o=1;o0&&(j=s.slice(0,u)),Number.isInteger(i)&&i>0)for(let s=0;j.length{throw new Error("Not implemented")},bytes=s=>St()(s),random_pick=s=>s.at(0),predicates_isBooleanJSONSchema=s=>"boolean"==typeof s,isJSONSchemaObject=s=>cI()(s),isJSONSchema=s=>predicates_isBooleanJSONSchema(s)||isJSONSchemaObject(s);const uI=class Registry{data={};register(s,o){this.data[s]=o}unregister(s){void 0===s?this.data={}:delete this.data[s]}get(s){return this.data[s]}},int32=()=>2**30>>>0,int64=()=>2**53-1,generators_float=()=>.1,generators_double=()=>.1,email=()=>"user@example.com",idn_email=()=>"실례@example.com",hostname=()=>"example.com",idn_hostname=()=>"실례.com",ipv4=()=>"198.51.100.42",ipv6=()=>"2001:0db8:5b96:0000:0000:426f:8e17:642a",uri=()=>"https://example.com/",uri_reference=()=>"path/index.html",iri=()=>"https://실례.com/",iri_reference=()=>"path/실례.html",uuid=()=>"3fa85f64-5717-4562-b3fc-2c963f66afa6",uri_template=()=>"https://example.com/dictionary/{term:1}/{term}",json_pointer=()=>"/a/b/c",relative_json_pointer=()=>"1/0",date_time=()=>(new Date).toISOString(),date=()=>(new Date).toISOString().substring(0,10),time=()=>(new Date).toISOString().substring(11),duration=()=>"P3D",generators_password=()=>"********",regex=()=>"^[a-z]+$";const pI=new class FormatRegistry extends uI{#t={int32,int64,float:generators_float,double:generators_double,email,"idn-email":idn_email,hostname,"idn-hostname":idn_hostname,ipv4,ipv6,uri,"uri-reference":uri_reference,iri,"iri-reference":iri_reference,uuid,"uri-template":uri_template,"json-pointer":json_pointer,"relative-json-pointer":relative_json_pointer,"date-time":date_time,date,time,duration,password:generators_password,regex};data={...this.#t};get defaults(){return{...this.#t}}},formatAPI=(s,o)=>"function"==typeof o?pI.register(s,o):null===o?pI.unregister(s):pI.get(s);formatAPI.getDefaults=()=>pI.defaults;const hI=formatAPI;var dI=__webpack_require__(48287).Buffer;const _7bit=s=>dI.from(s).toString("ascii");var fI=__webpack_require__(48287).Buffer;const _8bit=s=>fI.from(s).toString("utf8");var mI=__webpack_require__(48287).Buffer;const encoders_binary=s=>mI.from(s).toString("binary"),quoted_printable=s=>{let o="";for(let i=0;i=33&&u<=60||u>=62&&u<=126||9===u||32===u)o+=s.charAt(i);else if(13===u||10===u)o+="\r\n";else if(u>126){const u=unescape(encodeURIComponent(s.charAt(i)));for(let s=0;sgI.from(s).toString("hex");var yI=__webpack_require__(48287).Buffer;const base32=s=>{const o=yI.from(s).toString("utf8"),i="ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";let u=0,_="",w=0,x=0;for(let s=0;s=5;)_+=i.charAt(w>>>x-5&31),x-=5;x>0&&(_+=i.charAt(w<<5-x&31),u=(8-8*o.length%5)%5);for(let s=0;svI.from(s).toString("base64");var bI=__webpack_require__(48287).Buffer;const base64url=s=>bI.from(s).toString("base64url");const _I=new class EncoderRegistry extends uI{#t={"7bit":_7bit,"8bit":_8bit,binary:encoders_binary,"quoted-printable":quoted_printable,base16,base32,base64,base64url};data={...this.#t};get defaults(){return{...this.#t}}},encoderAPI=(s,o)=>"function"==typeof o?_I.register(s,o):null===o?_I.unregister(s):_I.get(s);encoderAPI.getDefaults=()=>_I.defaults;const EI=encoderAPI,wI={"text/plain":()=>"string","text/css":()=>".selector { border: 1px solid red }","text/csv":()=>"value1,value2,value3","text/html":()=>"

    content

    ","text/calendar":()=>"BEGIN:VCALENDAR","text/javascript":()=>"console.dir('Hello world!');","text/xml":()=>'John Doe',"text/*":()=>"string"},SI={"image/*":()=>bytes(25).toString("binary")},xI={"audio/*":()=>bytes(25).toString("binary")},kI={"video/*":()=>bytes(25).toString("binary")},CI={"application/json":()=>'{"key":"value"}',"application/ld+json":()=>'{"name": "John Doe"}',"application/x-httpd-php":()=>"Hello World!

    '; ?>","application/rtf":()=>String.raw`{\rtf1\adeflang1025\ansi\ansicpg1252\uc1`,"application/x-sh":()=>'echo "Hello World!"',"application/xhtml+xml":()=>"

    content

    ","application/*":()=>bytes(25).toString("binary")};const OI=new class MediaTypeRegistry extends uI{#t={...wI,...SI,...xI,...kI,...CI};data={...this.#t};get defaults(){return{...this.#t}}},mediaTypeAPI=(s,o)=>{if("function"==typeof o)return OI.register(s,o);if(null===o)return OI.unregister(s);const i=s.split(";").at(0),u=`${i.split("/").at(0)}/*`;return OI.get(s)||OI.get(i)||OI.get(u)};mediaTypeAPI.getDefaults=()=>OI.defaults;const AI=mediaTypeAPI,applyStringConstraints=(s,o={})=>{const{maxLength:i,minLength:u}=o;let _=s;if(Number.isInteger(i)&&i>0&&(_=_.slice(0,i)),Number.isInteger(u)&&u>0){let s=0;for(;_.length{const{contentEncoding:i,contentMediaType:u,contentSchema:_}=s,{pattern:w,format:x}=s,C=EI(i)||Mx();let j;return j="string"==typeof w?applyStringConstraints((s=>{try{return new(us())(s).gen()}catch{return"string"}})(w),s):"string"==typeof x?(s=>{const{format:o}=s,i=hI(o);return"function"==typeof i?i(s):"string"})(s):isJSONSchema(_)&&"string"==typeof u&&void 0!==o?Array.isArray(o)||"object"==typeof o?JSON.stringify(o):applyStringConstraints(String(o),s):"string"==typeof u?(s=>{const{contentMediaType:o}=s,i=AI(o);return"function"==typeof i?i(s):"string"})(s):applyStringConstraints("string",s),C(j)},applyNumberConstraints=(s,o={})=>{const{minimum:i,maximum:u,exclusiveMinimum:_,exclusiveMaximum:w}=o,{multipleOf:x}=o,C=Number.isInteger(s)?1:Number.EPSILON;let j="number"==typeof i?i:null,L="number"==typeof u?u:null,B=s;if("number"==typeof _&&(j=null!==j?Math.max(j,_+C):_+C),"number"==typeof w&&(L=null!==L?Math.min(L,w-C):w-C),B=j>L&&s||j||L||B,"number"==typeof x&&x>0){const s=B%x;B=0===s?B:B+x-s}return B},types_number=s=>{const{format:o}=s;let i;return i="string"==typeof o?(s=>{const{format:o}=s,i=hI(o);return"function"==typeof i?i(s):0})(s):0,applyNumberConstraints(i,s)},types_integer=s=>{const{format:o}=s;let i;return i="string"==typeof o?(s=>{const{format:o}=s,i=hI(o);if("function"==typeof i)return i(s);switch(o){case"int32":return int32();case"int64":return int64()}return 0})(s):0,applyNumberConstraints(i,s)},types_boolean=s=>"boolean"!=typeof s.default||s.default,jI=new Proxy({array,object,string:types_string,number:types_number,integer:types_integer,boolean:types_boolean,null:()=>null},{get:(s,o)=>"string"==typeof o&&Object.hasOwn(s,o)?s[o]:()=>`Unknown Type: ${o}`}),II=["array","object","number","integer","string","boolean","null"],hasExample=s=>{if(!isJSONSchemaObject(s))return!1;const{examples:o,example:i,default:u}=s;return!!(Array.isArray(o)&&o.length>=1)||(void 0!==u||void 0!==i)},extractExample=s=>{if(!isJSONSchemaObject(s))return null;const{examples:o,example:i,default:u}=s;return Array.isArray(o)&&o.length>=1?o.at(0):void 0!==u?u:void 0!==i?i:void 0},PI={array:["items","prefixItems","contains","maxContains","minContains","maxItems","minItems","uniqueItems","unevaluatedItems"],object:["properties","additionalProperties","patternProperties","propertyNames","minProperties","maxProperties","required","dependentSchemas","dependentRequired","unevaluatedProperties"],string:["pattern","format","minLength","maxLength","contentEncoding","contentMediaType","contentSchema"],integer:["minimum","maximum","exclusiveMinimum","exclusiveMaximum","multipleOf"]};PI.number=PI.integer;const MI="string",inferTypeFromValue=s=>void 0===s?null:null===s?"null":Array.isArray(s)?"array":Number.isInteger(s)?"integer":typeof s,foldType=s=>{if(Array.isArray(s)&&s.length>=1){if(s.includes("array"))return"array";if(s.includes("object"))return"object";{const o=random_pick(s);if(II.includes(o))return o}}return II.includes(s)?s:null},inferType=(s,o=new WeakSet)=>{if(!isJSONSchemaObject(s))return MI;if(o.has(s))return MI;o.add(s);let{type:i,const:u}=s;if(i=foldType(i),"string"!=typeof i){const o=Object.keys(PI);e:for(let u=0;u{if(Array.isArray(s[i])){const u=s[i].map((s=>inferType(s,o)));return foldType(u)}return null},u=combineTypes("allOf"),_=combineTypes("anyOf"),w=combineTypes("oneOf"),x=s.not?inferType(s.not,o):null;(u||_||w||x)&&(i=foldType([u,_,w,x].filter(Boolean)))}if("string"!=typeof i&&hasExample(s)){const o=extractExample(s),u=inferTypeFromValue(o);i="string"==typeof u?u:i}return o.delete(s),i||MI},type_getType=s=>inferType(s),typeCast=s=>predicates_isBooleanJSONSchema(s)?(s=>!1===s?{not:{}}:{})(s):isJSONSchemaObject(s)?s:{},merge_merge=(s,o,i={})=>{if(predicates_isBooleanJSONSchema(s)&&!0===s)return!0;if(predicates_isBooleanJSONSchema(s)&&!1===s)return!1;if(predicates_isBooleanJSONSchema(o)&&!0===o)return!0;if(predicates_isBooleanJSONSchema(o)&&!1===o)return!1;if(!isJSONSchema(s))return o;if(!isJSONSchema(o))return s;const u={...o,...s};if(o.type&&s.type&&Array.isArray(o.type)&&"string"==typeof o.type){const i=normalizeArray(o.type).concat(s.type);u.type=Array.from(new Set(i))}if(Array.isArray(o.required)&&Array.isArray(s.required)&&(u.required=[...new Set([...s.required,...o.required])]),o.properties&&s.properties){const _=new Set([...Object.keys(o.properties),...Object.keys(s.properties)]);u.properties={};for(const w of _){const _=o.properties[w]||{},x=s.properties[w]||{};_.readOnly&&!i.includeReadOnly||_.writeOnly&&!i.includeWriteOnly?u.required=(u.required||[]).filter((s=>s!==w)):u.properties[w]=merge_merge(x,_,i)}}return isJSONSchema(o.items)&&isJSONSchema(s.items)&&(u.items=merge_merge(s.items,o.items,i)),isJSONSchema(o.contains)&&isJSONSchema(s.contains)&&(u.contains=merge_merge(s.contains,o.contains,i)),isJSONSchema(o.contentSchema)&&isJSONSchema(s.contentSchema)&&(u.contentSchema=merge_merge(s.contentSchema,o.contentSchema,i)),u},TI=merge_merge,main_sampleFromSchemaGeneric=(s,o={},i=void 0,u=!1)=>{if(null==s&&void 0===i)return;"function"==typeof s?.toJS&&(s=s.toJS()),s=typeCast(s);let _=void 0!==i||hasExample(s);const w=!_&&Array.isArray(s.oneOf)&&s.oneOf.length>0,x=!_&&Array.isArray(s.anyOf)&&s.anyOf.length>0;if(!_&&(w||x)){const i=typeCast(random_pick(w?s.oneOf:s.anyOf));!(s=TI(s,i,o)).xml&&i.xml&&(s.xml=i.xml),hasExample(s)&&hasExample(i)&&(_=!0)}const C={};let{xml:j,properties:L,additionalProperties:B,items:$,contains:V}=s||{},U=type_getType(s),{includeReadOnly:z,includeWriteOnly:Y}=o;j=j||{};let Z,{name:ee,prefix:ie,namespace:ae}=j,le={};if(Object.hasOwn(s,"type")||(s.type=U),u&&(ee=ee||"notagname",Z=(ie?`${ie}:`:"")+ee,ae)){C[ie?`xmlns:${ie}`:"xmlns"]=ae}u&&(le[Z]=[]);const ce=objectify(L);let pe,de=0;const hasExceededMaxProperties=()=>Number.isInteger(s.maxProperties)&&s.maxProperties>0&&de>=s.maxProperties,canAddProperty=o=>!(Number.isInteger(s.maxProperties)&&s.maxProperties>0)||!hasExceededMaxProperties()&&(!(o=>!Array.isArray(s.required)||0===s.required.length||!s.required.includes(o))(o)||s.maxProperties-de-(()=>{if(!Array.isArray(s.required)||0===s.required.length)return 0;let o=0;return u?s.required.forEach((s=>o+=void 0===le[s]?0:1)):s.required.forEach((s=>{o+=void 0===le[Z]?.find((o=>void 0!==o[s]))?0:1})),s.required.length-o})()>0);if(pe=u?(i,_=void 0)=>{if(s&&ce[i]){if(ce[i].xml=ce[i].xml||{},ce[i].xml.attribute){const s=Array.isArray(ce[i].enum)?random_pick(ce[i].enum):void 0;if(hasExample(ce[i]))C[ce[i].xml.name||i]=extractExample(ce[i]);else if(void 0!==s)C[ce[i].xml.name||i]=s;else{const s=typeCast(ce[i]),o=type_getType(s),u=ce[i].xml.name||i;C[u]=jI[o](s)}return}ce[i].xml.name=ce[i].xml.name||i}else ce[i]||!1===B||(ce[i]={xml:{name:i}});let w=main_sampleFromSchemaGeneric(ce[i],o,_,u);canAddProperty(i)&&(de++,Array.isArray(w)?le[Z]=le[Z].concat(w):le[Z].push(w))}:(i,_)=>{if(canAddProperty(i)){if(cI()(s.discriminator?.mapping)&&s.discriminator.propertyName===i&&"string"==typeof s.$$ref){for(const o in s.discriminator.mapping)if(-1!==s.$$ref.search(s.discriminator.mapping[o])){le[i]=o;break}}else le[i]=main_sampleFromSchemaGeneric(ce[i],o,_,u);de++}},_){let _;if(_=void 0!==i?i:extractExample(s),!u){if("number"==typeof _&&"string"===U)return`${_}`;if("string"!=typeof _||"string"===U)return _;try{return JSON.parse(_)}catch{return _}}if("array"===U){if(!Array.isArray(_)){if("string"==typeof _)return _;_=[_]}let i=[];return isJSONSchemaObject($)&&($.xml=$.xml||j||{},$.xml.name=$.xml.name||j.name,i=_.map((s=>main_sampleFromSchemaGeneric($,o,s,u)))),isJSONSchemaObject(V)&&(V.xml=V.xml||j||{},V.xml.name=V.xml.name||j.name,i=[main_sampleFromSchemaGeneric(V,o,void 0,u),...i]),i=jI.array(s,{sample:i}),j.wrapped?(le[Z]=i,hs()(C)||le[Z].push({_attr:C})):le=i,le}if("object"===U){if("string"==typeof _)return _;for(const s in _)Object.hasOwn(_,s)&&(ce[s]?.readOnly&&!z||ce[s]?.writeOnly&&!Y||(ce[s]?.xml?.attribute?C[ce[s].xml.name||s]=_[s]:pe(s,_[s])));return hs()(C)||le[Z].push({_attr:C}),le}return le[Z]=hs()(C)?_:[{_attr:C},_],le}if("array"===U){let i=[];if(isJSONSchemaObject(V))if(u&&(V.xml=V.xml||s.xml||{},V.xml.name=V.xml.name||j.name),Array.isArray(V.anyOf)){const{anyOf:s,..._}=$;i.push(...V.anyOf.map((s=>main_sampleFromSchemaGeneric(TI(s,_,o),o,void 0,u))))}else if(Array.isArray(V.oneOf)){const{oneOf:s,..._}=$;i.push(...V.oneOf.map((s=>main_sampleFromSchemaGeneric(TI(s,_,o),o,void 0,u))))}else{if(!(!u||u&&j.wrapped))return main_sampleFromSchemaGeneric(V,o,void 0,u);i.push(main_sampleFromSchemaGeneric(V,o,void 0,u))}if(isJSONSchemaObject($))if(u&&($.xml=$.xml||s.xml||{},$.xml.name=$.xml.name||j.name),Array.isArray($.anyOf)){const{anyOf:s,..._}=$;i.push(...$.anyOf.map((s=>main_sampleFromSchemaGeneric(TI(s,_,o),o,void 0,u))))}else if(Array.isArray($.oneOf)){const{oneOf:s,..._}=$;i.push(...$.oneOf.map((s=>main_sampleFromSchemaGeneric(TI(s,_,o),o,void 0,u))))}else{if(!(!u||u&&j.wrapped))return main_sampleFromSchemaGeneric($,o,void 0,u);i.push(main_sampleFromSchemaGeneric($,o,void 0,u))}return i=jI.array(s,{sample:i}),u&&j.wrapped?(le[Z]=i,hs()(C)||le[Z].push({_attr:C}),le):i}if("object"===U){for(let s in ce)Object.hasOwn(ce,s)&&(ce[s]?.deprecated||ce[s]?.readOnly&&!z||ce[s]?.writeOnly&&!Y||pe(s));if(u&&C&&le[Z].push({_attr:C}),hasExceededMaxProperties())return le;if(predicates_isBooleanJSONSchema(B)&&B)u?le[Z].push({additionalProp:"Anything can be here"}):le.additionalProp1={},de++;else if(isJSONSchemaObject(B)){const i=B,_=main_sampleFromSchemaGeneric(i,o,void 0,u);if(u&&"string"==typeof i?.xml?.name&&"notagname"!==i?.xml?.name)le[Z].push(_);else{const o=Number.isInteger(s.minProperties)&&s.minProperties>0&&de{const u=main_sampleFromSchemaGeneric(s,o,i,!0);if(u)return"string"==typeof u?u:ls()(u,{declaration:!0,indent:"\t"})},main_sampleFromSchema=(s,o,i)=>main_sampleFromSchemaGeneric(s,o,i,!1),main_resolver=(s,o,i)=>[s,JSON.stringify(o),JSON.stringify(i)],NI=utils_memoizeN(main_createXMLExample,main_resolver),RI=utils_memoizeN(main_sampleFromSchema,main_resolver);const DI=new class OptionRegistry extends uI{#t={};data={...this.#t};get defaults(){return{...this.#t}}},api_optionAPI=(s,o)=>(void 0!==o&&DI.register(s,o),DI.get(s)),LI=[{when:/json/,shouldStringifyTypes:["string"]}],BI=["object"],fn_get_json_sample_schema=s=>(o,i,u,_)=>{const{fn:w}=s(),x=w.jsonSchema202012.memoizedSampleFromSchema(o,i,_),C=typeof x,j=LI.reduce(((s,o)=>o.when.test(u)?[...s,...o.shouldStringifyTypes]:s),BI);return mt()(j,(s=>s===C))?JSON.stringify(x,null,2):x},fn_get_yaml_sample_schema=s=>(o,i,u,_)=>{const{fn:w}=s(),x=w.jsonSchema202012.getJsonSampleSchema(o,i,u,_);let C;try{C=mn.dump(mn.load(x),{lineWidth:-1},{schema:nn}),"\n"===C[C.length-1]&&(C=C.slice(0,C.length-1))}catch(s){return console.error(s),"error: could not generate yaml example"}return C.replace(/\t/g," ")},fn_get_xml_sample_schema=s=>(o,i,u)=>{const{fn:_}=s();if(o&&!o.xml&&(o.xml={}),o&&!o.xml.name){if(!o.$$ref&&(o.type||o.items||o.properties||o.additionalProperties))return'\n\x3c!-- XML example cannot be generated; root element name is undefined --\x3e';if(o.$$ref){let s=o.$$ref.match(/\S*\/(\S+)$/);o.xml.name=s[1]}}return _.jsonSchema202012.memoizedCreateXMLExample(o,i,u)},fn_get_sample_schema=s=>(o,i="",u={},_=void 0)=>{const{fn:w}=s();return"function"==typeof o?.toJS&&(o=o.toJS()),"function"==typeof _?.toJS&&(_=_.toJS()),/xml/.test(i)?w.jsonSchema202012.getXmlSampleSchema(o,u,_):/(yaml|yml)/.test(i)?w.jsonSchema202012.getYamlSampleSchema(o,u,i,_):w.jsonSchema202012.getJsonSampleSchema(o,u,i,_)},json_schema_2020_12_samples=({getSystem:s})=>{const o=fn_get_json_sample_schema(s),i=fn_get_yaml_sample_schema(s),u=fn_get_xml_sample_schema(s),_=fn_get_sample_schema(s);return{fn:{jsonSchema202012:{sampleFromSchema:main_sampleFromSchema,sampleFromSchemaGeneric:main_sampleFromSchemaGeneric,sampleOptionAPI:api_optionAPI,sampleEncoderAPI:EI,sampleFormatAPI:hI,sampleMediaTypeAPI:AI,createXMLExample:main_createXMLExample,memoizedSampleFromSchema:RI,memoizedCreateXMLExample:NI,getJsonSampleSchema:o,getYamlSampleSchema:i,getXmlSampleSchema:u,getSampleSchema:_,mergeJsonSchema:TI}}}};function PresetApis(){return[base,oas3,json_schema_2020_12,json_schema_2020_12_samples,oas31]}const inline_plugin=s=>()=>({fn:s.fn,components:s.components}),factorization_system=s=>{const o=We()({layout:{layout:s.layout,filter:s.filter},spec:{spec:"",url:s.url},requestSnippets:s.requestSnippets},s.initialState);if(s.initialState)for(const[i,u]of Object.entries(s.initialState))void 0===u&&delete o[i];return{system:{configs:s.configs},plugins:s.presets,state:o}},sources_query=()=>s=>{const o=s.queryConfigEnabled?(()=>{const s=new URLSearchParams(at.location.search);return Object.fromEntries(s)})():{};return Object.entries(o).reduce(((s,[o,i])=>("config"===o?s.configUrl=i:"urls.primaryName"===o?s[o]=i:s=ao()(s,o,i),s)),{})},sources_url=({url:s,system:o})=>async i=>{if(!s)return{};if("function"!=typeof o.configsActions?.getConfigByUrl)return{};const u=(()=>{const s={};return s.promise=new Promise(((o,i)=>{s.resolve=o,s.reject=i})),s})();return o.configsActions.getConfigByUrl({url:s,loadRemoteConfig:!0,requestInterceptor:i.requestInterceptor,responseInterceptor:i.responseInterceptor},(s=>{u.resolve(s)})),u.promise},runtime=()=>()=>{const s={};return globalThis.location&&(s.oauth2RedirectUrl=`${globalThis.location.protocol}//${globalThis.location.host}${globalThis.location.pathname.substring(0,globalThis.location.pathname.lastIndexOf("/"))}/oauth2-redirect.html`),s},FI=Object.freeze({dom_id:null,domNode:null,spec:{},url:"",urls:null,configUrl:null,layout:"BaseLayout",docExpansion:"list",maxDisplayedTags:-1,filter:!1,validatorUrl:"https://validator.swagger.io/validator",oauth2RedirectUrl:void 0,persistAuthorization:!1,configs:{},displayOperationId:!1,displayRequestDuration:!1,deepLinking:!1,tryItOutEnabled:!1,requestInterceptor:s=>(s.curlOptions=[],s),responseInterceptor:s=>s,showMutatedRequest:!0,defaultModelRendering:"example",defaultModelExpandDepth:1,defaultModelsExpandDepth:1,showExtensions:!1,showCommonExtensions:!1,withCredentials:!1,requestSnippetsEnabled:!1,requestSnippets:{generators:{curl_bash:{title:"cURL (bash)",syntax:"bash"},curl_powershell:{title:"cURL (PowerShell)",syntax:"powershell"},curl_cmd:{title:"cURL (CMD)",syntax:"bash"}},defaultExpanded:!0,languages:null},supportedSubmitMethods:["get","put","post","delete","options","head","patch","trace"],queryConfigEnabled:!1,presets:[PresetApis],plugins:[],initialState:{},fn:{},components:{},syntaxHighlight:{activated:!0,theme:"agate"},operationsSorter:null,tagsSorter:null,onComplete:null,modelPropertyMacro:null,parameterMacro:null});var qI=__webpack_require__(61448),$I=__webpack_require__.n(qI),VI=__webpack_require__(77731),UI=__webpack_require__.n(VI);const type_casters_array=(s,o=[])=>Array.isArray(s)?s:o,type_casters_boolean=(s,o=!1)=>!0===s||"true"===s||1===s||"1"===s||!1!==s&&"false"!==s&&0!==s&&"0"!==s&&o,dom_node=s=>null===s||"null"===s?null:s,type_casters_filter=s=>{const o=String(s);return type_casters_boolean(s,o)},type_casters_function=(s,o)=>"function"==typeof s?s:o,nullable_array=s=>Array.isArray(s)?s:null,nullable_function=s=>"function"==typeof s?s:null,nullable_string=s=>null===s||"null"===s?null:String(s),type_casters_number=(s,o=-1)=>{const i=parseInt(s,10);return Number.isNaN(i)?o:i},type_casters_object=(s,o={})=>cI()(s)?s:o,sorter=s=>"function"==typeof s||"string"==typeof s?s:null,type_casters_string=s=>String(s),syntax_highlight=(s,o)=>cI()(s)?s:!1===s||"false"===s||0===s||"0"===s?{activated:!1}:o,undefined_string=s=>void 0===s||"undefined"===s?void 0:String(s),zI={components:{typeCaster:type_casters_object},configs:{typeCaster:type_casters_object},configUrl:{typeCaster:nullable_string},deepLinking:{typeCaster:type_casters_boolean,defaultValue:FI.deepLinking},defaultModelExpandDepth:{typeCaster:type_casters_number,defaultValue:FI.defaultModelExpandDepth},defaultModelRendering:{typeCaster:type_casters_string},defaultModelsExpandDepth:{typeCaster:type_casters_number,defaultValue:FI.defaultModelsExpandDepth},displayOperationId:{typeCaster:type_casters_boolean,defaultValue:FI.displayOperationId},displayRequestDuration:{typeCaster:type_casters_boolean,defaultValue:FI.displayRequestDuration},docExpansion:{typeCaster:type_casters_string},dom_id:{typeCaster:nullable_string},domNode:{typeCaster:dom_node},filter:{typeCaster:type_casters_filter},fn:{typeCaster:type_casters_object},initialState:{typeCaster:type_casters_object},layout:{typeCaster:type_casters_string},maxDisplayedTags:{typeCaster:type_casters_number,defaultValue:FI.maxDisplayedTags},modelPropertyMacro:{typeCaster:nullable_function},oauth2RedirectUrl:{typeCaster:undefined_string},onComplete:{typeCaster:nullable_function},operationsSorter:{typeCaster:sorter},paramaterMacro:{typeCaster:nullable_function},persistAuthorization:{typeCaster:type_casters_boolean,defaultValue:FI.persistAuthorization},plugins:{typeCaster:type_casters_array,defaultValue:FI.plugins},presets:{typeCaster:type_casters_array,defaultValue:FI.presets},requestInterceptor:{typeCaster:type_casters_function,defaultValue:FI.requestInterceptor},requestSnippets:{typeCaster:type_casters_object,defaultValue:FI.requestSnippets},requestSnippetsEnabled:{typeCaster:type_casters_boolean,defaultValue:FI.requestSnippetsEnabled},responseInterceptor:{typeCaster:type_casters_function,defaultValue:FI.responseInterceptor},showCommonExtensions:{typeCaster:type_casters_boolean,defaultValue:FI.showCommonExtensions},showExtensions:{typeCaster:type_casters_boolean,defaultValue:FI.showExtensions},showMutatedRequest:{typeCaster:type_casters_boolean,defaultValue:FI.showMutatedRequest},spec:{typeCaster:type_casters_object,defaultValue:FI.spec},supportedSubmitMethods:{typeCaster:type_casters_array,defaultValue:FI.supportedSubmitMethods},syntaxHighlight:{typeCaster:syntax_highlight,defaultValue:FI.syntaxHighlight},"syntaxHighlight.activated":{typeCaster:type_casters_boolean,defaultValue:FI.syntaxHighlight.activated},"syntaxHighlight.theme":{typeCaster:type_casters_string},tagsSorter:{typeCaster:sorter},tryItOutEnabled:{typeCaster:type_casters_boolean,defaultValue:FI.tryItOutEnabled},url:{typeCaster:type_casters_string},urls:{typeCaster:nullable_array},"urls.primaryName":{typeCaster:type_casters_string},validatorUrl:{typeCaster:nullable_string},withCredentials:{typeCaster:type_casters_boolean,defaultValue:FI.withCredentials}},type_cast=s=>Object.entries(zI).reduce(((s,[o,{typeCaster:i,defaultValue:u}])=>{if($I()(s,o)){const _=i(jn()(s,o),u);s=UI()(o,_,s)}return s}),{...s}),config_merge=(s,...o)=>{let i=Symbol.for("domNode"),u=Symbol.for("primaryName");const _=[];for(const s of o){const o={...s};Object.hasOwn(o,"domNode")&&(i=o.domNode,delete o.domNode),Object.hasOwn(o,"urls.primaryName")?(u=o["urls.primaryName"],delete o["urls.primaryName"]):Array.isArray(o.urls)&&Object.hasOwn(o.urls,"primaryName")&&(u=o.urls.primaryName,delete o.urls.primaryName),_.push(o)}const w=We()(s,..._);return i!==Symbol.for("domNode")&&(w.domNode=i),u!==Symbol.for("primaryName")&&Array.isArray(w.urls)&&(w.urls.primaryName=u),type_cast(w)};function SwaggerUI(s){const o=sources_query()(s),i=runtime()(),u=SwaggerUI.config.merge({},SwaggerUI.config.defaults,i,s,o),_=factorization_system(u),w=inline_plugin(u),x=new Store(_);x.register([u.plugins,w]);const C=x.getSystem(),persistConfigs=s=>{x.setConfigs(s),C.configsActions.loaded()},updateSpec=s=>{!o.url&&"object"==typeof s.spec&&Object.keys(s.spec).length>0?(C.specActions.updateUrl(""),C.specActions.updateLoadingStatus("success"),C.specActions.updateSpec(JSON.stringify(s.spec))):"function"==typeof C.specActions.download&&s.url&&!s.urls&&(C.specActions.updateUrl(s.url),C.specActions.download(s.url))},render=s=>{if(s.domNode)C.render(s.domNode,"App");else if(s.dom_id){const o=document.querySelector(s.dom_id);C.render(o,"App")}else null===s.dom_id||null===s.domNode||console.error("Skipped rendering: no `dom_id` or `domNode` was specified")};return u.configUrl?((async()=>{const{configUrl:s}=u,i=await sources_url({url:s,system:C})(u),_=SwaggerUI.config.merge({},u,i,o);persistConfigs(_),null!==i&&updateSpec(_),render(_)})(),C):(persistConfigs(u),updateSpec(u),render(u),C)}SwaggerUI.System=Store,SwaggerUI.config={defaults:FI,merge:config_merge,typeCast:type_cast,typeCastMappings:zI},SwaggerUI.presets={base,apis:PresetApis},SwaggerUI.plugins={Auth:auth,Configs:configsPlugin,DeepLining:deep_linking,Err:err,Filter:filter,Icons:icons,JSONSchema5:json_schema_5,JSONSchema5Samples:json_schema_5_samples,JSONSchema202012:json_schema_2020_12,JSONSchema202012Samples:json_schema_2020_12_samples,Layout:plugins_layout,Logs:logs,OpenAPI30:oas3,OpenAPI31:oas3,OnComplete:on_complete,RequestSnippets:plugins_request_snippets,Spec:plugins_spec,SwaggerClient:swagger_client,Util:util,View:view,ViewLegacy:view_legacy,DownloadUrl:downloadUrlPlugin,SyntaxHighlighting:syntax_highlighting,Versions:versions,SafeRender:safe_render};const WI=SwaggerUI})(),_=_.default})())); \ No newline at end of file diff --git a/server/internal/httpapi/docs/swagger-ui/swagger-ui-standalone-preset.js b/server/internal/httpapi/docs/swagger-ui/swagger-ui-standalone-preset.js new file mode 100644 index 0000000..6ea56ce --- /dev/null +++ b/server/internal/httpapi/docs/swagger-ui/swagger-ui-standalone-preset.js @@ -0,0 +1,2 @@ +/*! For license information please see swagger-ui-standalone-preset.js.LICENSE.txt */ +!function webpackUniversalModuleDefinition(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.SwaggerUIStandalonePreset=t():e.SwaggerUIStandalonePreset=t()}(this,(()=>(()=>{var e={9119:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.BLANK_URL=t.relativeFirstCharacters=t.whitespaceEscapeCharsRegex=t.urlSchemeRegex=t.ctrlCharactersRegex=t.htmlCtrlEntityRegex=t.htmlEntitiesRegex=t.invalidProtocolRegex=void 0,t.invalidProtocolRegex=/^([^\w]*)(javascript|data|vbscript)/im,t.htmlEntitiesRegex=/&#(\w+)(^\w|;)?/g,t.htmlCtrlEntityRegex=/&(newline|tab);/gi,t.ctrlCharactersRegex=/[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim,t.urlSchemeRegex=/^.+(:|:)/gim,t.whitespaceEscapeCharsRegex=/(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g,t.relativeFirstCharacters=[".","/"],t.BLANK_URL="about:blank"},6750:(e,t,r)=>{"use strict";var n=r(9119);function decodeURI(e){try{return decodeURIComponent(e)}catch(t){return e}}},7526:(e,t)=>{"use strict";t.byteLength=function byteLength(e){var t=getLens(e),r=t[0],n=t[1];return 3*(r+n)/4-n},t.toByteArray=function toByteArray(e){var t,r,o=getLens(e),a=o[0],s=o[1],u=new i(function _byteLength(e,t,r){return 3*(t+r)/4-r}(0,a,s)),c=0,f=s>0?a-4:a;for(r=0;r>16&255,u[c++]=t>>8&255,u[c++]=255&t;2===s&&(t=n[e.charCodeAt(r)]<<2|n[e.charCodeAt(r+1)]>>4,u[c++]=255&t);1===s&&(t=n[e.charCodeAt(r)]<<10|n[e.charCodeAt(r+1)]<<4|n[e.charCodeAt(r+2)]>>2,u[c++]=t>>8&255,u[c++]=255&t);return u},t.fromByteArray=function fromByteArray(e){for(var t,n=e.length,i=n%3,o=[],a=16383,s=0,u=n-i;su?u:s+a));1===i?(t=e[n-1],o.push(r[t>>2]+r[t<<4&63]+"==")):2===i&&(t=(e[n-2]<<8)+e[n-1],o.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"="));return o.join("")};for(var r=[],n=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=0;a<64;++a)r[a]=o[a],n[o.charCodeAt(a)]=a;function getLens(e){var t=e.length;if(t%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var r=e.indexOf("=");return-1===r&&(r=t),[r,r===t?0:4-r%4]}function encodeChunk(e,t,n){for(var i,o,a=[],s=t;s>18&63]+r[o>>12&63]+r[o>>6&63]+r[63&o]);return a.join("")}n["-".charCodeAt(0)]=62,n["_".charCodeAt(0)]=63},8287:(e,t,r)=>{"use strict";const n=r(7526),i=r(251),o="function"==typeof Symbol&&"function"==typeof Symbol.for?Symbol.for("nodejs.util.inspect.custom"):null;t.Buffer=Buffer,t.SlowBuffer=function SlowBuffer(e){+e!=e&&(e=0);return Buffer.alloc(+e)},t.INSPECT_MAX_BYTES=50;const a=2147483647;function createBuffer(e){if(e>a)throw new RangeError('The value "'+e+'" is invalid for option "size"');const t=new Uint8Array(e);return Object.setPrototypeOf(t,Buffer.prototype),t}function Buffer(e,t,r){if("number"==typeof e){if("string"==typeof t)throw new TypeError('The "string" argument must be of type string. Received type number');return allocUnsafe(e)}return from(e,t,r)}function from(e,t,r){if("string"==typeof e)return function fromString(e,t){"string"==typeof t&&""!==t||(t="utf8");if(!Buffer.isEncoding(t))throw new TypeError("Unknown encoding: "+t);const r=0|byteLength(e,t);let n=createBuffer(r);const i=n.write(e,t);i!==r&&(n=n.slice(0,i));return n}(e,t);if(ArrayBuffer.isView(e))return function fromArrayView(e){if(isInstance(e,Uint8Array)){const t=new Uint8Array(e);return fromArrayBuffer(t.buffer,t.byteOffset,t.byteLength)}return fromArrayLike(e)}(e);if(null==e)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e);if(isInstance(e,ArrayBuffer)||e&&isInstance(e.buffer,ArrayBuffer))return fromArrayBuffer(e,t,r);if("undefined"!=typeof SharedArrayBuffer&&(isInstance(e,SharedArrayBuffer)||e&&isInstance(e.buffer,SharedArrayBuffer)))return fromArrayBuffer(e,t,r);if("number"==typeof e)throw new TypeError('The "value" argument must not be of type number. Received type number');const n=e.valueOf&&e.valueOf();if(null!=n&&n!==e)return Buffer.from(n,t,r);const i=function fromObject(e){if(Buffer.isBuffer(e)){const t=0|checked(e.length),r=createBuffer(t);return 0===r.length||e.copy(r,0,0,t),r}if(void 0!==e.length)return"number"!=typeof e.length||numberIsNaN(e.length)?createBuffer(0):fromArrayLike(e);if("Buffer"===e.type&&Array.isArray(e.data))return fromArrayLike(e.data)}(e);if(i)return i;if("undefined"!=typeof Symbol&&null!=Symbol.toPrimitive&&"function"==typeof e[Symbol.toPrimitive])return Buffer.from(e[Symbol.toPrimitive]("string"),t,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e)}function assertSize(e){if("number"!=typeof e)throw new TypeError('"size" argument must be of type number');if(e<0)throw new RangeError('The value "'+e+'" is invalid for option "size"')}function allocUnsafe(e){return assertSize(e),createBuffer(e<0?0:0|checked(e))}function fromArrayLike(e){const t=e.length<0?0:0|checked(e.length),r=createBuffer(t);for(let n=0;n=a)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a.toString(16)+" bytes");return 0|e}function byteLength(e,t){if(Buffer.isBuffer(e))return e.length;if(ArrayBuffer.isView(e)||isInstance(e,ArrayBuffer))return e.byteLength;if("string"!=typeof e)throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof e);const r=e.length,n=arguments.length>2&&!0===arguments[2];if(!n&&0===r)return 0;let i=!1;for(;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return utf8ToBytes(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return base64ToBytes(e).length;default:if(i)return n?-1:utf8ToBytes(e).length;t=(""+t).toLowerCase(),i=!0}}function slowToString(e,t,r){let n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return hexSlice(this,t,r);case"utf8":case"utf-8":return utf8Slice(this,t,r);case"ascii":return asciiSlice(this,t,r);case"latin1":case"binary":return latin1Slice(this,t,r);case"base64":return base64Slice(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function swap(e,t,r){const n=e[t];e[t]=e[r],e[r]=n}function bidirectionalIndexOf(e,t,r,n,i){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),numberIsNaN(r=+r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof t&&(t=Buffer.from(t,n)),Buffer.isBuffer(t))return 0===t.length?-1:arrayIndexOf(e,t,r,n,i);if("number"==typeof t)return t&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):arrayIndexOf(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(e,t,r,n,i){let o,a=1,s=e.length,u=t.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;a=2,s/=2,u/=2,r/=2}function read(e,t){return 1===a?e[t]:e.readUInt16BE(t*a)}if(i){let n=-1;for(o=r;os&&(r=s-u),o=r;o>=0;o--){let r=!0;for(let n=0;ni&&(n=i):n=i;const o=t.length;let a;for(n>o/2&&(n=o/2),a=0;a>8,i=r%256,o.push(i),o.push(n);return o}(t,e.length-r),e,r,n)}function base64Slice(e,t,r){return 0===t&&r===e.length?n.fromByteArray(e):n.fromByteArray(e.slice(t,r))}function utf8Slice(e,t,r){r=Math.min(e.length,r);const n=[];let i=t;for(;i239?4:t>223?3:t>191?2:1;if(i+a<=r){let r,n,s,u;switch(a){case 1:t<128&&(o=t);break;case 2:r=e[i+1],128==(192&r)&&(u=(31&t)<<6|63&r,u>127&&(o=u));break;case 3:r=e[i+1],n=e[i+2],128==(192&r)&&128==(192&n)&&(u=(15&t)<<12|(63&r)<<6|63&n,u>2047&&(u<55296||u>57343)&&(o=u));break;case 4:r=e[i+1],n=e[i+2],s=e[i+3],128==(192&r)&&128==(192&n)&&128==(192&s)&&(u=(15&t)<<18|(63&r)<<12|(63&n)<<6|63&s,u>65535&&u<1114112&&(o=u))}}null===o?(o=65533,a=1):o>65535&&(o-=65536,n.push(o>>>10&1023|55296),o=56320|1023&o),n.push(o),i+=a}return function decodeCodePointsArray(e){const t=e.length;if(t<=s)return String.fromCharCode.apply(String,e);let r="",n=0;for(;nn.length?(Buffer.isBuffer(t)||(t=Buffer.from(t)),t.copy(n,i)):Uint8Array.prototype.set.call(n,t,i);else{if(!Buffer.isBuffer(t))throw new TypeError('"list" argument must be an Array of Buffers');t.copy(n,i)}i+=t.length}return n},Buffer.byteLength=byteLength,Buffer.prototype._isBuffer=!0,Buffer.prototype.swap16=function swap16(){const e=this.length;if(e%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let t=0;tr&&(e+=" ... "),""},o&&(Buffer.prototype[o]=Buffer.prototype.inspect),Buffer.prototype.compare=function compare(e,t,r,n,i){if(isInstance(e,Uint8Array)&&(e=Buffer.from(e,e.offset,e.byteLength)),!Buffer.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(this===e)return 0;let o=(i>>>=0)-(n>>>=0),a=(r>>>=0)-(t>>>=0);const s=Math.min(o,a),u=this.slice(n,i),c=e.slice(t,r);for(let e=0;e>>=0,isFinite(r)?(r>>>=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}const i=this.length-t;if((void 0===r||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");let o=!1;for(;;)switch(n){case"hex":return hexWrite(this,e,t,r);case"utf8":case"utf-8":return utf8Write(this,e,t,r);case"ascii":case"latin1":case"binary":return asciiWrite(this,e,t,r);case"base64":return base64Write(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}},Buffer.prototype.toJSON=function toJSON(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};const s=4096;function asciiSlice(e,t,r){let n="";r=Math.min(e.length,r);for(let i=t;in)&&(r=n);let i="";for(let n=t;nr)throw new RangeError("Trying to access beyond buffer length")}function checkInt(e,t,r,n,i,o){if(!Buffer.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}function wrtBigUInt64LE(e,t,r,n,i){checkIntBI(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r++]=o,o>>=8,e[r++]=o,o>>=8,e[r++]=o,o>>=8,e[r++]=o;let a=Number(t>>BigInt(32)&BigInt(4294967295));return e[r++]=a,a>>=8,e[r++]=a,a>>=8,e[r++]=a,a>>=8,e[r++]=a,r}function wrtBigUInt64BE(e,t,r,n,i){checkIntBI(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r+7]=o,o>>=8,e[r+6]=o,o>>=8,e[r+5]=o,o>>=8,e[r+4]=o;let a=Number(t>>BigInt(32)&BigInt(4294967295));return e[r+3]=a,a>>=8,e[r+2]=a,a>>=8,e[r+1]=a,a>>=8,e[r]=a,r+8}function checkIEEE754(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function writeFloat(e,t,r,n,o){return t=+t,r>>>=0,o||checkIEEE754(e,0,r,4),i.write(e,t,r,n,23,4),r+4}function writeDouble(e,t,r,n,o){return t=+t,r>>>=0,o||checkIEEE754(e,0,r,8),i.write(e,t,r,n,52,8),r+8}Buffer.prototype.slice=function slice(e,t){const r=this.length;(e=~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),(t=void 0===t?r:~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),t>>=0,t>>>=0,r||checkOffset(e,t,this.length);let n=this[e],i=1,o=0;for(;++o>>=0,t>>>=0,r||checkOffset(e,t,this.length);let n=this[e+--t],i=1;for(;t>0&&(i*=256);)n+=this[e+--t]*i;return n},Buffer.prototype.readUint8=Buffer.prototype.readUInt8=function readUInt8(e,t){return e>>>=0,t||checkOffset(e,1,this.length),this[e]},Buffer.prototype.readUint16LE=Buffer.prototype.readUInt16LE=function readUInt16LE(e,t){return e>>>=0,t||checkOffset(e,2,this.length),this[e]|this[e+1]<<8},Buffer.prototype.readUint16BE=Buffer.prototype.readUInt16BE=function readUInt16BE(e,t){return e>>>=0,t||checkOffset(e,2,this.length),this[e]<<8|this[e+1]},Buffer.prototype.readUint32LE=Buffer.prototype.readUInt32LE=function readUInt32LE(e,t){return e>>>=0,t||checkOffset(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},Buffer.prototype.readUint32BE=Buffer.prototype.readUInt32BE=function readUInt32BE(e,t){return e>>>=0,t||checkOffset(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},Buffer.prototype.readBigUInt64LE=defineBigIntMethod((function readBigUInt64LE(e){validateNumber(e>>>=0,"offset");const t=this[e],r=this[e+7];void 0!==t&&void 0!==r||boundsError(e,this.length-8);const n=t+256*this[++e]+65536*this[++e]+this[++e]*2**24,i=this[++e]+256*this[++e]+65536*this[++e]+r*2**24;return BigInt(n)+(BigInt(i)<>>=0,"offset");const t=this[e],r=this[e+7];void 0!==t&&void 0!==r||boundsError(e,this.length-8);const n=t*2**24+65536*this[++e]+256*this[++e]+this[++e],i=this[++e]*2**24+65536*this[++e]+256*this[++e]+r;return(BigInt(n)<>>=0,t>>>=0,r||checkOffset(e,t,this.length);let n=this[e],i=1,o=0;for(;++o=i&&(n-=Math.pow(2,8*t)),n},Buffer.prototype.readIntBE=function readIntBE(e,t,r){e>>>=0,t>>>=0,r||checkOffset(e,t,this.length);let n=t,i=1,o=this[e+--n];for(;n>0&&(i*=256);)o+=this[e+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*t)),o},Buffer.prototype.readInt8=function readInt8(e,t){return e>>>=0,t||checkOffset(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},Buffer.prototype.readInt16LE=function readInt16LE(e,t){e>>>=0,t||checkOffset(e,2,this.length);const r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},Buffer.prototype.readInt16BE=function readInt16BE(e,t){e>>>=0,t||checkOffset(e,2,this.length);const r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},Buffer.prototype.readInt32LE=function readInt32LE(e,t){return e>>>=0,t||checkOffset(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},Buffer.prototype.readInt32BE=function readInt32BE(e,t){return e>>>=0,t||checkOffset(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},Buffer.prototype.readBigInt64LE=defineBigIntMethod((function readBigInt64LE(e){validateNumber(e>>>=0,"offset");const t=this[e],r=this[e+7];void 0!==t&&void 0!==r||boundsError(e,this.length-8);const n=this[e+4]+256*this[e+5]+65536*this[e+6]+(r<<24);return(BigInt(n)<>>=0,"offset");const t=this[e],r=this[e+7];void 0!==t&&void 0!==r||boundsError(e,this.length-8);const n=(t<<24)+65536*this[++e]+256*this[++e]+this[++e];return(BigInt(n)<>>=0,t||checkOffset(e,4,this.length),i.read(this,e,!0,23,4)},Buffer.prototype.readFloatBE=function readFloatBE(e,t){return e>>>=0,t||checkOffset(e,4,this.length),i.read(this,e,!1,23,4)},Buffer.prototype.readDoubleLE=function readDoubleLE(e,t){return e>>>=0,t||checkOffset(e,8,this.length),i.read(this,e,!0,52,8)},Buffer.prototype.readDoubleBE=function readDoubleBE(e,t){return e>>>=0,t||checkOffset(e,8,this.length),i.read(this,e,!1,52,8)},Buffer.prototype.writeUintLE=Buffer.prototype.writeUIntLE=function writeUIntLE(e,t,r,n){if(e=+e,t>>>=0,r>>>=0,!n){checkInt(this,e,t,r,Math.pow(2,8*r)-1,0)}let i=1,o=0;for(this[t]=255&e;++o>>=0,r>>>=0,!n){checkInt(this,e,t,r,Math.pow(2,8*r)-1,0)}let i=r-1,o=1;for(this[t+i]=255&e;--i>=0&&(o*=256);)this[t+i]=e/o&255;return t+r},Buffer.prototype.writeUint8=Buffer.prototype.writeUInt8=function writeUInt8(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,1,255,0),this[t]=255&e,t+1},Buffer.prototype.writeUint16LE=Buffer.prototype.writeUInt16LE=function writeUInt16LE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,2,65535,0),this[t]=255&e,this[t+1]=e>>>8,t+2},Buffer.prototype.writeUint16BE=Buffer.prototype.writeUInt16BE=function writeUInt16BE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=255&e,t+2},Buffer.prototype.writeUint32LE=Buffer.prototype.writeUInt32LE=function writeUInt32LE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e,t+4},Buffer.prototype.writeUint32BE=Buffer.prototype.writeUInt32BE=function writeUInt32BE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},Buffer.prototype.writeBigUInt64LE=defineBigIntMethod((function writeBigUInt64LE(e,t=0){return wrtBigUInt64LE(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))})),Buffer.prototype.writeBigUInt64BE=defineBigIntMethod((function writeBigUInt64BE(e,t=0){return wrtBigUInt64BE(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))})),Buffer.prototype.writeIntLE=function writeIntLE(e,t,r,n){if(e=+e,t>>>=0,!n){const n=Math.pow(2,8*r-1);checkInt(this,e,t,r,n-1,-n)}let i=0,o=1,a=0;for(this[t]=255&e;++i>>=0,!n){const n=Math.pow(2,8*r-1);checkInt(this,e,t,r,n-1,-n)}let i=r-1,o=1,a=0;for(this[t+i]=255&e;--i>=0&&(o*=256);)e<0&&0===a&&0!==this[t+i+1]&&(a=1),this[t+i]=(e/o|0)-a&255;return t+r},Buffer.prototype.writeInt8=function writeInt8(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=255&e,t+1},Buffer.prototype.writeInt16LE=function writeInt16LE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,2,32767,-32768),this[t]=255&e,this[t+1]=e>>>8,t+2},Buffer.prototype.writeInt16BE=function writeInt16BE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=255&e,t+2},Buffer.prototype.writeInt32LE=function writeInt32LE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,4,2147483647,-2147483648),this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4},Buffer.prototype.writeInt32BE=function writeInt32BE(e,t,r){return e=+e,t>>>=0,r||checkInt(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},Buffer.prototype.writeBigInt64LE=defineBigIntMethod((function writeBigInt64LE(e,t=0){return wrtBigUInt64LE(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),Buffer.prototype.writeBigInt64BE=defineBigIntMethod((function writeBigInt64BE(e,t=0){return wrtBigUInt64BE(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),Buffer.prototype.writeFloatLE=function writeFloatLE(e,t,r){return writeFloat(this,e,t,!0,r)},Buffer.prototype.writeFloatBE=function writeFloatBE(e,t,r){return writeFloat(this,e,t,!1,r)},Buffer.prototype.writeDoubleLE=function writeDoubleLE(e,t,r){return writeDouble(this,e,t,!0,r)},Buffer.prototype.writeDoubleBE=function writeDoubleBE(e,t,r){return writeDouble(this,e,t,!1,r)},Buffer.prototype.copy=function copy(e,t,r,n){if(!Buffer.isBuffer(e))throw new TypeError("argument should be a Buffer");if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(i=t;i=n+4;r-=3)t=`_${e.slice(r-3,r)}${t}`;return`${e.slice(0,r)}${t}`}function checkIntBI(e,t,r,n,i,o){if(e>r||e3?0===t||t===BigInt(0)?`>= 0${n} and < 2${n} ** ${8*(o+1)}${n}`:`>= -(2${n} ** ${8*(o+1)-1}${n}) and < 2 ** ${8*(o+1)-1}${n}`:`>= ${t}${n} and <= ${r}${n}`,new u.ERR_OUT_OF_RANGE("value",i,e)}!function checkBounds(e,t,r){validateNumber(t,"offset"),void 0!==e[t]&&void 0!==e[t+r]||boundsError(t,e.length-(r+1))}(n,i,o)}function validateNumber(e,t){if("number"!=typeof e)throw new u.ERR_INVALID_ARG_TYPE(t,"number",e)}function boundsError(e,t,r){if(Math.floor(e)!==e)throw validateNumber(e,r),new u.ERR_OUT_OF_RANGE(r||"offset","an integer",e);if(t<0)throw new u.ERR_BUFFER_OUT_OF_BOUNDS;throw new u.ERR_OUT_OF_RANGE(r||"offset",`>= ${r?1:0} and <= ${t}`,e)}E("ERR_BUFFER_OUT_OF_BOUNDS",(function(e){return e?`${e} is outside of buffer bounds`:"Attempt to access memory outside buffer bounds"}),RangeError),E("ERR_INVALID_ARG_TYPE",(function(e,t){return`The "${e}" argument must be of type number. Received type ${typeof t}`}),TypeError),E("ERR_OUT_OF_RANGE",(function(e,t,r){let n=`The value of "${e}" is out of range.`,i=r;return Number.isInteger(r)&&Math.abs(r)>2**32?i=addNumericalSeparator(String(r)):"bigint"==typeof r&&(i=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(i=addNumericalSeparator(i)),i+="n"),n+=` It must be ${t}. Received ${i}`,n}),RangeError);const c=/[^+/0-9A-Za-z-_]/g;function utf8ToBytes(e,t){let r;t=t||1/0;const n=e.length;let i=null;const o=[];for(let a=0;a55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}if(a+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return o}function base64ToBytes(e){return n.toByteArray(function base64clean(e){if((e=(e=e.split("=")[0]).trim().replace(c,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function blitBuffer(e,t,r,n){let i;for(i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function isInstance(e,t){return e instanceof t||null!=e&&null!=e.constructor&&null!=e.constructor.name&&e.constructor.name===t.name}function numberIsNaN(e){return e!=e}const f=function(){const e="0123456789abcdef",t=new Array(256);for(let r=0;r<16;++r){const n=16*r;for(let i=0;i<16;++i)t[n+i]=e[r]+e[i]}return t}();function defineBigIntMethod(e){return"undefined"==typeof BigInt?BufferBigIntNotDefined:e}function BufferBigIntNotDefined(){throw new Error("BigInt not supported")}},2205:function(e,t,r){var n;n=void 0!==r.g?r.g:this,e.exports=function(e){if(e.CSS&&e.CSS.escape)return e.CSS.escape;var cssEscape=function(e){if(0==arguments.length)throw new TypeError("`CSS.escape` requires an argument.");for(var t,r=String(e),n=r.length,i=-1,o="",a=r.charCodeAt(0);++i=1&&t<=31||127==t||0==i&&t>=48&&t<=57||1==i&&t>=48&&t<=57&&45==a?"\\"+t.toString(16)+" ":0==i&&1==n&&45==t||!(t>=128||45==t||95==t||t>=48&&t<=57||t>=65&&t<=90||t>=97&&t<=122)?"\\"+r.charAt(i):r.charAt(i):o+="�";return o};return e.CSS||(e.CSS={}),e.CSS.escape=cssEscape,cssEscape}(n)},251:(e,t)=>{t.read=function(e,t,r,n,i){var o,a,s=8*i-n-1,u=(1<>1,f=-7,l=r?i-1:0,h=r?-1:1,p=e[t+l];for(l+=h,o=p&(1<<-f)-1,p>>=-f,f+=s;f>0;o=256*o+e[t+l],l+=h,f-=8);for(a=o&(1<<-f)-1,o>>=-f,f+=n;f>0;a=256*a+e[t+l],l+=h,f-=8);if(0===o)o=1-c;else{if(o===u)return a?NaN:1/0*(p?-1:1);a+=Math.pow(2,n),o-=c}return(p?-1:1)*a*Math.pow(2,o-n)},t.write=function(e,t,r,n,i,o){var a,s,u,c=8*o-i-1,f=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:o-1,d=n?1:-1,_=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,a=f):(a=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-a))<1&&(a--,u*=2),(t+=a+l>=1?h/u:h*Math.pow(2,1-l))*u>=2&&(a++,u/=2),a+l>=f?(s=0,a=f):a+l>=1?(s=(t*u-1)*Math.pow(2,i),a+=l):(s=t*Math.pow(2,l-1)*Math.pow(2,i),a=0));i>=8;e[r+p]=255&s,p+=d,s/=256,i-=8);for(a=a<0;e[r+p]=255&a,p+=d,a/=256,c-=8);e[r+p-d]|=128*_}},9404:function(e){e.exports=function(){"use strict";var e=Array.prototype.slice;function createClass(e,t){t&&(e.prototype=Object.create(t.prototype)),e.prototype.constructor=e}function Iterable(e){return isIterable(e)?e:Seq(e)}function KeyedIterable(e){return isKeyed(e)?e:KeyedSeq(e)}function IndexedIterable(e){return isIndexed(e)?e:IndexedSeq(e)}function SetIterable(e){return isIterable(e)&&!isAssociative(e)?e:SetSeq(e)}function isIterable(e){return!(!e||!e[t])}function isKeyed(e){return!(!e||!e[r])}function isIndexed(e){return!(!e||!e[n])}function isAssociative(e){return isKeyed(e)||isIndexed(e)}function isOrdered(e){return!(!e||!e[i])}createClass(KeyedIterable,Iterable),createClass(IndexedIterable,Iterable),createClass(SetIterable,Iterable),Iterable.isIterable=isIterable,Iterable.isKeyed=isKeyed,Iterable.isIndexed=isIndexed,Iterable.isAssociative=isAssociative,Iterable.isOrdered=isOrdered,Iterable.Keyed=KeyedIterable,Iterable.Indexed=IndexedIterable,Iterable.Set=SetIterable;var t="@@__IMMUTABLE_ITERABLE__@@",r="@@__IMMUTABLE_KEYED__@@",n="@@__IMMUTABLE_INDEXED__@@",i="@@__IMMUTABLE_ORDERED__@@",o="delete",a=5,s=1<>>0;if(""+r!==t||4294967295===r)return NaN;t=r}return t<0?ensureSize(e)+t:t}function returnTrue(){return!0}function wholeSlice(e,t,r){return(0===e||void 0!==r&&e<=-r)&&(void 0===t||void 0!==r&&t>=r)}function resolveBegin(e,t){return resolveIndex(e,t,0)}function resolveEnd(e,t){return resolveIndex(e,t,t)}function resolveIndex(e,t,r){return void 0===e?r:e<0?Math.max(0,t+e):void 0===t?e:Math.min(t,e)}var h=0,p=1,d=2,_="function"==typeof Symbol&&Symbol.iterator,y="@@iterator",m=_||y;function Iterator(e){this.next=e}function iteratorValue(e,t,r,n){var i=0===e?t:1===e?r:[t,r];return n?n.value=i:n={value:i,done:!1},n}function iteratorDone(){return{value:void 0,done:!0}}function hasIterator(e){return!!getIteratorFn(e)}function isIterator(e){return e&&"function"==typeof e.next}function getIterator(e){var t=getIteratorFn(e);return t&&t.call(e)}function getIteratorFn(e){var t=e&&(_&&e[_]||e[y]);if("function"==typeof t)return t}function isArrayLike(e){return e&&"number"==typeof e.length}function Seq(e){return null==e?emptySequence():isIterable(e)?e.toSeq():seqFromValue(e)}function KeyedSeq(e){return null==e?emptySequence().toKeyedSeq():isIterable(e)?isKeyed(e)?e.toSeq():e.fromEntrySeq():keyedSeqFromValue(e)}function IndexedSeq(e){return null==e?emptySequence():isIterable(e)?isKeyed(e)?e.entrySeq():e.toIndexedSeq():indexedSeqFromValue(e)}function SetSeq(e){return(null==e?emptySequence():isIterable(e)?isKeyed(e)?e.entrySeq():e:indexedSeqFromValue(e)).toSetSeq()}Iterator.prototype.toString=function(){return"[Iterator]"},Iterator.KEYS=h,Iterator.VALUES=p,Iterator.ENTRIES=d,Iterator.prototype.inspect=Iterator.prototype.toSource=function(){return this.toString()},Iterator.prototype[m]=function(){return this},createClass(Seq,Iterable),Seq.of=function(){return Seq(arguments)},Seq.prototype.toSeq=function(){return this},Seq.prototype.toString=function(){return this.__toString("Seq {","}")},Seq.prototype.cacheResult=function(){return!this._cache&&this.__iterateUncached&&(this._cache=this.entrySeq().toArray(),this.size=this._cache.length),this},Seq.prototype.__iterate=function(e,t){return seqIterate(this,e,t,!0)},Seq.prototype.__iterator=function(e,t){return seqIterator(this,e,t,!0)},createClass(KeyedSeq,Seq),KeyedSeq.prototype.toKeyedSeq=function(){return this},createClass(IndexedSeq,Seq),IndexedSeq.of=function(){return IndexedSeq(arguments)},IndexedSeq.prototype.toIndexedSeq=function(){return this},IndexedSeq.prototype.toString=function(){return this.__toString("Seq [","]")},IndexedSeq.prototype.__iterate=function(e,t){return seqIterate(this,e,t,!1)},IndexedSeq.prototype.__iterator=function(e,t){return seqIterator(this,e,t,!1)},createClass(SetSeq,Seq),SetSeq.of=function(){return SetSeq(arguments)},SetSeq.prototype.toSetSeq=function(){return this},Seq.isSeq=isSeq,Seq.Keyed=KeyedSeq,Seq.Set=SetSeq,Seq.Indexed=IndexedSeq;var g,v,b,w="@@__IMMUTABLE_SEQ__@@";function ArraySeq(e){this._array=e,this.size=e.length}function ObjectSeq(e){var t=Object.keys(e);this._object=e,this._keys=t,this.size=t.length}function IterableSeq(e){this._iterable=e,this.size=e.length||e.size}function IteratorSeq(e){this._iterator=e,this._iteratorCache=[]}function isSeq(e){return!(!e||!e[w])}function emptySequence(){return g||(g=new ArraySeq([]))}function keyedSeqFromValue(e){var t=Array.isArray(e)?new ArraySeq(e).fromEntrySeq():isIterator(e)?new IteratorSeq(e).fromEntrySeq():hasIterator(e)?new IterableSeq(e).fromEntrySeq():"object"==typeof e?new ObjectSeq(e):void 0;if(!t)throw new TypeError("Expected Array or iterable object of [k, v] entries, or keyed object: "+e);return t}function indexedSeqFromValue(e){var t=maybeIndexedSeqFromValue(e);if(!t)throw new TypeError("Expected Array or iterable object of values: "+e);return t}function seqFromValue(e){var t=maybeIndexedSeqFromValue(e)||"object"==typeof e&&new ObjectSeq(e);if(!t)throw new TypeError("Expected Array or iterable object of values, or keyed object: "+e);return t}function maybeIndexedSeqFromValue(e){return isArrayLike(e)?new ArraySeq(e):isIterator(e)?new IteratorSeq(e):hasIterator(e)?new IterableSeq(e):void 0}function seqIterate(e,t,r,n){var i=e._cache;if(i){for(var o=i.length-1,a=0;a<=o;a++){var s=i[r?o-a:a];if(!1===t(s[1],n?s[0]:a,e))return a+1}return a}return e.__iterateUncached(t,r)}function seqIterator(e,t,r,n){var i=e._cache;if(i){var o=i.length-1,a=0;return new Iterator((function(){var e=i[r?o-a:a];return a++>o?iteratorDone():iteratorValue(t,n?e[0]:a-1,e[1])}))}return e.__iteratorUncached(t,r)}function fromJS(e,t){return t?fromJSWith(t,e,"",{"":e}):fromJSDefault(e)}function fromJSWith(e,t,r,n){return Array.isArray(t)?e.call(n,r,IndexedSeq(t).map((function(r,n){return fromJSWith(e,r,n,t)}))):isPlainObj(t)?e.call(n,r,KeyedSeq(t).map((function(r,n){return fromJSWith(e,r,n,t)}))):t}function fromJSDefault(e){return Array.isArray(e)?IndexedSeq(e).map(fromJSDefault).toList():isPlainObj(e)?KeyedSeq(e).map(fromJSDefault).toMap():e}function isPlainObj(e){return e&&(e.constructor===Object||void 0===e.constructor)}function is(e,t){if(e===t||e!=e&&t!=t)return!0;if(!e||!t)return!1;if("function"==typeof e.valueOf&&"function"==typeof t.valueOf){if((e=e.valueOf())===(t=t.valueOf())||e!=e&&t!=t)return!0;if(!e||!t)return!1}return!("function"!=typeof e.equals||"function"!=typeof t.equals||!e.equals(t))}function deepEqual(e,t){if(e===t)return!0;if(!isIterable(t)||void 0!==e.size&&void 0!==t.size&&e.size!==t.size||void 0!==e.__hash&&void 0!==t.__hash&&e.__hash!==t.__hash||isKeyed(e)!==isKeyed(t)||isIndexed(e)!==isIndexed(t)||isOrdered(e)!==isOrdered(t))return!1;if(0===e.size&&0===t.size)return!0;var r=!isAssociative(e);if(isOrdered(e)){var n=e.entries();return t.every((function(e,t){var i=n.next().value;return i&&is(i[1],e)&&(r||is(i[0],t))}))&&n.next().done}var i=!1;if(void 0===e.size)if(void 0===t.size)"function"==typeof e.cacheResult&&e.cacheResult();else{i=!0;var o=e;e=t,t=o}var a=!0,s=t.__iterate((function(t,n){if(r?!e.has(t):i?!is(t,e.get(n,c)):!is(e.get(n,c),t))return a=!1,!1}));return a&&e.size===s}function Repeat(e,t){if(!(this instanceof Repeat))return new Repeat(e,t);if(this._value=e,this.size=void 0===t?1/0:Math.max(0,t),0===this.size){if(v)return v;v=this}}function invariant(e,t){if(!e)throw new Error(t)}function Range(e,t,r){if(!(this instanceof Range))return new Range(e,t,r);if(invariant(0!==r,"Cannot step a Range by 0"),e=e||0,void 0===t&&(t=1/0),r=void 0===r?1:Math.abs(r),tn?iteratorDone():iteratorValue(e,i,r[t?n-i++:i++])}))},createClass(ObjectSeq,KeyedSeq),ObjectSeq.prototype.get=function(e,t){return void 0===t||this.has(e)?this._object[e]:t},ObjectSeq.prototype.has=function(e){return this._object.hasOwnProperty(e)},ObjectSeq.prototype.__iterate=function(e,t){for(var r=this._object,n=this._keys,i=n.length-1,o=0;o<=i;o++){var a=n[t?i-o:o];if(!1===e(r[a],a,this))return o+1}return o},ObjectSeq.prototype.__iterator=function(e,t){var r=this._object,n=this._keys,i=n.length-1,o=0;return new Iterator((function(){var a=n[t?i-o:o];return o++>i?iteratorDone():iteratorValue(e,a,r[a])}))},ObjectSeq.prototype[i]=!0,createClass(IterableSeq,IndexedSeq),IterableSeq.prototype.__iterateUncached=function(e,t){if(t)return this.cacheResult().__iterate(e,t);var r=getIterator(this._iterable),n=0;if(isIterator(r))for(var i;!(i=r.next()).done&&!1!==e(i.value,n++,this););return n},IterableSeq.prototype.__iteratorUncached=function(e,t){if(t)return this.cacheResult().__iterator(e,t);var r=getIterator(this._iterable);if(!isIterator(r))return new Iterator(iteratorDone);var n=0;return new Iterator((function(){var t=r.next();return t.done?t:iteratorValue(e,n++,t.value)}))},createClass(IteratorSeq,IndexedSeq),IteratorSeq.prototype.__iterateUncached=function(e,t){if(t)return this.cacheResult().__iterate(e,t);for(var r,n=this._iterator,i=this._iteratorCache,o=0;o=n.length){var t=r.next();if(t.done)return t;n[i]=t.value}return iteratorValue(e,i,n[i++])}))},createClass(Repeat,IndexedSeq),Repeat.prototype.toString=function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},Repeat.prototype.get=function(e,t){return this.has(e)?this._value:t},Repeat.prototype.includes=function(e){return is(this._value,e)},Repeat.prototype.slice=function(e,t){var r=this.size;return wholeSlice(e,t,r)?this:new Repeat(this._value,resolveEnd(t,r)-resolveBegin(e,r))},Repeat.prototype.reverse=function(){return this},Repeat.prototype.indexOf=function(e){return is(this._value,e)?0:-1},Repeat.prototype.lastIndexOf=function(e){return is(this._value,e)?this.size:-1},Repeat.prototype.__iterate=function(e,t){for(var r=0;r=0&&t=0&&rr?iteratorDone():iteratorValue(e,o++,a)}))},Range.prototype.equals=function(e){return e instanceof Range?this._start===e._start&&this._end===e._end&&this._step===e._step:deepEqual(this,e)},createClass(Collection,Iterable),createClass(KeyedCollection,Collection),createClass(IndexedCollection,Collection),createClass(SetCollection,Collection),Collection.Keyed=KeyedCollection,Collection.Indexed=IndexedCollection,Collection.Set=SetCollection;var I="function"==typeof Math.imul&&-2===Math.imul(4294967295,2)?Math.imul:function imul(e,t){var r=65535&(e|=0),n=65535&(t|=0);return r*n+((e>>>16)*n+r*(t>>>16)<<16>>>0)|0};function smi(e){return e>>>1&1073741824|3221225471&e}function hash(e){if(!1===e||null==e)return 0;if("function"==typeof e.valueOf&&(!1===(e=e.valueOf())||null==e))return 0;if(!0===e)return 1;var t=typeof e;if("number"===t){if(e!=e||e===1/0)return 0;var r=0|e;for(r!==e&&(r^=4294967295*e);e>4294967295;)r^=e/=4294967295;return smi(r)}if("string"===t)return e.length>j?cachedHashString(e):hashString(e);if("function"==typeof e.hashCode)return e.hashCode();if("object"===t)return hashJSObj(e);if("function"==typeof e.toString)return hashString(e.toString());throw new Error("Value type "+t+" cannot be hashed.")}function cachedHashString(e){var t=D[e];return void 0===t&&(t=hashString(e),P===z&&(P=0,D={}),P++,D[e]=t),t}function hashString(e){for(var t=0,r=0;r0)switch(e.nodeType){case 1:return e.uniqueID;case 9:return e.documentElement&&e.documentElement.uniqueID}}var k,C="function"==typeof WeakMap;C&&(k=new WeakMap);var q=0,L="__immutablehash__";"function"==typeof Symbol&&(L=Symbol(L));var j=16,z=255,P=0,D={};function assertNotInfinite(e){invariant(e!==1/0,"Cannot perform this action with an infinite size.")}function Map(e){return null==e?emptyMap():isMap(e)&&!isOrdered(e)?e:emptyMap().withMutations((function(t){var r=KeyedIterable(e);assertNotInfinite(r.size),r.forEach((function(e,r){return t.set(r,e)}))}))}function isMap(e){return!(!e||!e[W])}createClass(Map,KeyedCollection),Map.of=function(){var t=e.call(arguments,0);return emptyMap().withMutations((function(e){for(var r=0;r=t.length)throw new Error("Missing value for key: "+t[r]);e.set(t[r],t[r+1])}}))},Map.prototype.toString=function(){return this.__toString("Map {","}")},Map.prototype.get=function(e,t){return this._root?this._root.get(0,void 0,e,t):t},Map.prototype.set=function(e,t){return updateMap(this,e,t)},Map.prototype.setIn=function(e,t){return this.updateIn(e,c,(function(){return t}))},Map.prototype.remove=function(e){return updateMap(this,e,c)},Map.prototype.deleteIn=function(e){return this.updateIn(e,(function(){return c}))},Map.prototype.update=function(e,t,r){return 1===arguments.length?e(this):this.updateIn([e],t,r)},Map.prototype.updateIn=function(e,t,r){r||(r=t,t=void 0);var n=updateInDeepMap(this,forceIterator(e),t,r);return n===c?void 0:n},Map.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):emptyMap()},Map.prototype.merge=function(){return mergeIntoMapWith(this,void 0,arguments)},Map.prototype.mergeWith=function(t){return mergeIntoMapWith(this,t,e.call(arguments,1))},Map.prototype.mergeIn=function(t){var r=e.call(arguments,1);return this.updateIn(t,emptyMap(),(function(e){return"function"==typeof e.merge?e.merge.apply(e,r):r[r.length-1]}))},Map.prototype.mergeDeep=function(){return mergeIntoMapWith(this,deepMerger,arguments)},Map.prototype.mergeDeepWith=function(t){var r=e.call(arguments,1);return mergeIntoMapWith(this,deepMergerWith(t),r)},Map.prototype.mergeDeepIn=function(t){var r=e.call(arguments,1);return this.updateIn(t,emptyMap(),(function(e){return"function"==typeof e.mergeDeep?e.mergeDeep.apply(e,r):r[r.length-1]}))},Map.prototype.sort=function(e){return OrderedMap(sortFactory(this,e))},Map.prototype.sortBy=function(e,t){return OrderedMap(sortFactory(this,t,e))},Map.prototype.withMutations=function(e){var t=this.asMutable();return e(t),t.wasAltered()?t.__ensureOwner(this.__ownerID):this},Map.prototype.asMutable=function(){return this.__ownerID?this:this.__ensureOwner(new OwnerID)},Map.prototype.asImmutable=function(){return this.__ensureOwner()},Map.prototype.wasAltered=function(){return this.__altered},Map.prototype.__iterator=function(e,t){return new MapIterator(this,e,t)},Map.prototype.__iterate=function(e,t){var r=this,n=0;return this._root&&this._root.iterate((function(t){return n++,e(t[1],t[0],r)}),t),n},Map.prototype.__ensureOwner=function(e){return e===this.__ownerID?this:e?makeMap(this.size,this._root,e,this.__hash):(this.__ownerID=e,this.__altered=!1,this)},Map.isMap=isMap;var U,W="@@__IMMUTABLE_MAP__@@",K=Map.prototype;function ArrayMapNode(e,t){this.ownerID=e,this.entries=t}function BitmapIndexedNode(e,t,r){this.ownerID=e,this.bitmap=t,this.nodes=r}function HashArrayMapNode(e,t,r){this.ownerID=e,this.count=t,this.nodes=r}function HashCollisionNode(e,t,r){this.ownerID=e,this.keyHash=t,this.entries=r}function ValueNode(e,t,r){this.ownerID=e,this.keyHash=t,this.entry=r}function MapIterator(e,t,r){this._type=t,this._reverse=r,this._stack=e._root&&mapIteratorFrame(e._root)}function mapIteratorValue(e,t){return iteratorValue(e,t[0],t[1])}function mapIteratorFrame(e,t){return{node:e,index:0,__prev:t}}function makeMap(e,t,r,n){var i=Object.create(K);return i.size=e,i._root=t,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function emptyMap(){return U||(U=makeMap(0))}function updateMap(e,t,r){var n,i;if(e._root){var o=MakeRef(f),a=MakeRef(l);if(n=updateNode(e._root,e.__ownerID,0,void 0,t,r,o,a),!a.value)return e;i=e.size+(o.value?r===c?-1:1:0)}else{if(r===c)return e;i=1,n=new ArrayMapNode(e.__ownerID,[[t,r]])}return e.__ownerID?(e.size=i,e._root=n,e.__hash=void 0,e.__altered=!0,e):n?makeMap(i,n):emptyMap()}function updateNode(e,t,r,n,i,o,a,s){return e?e.update(t,r,n,i,o,a,s):o===c?e:(SetRef(s),SetRef(a),new ValueNode(t,n,[i,o]))}function isLeafNode(e){return e.constructor===ValueNode||e.constructor===HashCollisionNode}function mergeIntoNode(e,t,r,n,i){if(e.keyHash===n)return new HashCollisionNode(t,n,[e.entry,i]);var o,s=(0===r?e.keyHash:e.keyHash>>>r)&u,c=(0===r?n:n>>>r)&u;return new BitmapIndexedNode(t,1<>>=1)a[u]=1&r?t[o++]:void 0;return a[n]=i,new HashArrayMapNode(e,o+1,a)}function mergeIntoMapWith(e,t,r){for(var n=[],i=0;i>1&1431655765))+(e>>2&858993459))+(e>>4)&252645135,e+=e>>8,127&(e+=e>>16)}function setIn(e,t,r,n){var i=n?e:arrCopy(e);return i[t]=r,i}function spliceIn(e,t,r,n){var i=e.length+1;if(n&&t+1===i)return e[t]=r,e;for(var o=new Array(i),a=0,s=0;s=V)return createNodes(e,u,n,i);var p=e&&e===this.ownerID,d=p?u:arrCopy(u);return h?s?f===l-1?d.pop():d[f]=d.pop():d[f]=[n,i]:d.push([n,i]),p?(this.entries=d,this):new ArrayMapNode(e,d)}},BitmapIndexedNode.prototype.get=function(e,t,r,n){void 0===t&&(t=hash(r));var i=1<<((0===e?t:t>>>e)&u),o=this.bitmap;return o&i?this.nodes[popCount(o&i-1)].get(e+a,t,r,n):n},BitmapIndexedNode.prototype.update=function(e,t,r,n,i,o,s){void 0===r&&(r=hash(n));var f=(0===t?r:r>>>t)&u,l=1<=$)return expandNodes(e,_,h,f,m);if(p&&!m&&2===_.length&&isLeafNode(_[1^d]))return _[1^d];if(p&&m&&1===_.length&&isLeafNode(m))return m;var g=e&&e===this.ownerID,v=p?m?h:h^l:h|l,b=p?m?setIn(_,d,m,g):spliceOut(_,d,g):spliceIn(_,d,m,g);return g?(this.bitmap=v,this.nodes=b,this):new BitmapIndexedNode(e,v,b)},HashArrayMapNode.prototype.get=function(e,t,r,n){void 0===t&&(t=hash(r));var i=(0===e?t:t>>>e)&u,o=this.nodes[i];return o?o.get(e+a,t,r,n):n},HashArrayMapNode.prototype.update=function(e,t,r,n,i,o,s){void 0===r&&(r=hash(n));var f=(0===t?r:r>>>t)&u,l=i===c,h=this.nodes,p=h[f];if(l&&!p)return this;var d=updateNode(p,e,t+a,r,n,i,o,s);if(d===p)return this;var _=this.count;if(p){if(!d&&--_0&&n=0&&e>>t&u;if(n>=this.array.length)return new VNode([],e);var i,o=0===n;if(t>0){var s=this.array[n];if((i=s&&s.removeBefore(e,t-a,r))===s&&o)return this}if(o&&!i)return this;var c=editableVNode(this,e);if(!o)for(var f=0;f>>t&u;if(i>=this.array.length)return this;if(t>0){var o=this.array[i];if((n=o&&o.removeAfter(e,t-a,r))===o&&i===this.array.length-1)return this}var s=editableVNode(this,e);return s.array.splice(i+1),n&&(s.array[i]=n),s};var J,ee,te={};function iterateList(e,t){var r=e._origin,n=e._capacity,i=getTailOffset(n),o=e._tail;return iterateNodeOrLeaf(e._root,e._level,0);function iterateNodeOrLeaf(e,t,r){return 0===t?iterateLeaf(e,r):iterateNode(e,t,r)}function iterateLeaf(e,a){var u=a===i?o&&o.array:e&&e.array,c=a>r?0:r-a,f=n-a;return f>s&&(f=s),function(){if(c===f)return te;var e=t?--f:c++;return u&&u[e]}}function iterateNode(e,i,o){var u,c=e&&e.array,f=o>r?0:r-o>>i,l=1+(n-o>>i);return l>s&&(l=s),function(){for(;;){if(u){var e=u();if(e!==te)return e;u=null}if(f===l)return te;var r=t?--l:f++;u=iterateNodeOrLeaf(c&&c[r],i-a,o+(r<=e.size||t<0)return e.withMutations((function(e){t<0?setListBounds(e,t).set(0,r):setListBounds(e,0,t+1).set(t,r)}));t+=e._origin;var n=e._tail,i=e._root,o=MakeRef(l);return t>=getTailOffset(e._capacity)?n=updateVNode(n,e.__ownerID,0,t,r,o):i=updateVNode(i,e.__ownerID,e._level,t,r,o),o.value?e.__ownerID?(e._root=i,e._tail=n,e.__hash=void 0,e.__altered=!0,e):makeList(e._origin,e._capacity,e._level,i,n):e}function updateVNode(e,t,r,n,i,o){var s,c=n>>>r&u,f=e&&c0){var l=e&&e.array[c],h=updateVNode(l,t,r-a,n,i,o);return h===l?e:((s=editableVNode(e,t)).array[c]=h,s)}return f&&e.array[c]===i?e:(SetRef(o),s=editableVNode(e,t),void 0===i&&c===s.array.length-1?s.array.pop():s.array[c]=i,s)}function editableVNode(e,t){return t&&e&&t===e.ownerID?e:new VNode(e?e.array.slice():[],t)}function listNodeFor(e,t){if(t>=getTailOffset(e._capacity))return e._tail;if(t<1<0;)r=r.array[t>>>n&u],n-=a;return r}}function setListBounds(e,t,r){void 0!==t&&(t|=0),void 0!==r&&(r|=0);var n=e.__ownerID||new OwnerID,i=e._origin,o=e._capacity,s=i+t,c=void 0===r?o:r<0?o+r:i+r;if(s===i&&c===o)return e;if(s>=c)return e.clear();for(var f=e._level,l=e._root,h=0;s+h<0;)l=new VNode(l&&l.array.length?[void 0,l]:[],n),h+=1<<(f+=a);h&&(s+=h,i+=h,c+=h,o+=h);for(var p=getTailOffset(o),d=getTailOffset(c);d>=1<p?new VNode([],n):_;if(_&&d>p&&sa;g-=a){var v=p>>>g&u;m=m.array[v]=editableVNode(m.array[v],n)}m.array[p>>>a&u]=_}if(c=d)s-=d,c-=d,f=a,l=null,y=y&&y.removeBefore(n,0,s);else if(s>i||d>>f&u;if(b!==d>>>f&u)break;b&&(h+=(1<i&&(l=l.removeBefore(n,f,s-h)),l&&di&&(i=s.size),isIterable(a)||(s=s.map((function(e){return fromJS(e)}))),n.push(s)}return i>e.size&&(e=e.setSize(i)),mergeIntoCollectionWith(e,t,n)}function getTailOffset(e){return e>>a<=s&&a.size>=2*o.size?(n=(i=a.filter((function(e,t){return void 0!==e&&u!==t}))).toKeyedSeq().map((function(e){return e[0]})).flip().toMap(),e.__ownerID&&(n.__ownerID=i.__ownerID=e.__ownerID)):(n=o.remove(t),i=u===a.size-1?a.pop():a.set(u,void 0))}else if(f){if(r===a.get(u)[1])return e;n=o,i=a.set(u,[t,r])}else n=o.set(t,a.size),i=a.set(a.size,[t,r]);return e.__ownerID?(e.size=n.size,e._map=n,e._list=i,e.__hash=void 0,e):makeOrderedMap(n,i)}function ToKeyedSequence(e,t){this._iter=e,this._useKeys=t,this.size=e.size}function ToIndexedSequence(e){this._iter=e,this.size=e.size}function ToSetSequence(e){this._iter=e,this.size=e.size}function FromEntriesSequence(e){this._iter=e,this.size=e.size}function flipFactory(e){var t=makeSequence(e);return t._iter=e,t.size=e.size,t.flip=function(){return e},t.reverse=function(){var t=e.reverse.apply(this);return t.flip=function(){return e.reverse()},t},t.has=function(t){return e.includes(t)},t.includes=function(t){return e.has(t)},t.cacheResult=cacheResultThrough,t.__iterateUncached=function(t,r){var n=this;return e.__iterate((function(e,r){return!1!==t(r,e,n)}),r)},t.__iteratorUncached=function(t,r){if(t===d){var n=e.__iterator(t,r);return new Iterator((function(){var e=n.next();if(!e.done){var t=e.value[0];e.value[0]=e.value[1],e.value[1]=t}return e}))}return e.__iterator(t===p?h:p,r)},t}function mapFactory(e,t,r){var n=makeSequence(e);return n.size=e.size,n.has=function(t){return e.has(t)},n.get=function(n,i){var o=e.get(n,c);return o===c?i:t.call(r,o,n,e)},n.__iterateUncached=function(n,i){var o=this;return e.__iterate((function(e,i,a){return!1!==n(t.call(r,e,i,a),i,o)}),i)},n.__iteratorUncached=function(n,i){var o=e.__iterator(d,i);return new Iterator((function(){var i=o.next();if(i.done)return i;var a=i.value,s=a[0];return iteratorValue(n,s,t.call(r,a[1],s,e),i)}))},n}function reverseFactory(e,t){var r=makeSequence(e);return r._iter=e,r.size=e.size,r.reverse=function(){return e},e.flip&&(r.flip=function(){var t=flipFactory(e);return t.reverse=function(){return e.flip()},t}),r.get=function(r,n){return e.get(t?r:-1-r,n)},r.has=function(r){return e.has(t?r:-1-r)},r.includes=function(t){return e.includes(t)},r.cacheResult=cacheResultThrough,r.__iterate=function(t,r){var n=this;return e.__iterate((function(e,r){return t(e,r,n)}),!r)},r.__iterator=function(t,r){return e.__iterator(t,!r)},r}function filterFactory(e,t,r,n){var i=makeSequence(e);return n&&(i.has=function(n){var i=e.get(n,c);return i!==c&&!!t.call(r,i,n,e)},i.get=function(n,i){var o=e.get(n,c);return o!==c&&t.call(r,o,n,e)?o:i}),i.__iterateUncached=function(i,o){var a=this,s=0;return e.__iterate((function(e,o,u){if(t.call(r,e,o,u))return s++,i(e,n?o:s-1,a)}),o),s},i.__iteratorUncached=function(i,o){var a=e.__iterator(d,o),s=0;return new Iterator((function(){for(;;){var o=a.next();if(o.done)return o;var u=o.value,c=u[0],f=u[1];if(t.call(r,f,c,e))return iteratorValue(i,n?c:s++,f,o)}}))},i}function countByFactory(e,t,r){var n=Map().asMutable();return e.__iterate((function(i,o){n.update(t.call(r,i,o,e),0,(function(e){return e+1}))})),n.asImmutable()}function groupByFactory(e,t,r){var n=isKeyed(e),i=(isOrdered(e)?OrderedMap():Map()).asMutable();e.__iterate((function(o,a){i.update(t.call(r,o,a,e),(function(e){return(e=e||[]).push(n?[a,o]:o),e}))}));var o=iterableClass(e);return i.map((function(t){return reify(e,o(t))}))}function sliceFactory(e,t,r,n){var i=e.size;if(void 0!==t&&(t|=0),void 0!==r&&(r===1/0?r=i:r|=0),wholeSlice(t,r,i))return e;var o=resolveBegin(t,i),a=resolveEnd(r,i);if(o!=o||a!=a)return sliceFactory(e.toSeq().cacheResult(),t,r,n);var s,u=a-o;u==u&&(s=u<0?0:u);var c=makeSequence(e);return c.size=0===s?s:e.size&&s||void 0,!n&&isSeq(e)&&s>=0&&(c.get=function(t,r){return(t=wrapIndex(this,t))>=0&&ts)return iteratorDone();var e=i.next();return n||t===p?e:iteratorValue(t,u-1,t===h?void 0:e.value[1],e)}))},c}function takeWhileFactory(e,t,r){var n=makeSequence(e);return n.__iterateUncached=function(n,i){var o=this;if(i)return this.cacheResult().__iterate(n,i);var a=0;return e.__iterate((function(e,i,s){return t.call(r,e,i,s)&&++a&&n(e,i,o)})),a},n.__iteratorUncached=function(n,i){var o=this;if(i)return this.cacheResult().__iterator(n,i);var a=e.__iterator(d,i),s=!0;return new Iterator((function(){if(!s)return iteratorDone();var e=a.next();if(e.done)return e;var i=e.value,u=i[0],c=i[1];return t.call(r,c,u,o)?n===d?e:iteratorValue(n,u,c,e):(s=!1,iteratorDone())}))},n}function skipWhileFactory(e,t,r,n){var i=makeSequence(e);return i.__iterateUncached=function(i,o){var a=this;if(o)return this.cacheResult().__iterate(i,o);var s=!0,u=0;return e.__iterate((function(e,o,c){if(!s||!(s=t.call(r,e,o,c)))return u++,i(e,n?o:u-1,a)})),u},i.__iteratorUncached=function(i,o){var a=this;if(o)return this.cacheResult().__iterator(i,o);var s=e.__iterator(d,o),u=!0,c=0;return new Iterator((function(){var e,o,f;do{if((e=s.next()).done)return n||i===p?e:iteratorValue(i,c++,i===h?void 0:e.value[1],e);var l=e.value;o=l[0],f=l[1],u&&(u=t.call(r,f,o,a))}while(u);return i===d?e:iteratorValue(i,o,f,e)}))},i}function concatFactory(e,t){var r=isKeyed(e),n=[e].concat(t).map((function(e){return isIterable(e)?r&&(e=KeyedIterable(e)):e=r?keyedSeqFromValue(e):indexedSeqFromValue(Array.isArray(e)?e:[e]),e})).filter((function(e){return 0!==e.size}));if(0===n.length)return e;if(1===n.length){var i=n[0];if(i===e||r&&isKeyed(i)||isIndexed(e)&&isIndexed(i))return i}var o=new ArraySeq(n);return r?o=o.toKeyedSeq():isIndexed(e)||(o=o.toSetSeq()),(o=o.flatten(!0)).size=n.reduce((function(e,t){if(void 0!==e){var r=t.size;if(void 0!==r)return e+r}}),0),o}function flattenFactory(e,t,r){var n=makeSequence(e);return n.__iterateUncached=function(n,i){var o=0,a=!1;function flatDeep(e,s){var u=this;e.__iterate((function(e,i){return(!t||s0}function zipWithFactory(e,t,r){var n=makeSequence(e);return n.size=new ArraySeq(r).map((function(e){return e.size})).min(),n.__iterate=function(e,t){for(var r,n=this.__iterator(p,t),i=0;!(r=n.next()).done&&!1!==e(r.value,i++,this););return i},n.__iteratorUncached=function(e,n){var i=r.map((function(e){return e=Iterable(e),getIterator(n?e.reverse():e)})),o=0,a=!1;return new Iterator((function(){var r;return a||(r=i.map((function(e){return e.next()})),a=r.some((function(e){return e.done}))),a?iteratorDone():iteratorValue(e,o++,t.apply(null,r.map((function(e){return e.value}))))}))},n}function reify(e,t){return isSeq(e)?t:e.constructor(t)}function validateEntry(e){if(e!==Object(e))throw new TypeError("Expected [K, V] tuple: "+e)}function resolveSize(e){return assertNotInfinite(e.size),ensureSize(e)}function iterableClass(e){return isKeyed(e)?KeyedIterable:isIndexed(e)?IndexedIterable:SetIterable}function makeSequence(e){return Object.create((isKeyed(e)?KeyedSeq:isIndexed(e)?IndexedSeq:SetSeq).prototype)}function cacheResultThrough(){return this._iter.cacheResult?(this._iter.cacheResult(),this.size=this._iter.size,this):Seq.prototype.cacheResult.call(this)}function defaultComparator(e,t){return e>t?1:e=0;r--)t={value:arguments[r],next:t};return this.__ownerID?(this.size=e,this._head=t,this.__hash=void 0,this.__altered=!0,this):makeStack(e,t)},Stack.prototype.pushAll=function(e){if(0===(e=IndexedIterable(e)).size)return this;assertNotInfinite(e.size);var t=this.size,r=this._head;return e.reverse().forEach((function(e){t++,r={value:e,next:r}})),this.__ownerID?(this.size=t,this._head=r,this.__hash=void 0,this.__altered=!0,this):makeStack(t,r)},Stack.prototype.pop=function(){return this.slice(1)},Stack.prototype.unshift=function(){return this.push.apply(this,arguments)},Stack.prototype.unshiftAll=function(e){return this.pushAll(e)},Stack.prototype.shift=function(){return this.pop.apply(this,arguments)},Stack.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):emptyStack()},Stack.prototype.slice=function(e,t){if(wholeSlice(e,t,this.size))return this;var r=resolveBegin(e,this.size);if(resolveEnd(t,this.size)!==this.size)return IndexedCollection.prototype.slice.call(this,e,t);for(var n=this.size-r,i=this._head;r--;)i=i.next;return this.__ownerID?(this.size=n,this._head=i,this.__hash=void 0,this.__altered=!0,this):makeStack(n,i)},Stack.prototype.__ensureOwner=function(e){return e===this.__ownerID?this:e?makeStack(this.size,this._head,e,this.__hash):(this.__ownerID=e,this.__altered=!1,this)},Stack.prototype.__iterate=function(e,t){if(t)return this.reverse().__iterate(e);for(var r=0,n=this._head;n&&!1!==e(n.value,r++,this);)n=n.next;return r},Stack.prototype.__iterator=function(e,t){if(t)return this.reverse().__iterator(e);var r=0,n=this._head;return new Iterator((function(){if(n){var t=n.value;return n=n.next,iteratorValue(e,r++,t)}return iteratorDone()}))},Stack.isStack=isStack;var ue,ce="@@__IMMUTABLE_STACK__@@",fe=Stack.prototype;function makeStack(e,t,r,n){var i=Object.create(fe);return i.size=e,i._head=t,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function emptyStack(){return ue||(ue=makeStack(0))}function mixin(e,t){var keyCopier=function(r){e.prototype[r]=t[r]};return Object.keys(t).forEach(keyCopier),Object.getOwnPropertySymbols&&Object.getOwnPropertySymbols(t).forEach(keyCopier),e}fe[ce]=!0,fe.withMutations=K.withMutations,fe.asMutable=K.asMutable,fe.asImmutable=K.asImmutable,fe.wasAltered=K.wasAltered,Iterable.Iterator=Iterator,mixin(Iterable,{toArray:function(){assertNotInfinite(this.size);var e=new Array(this.size||0);return this.valueSeq().__iterate((function(t,r){e[r]=t})),e},toIndexedSeq:function(){return new ToIndexedSequence(this)},toJS:function(){return this.toSeq().map((function(e){return e&&"function"==typeof e.toJS?e.toJS():e})).__toJS()},toJSON:function(){return this.toSeq().map((function(e){return e&&"function"==typeof e.toJSON?e.toJSON():e})).__toJS()},toKeyedSeq:function(){return new ToKeyedSequence(this,!0)},toMap:function(){return Map(this.toKeyedSeq())},toObject:function(){assertNotInfinite(this.size);var e={};return this.__iterate((function(t,r){e[r]=t})),e},toOrderedMap:function(){return OrderedMap(this.toKeyedSeq())},toOrderedSet:function(){return OrderedSet(isKeyed(this)?this.valueSeq():this)},toSet:function(){return Set(isKeyed(this)?this.valueSeq():this)},toSetSeq:function(){return new ToSetSequence(this)},toSeq:function(){return isIndexed(this)?this.toIndexedSeq():isKeyed(this)?this.toKeyedSeq():this.toSetSeq()},toStack:function(){return Stack(isKeyed(this)?this.valueSeq():this)},toList:function(){return List(isKeyed(this)?this.valueSeq():this)},toString:function(){return"[Iterable]"},__toString:function(e,t){return 0===this.size?e+t:e+" "+this.toSeq().map(this.__toStringMapper).join(", ")+" "+t},concat:function(){return reify(this,concatFactory(this,e.call(arguments,0)))},includes:function(e){return this.some((function(t){return is(t,e)}))},entries:function(){return this.__iterator(d)},every:function(e,t){assertNotInfinite(this.size);var r=!0;return this.__iterate((function(n,i,o){if(!e.call(t,n,i,o))return r=!1,!1})),r},filter:function(e,t){return reify(this,filterFactory(this,e,t,!0))},find:function(e,t,r){var n=this.findEntry(e,t);return n?n[1]:r},forEach:function(e,t){return assertNotInfinite(this.size),this.__iterate(t?e.bind(t):e)},join:function(e){assertNotInfinite(this.size),e=void 0!==e?""+e:",";var t="",r=!0;return this.__iterate((function(n){r?r=!1:t+=e,t+=null!=n?n.toString():""})),t},keys:function(){return this.__iterator(h)},map:function(e,t){return reify(this,mapFactory(this,e,t))},reduce:function(e,t,r){var n,i;return assertNotInfinite(this.size),arguments.length<2?i=!0:n=t,this.__iterate((function(t,o,a){i?(i=!1,n=t):n=e.call(r,n,t,o,a)})),n},reduceRight:function(e,t,r){var n=this.toKeyedSeq().reverse();return n.reduce.apply(n,arguments)},reverse:function(){return reify(this,reverseFactory(this,!0))},slice:function(e,t){return reify(this,sliceFactory(this,e,t,!0))},some:function(e,t){return!this.every(not(e),t)},sort:function(e){return reify(this,sortFactory(this,e))},values:function(){return this.__iterator(p)},butLast:function(){return this.slice(0,-1)},isEmpty:function(){return void 0!==this.size?0===this.size:!this.some((function(){return!0}))},count:function(e,t){return ensureSize(e?this.toSeq().filter(e,t):this)},countBy:function(e,t){return countByFactory(this,e,t)},equals:function(e){return deepEqual(this,e)},entrySeq:function(){var e=this;if(e._cache)return new ArraySeq(e._cache);var t=e.toSeq().map(entryMapper).toIndexedSeq();return t.fromEntrySeq=function(){return e.toSeq()},t},filterNot:function(e,t){return this.filter(not(e),t)},findEntry:function(e,t,r){var n=r;return this.__iterate((function(r,i,o){if(e.call(t,r,i,o))return n=[i,r],!1})),n},findKey:function(e,t){var r=this.findEntry(e,t);return r&&r[0]},findLast:function(e,t,r){return this.toKeyedSeq().reverse().find(e,t,r)},findLastEntry:function(e,t,r){return this.toKeyedSeq().reverse().findEntry(e,t,r)},findLastKey:function(e,t){return this.toKeyedSeq().reverse().findKey(e,t)},first:function(){return this.find(returnTrue)},flatMap:function(e,t){return reify(this,flatMapFactory(this,e,t))},flatten:function(e){return reify(this,flattenFactory(this,e,!0))},fromEntrySeq:function(){return new FromEntriesSequence(this)},get:function(e,t){return this.find((function(t,r){return is(r,e)}),void 0,t)},getIn:function(e,t){for(var r,n=this,i=forceIterator(e);!(r=i.next()).done;){var o=r.value;if((n=n&&n.get?n.get(o,c):c)===c)return t}return n},groupBy:function(e,t){return groupByFactory(this,e,t)},has:function(e){return this.get(e,c)!==c},hasIn:function(e){return this.getIn(e,c)!==c},isSubset:function(e){return e="function"==typeof e.includes?e:Iterable(e),this.every((function(t){return e.includes(t)}))},isSuperset:function(e){return(e="function"==typeof e.isSubset?e:Iterable(e)).isSubset(this)},keyOf:function(e){return this.findKey((function(t){return is(t,e)}))},keySeq:function(){return this.toSeq().map(keyMapper).toIndexedSeq()},last:function(){return this.toSeq().reverse().first()},lastKeyOf:function(e){return this.toKeyedSeq().reverse().keyOf(e)},max:function(e){return maxFactory(this,e)},maxBy:function(e,t){return maxFactory(this,t,e)},min:function(e){return maxFactory(this,e?neg(e):defaultNegComparator)},minBy:function(e,t){return maxFactory(this,t?neg(t):defaultNegComparator,e)},rest:function(){return this.slice(1)},skip:function(e){return this.slice(Math.max(0,e))},skipLast:function(e){return reify(this,this.toSeq().reverse().skip(e).reverse())},skipWhile:function(e,t){return reify(this,skipWhileFactory(this,e,t,!0))},skipUntil:function(e,t){return this.skipWhile(not(e),t)},sortBy:function(e,t){return reify(this,sortFactory(this,t,e))},take:function(e){return this.slice(0,Math.max(0,e))},takeLast:function(e){return reify(this,this.toSeq().reverse().take(e).reverse())},takeWhile:function(e,t){return reify(this,takeWhileFactory(this,e,t))},takeUntil:function(e,t){return this.takeWhile(not(e),t)},valueSeq:function(){return this.toIndexedSeq()},hashCode:function(){return this.__hash||(this.__hash=hashIterable(this))}});var le=Iterable.prototype;le[t]=!0,le[m]=le.values,le.__toJS=le.toArray,le.__toStringMapper=quoteString,le.inspect=le.toSource=function(){return this.toString()},le.chain=le.flatMap,le.contains=le.includes,mixin(KeyedIterable,{flip:function(){return reify(this,flipFactory(this))},mapEntries:function(e,t){var r=this,n=0;return reify(this,this.toSeq().map((function(i,o){return e.call(t,[o,i],n++,r)})).fromEntrySeq())},mapKeys:function(e,t){var r=this;return reify(this,this.toSeq().flip().map((function(n,i){return e.call(t,n,i,r)})).flip())}});var he=KeyedIterable.prototype;function keyMapper(e,t){return t}function entryMapper(e,t){return[t,e]}function not(e){return function(){return!e.apply(this,arguments)}}function neg(e){return function(){return-e.apply(this,arguments)}}function quoteString(e){return"string"==typeof e?JSON.stringify(e):String(e)}function defaultZipper(){return arrCopy(arguments)}function defaultNegComparator(e,t){return et?-1:0}function hashIterable(e){if(e.size===1/0)return 0;var t=isOrdered(e),r=isKeyed(e),n=t?1:0;return murmurHashOfSize(e.__iterate(r?t?function(e,t){n=31*n+hashMerge(hash(e),hash(t))|0}:function(e,t){n=n+hashMerge(hash(e),hash(t))|0}:t?function(e){n=31*n+hash(e)|0}:function(e){n=n+hash(e)|0}),n)}function murmurHashOfSize(e,t){return t=I(t,3432918353),t=I(t<<15|t>>>-15,461845907),t=I(t<<13|t>>>-13,5),t=I((t=t+3864292196^e)^t>>>16,2246822507),t=smi((t=I(t^t>>>13,3266489909))^t>>>16)}function hashMerge(e,t){return e^t+2654435769+(e<<6)+(e>>2)}return he[r]=!0,he[m]=le.entries,he.__toJS=le.toObject,he.__toStringMapper=function(e,t){return JSON.stringify(t)+": "+quoteString(e)},mixin(IndexedIterable,{toKeyedSeq:function(){return new ToKeyedSequence(this,!1)},filter:function(e,t){return reify(this,filterFactory(this,e,t,!1))},findIndex:function(e,t){var r=this.findEntry(e,t);return r?r[0]:-1},indexOf:function(e){var t=this.keyOf(e);return void 0===t?-1:t},lastIndexOf:function(e){var t=this.lastKeyOf(e);return void 0===t?-1:t},reverse:function(){return reify(this,reverseFactory(this,!1))},slice:function(e,t){return reify(this,sliceFactory(this,e,t,!1))},splice:function(e,t){var r=arguments.length;if(t=Math.max(0|t,0),0===r||2===r&&!t)return this;e=resolveBegin(e,e<0?this.count():this.size);var n=this.slice(0,e);return reify(this,1===r?n:n.concat(arrCopy(arguments,2),this.slice(e+t)))},findLastIndex:function(e,t){var r=this.findLastEntry(e,t);return r?r[0]:-1},first:function(){return this.get(0)},flatten:function(e){return reify(this,flattenFactory(this,e,!1))},get:function(e,t){return(e=wrapIndex(this,e))<0||this.size===1/0||void 0!==this.size&&e>this.size?t:this.find((function(t,r){return r===e}),void 0,t)},has:function(e){return(e=wrapIndex(this,e))>=0&&(void 0!==this.size?this.size===1/0||e{"function"==typeof Object.create?e.exports=function inherits(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:e.exports=function inherits(e,t){if(t){e.super_=t;var TempCtor=function(){};TempCtor.prototype=t.prototype,e.prototype=new TempCtor,e.prototype.constructor=e}}},5580:(e,t,r)=>{var n=r(6110)(r(9325),"DataView");e.exports=n},1549:(e,t,r)=>{var n=r(2032),i=r(3862),o=r(6721),a=r(2749),s=r(5749);function Hash(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t{var n=r(3702),i=r(80),o=r(4739),a=r(8655),s=r(1175);function ListCache(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t{var n=r(6110)(r(9325),"Map");e.exports=n},3661:(e,t,r)=>{var n=r(3040),i=r(7670),o=r(289),a=r(4509),s=r(2949);function MapCache(e){var t=-1,r=null==e?0:e.length;for(this.clear();++t{var n=r(6110)(r(9325),"Promise");e.exports=n},6545:(e,t,r)=>{var n=r(6110)(r(9325),"Set");e.exports=n},8859:(e,t,r)=>{var n=r(3661),i=r(1380),o=r(1459);function SetCache(e){var t=-1,r=null==e?0:e.length;for(this.__data__=new n;++t{var n=r(79),i=r(1420),o=r(938),a=r(3605),s=r(9817),u=r(945);function Stack(e){var t=this.__data__=new n(e);this.size=t.size}Stack.prototype.clear=i,Stack.prototype.delete=o,Stack.prototype.get=a,Stack.prototype.has=s,Stack.prototype.set=u,e.exports=Stack},1873:(e,t,r)=>{var n=r(9325).Symbol;e.exports=n},7828:(e,t,r)=>{var n=r(9325).Uint8Array;e.exports=n},8303:(e,t,r)=>{var n=r(6110)(r(9325),"WeakMap");e.exports=n},9770:e=>{e.exports=function arrayFilter(e,t){for(var r=-1,n=null==e?0:e.length,i=0,o=[];++r{var n=r(8096),i=r(2428),o=r(6449),a=r(3656),s=r(361),u=r(7167),c=Object.prototype.hasOwnProperty;e.exports=function arrayLikeKeys(e,t){var r=o(e),f=!r&&i(e),l=!r&&!f&&a(e),h=!r&&!f&&!l&&u(e),p=r||f||l||h,d=p?n(e.length,String):[],_=d.length;for(var y in e)!t&&!c.call(e,y)||p&&("length"==y||l&&("offset"==y||"parent"==y)||h&&("buffer"==y||"byteLength"==y||"byteOffset"==y)||s(y,_))||d.push(y);return d}},4932:e=>{e.exports=function arrayMap(e,t){for(var r=-1,n=null==e?0:e.length,i=Array(n);++r{e.exports=function arrayPush(e,t){for(var r=-1,n=t.length,i=e.length;++r{e.exports=function arrayReduce(e,t,r,n){var i=-1,o=null==e?0:e.length;for(n&&o&&(r=e[++i]);++i{e.exports=function arraySome(e,t){for(var r=-1,n=null==e?0:e.length;++r{e.exports=function asciiToArray(e){return e.split("")}},1733:e=>{var t=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;e.exports=function asciiWords(e){return e.match(t)||[]}},6547:(e,t,r)=>{var n=r(3360),i=r(5288),o=Object.prototype.hasOwnProperty;e.exports=function assignValue(e,t,r){var a=e[t];o.call(e,t)&&i(a,r)&&(void 0!==r||t in e)||n(e,t,r)}},6025:(e,t,r)=>{var n=r(5288);e.exports=function assocIndexOf(e,t){for(var r=e.length;r--;)if(n(e[r][0],t))return r;return-1}},3360:(e,t,r)=>{var n=r(3243);e.exports=function baseAssignValue(e,t,r){"__proto__"==t&&n?n(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}},909:(e,t,r)=>{var n=r(641),i=r(8329)(n);e.exports=i},2523:e=>{e.exports=function baseFindIndex(e,t,r,n){for(var i=e.length,o=r+(n?1:-1);n?o--:++o{var n=r(3221)();e.exports=n},641:(e,t,r)=>{var n=r(6649),i=r(5950);e.exports=function baseForOwn(e,t){return e&&n(e,t,i)}},7422:(e,t,r)=>{var n=r(1769),i=r(7797);e.exports=function baseGet(e,t){for(var r=0,o=(t=n(t,e)).length;null!=e&&r{var n=r(4528),i=r(6449);e.exports=function baseGetAllKeys(e,t,r){var o=t(e);return i(e)?o:n(o,r(e))}},2552:(e,t,r)=>{var n=r(1873),i=r(659),o=r(9350),a=n?n.toStringTag:void 0;e.exports=function baseGetTag(e){return null==e?void 0===e?"[object Undefined]":"[object Null]":a&&a in Object(e)?i(e):o(e)}},8077:e=>{e.exports=function baseHasIn(e,t){return null!=e&&t in Object(e)}},7534:(e,t,r)=>{var n=r(2552),i=r(346);e.exports=function baseIsArguments(e){return i(e)&&"[object Arguments]"==n(e)}},270:(e,t,r)=>{var n=r(7068),i=r(346);e.exports=function baseIsEqual(e,t,r,o,a){return e===t||(null==e||null==t||!i(e)&&!i(t)?e!=e&&t!=t:n(e,t,r,o,baseIsEqual,a))}},7068:(e,t,r)=>{var n=r(7217),i=r(5911),o=r(1986),a=r(689),s=r(5861),u=r(6449),c=r(3656),f=r(7167),l="[object Arguments]",h="[object Array]",p="[object Object]",d=Object.prototype.hasOwnProperty;e.exports=function baseIsEqualDeep(e,t,r,_,y,m){var g=u(e),v=u(t),b=g?h:s(e),w=v?h:s(t),I=(b=b==l?p:b)==p,x=(w=w==l?p:w)==p,B=b==w;if(B&&c(e)){if(!c(t))return!1;g=!0,I=!1}if(B&&!I)return m||(m=new n),g||f(e)?i(e,t,r,_,y,m):o(e,t,b,r,_,y,m);if(!(1&r)){var k=I&&d.call(e,"__wrapped__"),C=x&&d.call(t,"__wrapped__");if(k||C){var q=k?e.value():e,L=C?t.value():t;return m||(m=new n),y(q,L,r,_,m)}}return!!B&&(m||(m=new n),a(e,t,r,_,y,m))}},1799:(e,t,r)=>{var n=r(7217),i=r(270);e.exports=function baseIsMatch(e,t,r,o){var a=r.length,s=a,u=!o;if(null==e)return!s;for(e=Object(e);a--;){var c=r[a];if(u&&c[2]?c[1]!==e[c[0]]:!(c[0]in e))return!1}for(;++a{var n=r(1882),i=r(7296),o=r(3805),a=r(7473),s=/^\[object .+?Constructor\]$/,u=Function.prototype,c=Object.prototype,f=u.toString,l=c.hasOwnProperty,h=RegExp("^"+f.call(l).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");e.exports=function baseIsNative(e){return!(!o(e)||i(e))&&(n(e)?h:s).test(a(e))}},4901:(e,t,r)=>{var n=r(2552),i=r(294),o=r(346),a={};a["[object Float32Array]"]=a["[object Float64Array]"]=a["[object Int8Array]"]=a["[object Int16Array]"]=a["[object Int32Array]"]=a["[object Uint8Array]"]=a["[object Uint8ClampedArray]"]=a["[object Uint16Array]"]=a["[object Uint32Array]"]=!0,a["[object Arguments]"]=a["[object Array]"]=a["[object ArrayBuffer]"]=a["[object Boolean]"]=a["[object DataView]"]=a["[object Date]"]=a["[object Error]"]=a["[object Function]"]=a["[object Map]"]=a["[object Number]"]=a["[object Object]"]=a["[object RegExp]"]=a["[object Set]"]=a["[object String]"]=a["[object WeakMap]"]=!1,e.exports=function baseIsTypedArray(e){return o(e)&&i(e.length)&&!!a[n(e)]}},5389:(e,t,r)=>{var n=r(3663),i=r(7978),o=r(3488),a=r(6449),s=r(583);e.exports=function baseIteratee(e){return"function"==typeof e?e:null==e?o:"object"==typeof e?a(e)?i(e[0],e[1]):n(e):s(e)}},8984:(e,t,r)=>{var n=r(5527),i=r(3650),o=Object.prototype.hasOwnProperty;e.exports=function baseKeys(e){if(!n(e))return i(e);var t=[];for(var r in Object(e))o.call(e,r)&&"constructor"!=r&&t.push(r);return t}},3663:(e,t,r)=>{var n=r(1799),i=r(776),o=r(7197);e.exports=function baseMatches(e){var t=i(e);return 1==t.length&&t[0][2]?o(t[0][0],t[0][1]):function(r){return r===e||n(r,e,t)}}},7978:(e,t,r)=>{var n=r(270),i=r(8156),o=r(631),a=r(8586),s=r(756),u=r(7197),c=r(7797);e.exports=function baseMatchesProperty(e,t){return a(e)&&s(t)?u(c(e),t):function(r){var a=i(r,e);return void 0===a&&a===t?o(r,e):n(t,a,3)}}},7237:e=>{e.exports=function baseProperty(e){return function(t){return null==t?void 0:t[e]}}},7255:(e,t,r)=>{var n=r(7422);e.exports=function basePropertyDeep(e){return function(t){return n(t,e)}}},4552:e=>{e.exports=function basePropertyOf(e){return function(t){return null==e?void 0:e[t]}}},5160:e=>{e.exports=function baseSlice(e,t,r){var n=-1,i=e.length;t<0&&(t=-t>i?0:i+t),(r=r>i?i:r)<0&&(r+=i),i=t>r?0:r-t>>>0,t>>>=0;for(var o=Array(i);++n{var n=r(909);e.exports=function baseSome(e,t){var r;return n(e,(function(e,n,i){return!(r=t(e,n,i))})),!!r}},8096:e=>{e.exports=function baseTimes(e,t){for(var r=-1,n=Array(e);++r{var n=r(1873),i=r(4932),o=r(6449),a=r(4394),s=n?n.prototype:void 0,u=s?s.toString:void 0;e.exports=function baseToString(e){if("string"==typeof e)return e;if(o(e))return i(e,baseToString)+"";if(a(e))return u?u.call(e):"";var t=e+"";return"0"==t&&1/e==-1/0?"-0":t}},4128:(e,t,r)=>{var n=r(1800),i=/^\s+/;e.exports=function baseTrim(e){return e?e.slice(0,n(e)+1).replace(i,""):e}},7301:e=>{e.exports=function baseUnary(e){return function(t){return e(t)}}},1234:e=>{e.exports=function baseZipObject(e,t,r){for(var n=-1,i=e.length,o=t.length,a={};++n{e.exports=function cacheHas(e,t){return e.has(t)}},1769:(e,t,r)=>{var n=r(6449),i=r(8586),o=r(1802),a=r(3222);e.exports=function castPath(e,t){return n(e)?e:i(e,t)?[e]:o(a(e))}},8754:(e,t,r)=>{var n=r(5160);e.exports=function castSlice(e,t,r){var i=e.length;return r=void 0===r?i:r,!t&&r>=i?e:n(e,t,r)}},5481:(e,t,r)=>{var n=r(9325)["__core-js_shared__"];e.exports=n},8329:(e,t,r)=>{var n=r(4894);e.exports=function createBaseEach(e,t){return function(r,i){if(null==r)return r;if(!n(r))return e(r,i);for(var o=r.length,a=t?o:-1,s=Object(r);(t?a--:++a{e.exports=function createBaseFor(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var u=a[e?s:++i];if(!1===r(o[u],u,o))break}return t}}},2507:(e,t,r)=>{var n=r(8754),i=r(9698),o=r(3912),a=r(3222);e.exports=function createCaseFirst(e){return function(t){t=a(t);var r=i(t)?o(t):void 0,s=r?r[0]:t.charAt(0),u=r?n(r,1).join(""):t.slice(1);return s[e]()+u}}},5539:(e,t,r)=>{var n=r(882),i=r(828),o=r(6645),a=RegExp("['’]","g");e.exports=function createCompounder(e){return function(t){return n(o(i(t).replace(a,"")),e,"")}}},2006:(e,t,r)=>{var n=r(5389),i=r(4894),o=r(5950);e.exports=function createFind(e){return function(t,r,a){var s=Object(t);if(!i(t)){var u=n(r,3);t=o(t),r=function(e){return u(s[e],e,s)}}var c=e(t,r,a);return c>-1?s[u?t[c]:c]:void 0}}},4647:(e,t,r)=>{var n=r(4552)({À:"A",Á:"A",Â:"A",Ã:"A",Ä:"A",Å:"A",à:"a",á:"a",â:"a",ã:"a",ä:"a",å:"a",Ç:"C",ç:"c",Ð:"D",ð:"d",È:"E",É:"E",Ê:"E",Ë:"E",è:"e",é:"e",ê:"e",ë:"e",Ì:"I",Í:"I",Î:"I",Ï:"I",ì:"i",í:"i",î:"i",ï:"i",Ñ:"N",ñ:"n",Ò:"O",Ó:"O",Ô:"O",Õ:"O",Ö:"O",Ø:"O",ò:"o",ó:"o",ô:"o",õ:"o",ö:"o",ø:"o",Ù:"U",Ú:"U",Û:"U",Ü:"U",ù:"u",ú:"u",û:"u",ü:"u",Ý:"Y",ý:"y",ÿ:"y",Æ:"Ae",æ:"ae",Þ:"Th",þ:"th",ß:"ss",Ā:"A",Ă:"A",Ą:"A",ā:"a",ă:"a",ą:"a",Ć:"C",Ĉ:"C",Ċ:"C",Č:"C",ć:"c",ĉ:"c",ċ:"c",č:"c",Ď:"D",Đ:"D",ď:"d",đ:"d",Ē:"E",Ĕ:"E",Ė:"E",Ę:"E",Ě:"E",ē:"e",ĕ:"e",ė:"e",ę:"e",ě:"e",Ĝ:"G",Ğ:"G",Ġ:"G",Ģ:"G",ĝ:"g",ğ:"g",ġ:"g",ģ:"g",Ĥ:"H",Ħ:"H",ĥ:"h",ħ:"h",Ĩ:"I",Ī:"I",Ĭ:"I",Į:"I",İ:"I",ĩ:"i",ī:"i",ĭ:"i",į:"i",ı:"i",Ĵ:"J",ĵ:"j",Ķ:"K",ķ:"k",ĸ:"k",Ĺ:"L",Ļ:"L",Ľ:"L",Ŀ:"L",Ł:"L",ĺ:"l",ļ:"l",ľ:"l",ŀ:"l",ł:"l",Ń:"N",Ņ:"N",Ň:"N",Ŋ:"N",ń:"n",ņ:"n",ň:"n",ŋ:"n",Ō:"O",Ŏ:"O",Ő:"O",ō:"o",ŏ:"o",ő:"o",Ŕ:"R",Ŗ:"R",Ř:"R",ŕ:"r",ŗ:"r",ř:"r",Ś:"S",Ŝ:"S",Ş:"S",Š:"S",ś:"s",ŝ:"s",ş:"s",š:"s",Ţ:"T",Ť:"T",Ŧ:"T",ţ:"t",ť:"t",ŧ:"t",Ũ:"U",Ū:"U",Ŭ:"U",Ů:"U",Ű:"U",Ų:"U",ũ:"u",ū:"u",ŭ:"u",ů:"u",ű:"u",ų:"u",Ŵ:"W",ŵ:"w",Ŷ:"Y",ŷ:"y",Ÿ:"Y",Ź:"Z",Ż:"Z",Ž:"Z",ź:"z",ż:"z",ž:"z",IJ:"IJ",ij:"ij",Œ:"Oe",œ:"oe",ʼn:"'n",ſ:"s"});e.exports=n},3243:(e,t,r)=>{var n=r(6110),i=function(){try{var e=n(Object,"defineProperty");return e({},"",{}),e}catch(e){}}();e.exports=i},5911:(e,t,r)=>{var n=r(8859),i=r(4248),o=r(9219);e.exports=function equalArrays(e,t,r,a,s,u){var c=1&r,f=e.length,l=t.length;if(f!=l&&!(c&&l>f))return!1;var h=u.get(e),p=u.get(t);if(h&&p)return h==t&&p==e;var d=-1,_=!0,y=2&r?new n:void 0;for(u.set(e,t),u.set(t,e);++d{var n=r(1873),i=r(7828),o=r(5288),a=r(5911),s=r(317),u=r(4247),c=n?n.prototype:void 0,f=c?c.valueOf:void 0;e.exports=function equalByTag(e,t,r,n,c,l,h){switch(r){case"[object DataView]":if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case"[object ArrayBuffer]":return!(e.byteLength!=t.byteLength||!l(new i(e),new i(t)));case"[object Boolean]":case"[object Date]":case"[object Number]":return o(+e,+t);case"[object Error]":return e.name==t.name&&e.message==t.message;case"[object RegExp]":case"[object String]":return e==t+"";case"[object Map]":var p=s;case"[object Set]":var d=1&n;if(p||(p=u),e.size!=t.size&&!d)return!1;var _=h.get(e);if(_)return _==t;n|=2,h.set(e,t);var y=a(p(e),p(t),n,c,l,h);return h.delete(e),y;case"[object Symbol]":if(f)return f.call(e)==f.call(t)}return!1}},689:(e,t,r)=>{var n=r(2),i=Object.prototype.hasOwnProperty;e.exports=function equalObjects(e,t,r,o,a,s){var u=1&r,c=n(e),f=c.length;if(f!=n(t).length&&!u)return!1;for(var l=f;l--;){var h=c[l];if(!(u?h in t:i.call(t,h)))return!1}var p=s.get(e),d=s.get(t);if(p&&d)return p==t&&d==e;var _=!0;s.set(e,t),s.set(t,e);for(var y=u;++l{var n="object"==typeof r.g&&r.g&&r.g.Object===Object&&r.g;e.exports=n},2:(e,t,r)=>{var n=r(2199),i=r(4664),o=r(5950);e.exports=function getAllKeys(e){return n(e,o,i)}},2651:(e,t,r)=>{var n=r(4218);e.exports=function getMapData(e,t){var r=e.__data__;return n(t)?r["string"==typeof t?"string":"hash"]:r.map}},776:(e,t,r)=>{var n=r(756),i=r(5950);e.exports=function getMatchData(e){for(var t=i(e),r=t.length;r--;){var o=t[r],a=e[o];t[r]=[o,a,n(a)]}return t}},6110:(e,t,r)=>{var n=r(5083),i=r(392);e.exports=function getNative(e,t){var r=i(e,t);return n(r)?r:void 0}},659:(e,t,r)=>{var n=r(1873),i=Object.prototype,o=i.hasOwnProperty,a=i.toString,s=n?n.toStringTag:void 0;e.exports=function getRawTag(e){var t=o.call(e,s),r=e[s];try{e[s]=void 0;var n=!0}catch(e){}var i=a.call(e);return n&&(t?e[s]=r:delete e[s]),i}},4664:(e,t,r)=>{var n=r(9770),i=r(3345),o=Object.prototype.propertyIsEnumerable,a=Object.getOwnPropertySymbols,s=a?function(e){return null==e?[]:(e=Object(e),n(a(e),(function(t){return o.call(e,t)})))}:i;e.exports=s},5861:(e,t,r)=>{var n=r(5580),i=r(8223),o=r(2804),a=r(6545),s=r(8303),u=r(2552),c=r(7473),f="[object Map]",l="[object Promise]",h="[object Set]",p="[object WeakMap]",d="[object DataView]",_=c(n),y=c(i),m=c(o),g=c(a),v=c(s),b=u;(n&&b(new n(new ArrayBuffer(1)))!=d||i&&b(new i)!=f||o&&b(o.resolve())!=l||a&&b(new a)!=h||s&&b(new s)!=p)&&(b=function(e){var t=u(e),r="[object Object]"==t?e.constructor:void 0,n=r?c(r):"";if(n)switch(n){case _:return d;case y:return f;case m:return l;case g:return h;case v:return p}return t}),e.exports=b},392:e=>{e.exports=function getValue(e,t){return null==e?void 0:e[t]}},9326:(e,t,r)=>{var n=r(1769),i=r(2428),o=r(6449),a=r(361),s=r(294),u=r(7797);e.exports=function hasPath(e,t,r){for(var c=-1,f=(t=n(t,e)).length,l=!1;++c{var t=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");e.exports=function hasUnicode(e){return t.test(e)}},5434:e=>{var t=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;e.exports=function hasUnicodeWord(e){return t.test(e)}},2032:(e,t,r)=>{var n=r(1042);e.exports=function hashClear(){this.__data__=n?n(null):{},this.size=0}},3862:e=>{e.exports=function hashDelete(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}},6721:(e,t,r)=>{var n=r(1042),i=Object.prototype.hasOwnProperty;e.exports=function hashGet(e){var t=this.__data__;if(n){var r=t[e];return"__lodash_hash_undefined__"===r?void 0:r}return i.call(t,e)?t[e]:void 0}},2749:(e,t,r)=>{var n=r(1042),i=Object.prototype.hasOwnProperty;e.exports=function hashHas(e){var t=this.__data__;return n?void 0!==t[e]:i.call(t,e)}},5749:(e,t,r)=>{var n=r(1042);e.exports=function hashSet(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=n&&void 0===t?"__lodash_hash_undefined__":t,this}},361:e=>{var t=/^(?:0|[1-9]\d*)$/;e.exports=function isIndex(e,r){var n=typeof e;return!!(r=null==r?9007199254740991:r)&&("number"==n||"symbol"!=n&&t.test(e))&&e>-1&&e%1==0&&e{var n=r(5288),i=r(4894),o=r(361),a=r(3805);e.exports=function isIterateeCall(e,t,r){if(!a(r))return!1;var s=typeof t;return!!("number"==s?i(r)&&o(t,r.length):"string"==s&&t in r)&&n(r[t],e)}},8586:(e,t,r)=>{var n=r(6449),i=r(4394),o=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,a=/^\w*$/;e.exports=function isKey(e,t){if(n(e))return!1;var r=typeof e;return!("number"!=r&&"symbol"!=r&&"boolean"!=r&&null!=e&&!i(e))||(a.test(e)||!o.test(e)||null!=t&&e in Object(t))}},4218:e=>{e.exports=function isKeyable(e){var t=typeof e;return"string"==t||"number"==t||"symbol"==t||"boolean"==t?"__proto__"!==e:null===e}},7296:(e,t,r)=>{var n,i=r(5481),o=(n=/[^.]+$/.exec(i&&i.keys&&i.keys.IE_PROTO||""))?"Symbol(src)_1."+n:"";e.exports=function isMasked(e){return!!o&&o in e}},5527:e=>{var t=Object.prototype;e.exports=function isPrototype(e){var r=e&&e.constructor;return e===("function"==typeof r&&r.prototype||t)}},756:(e,t,r)=>{var n=r(3805);e.exports=function isStrictComparable(e){return e==e&&!n(e)}},3702:e=>{e.exports=function listCacheClear(){this.__data__=[],this.size=0}},80:(e,t,r)=>{var n=r(6025),i=Array.prototype.splice;e.exports=function listCacheDelete(e){var t=this.__data__,r=n(t,e);return!(r<0)&&(r==t.length-1?t.pop():i.call(t,r,1),--this.size,!0)}},4739:(e,t,r)=>{var n=r(6025);e.exports=function listCacheGet(e){var t=this.__data__,r=n(t,e);return r<0?void 0:t[r][1]}},8655:(e,t,r)=>{var n=r(6025);e.exports=function listCacheHas(e){return n(this.__data__,e)>-1}},1175:(e,t,r)=>{var n=r(6025);e.exports=function listCacheSet(e,t){var r=this.__data__,i=n(r,e);return i<0?(++this.size,r.push([e,t])):r[i][1]=t,this}},3040:(e,t,r)=>{var n=r(1549),i=r(79),o=r(8223);e.exports=function mapCacheClear(){this.size=0,this.__data__={hash:new n,map:new(o||i),string:new n}}},7670:(e,t,r)=>{var n=r(2651);e.exports=function mapCacheDelete(e){var t=n(this,e).delete(e);return this.size-=t?1:0,t}},289:(e,t,r)=>{var n=r(2651);e.exports=function mapCacheGet(e){return n(this,e).get(e)}},4509:(e,t,r)=>{var n=r(2651);e.exports=function mapCacheHas(e){return n(this,e).has(e)}},2949:(e,t,r)=>{var n=r(2651);e.exports=function mapCacheSet(e,t){var r=n(this,e),i=r.size;return r.set(e,t),this.size+=r.size==i?0:1,this}},317:e=>{e.exports=function mapToArray(e){var t=-1,r=Array(e.size);return e.forEach((function(e,n){r[++t]=[n,e]})),r}},7197:e=>{e.exports=function matchesStrictComparable(e,t){return function(r){return null!=r&&(r[e]===t&&(void 0!==t||e in Object(r)))}}},2224:(e,t,r)=>{var n=r(104);e.exports=function memoizeCapped(e){var t=n(e,(function(e){return 500===r.size&&r.clear(),e})),r=t.cache;return t}},1042:(e,t,r)=>{var n=r(6110)(Object,"create");e.exports=n},3650:(e,t,r)=>{var n=r(4335)(Object.keys,Object);e.exports=n},6009:(e,t,r)=>{e=r.nmd(e);var n=r(4840),i=t&&!t.nodeType&&t,o=i&&e&&!e.nodeType&&e,a=o&&o.exports===i&&n.process,s=function(){try{var e=o&&o.require&&o.require("util").types;return e||a&&a.binding&&a.binding("util")}catch(e){}}();e.exports=s},9350:e=>{var t=Object.prototype.toString;e.exports=function objectToString(e){return t.call(e)}},4335:e=>{e.exports=function overArg(e,t){return function(r){return e(t(r))}}},9325:(e,t,r)=>{var n=r(4840),i="object"==typeof self&&self&&self.Object===Object&&self,o=n||i||Function("return this")();e.exports=o},1380:e=>{e.exports=function setCacheAdd(e){return this.__data__.set(e,"__lodash_hash_undefined__"),this}},1459:e=>{e.exports=function setCacheHas(e){return this.__data__.has(e)}},4247:e=>{e.exports=function setToArray(e){var t=-1,r=Array(e.size);return e.forEach((function(e){r[++t]=e})),r}},1420:(e,t,r)=>{var n=r(79);e.exports=function stackClear(){this.__data__=new n,this.size=0}},938:e=>{e.exports=function stackDelete(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}},3605:e=>{e.exports=function stackGet(e){return this.__data__.get(e)}},9817:e=>{e.exports=function stackHas(e){return this.__data__.has(e)}},945:(e,t,r)=>{var n=r(79),i=r(8223),o=r(3661);e.exports=function stackSet(e,t){var r=this.__data__;if(r instanceof n){var a=r.__data__;if(!i||a.length<199)return a.push([e,t]),this.size=++r.size,this;r=this.__data__=new o(a)}return r.set(e,t),this.size=r.size,this}},3912:(e,t,r)=>{var n=r(1074),i=r(9698),o=r(2054);e.exports=function stringToArray(e){return i(e)?o(e):n(e)}},1802:(e,t,r)=>{var n=r(2224),i=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,o=/\\(\\)?/g,a=n((function(e){var t=[];return 46===e.charCodeAt(0)&&t.push(""),e.replace(i,(function(e,r,n,i){t.push(n?i.replace(o,"$1"):r||e)})),t}));e.exports=a},7797:(e,t,r)=>{var n=r(4394);e.exports=function toKey(e){if("string"==typeof e||n(e))return e;var t=e+"";return"0"==t&&1/e==-1/0?"-0":t}},7473:e=>{var t=Function.prototype.toString;e.exports=function toSource(e){if(null!=e){try{return t.call(e)}catch(e){}try{return e+""}catch(e){}}return""}},1800:e=>{var t=/\s/;e.exports=function trimmedEndIndex(e){for(var r=e.length;r--&&t.test(e.charAt(r)););return r}},2054:e=>{var t="\\ud800-\\udfff",r="["+t+"]",n="[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",i="\\ud83c[\\udffb-\\udfff]",o="[^"+t+"]",a="(?:\\ud83c[\\udde6-\\uddff]){2}",s="[\\ud800-\\udbff][\\udc00-\\udfff]",u="(?:"+n+"|"+i+")"+"?",c="[\\ufe0e\\ufe0f]?",f=c+u+("(?:\\u200d(?:"+[o,a,s].join("|")+")"+c+u+")*"),l="(?:"+[o+n+"?",n,a,s,r].join("|")+")",h=RegExp(i+"(?="+i+")|"+l+f,"g");e.exports=function unicodeToArray(e){return e.match(h)||[]}},2225:e=>{var t="\\ud800-\\udfff",r="\\u2700-\\u27bf",n="a-z\\xdf-\\xf6\\xf8-\\xff",i="A-Z\\xc0-\\xd6\\xd8-\\xde",o="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",a="["+o+"]",s="\\d+",u="["+r+"]",c="["+n+"]",f="[^"+t+o+s+r+n+i+"]",l="(?:\\ud83c[\\udde6-\\uddff]){2}",h="[\\ud800-\\udbff][\\udc00-\\udfff]",p="["+i+"]",d="(?:"+c+"|"+f+")",_="(?:"+p+"|"+f+")",y="(?:['’](?:d|ll|m|re|s|t|ve))?",m="(?:['’](?:D|LL|M|RE|S|T|VE))?",g="(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?",v="[\\ufe0e\\ufe0f]?",b=v+g+("(?:\\u200d(?:"+["[^"+t+"]",l,h].join("|")+")"+v+g+")*"),w="(?:"+[u,l,h].join("|")+")"+b,I=RegExp([p+"?"+c+"+"+y+"(?="+[a,p,"$"].join("|")+")",_+"+"+m+"(?="+[a,p+d,"$"].join("|")+")",p+"?"+d+"+"+y,p+"+"+m,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",s,w].join("|"),"g");e.exports=function unicodeWords(e){return e.match(I)||[]}},4058:(e,t,r)=>{var n=r(4792),i=r(5539)((function(e,t,r){return t=t.toLowerCase(),e+(r?n(t):t)}));e.exports=i},4792:(e,t,r)=>{var n=r(3222),i=r(5808);e.exports=function capitalize(e){return i(n(e).toLowerCase())}},828:(e,t,r)=>{var n=r(4647),i=r(3222),o=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,a=RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]","g");e.exports=function deburr(e){return(e=i(e))&&e.replace(o,n).replace(a,"")}},5288:e=>{e.exports=function eq(e,t){return e===t||e!=e&&t!=t}},7309:(e,t,r)=>{var n=r(2006)(r(4713));e.exports=n},4713:(e,t,r)=>{var n=r(2523),i=r(5389),o=r(1489),a=Math.max;e.exports=function findIndex(e,t,r){var s=null==e?0:e.length;if(!s)return-1;var u=null==r?0:o(r);return u<0&&(u=a(s+u,0)),n(e,i(t,3),u)}},8156:(e,t,r)=>{var n=r(7422);e.exports=function get(e,t,r){var i=null==e?void 0:n(e,t);return void 0===i?r:i}},631:(e,t,r)=>{var n=r(8077),i=r(9326);e.exports=function hasIn(e,t){return null!=e&&i(e,t,n)}},3488:e=>{e.exports=function identity(e){return e}},2428:(e,t,r)=>{var n=r(7534),i=r(346),o=Object.prototype,a=o.hasOwnProperty,s=o.propertyIsEnumerable,u=n(function(){return arguments}())?n:function(e){return i(e)&&a.call(e,"callee")&&!s.call(e,"callee")};e.exports=u},6449:e=>{var t=Array.isArray;e.exports=t},4894:(e,t,r)=>{var n=r(1882),i=r(294);e.exports=function isArrayLike(e){return null!=e&&i(e.length)&&!n(e)}},3656:(e,t,r)=>{e=r.nmd(e);var n=r(9325),i=r(9935),o=t&&!t.nodeType&&t,a=o&&e&&!e.nodeType&&e,s=a&&a.exports===o?n.Buffer:void 0,u=(s?s.isBuffer:void 0)||i;e.exports=u},1882:(e,t,r)=>{var n=r(2552),i=r(3805);e.exports=function isFunction(e){if(!i(e))return!1;var t=n(e);return"[object Function]"==t||"[object GeneratorFunction]"==t||"[object AsyncFunction]"==t||"[object Proxy]"==t}},294:e=>{e.exports=function isLength(e){return"number"==typeof e&&e>-1&&e%1==0&&e<=9007199254740991}},3805:e=>{e.exports=function isObject(e){var t=typeof e;return null!=e&&("object"==t||"function"==t)}},346:e=>{e.exports=function isObjectLike(e){return null!=e&&"object"==typeof e}},4394:(e,t,r)=>{var n=r(2552),i=r(346);e.exports=function isSymbol(e){return"symbol"==typeof e||i(e)&&"[object Symbol]"==n(e)}},7167:(e,t,r)=>{var n=r(4901),i=r(7301),o=r(6009),a=o&&o.isTypedArray,s=a?i(a):n;e.exports=s},5950:(e,t,r)=>{var n=r(695),i=r(8984),o=r(4894);e.exports=function keys(e){return o(e)?n(e):i(e)}},104:(e,t,r)=>{var n=r(3661);function memoize(e,t){if("function"!=typeof e||null!=t&&"function"!=typeof t)throw new TypeError("Expected a function");var memoized=function(){var r=arguments,n=t?t.apply(this,r):r[0],i=memoized.cache;if(i.has(n))return i.get(n);var o=e.apply(this,r);return memoized.cache=i.set(n,o)||i,o};return memoized.cache=new(memoize.Cache||n),memoized}memoize.Cache=n,e.exports=memoize},583:(e,t,r)=>{var n=r(7237),i=r(7255),o=r(8586),a=r(7797);e.exports=function property(e){return o(e)?n(a(e)):i(e)}},2426:(e,t,r)=>{var n=r(4248),i=r(5389),o=r(916),a=r(6449),s=r(6800);e.exports=function some(e,t,r){var u=a(e)?n:o;return r&&s(e,t,r)&&(t=void 0),u(e,i(t,3))}},3345:e=>{e.exports=function stubArray(){return[]}},9935:e=>{e.exports=function stubFalse(){return!1}},7400:(e,t,r)=>{var n=r(9374),i=1/0;e.exports=function toFinite(e){return e?(e=n(e))===i||e===-1/0?17976931348623157e292*(e<0?-1:1):e==e?e:0:0===e?e:0}},1489:(e,t,r)=>{var n=r(7400);e.exports=function toInteger(e){var t=n(e),r=t%1;return t==t?r?t-r:t:0}},9374:(e,t,r)=>{var n=r(4128),i=r(3805),o=r(4394),a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,u=/^0o[0-7]+$/i,c=parseInt;e.exports=function toNumber(e){if("number"==typeof e)return e;if(o(e))return NaN;if(i(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=i(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=n(e);var r=s.test(e);return r||u.test(e)?c(e.slice(2),r?2:8):a.test(e)?NaN:+e}},3222:(e,t,r)=>{var n=r(7556);e.exports=function toString(e){return null==e?"":n(e)}},5808:(e,t,r)=>{var n=r(2507)("toUpperCase");e.exports=n},6645:(e,t,r)=>{var n=r(1733),i=r(5434),o=r(3222),a=r(2225);e.exports=function words(e,t,r){return e=o(e),void 0===(t=r?void 0:t)?i(e)?a(e):n(e):e.match(t)||[]}},7248:(e,t,r)=>{var n=r(6547),i=r(1234);e.exports=function zipObject(e,t){return i(e||[],t||[],n)}},5606:e=>{var t,r,n=e.exports={};function defaultSetTimout(){throw new Error("setTimeout has not been defined")}function defaultClearTimeout(){throw new Error("clearTimeout has not been defined")}function runTimeout(e){if(t===setTimeout)return setTimeout(e,0);if((t===defaultSetTimout||!t)&&setTimeout)return t=setTimeout,setTimeout(e,0);try{return t(e,0)}catch(r){try{return t.call(null,e,0)}catch(r){return t.call(this,e,0)}}}!function(){try{t="function"==typeof setTimeout?setTimeout:defaultSetTimout}catch(e){t=defaultSetTimout}try{r="function"==typeof clearTimeout?clearTimeout:defaultClearTimeout}catch(e){r=defaultClearTimeout}}();var i,o=[],a=!1,s=-1;function cleanUpNextTick(){a&&i&&(a=!1,i.length?o=i.concat(o):s=-1,o.length&&drainQueue())}function drainQueue(){if(!a){var e=runTimeout(cleanUpNextTick);a=!0;for(var t=o.length;t;){for(i=o,o=[];++s1)for(var r=1;r{"use strict";var n=r(5606),i=65536,o=4294967295;var a=r(2861).Buffer,s=r.g.crypto||r.g.msCrypto;s&&s.getRandomValues?e.exports=function randomBytes(e,t){if(e>o)throw new RangeError("requested too many random bytes");var r=a.allocUnsafe(e);if(e>0)if(e>i)for(var u=0;u{"use strict";var r=Symbol.for("react.element"),n=Symbol.for("react.portal"),i=Symbol.for("react.fragment"),o=Symbol.for("react.strict_mode"),a=Symbol.for("react.profiler"),s=Symbol.for("react.provider"),u=Symbol.for("react.context"),c=Symbol.for("react.forward_ref"),f=Symbol.for("react.suspense"),l=Symbol.for("react.memo"),h=Symbol.for("react.lazy"),p=Symbol.iterator;var d={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},_=Object.assign,y={};function E(e,t,r){this.props=e,this.context=t,this.refs=y,this.updater=r||d}function F(){}function G(e,t,r){this.props=e,this.context=t,this.refs=y,this.updater=r||d}E.prototype.isReactComponent={},E.prototype.setState=function(e,t){if("object"!=typeof e&&"function"!=typeof e&&null!=e)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,e,t,"setState")},E.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")},F.prototype=E.prototype;var m=G.prototype=new F;m.constructor=G,_(m,E.prototype),m.isPureReactComponent=!0;var g=Array.isArray,v=Object.prototype.hasOwnProperty,b={current:null},w={key:!0,ref:!0,__self:!0,__source:!0};function M(e,t,n){var i,o={},a=null,s=null;if(null!=t)for(i in void 0!==t.ref&&(s=t.ref),void 0!==t.key&&(a=""+t.key),t)v.call(t,i)&&!w.hasOwnProperty(i)&&(o[i]=t[i]);var u=arguments.length-2;if(1===u)o.children=n;else if(1{"use strict";e.exports=r(5287)},2861:(e,t,r)=>{var n=r(8287),i=n.Buffer;function copyProps(e,t){for(var r in e)t[r]=e[r]}function SafeBuffer(e,t,r){return i(e,t,r)}i.from&&i.alloc&&i.allocUnsafe&&i.allocUnsafeSlow?e.exports=n:(copyProps(n,t),t.Buffer=SafeBuffer),SafeBuffer.prototype=Object.create(i.prototype),copyProps(i,SafeBuffer),SafeBuffer.from=function(e,t,r){if("number"==typeof e)throw new TypeError("Argument must not be a number");return i(e,t,r)},SafeBuffer.alloc=function(e,t,r){if("number"!=typeof e)throw new TypeError("Argument must be a number");var n=i(e);return void 0!==t?"string"==typeof r?n.fill(t,r):n.fill(t):n.fill(0),n},SafeBuffer.allocUnsafe=function(e){if("number"!=typeof e)throw new TypeError("Argument must be a number");return i(e)},SafeBuffer.allocUnsafeSlow=function(e){if("number"!=typeof e)throw new TypeError("Argument must be a number");return n.SlowBuffer(e)}},8011:(e,t,r)=>{var n=r(2861).Buffer;function Hash(e,t){this._block=n.alloc(e),this._finalSize=t,this._blockSize=e,this._len=0}Hash.prototype.update=function(e,t){"string"==typeof e&&(t=t||"utf8",e=n.from(e,t));for(var r=this._block,i=this._blockSize,o=e.length,a=this._len,s=0;s=this._finalSize&&(this._update(this._block),this._block.fill(0));var r=8*this._len;if(r<=4294967295)this._block.writeUInt32BE(r,this._blockSize-4);else{var n=(4294967295&r)>>>0,i=(r-n)/4294967296;this._block.writeUInt32BE(i,this._blockSize-8),this._block.writeUInt32BE(n,this._blockSize-4)}this._update(this._block);var o=this._hash();return e?o.toString(e):o},Hash.prototype._update=function(){throw new Error("_update must be implemented by subclass")},e.exports=Hash},2802:(e,t,r)=>{var n=e.exports=function SHA(e){e=e.toLowerCase();var t=n[e];if(!t)throw new Error(e+" is not supported (we accept pull requests)");return new t};n.sha=r(7816),n.sha1=r(3737),n.sha224=r(6710),n.sha256=r(4107),n.sha384=r(2827),n.sha512=r(2890)},7816:(e,t,r)=>{var n=r(6698),i=r(8011),o=r(2861).Buffer,a=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function Sha(){this.init(),this._w=s,i.call(this,64,56)}function rotl30(e){return e<<30|e>>>2}function ft(e,t,r,n){return 0===e?t&r|~t&n:2===e?t&r|t&n|r&n:t^r^n}n(Sha,i),Sha.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},Sha.prototype._update=function(e){for(var t,r=this._w,n=0|this._a,i=0|this._b,o=0|this._c,s=0|this._d,u=0|this._e,c=0;c<16;++c)r[c]=e.readInt32BE(4*c);for(;c<80;++c)r[c]=r[c-3]^r[c-8]^r[c-14]^r[c-16];for(var f=0;f<80;++f){var l=~~(f/20),h=0|((t=n)<<5|t>>>27)+ft(l,i,o,s)+u+r[f]+a[l];u=s,s=o,o=rotl30(i),i=n,n=h}this._a=n+this._a|0,this._b=i+this._b|0,this._c=o+this._c|0,this._d=s+this._d|0,this._e=u+this._e|0},Sha.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},e.exports=Sha},3737:(e,t,r)=>{var n=r(6698),i=r(8011),o=r(2861).Buffer,a=[1518500249,1859775393,-1894007588,-899497514],s=new Array(80);function Sha1(){this.init(),this._w=s,i.call(this,64,56)}function rotl5(e){return e<<5|e>>>27}function rotl30(e){return e<<30|e>>>2}function ft(e,t,r,n){return 0===e?t&r|~t&n:2===e?t&r|t&n|r&n:t^r^n}n(Sha1,i),Sha1.prototype.init=function(){return this._a=1732584193,this._b=4023233417,this._c=2562383102,this._d=271733878,this._e=3285377520,this},Sha1.prototype._update=function(e){for(var t,r=this._w,n=0|this._a,i=0|this._b,o=0|this._c,s=0|this._d,u=0|this._e,c=0;c<16;++c)r[c]=e.readInt32BE(4*c);for(;c<80;++c)r[c]=(t=r[c-3]^r[c-8]^r[c-14]^r[c-16])<<1|t>>>31;for(var f=0;f<80;++f){var l=~~(f/20),h=rotl5(n)+ft(l,i,o,s)+u+r[f]+a[l]|0;u=s,s=o,o=rotl30(i),i=n,n=h}this._a=n+this._a|0,this._b=i+this._b|0,this._c=o+this._c|0,this._d=s+this._d|0,this._e=u+this._e|0},Sha1.prototype._hash=function(){var e=o.allocUnsafe(20);return e.writeInt32BE(0|this._a,0),e.writeInt32BE(0|this._b,4),e.writeInt32BE(0|this._c,8),e.writeInt32BE(0|this._d,12),e.writeInt32BE(0|this._e,16),e},e.exports=Sha1},6710:(e,t,r)=>{var n=r(6698),i=r(4107),o=r(8011),a=r(2861).Buffer,s=new Array(64);function Sha224(){this.init(),this._w=s,o.call(this,64,56)}n(Sha224,i),Sha224.prototype.init=function(){return this._a=3238371032,this._b=914150663,this._c=812702999,this._d=4144912697,this._e=4290775857,this._f=1750603025,this._g=1694076839,this._h=3204075428,this},Sha224.prototype._hash=function(){var e=a.allocUnsafe(28);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e},e.exports=Sha224},4107:(e,t,r)=>{var n=r(6698),i=r(8011),o=r(2861).Buffer,a=[1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298],s=new Array(64);function Sha256(){this.init(),this._w=s,i.call(this,64,56)}function ch(e,t,r){return r^e&(t^r)}function maj(e,t,r){return e&t|r&(e|t)}function sigma0(e){return(e>>>2|e<<30)^(e>>>13|e<<19)^(e>>>22|e<<10)}function sigma1(e){return(e>>>6|e<<26)^(e>>>11|e<<21)^(e>>>25|e<<7)}function gamma0(e){return(e>>>7|e<<25)^(e>>>18|e<<14)^e>>>3}n(Sha256,i),Sha256.prototype.init=function(){return this._a=1779033703,this._b=3144134277,this._c=1013904242,this._d=2773480762,this._e=1359893119,this._f=2600822924,this._g=528734635,this._h=1541459225,this},Sha256.prototype._update=function(e){for(var t,r=this._w,n=0|this._a,i=0|this._b,o=0|this._c,s=0|this._d,u=0|this._e,c=0|this._f,f=0|this._g,l=0|this._h,h=0;h<16;++h)r[h]=e.readInt32BE(4*h);for(;h<64;++h)r[h]=0|(((t=r[h-2])>>>17|t<<15)^(t>>>19|t<<13)^t>>>10)+r[h-7]+gamma0(r[h-15])+r[h-16];for(var p=0;p<64;++p){var d=l+sigma1(u)+ch(u,c,f)+a[p]+r[p]|0,_=sigma0(n)+maj(n,i,o)|0;l=f,f=c,c=u,u=s+d|0,s=o,o=i,i=n,n=d+_|0}this._a=n+this._a|0,this._b=i+this._b|0,this._c=o+this._c|0,this._d=s+this._d|0,this._e=u+this._e|0,this._f=c+this._f|0,this._g=f+this._g|0,this._h=l+this._h|0},Sha256.prototype._hash=function(){var e=o.allocUnsafe(32);return e.writeInt32BE(this._a,0),e.writeInt32BE(this._b,4),e.writeInt32BE(this._c,8),e.writeInt32BE(this._d,12),e.writeInt32BE(this._e,16),e.writeInt32BE(this._f,20),e.writeInt32BE(this._g,24),e.writeInt32BE(this._h,28),e},e.exports=Sha256},2827:(e,t,r)=>{var n=r(6698),i=r(2890),o=r(8011),a=r(2861).Buffer,s=new Array(160);function Sha384(){this.init(),this._w=s,o.call(this,128,112)}n(Sha384,i),Sha384.prototype.init=function(){return this._ah=3418070365,this._bh=1654270250,this._ch=2438529370,this._dh=355462360,this._eh=1731405415,this._fh=2394180231,this._gh=3675008525,this._hh=1203062813,this._al=3238371032,this._bl=914150663,this._cl=812702999,this._dl=4144912697,this._el=4290775857,this._fl=1750603025,this._gl=1694076839,this._hl=3204075428,this},Sha384.prototype._hash=function(){var e=a.allocUnsafe(48);function writeInt64BE(t,r,n){e.writeInt32BE(t,n),e.writeInt32BE(r,n+4)}return writeInt64BE(this._ah,this._al,0),writeInt64BE(this._bh,this._bl,8),writeInt64BE(this._ch,this._cl,16),writeInt64BE(this._dh,this._dl,24),writeInt64BE(this._eh,this._el,32),writeInt64BE(this._fh,this._fl,40),e},e.exports=Sha384},2890:(e,t,r)=>{var n=r(6698),i=r(8011),o=r(2861).Buffer,a=[1116352408,3609767458,1899447441,602891725,3049323471,3964484399,3921009573,2173295548,961987163,4081628472,1508970993,3053834265,2453635748,2937671579,2870763221,3664609560,3624381080,2734883394,310598401,1164996542,607225278,1323610764,1426881987,3590304994,1925078388,4068182383,2162078206,991336113,2614888103,633803317,3248222580,3479774868,3835390401,2666613458,4022224774,944711139,264347078,2341262773,604807628,2007800933,770255983,1495990901,1249150122,1856431235,1555081692,3175218132,1996064986,2198950837,2554220882,3999719339,2821834349,766784016,2952996808,2566594879,3210313671,3203337956,3336571891,1034457026,3584528711,2466948901,113926993,3758326383,338241895,168717936,666307205,1188179964,773529912,1546045734,1294757372,1522805485,1396182291,2643833823,1695183700,2343527390,1986661051,1014477480,2177026350,1206759142,2456956037,344077627,2730485921,1290863460,2820302411,3158454273,3259730800,3505952657,3345764771,106217008,3516065817,3606008344,3600352804,1432725776,4094571909,1467031594,275423344,851169720,430227734,3100823752,506948616,1363258195,659060556,3750685593,883997877,3785050280,958139571,3318307427,1322822218,3812723403,1537002063,2003034995,1747873779,3602036899,1955562222,1575990012,2024104815,1125592928,2227730452,2716904306,2361852424,442776044,2428436474,593698344,2756734187,3733110249,3204031479,2999351573,3329325298,3815920427,3391569614,3928383900,3515267271,566280711,3940187606,3454069534,4118630271,4000239992,116418474,1914138554,174292421,2731055270,289380356,3203993006,460393269,320620315,685471733,587496836,852142971,1086792851,1017036298,365543100,1126000580,2618297676,1288033470,3409855158,1501505948,4234509866,1607167915,987167468,1816402316,1246189591],s=new Array(160);function Sha512(){this.init(),this._w=s,i.call(this,128,112)}function Ch(e,t,r){return r^e&(t^r)}function maj(e,t,r){return e&t|r&(e|t)}function sigma0(e,t){return(e>>>28|t<<4)^(t>>>2|e<<30)^(t>>>7|e<<25)}function sigma1(e,t){return(e>>>14|t<<18)^(e>>>18|t<<14)^(t>>>9|e<<23)}function Gamma0(e,t){return(e>>>1|t<<31)^(e>>>8|t<<24)^e>>>7}function Gamma0l(e,t){return(e>>>1|t<<31)^(e>>>8|t<<24)^(e>>>7|t<<25)}function Gamma1(e,t){return(e>>>19|t<<13)^(t>>>29|e<<3)^e>>>6}function Gamma1l(e,t){return(e>>>19|t<<13)^(t>>>29|e<<3)^(e>>>6|t<<26)}function getCarry(e,t){return e>>>0>>0?1:0}n(Sha512,i),Sha512.prototype.init=function(){return this._ah=1779033703,this._bh=3144134277,this._ch=1013904242,this._dh=2773480762,this._eh=1359893119,this._fh=2600822924,this._gh=528734635,this._hh=1541459225,this._al=4089235720,this._bl=2227873595,this._cl=4271175723,this._dl=1595750129,this._el=2917565137,this._fl=725511199,this._gl=4215389547,this._hl=327033209,this},Sha512.prototype._update=function(e){for(var t=this._w,r=0|this._ah,n=0|this._bh,i=0|this._ch,o=0|this._dh,s=0|this._eh,u=0|this._fh,c=0|this._gh,f=0|this._hh,l=0|this._al,h=0|this._bl,p=0|this._cl,d=0|this._dl,_=0|this._el,y=0|this._fl,m=0|this._gl,g=0|this._hl,v=0;v<32;v+=2)t[v]=e.readInt32BE(4*v),t[v+1]=e.readInt32BE(4*v+4);for(;v<160;v+=2){var b=t[v-30],w=t[v-30+1],I=Gamma0(b,w),x=Gamma0l(w,b),B=Gamma1(b=t[v-4],w=t[v-4+1]),k=Gamma1l(w,b),C=t[v-14],q=t[v-14+1],L=t[v-32],j=t[v-32+1],z=x+q|0,P=I+C+getCarry(z,x)|0;P=(P=P+B+getCarry(z=z+k|0,k)|0)+L+getCarry(z=z+j|0,j)|0,t[v]=P,t[v+1]=z}for(var D=0;D<160;D+=2){P=t[D],z=t[D+1];var U=maj(r,n,i),W=maj(l,h,p),K=sigma0(r,l),V=sigma0(l,r),$=sigma1(s,_),H=sigma1(_,s),Y=a[D],Z=a[D+1],J=Ch(s,u,c),ee=Ch(_,y,m),te=g+H|0,re=f+$+getCarry(te,g)|0;re=(re=(re=re+J+getCarry(te=te+ee|0,ee)|0)+Y+getCarry(te=te+Z|0,Z)|0)+P+getCarry(te=te+z|0,z)|0;var ne=V+W|0,ie=K+U+getCarry(ne,V)|0;f=c,g=m,c=u,m=y,u=s,y=_,s=o+re+getCarry(_=d+te|0,d)|0,o=i,d=p,i=n,p=h,n=r,h=l,r=re+ie+getCarry(l=te+ne|0,te)|0}this._al=this._al+l|0,this._bl=this._bl+h|0,this._cl=this._cl+p|0,this._dl=this._dl+d|0,this._el=this._el+_|0,this._fl=this._fl+y|0,this._gl=this._gl+m|0,this._hl=this._hl+g|0,this._ah=this._ah+r+getCarry(this._al,l)|0,this._bh=this._bh+n+getCarry(this._bl,h)|0,this._ch=this._ch+i+getCarry(this._cl,p)|0,this._dh=this._dh+o+getCarry(this._dl,d)|0,this._eh=this._eh+s+getCarry(this._el,_)|0,this._fh=this._fh+u+getCarry(this._fl,y)|0,this._gh=this._gh+c+getCarry(this._gl,m)|0,this._hh=this._hh+f+getCarry(this._hl,g)|0},Sha512.prototype._hash=function(){var e=o.allocUnsafe(64);function writeInt64BE(t,r,n){e.writeInt32BE(t,n),e.writeInt32BE(r,n+4)}return writeInt64BE(this._ah,this._al,0),writeInt64BE(this._bh,this._bl,8),writeInt64BE(this._ch,this._cl,16),writeInt64BE(this._dh,this._dl,24),writeInt64BE(this._eh,this._el,32),writeInt64BE(this._fh,this._fl,40),writeInt64BE(this._gh,this._gl,48),writeInt64BE(this._hh,this._hl,56),e},e.exports=Sha512},7666:(e,t,r)=>{var n=r(4851),i=r(953);function _extends(){var t;return e.exports=_extends=n?i(t=n).call(t):function(e){for(var t=1;t{"use strict";var n=r(9709);e.exports=n},462:(e,t,r)=>{"use strict";var n=r(975);e.exports=n},2567:(e,t,r)=>{"use strict";r(9307);var n=r(1747);e.exports=n("Function","bind")},3034:(e,t,r)=>{"use strict";var n=r(8280),i=r(2567),o=Function.prototype;e.exports=function(e){var t=e.bind;return e===o||n(o,e)&&t===o.bind?i:t}},9748:(e,t,r)=>{"use strict";r(1340);var n=r(2046);e.exports=n.Object.assign},953:(e,t,r)=>{"use strict";e.exports=r(3375)},4851:(e,t,r)=>{"use strict";e.exports=r(5401)},3375:(e,t,r)=>{"use strict";var n=r(3700);e.exports=n},5401:(e,t,r)=>{"use strict";var n=r(462);e.exports=n},2159:(e,t,r)=>{"use strict";var n=r(2250),i=r(4640),o=TypeError;e.exports=function(e){if(n(e))return e;throw new o(i(e)+" is not a function")}},6624:(e,t,r)=>{"use strict";var n=r(6285),i=String,o=TypeError;e.exports=function(e){if(n(e))return e;throw new o(i(e)+" is not an object")}},4436:(e,t,r)=>{"use strict";var n=r(7374),i=r(4849),o=r(575),createMethod=function(e){return function(t,r,a){var s=n(t),u=o(s);if(0===u)return!e&&-1;var c,f=i(a,u);if(e&&r!=r){for(;u>f;)if((c=s[f++])!=c)return!0}else for(;u>f;f++)if((e||f in s)&&s[f]===r)return e||f||0;return!e&&-1}};e.exports={includes:createMethod(!0),indexOf:createMethod(!1)}},3427:(e,t,r)=>{"use strict";var n=r(1907);e.exports=n([].slice)},5807:(e,t,r)=>{"use strict";var n=r(1907),i=n({}.toString),o=n("".slice);e.exports=function(e){return o(i(e),8,-1)}},1626:(e,t,r)=>{"use strict";var n=r(9447),i=r(4284),o=r(5817);e.exports=n?function(e,t,r){return i.f(e,t,o(1,r))}:function(e,t,r){return e[t]=r,e}},5817:e=>{"use strict";e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},2532:(e,t,r)=>{"use strict";var n=r(5951),i=Object.defineProperty;e.exports=function(e,t){try{i(n,e,{value:t,configurable:!0,writable:!0})}catch(r){n[e]=t}return t}},9447:(e,t,r)=>{"use strict";var n=r(8828);e.exports=!n((function(){return 7!==Object.defineProperty({},1,{get:function(){return 7}})[1]}))},9552:(e,t,r)=>{"use strict";var n=r(5951),i=r(6285),o=n.document,a=i(o)&&i(o.createElement);e.exports=function(e){return a?o.createElement(e):{}}},376:e=>{"use strict";e.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},6794:(e,t,r)=>{"use strict";var n=r(5951).navigator,i=n&&n.userAgent;e.exports=i?String(i):""},798:(e,t,r)=>{"use strict";var n,i,o=r(5951),a=r(6794),s=o.process,u=o.Deno,c=s&&s.versions||u&&u.version,f=c&&c.v8;f&&(i=(n=f.split("."))[0]>0&&n[0]<4?1:+(n[0]+n[1])),!i&&a&&(!(n=a.match(/Edge\/(\d+)/))||n[1]>=74)&&(n=a.match(/Chrome\/(\d+)/))&&(i=+n[1]),e.exports=i},1091:(e,t,r)=>{"use strict";var n=r(5951),i=r(6024),o=r(2361),a=r(2250),s=r(3846).f,u=r(7463),c=r(2046),f=r(8311),l=r(1626),h=r(9724);r(6128);var wrapConstructor=function(e){var Wrapper=function(t,r,n){if(this instanceof Wrapper){switch(arguments.length){case 0:return new e;case 1:return new e(t);case 2:return new e(t,r)}return new e(t,r,n)}return i(e,this,arguments)};return Wrapper.prototype=e.prototype,Wrapper};e.exports=function(e,t){var r,i,p,d,_,y,m,g,v,b=e.target,w=e.global,I=e.stat,x=e.proto,B=w?n:I?n[b]:n[b]&&n[b].prototype,k=w?c:c[b]||l(c,b,{})[b],C=k.prototype;for(d in t)i=!(r=u(w?d:b+(I?".":"#")+d,e.forced))&&B&&h(B,d),y=k[d],i&&(m=e.dontCallGetSet?(v=s(B,d))&&v.value:B[d]),_=i&&m?m:t[d],(r||x||typeof y!=typeof _)&&(g=e.bind&&i?f(_,n):e.wrap&&i?wrapConstructor(_):x&&a(_)?o(_):_,(e.sham||_&&_.sham||y&&y.sham)&&l(g,"sham",!0),l(k,d,g),x&&(h(c,p=b+"Prototype")||l(c,p,{}),l(c[p],d,_),e.real&&C&&(r||!C[d])&&l(C,d,_)))}},8828:e=>{"use strict";e.exports=function(e){try{return!!e()}catch(e){return!0}}},6024:(e,t,r)=>{"use strict";var n=r(1505),i=Function.prototype,o=i.apply,a=i.call;e.exports="object"==typeof Reflect&&Reflect.apply||(n?a.bind(o):function(){return a.apply(o,arguments)})},8311:(e,t,r)=>{"use strict";var n=r(2361),i=r(2159),o=r(1505),a=n(n.bind);e.exports=function(e,t){return i(e),void 0===t?e:o?a(e,t):function(){return e.apply(t,arguments)}}},1505:(e,t,r)=>{"use strict";var n=r(8828);e.exports=!n((function(){var e=function(){}.bind();return"function"!=typeof e||e.hasOwnProperty("prototype")}))},4673:(e,t,r)=>{"use strict";var n=r(1907),i=r(2159),o=r(6285),a=r(9724),s=r(3427),u=r(1505),c=Function,f=n([].concat),l=n([].join),h={};e.exports=u?c.bind:function bind(e){var t=i(this),r=t.prototype,n=s(arguments,1),u=function bound(){var r=f(n,s(arguments));return this instanceof u?function(e,t,r){if(!a(h,t)){for(var n=[],i=0;i{"use strict";var n=r(1505),i=Function.prototype.call;e.exports=n?i.bind(i):function(){return i.apply(i,arguments)}},2361:(e,t,r)=>{"use strict";var n=r(5807),i=r(1907);e.exports=function(e){if("Function"===n(e))return i(e)}},1907:(e,t,r)=>{"use strict";var n=r(1505),i=Function.prototype,o=i.call,a=n&&i.bind.bind(o,o);e.exports=n?a:function(e){return function(){return o.apply(e,arguments)}}},1747:(e,t,r)=>{"use strict";var n=r(5951),i=r(2046);e.exports=function(e,t){var r=i[e+"Prototype"],o=r&&r[t];if(o)return o;var a=n[e],s=a&&a.prototype;return s&&s[t]}},5582:(e,t,r)=>{"use strict";var n=r(2046),i=r(5951),o=r(2250),aFunction=function(e){return o(e)?e:void 0};e.exports=function(e,t){return arguments.length<2?aFunction(n[e])||aFunction(i[e]):n[e]&&n[e][t]||i[e]&&i[e][t]}},9367:(e,t,r)=>{"use strict";var n=r(2159),i=r(7136);e.exports=function(e,t){var r=e[t];return i(r)?void 0:n(r)}},5951:function(e,t,r){"use strict";var check=function(e){return e&&e.Math===Math&&e};e.exports=check("object"==typeof globalThis&&globalThis)||check("object"==typeof window&&window)||check("object"==typeof self&&self)||check("object"==typeof r.g&&r.g)||check("object"==typeof this&&this)||function(){return this}()||Function("return this")()},9724:(e,t,r)=>{"use strict";var n=r(1907),i=r(9298),o=n({}.hasOwnProperty);e.exports=Object.hasOwn||function hasOwn(e,t){return o(i(e),t)}},8530:e=>{"use strict";e.exports={}},3648:(e,t,r)=>{"use strict";var n=r(9447),i=r(8828),o=r(9552);e.exports=!n&&!i((function(){return 7!==Object.defineProperty(o("div"),"a",{get:function(){return 7}}).a}))},6946:(e,t,r)=>{"use strict";var n=r(1907),i=r(8828),o=r(5807),a=Object,s=n("".split);e.exports=i((function(){return!a("z").propertyIsEnumerable(0)}))?function(e){return"String"===o(e)?s(e,""):a(e)}:a},2250:e=>{"use strict";var t="object"==typeof document&&document.all;e.exports=void 0===t&&void 0!==t?function(e){return"function"==typeof e||e===t}:function(e){return"function"==typeof e}},7463:(e,t,r)=>{"use strict";var n=r(8828),i=r(2250),o=/#|\.prototype\./,isForced=function(e,t){var r=s[a(e)];return r===c||r!==u&&(i(t)?n(t):!!t)},a=isForced.normalize=function(e){return String(e).replace(o,".").toLowerCase()},s=isForced.data={},u=isForced.NATIVE="N",c=isForced.POLYFILL="P";e.exports=isForced},7136:e=>{"use strict";e.exports=function(e){return null==e}},6285:(e,t,r)=>{"use strict";var n=r(2250);e.exports=function(e){return"object"==typeof e?null!==e:n(e)}},7376:e=>{"use strict";e.exports=!0},5594:(e,t,r)=>{"use strict";var n=r(5582),i=r(2250),o=r(8280),a=r(3556),s=Object;e.exports=a?function(e){return"symbol"==typeof e}:function(e){var t=n("Symbol");return i(t)&&o(t.prototype,s(e))}},575:(e,t,r)=>{"use strict";var n=r(3121);e.exports=function(e){return n(e.length)}},1176:e=>{"use strict";var t=Math.ceil,r=Math.floor;e.exports=Math.trunc||function trunc(e){var n=+e;return(n>0?r:t)(n)}},9538:(e,t,r)=>{"use strict";var n=r(9447),i=r(1907),o=r(3930),a=r(8828),s=r(2875),u=r(7170),c=r(2574),f=r(9298),l=r(6946),h=Object.assign,p=Object.defineProperty,d=i([].concat);e.exports=!h||a((function(){if(n&&1!==h({b:1},h(p({},"a",{enumerable:!0,get:function(){p(this,"b",{value:3,enumerable:!1})}}),{b:2})).b)return!0;var e={},t={},r=Symbol("assign detection"),i="abcdefghijklmnopqrst";return e[r]=7,i.split("").forEach((function(e){t[e]=e})),7!==h({},e)[r]||s(h({},t)).join("")!==i}))?function assign(e,t){for(var r=f(e),i=arguments.length,a=1,h=u.f,p=c.f;i>a;)for(var _,y=l(arguments[a++]),m=h?d(s(y),h(y)):s(y),g=m.length,v=0;g>v;)_=m[v++],n&&!o(p,y,_)||(r[_]=y[_]);return r}:h},4284:(e,t,r)=>{"use strict";var n=r(9447),i=r(3648),o=r(8661),a=r(6624),s=r(470),u=TypeError,c=Object.defineProperty,f=Object.getOwnPropertyDescriptor,l="enumerable",h="configurable",p="writable";t.f=n?o?function defineProperty(e,t,r){if(a(e),t=s(t),a(r),"function"==typeof e&&"prototype"===t&&"value"in r&&p in r&&!r[p]){var n=f(e,t);n&&n[p]&&(e[t]=r.value,r={configurable:h in r?r[h]:n[h],enumerable:l in r?r[l]:n[l],writable:!1})}return c(e,t,r)}:c:function defineProperty(e,t,r){if(a(e),t=s(t),a(r),i)try{return c(e,t,r)}catch(e){}if("get"in r||"set"in r)throw new u("Accessors not supported");return"value"in r&&(e[t]=r.value),e}},3846:(e,t,r)=>{"use strict";var n=r(9447),i=r(3930),o=r(2574),a=r(5817),s=r(7374),u=r(470),c=r(9724),f=r(3648),l=Object.getOwnPropertyDescriptor;t.f=n?l:function getOwnPropertyDescriptor(e,t){if(e=s(e),t=u(t),f)try{return l(e,t)}catch(e){}if(c(e,t))return a(!i(o.f,e,t),e[t])}},7170:(e,t)=>{"use strict";t.f=Object.getOwnPropertySymbols},8280:(e,t,r)=>{"use strict";var n=r(1907);e.exports=n({}.isPrototypeOf)},3045:(e,t,r)=>{"use strict";var n=r(1907),i=r(9724),o=r(7374),a=r(4436).indexOf,s=r(8530),u=n([].push);e.exports=function(e,t){var r,n=o(e),c=0,f=[];for(r in n)!i(s,r)&&i(n,r)&&u(f,r);for(;t.length>c;)i(n,r=t[c++])&&(~a(f,r)||u(f,r));return f}},2875:(e,t,r)=>{"use strict";var n=r(3045),i=r(376);e.exports=Object.keys||function keys(e){return n(e,i)}},2574:(e,t)=>{"use strict";var r={}.propertyIsEnumerable,n=Object.getOwnPropertyDescriptor,i=n&&!r.call({1:2},1);t.f=i?function propertyIsEnumerable(e){var t=n(this,e);return!!t&&t.enumerable}:r},581:(e,t,r)=>{"use strict";var n=r(3930),i=r(2250),o=r(6285),a=TypeError;e.exports=function(e,t){var r,s;if("string"===t&&i(r=e.toString)&&!o(s=n(r,e)))return s;if(i(r=e.valueOf)&&!o(s=n(r,e)))return s;if("string"!==t&&i(r=e.toString)&&!o(s=n(r,e)))return s;throw new a("Can't convert object to primitive value")}},2046:e=>{"use strict";e.exports={}},4239:(e,t,r)=>{"use strict";var n=r(7136),i=TypeError;e.exports=function(e){if(n(e))throw new i("Can't call method on "+e);return e}},6128:(e,t,r)=>{"use strict";var n=r(7376),i=r(5951),o=r(2532),a="__core-js_shared__",s=e.exports=i[a]||o(a,{});(s.versions||(s.versions=[])).push({version:"3.39.0",mode:n?"pure":"global",copyright:"© 2014-2024 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE",source:"https://github.com/zloirock/core-js"})},5816:(e,t,r)=>{"use strict";var n=r(6128);e.exports=function(e,t){return n[e]||(n[e]=t||{})}},9846:(e,t,r)=>{"use strict";var n=r(798),i=r(8828),o=r(5951).String;e.exports=!!Object.getOwnPropertySymbols&&!i((function(){var e=Symbol("symbol detection");return!o(e)||!(Object(e)instanceof Symbol)||!Symbol.sham&&n&&n<41}))},4849:(e,t,r)=>{"use strict";var n=r(5482),i=Math.max,o=Math.min;e.exports=function(e,t){var r=n(e);return r<0?i(r+t,0):o(r,t)}},7374:(e,t,r)=>{"use strict";var n=r(6946),i=r(4239);e.exports=function(e){return n(i(e))}},5482:(e,t,r)=>{"use strict";var n=r(1176);e.exports=function(e){var t=+e;return t!=t||0===t?0:n(t)}},3121:(e,t,r)=>{"use strict";var n=r(5482),i=Math.min;e.exports=function(e){var t=n(e);return t>0?i(t,9007199254740991):0}},9298:(e,t,r)=>{"use strict";var n=r(4239),i=Object;e.exports=function(e){return i(n(e))}},6028:(e,t,r)=>{"use strict";var n=r(3930),i=r(6285),o=r(5594),a=r(9367),s=r(581),u=r(6264),c=TypeError,f=u("toPrimitive");e.exports=function(e,t){if(!i(e)||o(e))return e;var r,u=a(e,f);if(u){if(void 0===t&&(t="default"),r=n(u,e,t),!i(r)||o(r))return r;throw new c("Can't convert object to primitive value")}return void 0===t&&(t="number"),s(e,t)}},470:(e,t,r)=>{"use strict";var n=r(6028),i=r(5594);e.exports=function(e){var t=n(e,"string");return i(t)?t:t+""}},4640:e=>{"use strict";var t=String;e.exports=function(e){try{return t(e)}catch(e){return"Object"}}},6499:(e,t,r)=>{"use strict";var n=r(1907),i=0,o=Math.random(),a=n(1..toString);e.exports=function(e){return"Symbol("+(void 0===e?"":e)+")_"+a(++i+o,36)}},3556:(e,t,r)=>{"use strict";var n=r(9846);e.exports=n&&!Symbol.sham&&"symbol"==typeof Symbol.iterator},8661:(e,t,r)=>{"use strict";var n=r(9447),i=r(8828);e.exports=n&&i((function(){return 42!==Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype}))},6264:(e,t,r)=>{"use strict";var n=r(5951),i=r(5816),o=r(9724),a=r(6499),s=r(9846),u=r(3556),c=n.Symbol,f=i("wks"),l=u?c.for||c:c&&c.withoutSetter||a;e.exports=function(e){return o(f,e)||(f[e]=s&&o(c,e)?c[e]:l("Symbol."+e)),f[e]}},9307:(e,t,r)=>{"use strict";var n=r(1091),i=r(4673);n({target:"Function",proto:!0,forced:Function.bind!==i},{bind:i})},1340:(e,t,r)=>{"use strict";var n=r(1091),i=r(9538);n({target:"Object",stat:!0,arity:2,forced:Object.assign!==i},{assign:i})},9709:(e,t,r)=>{"use strict";var n=r(3034);e.exports=n},975:(e,t,r)=>{"use strict";var n=r(9748);e.exports=n}},t={};function __webpack_require__(r){var n=t[r];if(void 0!==n)return n.exports;var i=t[r]={id:r,loaded:!1,exports:{}};return e[r].call(i.exports,i,i.exports,__webpack_require__),i.loaded=!0,i.exports}__webpack_require__.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return __webpack_require__.d(t,{a:t}),t},__webpack_require__.d=(e,t)=>{for(var r in t)__webpack_require__.o(t,r)&&!__webpack_require__.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},__webpack_require__.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),__webpack_require__.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),__webpack_require__.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},__webpack_require__.nmd=e=>(e.paths=[],e.children||(e.children=[]),e);var r={};return(()=>{"use strict";__webpack_require__.d(r,{default:()=>ot});var e={};__webpack_require__.r(e),__webpack_require__.d(e,{TOGGLE_CONFIGS:()=>Je,UPDATE_CONFIGS:()=>Ge,downloadConfig:()=>downloadConfig,getConfigByUrl:()=>getConfigByUrl,loaded:()=>loaded,toggle:()=>toggle,update:()=>update});var t={};__webpack_require__.r(t),__webpack_require__.d(t,{get:()=>get});var n=__webpack_require__(6540);class StandaloneLayout extends n.Component{render(){const{getComponent:e}=this.props,t=e("Container"),r=e("Row"),i=e("Col"),o=e("Topbar",!0),a=e("BaseLayout",!0),s=e("onlineValidatorBadge",!0);return n.createElement(t,{className:"swagger-ui"},o?n.createElement(o,null):null,n.createElement(a,null),n.createElement(r,null,n.createElement(i,null,n.createElement(s,null))))}}const i=StandaloneLayout,stadalone_layout=()=>({components:{StandaloneLayout:i}});var o=__webpack_require__(9404),a=__webpack_require__.n(o);__webpack_require__(6750),__webpack_require__(4058),__webpack_require__(5808),__webpack_require__(104),__webpack_require__(7309),__webpack_require__(2426),__webpack_require__(5288),__webpack_require__(1882),__webpack_require__(2205),__webpack_require__(3209),__webpack_require__(2802);const s=function makeWindow(){var e={location:{},history:{},open:()=>{},close:()=>{},File:function(){},FormData:function(){}};if("undefined"==typeof window)return e;try{e=window;for(var t of["File","Blob","FormData"])t in window&&(e[t]=window[t])}catch(e){console.error(e)}return e}();a().Set.of("type","format","items","default","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","enum","multipleOf");__webpack_require__(8287).Buffer;const parseSearch=()=>{const e=new URLSearchParams(s.location.search);return Object.fromEntries(e)};class TopBar extends n.Component{constructor(e,t){super(e,t),this.state={url:e.specSelectors.url(),selectedIndex:0}}UNSAFE_componentWillReceiveProps(e){this.setState({url:e.specSelectors.url()})}onUrlChange=e=>{let{target:{value:t}}=e;this.setState({url:t})};flushAuthData(){const{persistAuthorization:e}=this.props.getConfigs();e||this.props.authActions.restoreAuthorization({authorized:{}})}loadSpec=e=>{this.flushAuthData(),this.props.specActions.updateUrl(e),this.props.specActions.download(e)};onUrlSelect=e=>{let t=e.target.value||e.target.href;this.loadSpec(t),this.setSelectedUrl(t),e.preventDefault()};downloadUrl=e=>{this.loadSpec(this.state.url),e.preventDefault()};setSearch=e=>{let t=parseSearch();t["urls.primaryName"]=e.name;const r=`${window.location.protocol}//${window.location.host}${window.location.pathname}`;window&&window.history&&window.history.pushState&&window.history.replaceState(null,"",`${r}?${(e=>{const t=new URLSearchParams(Object.entries(e));return String(t)})(t)}`)};setSelectedUrl=e=>{const t=this.props.getConfigs().urls||[];t&&t.length&&e&&t.forEach(((t,r)=>{t.url===e&&(this.setState({selectedIndex:r}),this.setSearch(t))}))};componentDidMount(){const e=this.props.getConfigs(),t=e.urls||[];if(t&&t.length){var r=this.state.selectedIndex;let n=parseSearch()["urls.primaryName"]||e.urls.primaryName;n&&t.forEach(((e,t)=>{e.name===n&&(this.setState({selectedIndex:t}),r=t)})),this.loadSpec(t[r].url)}}onFilterChange=e=>{let{target:{value:t}}=e;this.props.layoutActions.updateFilter(t)};render(){let{getComponent:e,specSelectors:t,getConfigs:r}=this.props;const i=e("Button"),o=e("Link"),a=e("Logo");let s="loading"===t.loadingStatus();const u=["download-url-input"];"failed"===t.loadingStatus()&&u.push("failed"),s&&u.push("loading");const{urls:c}=r();let f=[],l=null;if(c){let e=[];c.forEach(((t,r)=>{e.push(n.createElement("option",{key:r,value:t.url},t.name))})),f.push(n.createElement("label",{className:"select-label",htmlFor:"select"},n.createElement("span",null,"Select a definition"),n.createElement("select",{id:"select",disabled:s,onChange:this.onUrlSelect,value:c[this.state.selectedIndex].url},e)))}else l=this.downloadUrl,f.push(n.createElement("input",{className:u.join(" "),type:"text",onChange:this.onUrlChange,value:this.state.url,disabled:s,id:"download-url-input"})),f.push(n.createElement(i,{className:"download-url-button",onClick:this.downloadUrl},"Explore"));return n.createElement("div",{className:"topbar"},n.createElement("div",{className:"wrapper"},n.createElement("div",{className:"topbar-wrapper"},n.createElement(o,null,n.createElement(a,null)),n.createElement("form",{className:"download-url-wrapper",onSubmit:l},f.map(((e,t)=>(0,n.cloneElement)(e,{key:t})))))))}}const u=TopBar;var c,f,l,h,p,d,_,y,m,g,v,b,w,I,x,B,k,C,q,L,j,z,P,D,U,W,K,V,$,H,Y,Z;function _extends(){return _extends=Object.assign?Object.assign.bind():function(e){for(var t=1;tn.createElement("svg",_extends({xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 407 116"},e),c||(c=n.createElement("defs",null,n.createElement("clipPath",{id:"logo_small_svg__clip-SW_TM-logo-on-dark"},n.createElement("path",{d:"M0 0h407v116H0z"})),n.createElement("style",null,".logo_small_svg__cls-2{fill:#fff}.logo_small_svg__cls-3{fill:#85ea2d}"))),n.createElement("g",{id:"logo_small_svg__SW_TM-logo-on-dark",style:{clipPath:"url(#logo_small_svg__clip-SW_TM-logo-on-dark)"}},n.createElement("g",{id:"logo_small_svg__SW_In-Product",transform:"translate(-.301)"},f||(f=n.createElement("path",{id:"logo_small_svg__Path_2936",d:"M359.15 70.674h-.7v-3.682h-1.26v-.6h3.219v.6h-1.259Z",className:"logo_small_svg__cls-2","data-name":"Path 2936"})),l||(l=n.createElement("path",{id:"logo_small_svg__Path_2937",d:"m363.217 70.674-1.242-3.574h-.023q.05.8.05 1.494v2.083h-.636v-4.286h.987l1.19 3.407h.017l1.225-3.407h.99v4.283h-.675v-2.118a30 30 0 0 1 .044-1.453h-.023l-1.286 3.571Z",className:"logo_small_svg__cls-2","data-name":"Path 2937"})),h||(h=n.createElement("path",{id:"logo_small_svg__Path_2938",d:"M50.328 97.669a47.642 47.642 0 1 1 47.643-47.642 47.64 47.64 0 0 1-47.643 47.642",className:"logo_small_svg__cls-3","data-name":"Path 2938"})),p||(p=n.createElement("path",{id:"logo_small_svg__Path_2939",d:"M50.328 4.769A45.258 45.258 0 1 1 5.07 50.027 45.26 45.26 0 0 1 50.328 4.769m0-4.769a50.027 50.027 0 1 0 50.027 50.027A50.027 50.027 0 0 0 50.328 0",className:"logo_small_svg__cls-3","data-name":"Path 2939"})),n.createElement("path",{id:"logo_small_svg__Path_2940",d:"M31.8 33.854c-.154 1.712.058 3.482-.057 5.213a43 43 0 0 1-.693 5.156 9.53 9.53 0 0 1-4.1 5.829c4.079 2.654 4.54 6.771 4.81 10.946.135 2.25.077 4.52.308 6.752.173 1.731.846 2.174 2.636 2.231.73.02 1.48 0 2.327 0v5.349c-5.29.9-9.657-.6-10.734-5.079a31 31 0 0 1-.654-5c-.117-1.789.076-3.578-.058-5.367-.386-4.906-1.02-6.56-5.713-6.791v-6.1a9 9 0 0 1 1.028-.173c2.577-.135 3.674-.924 4.231-3.463a29 29 0 0 0 .481-4.329 82 82 0 0 1 .6-8.406c.673-3.982 3.136-5.906 7.234-6.137 1.154-.057 2.327 0 3.655 0v5.464c-.558.038-1.039.115-1.539.115-3.336-.115-3.51 1.02-3.762 3.79m6.406 12.658h-.077a3.515 3.515 0 1 0-.346 7.021h.231a3.46 3.46 0 0 0 3.655-3.251v-.192a3.523 3.523 0 0 0-3.461-3.578Zm12.062 0a3.373 3.373 0 0 0-3.482 3.251 2 2 0 0 0 .02.327 3.3 3.3 0 0 0 3.578 3.443 3.263 3.263 0 0 0 3.443-3.558 3.308 3.308 0 0 0-3.557-3.463Zm12.351 0a3.59 3.59 0 0 0-3.655 3.482 3.53 3.53 0 0 0 3.536 3.539h.039c1.769.309 3.559-1.4 3.674-3.462a3.57 3.57 0 0 0-3.6-3.559Zm16.948.288c-2.232-.1-3.348-.846-3.9-2.962a21.5 21.5 0 0 1-.635-4.136c-.154-2.578-.135-5.175-.308-7.753-.4-6.117-4.828-8.252-11.254-7.195v5.31c1.019 0 1.808 0 2.6.019 1.366.019 2.4.539 2.539 2.059.135 1.385.135 2.789.27 4.193.269 2.79.422 5.618.9 8.369a8.72 8.72 0 0 0 3.921 5.348c-3.4 2.289-4.406 5.559-4.578 9.234-.1 2.52-.154 5.059-.289 7.6-.115 2.308-.923 3.058-3.251 3.116-.654.019-1.289.077-2.019.115v5.445c1.365 0 2.616.077 3.866 0 3.886-.231 6.233-2.117 7-5.887A49 49 0 0 0 75 63.4c.135-1.923.116-3.866.308-5.771.289-2.982 1.655-4.213 4.636-4.4a4 4 0 0 0 .828-.192v-6.1c-.5-.058-.843-.115-1.208-.135Z","data-name":"Path 2940",style:{fill:"#173647"}}),d||(d=n.createElement("path",{id:"logo_small_svg__Path_2941",d:"M152.273 58.122a11.23 11.23 0 0 1-4.384 9.424q-4.383 3.382-11.9 3.382-8.14 0-12.524-2.1V63.7a33 33 0 0 0 6.137 1.879 32.3 32.3 0 0 0 6.575.689q5.322 0 8.015-2.02a6.63 6.63 0 0 0 2.692-5.62 7.2 7.2 0 0 0-.954-3.9 8.9 8.9 0 0 0-3.194-2.8 44.6 44.6 0 0 0-6.81-2.911q-6.387-2.286-9.126-5.417a11.96 11.96 0 0 1-2.74-8.172A10.16 10.16 0 0 1 128.039 27q3.977-3.131 10.52-3.131a31 31 0 0 1 12.555 2.5L149.455 31a28.4 28.4 0 0 0-11.021-2.38 10.67 10.67 0 0 0-6.606 1.816 5.98 5.98 0 0 0-2.38 5.041 7.7 7.7 0 0 0 .877 3.9 8.24 8.24 0 0 0 2.959 2.786 36.7 36.7 0 0 0 6.371 2.8q7.2 2.566 9.91 5.51a10.84 10.84 0 0 1 2.708 7.649",className:"logo_small_svg__cls-2","data-name":"Path 2941"})),_||(_=n.createElement("path",{id:"logo_small_svg__Path_2942",d:"M185.288 70.3 179 50.17q-.594-1.848-2.222-8.391h-.251q-1.252 5.479-2.192 8.453L167.849 70.3h-6.011l-9.361-34.315h5.447q3.318 12.931 5.057 19.693a80 80 0 0 1 1.988 9.111h.25q.345-1.785 1.112-4.618t1.33-4.493l6.294-19.693h5.635l6.137 19.693a66 66 0 0 1 2.379 9.048h.251a33 33 0 0 1 .673-3.475q.548-2.347 6.528-25.266h5.385L191.456 70.3Z",className:"logo_small_svg__cls-2","data-name":"Path 2942"})),y||(y=n.createElement("path",{id:"logo_small_svg__Path_2943",d:"m225.115 70.3-1.033-4.885h-.25a14.45 14.45 0 0 1-5.119 4.368 15.6 15.6 0 0 1-6.372 1.143q-5.1 0-8-2.63t-2.9-7.483q0-10.4 16.626-10.9l5.823-.188V47.6q0-4.038-1.738-5.964t-5.552-1.923a22.6 22.6 0 0 0-9.706 2.63l-1.6-3.977a24.4 24.4 0 0 1 5.557-2.16 24 24 0 0 1 6.058-.783q6.136 0 9.1 2.724t2.959 8.735V70.3Zm-11.741-3.663a10.55 10.55 0 0 0 7.626-2.66 9.85 9.85 0 0 0 2.771-7.451v-3.1l-5.2.219q-6.2.219-8.939 1.926a5.8 5.8 0 0 0-2.74 5.306 5.35 5.35 0 0 0 1.707 4.29 7.08 7.08 0 0 0 4.775 1.472Z",className:"logo_small_svg__cls-2","data-name":"Path 2943"})),m||(m=n.createElement("path",{id:"logo_small_svg__Path_2944",d:"M264.6 35.987v3.287l-6.356.752a11.16 11.16 0 0 1 2.255 6.856 10.15 10.15 0 0 1-3.444 8.047q-3.444 3-9.456 3a15.7 15.7 0 0 1-2.88-.25Q241.4 59.438 241.4 62.1a2.24 2.24 0 0 0 1.159 2.082 8.46 8.46 0 0 0 3.976.673h6.074q5.573 0 8.563 2.348a8.16 8.16 0 0 1 2.99 6.825 9.74 9.74 0 0 1-4.571 8.688q-4.572 2.989-13.338 2.99-6.732 0-10.379-2.5a8.09 8.09 0 0 1-3.647-7.076 7.95 7.95 0 0 1 2-5.417 10.2 10.2 0 0 1 5.636-3.1 5.43 5.43 0 0 1-2.207-1.847 4.9 4.9 0 0 1-.893-2.912 5.53 5.53 0 0 1 1-3.288 10.5 10.5 0 0 1 3.162-2.723 9.28 9.28 0 0 1-4.336-3.726 10.95 10.95 0 0 1-1.675-6.012q0-5.634 3.382-8.688t9.58-3.052a17.4 17.4 0 0 1 4.853.626Zm-27.367 40.075a4.66 4.66 0 0 0 2.348 4.227 12.97 12.97 0 0 0 6.732 1.44q6.543 0 9.69-1.956a5.99 5.99 0 0 0 3.147-5.307q0-2.787-1.723-3.867t-6.481-1.08h-6.23a8.2 8.2 0 0 0-5.51 1.69 6.04 6.04 0 0 0-1.973 4.853m2.818-29.086a6.98 6.98 0 0 0 2.035 5.448 8.12 8.12 0 0 0 5.667 1.847q7.608 0 7.608-7.389 0-7.733-7.7-7.733a7.63 7.63 0 0 0-5.635 1.972q-1.976 1.973-1.975 5.855",className:"logo_small_svg__cls-2","data-name":"Path 2944"})),g||(g=n.createElement("path",{id:"logo_small_svg__Path_2945",d:"M299.136 35.987v3.287l-6.356.752a11.17 11.17 0 0 1 2.254 6.856 10.15 10.15 0 0 1-3.444 8.047q-3.444 3-9.455 3a15.7 15.7 0 0 1-2.88-.25q-3.32 1.754-3.319 4.415a2.24 2.24 0 0 0 1.158 2.082 8.46 8.46 0 0 0 3.976.673h6.074q5.574 0 8.563 2.348a8.16 8.16 0 0 1 2.99 6.825 9.74 9.74 0 0 1-4.571 8.688q-4.57 2.989-13.337 2.99-6.732 0-10.379-2.5a8.09 8.09 0 0 1-3.648-7.076 7.95 7.95 0 0 1 2-5.417 10.2 10.2 0 0 1 5.636-3.1 5.43 5.43 0 0 1-2.208-1.847 4.9 4.9 0 0 1-.892-2.912 5.53 5.53 0 0 1 1-3.288 10.5 10.5 0 0 1 3.162-2.723 9.27 9.27 0 0 1-4.336-3.726 10.95 10.95 0 0 1-1.675-6.012q0-5.634 3.381-8.688t9.581-3.052a17.4 17.4 0 0 1 4.853.626Zm-27.364 40.075a4.66 4.66 0 0 0 2.348 4.227 12.97 12.97 0 0 0 6.731 1.44q6.544 0 9.691-1.956a5.99 5.99 0 0 0 3.146-5.307q0-2.787-1.722-3.867t-6.481-1.08h-6.23a8.2 8.2 0 0 0-5.511 1.69 6.04 6.04 0 0 0-1.972 4.853m2.818-29.086a6.98 6.98 0 0 0 2.035 5.448 8.12 8.12 0 0 0 5.667 1.847q7.607 0 7.608-7.389 0-7.733-7.7-7.733a7.63 7.63 0 0 0-5.635 1.972q-1.975 1.973-1.975 5.855",className:"logo_small_svg__cls-2","data-name":"Path 2945"})),v||(v=n.createElement("path",{id:"logo_small_svg__Path_2946",d:"M316.778 70.928q-7.608 0-12.007-4.634t-4.4-12.868q0-8.3 4.086-13.181a13.57 13.57 0 0 1 10.974-4.884 12.94 12.94 0 0 1 10.207 4.239q3.762 4.247 3.762 11.2v3.287h-23.643q.156 6.044 3.053 9.174t8.156 3.131a27.6 27.6 0 0 0 10.958-2.317v4.634a27.5 27.5 0 0 1-5.213 1.706 29.3 29.3 0 0 1-5.933.513m-1.409-31.215a8.49 8.49 0 0 0-6.591 2.692 12.4 12.4 0 0 0-2.9 7.452h17.94q0-4.916-2.191-7.53a7.71 7.71 0 0 0-6.258-2.614",className:"logo_small_svg__cls-2","data-name":"Path 2946"})),b||(b=n.createElement("path",{id:"logo_small_svg__Path_2947",d:"M350.9 35.361a20.4 20.4 0 0 1 4.1.375l-.721 4.822a17.7 17.7 0 0 0-3.757-.47 9.14 9.14 0 0 0-7.122 3.382 12.33 12.33 0 0 0-2.959 8.422V70.3h-5.2V35.987h4.29l.6 6.356h.25a15.1 15.1 0 0 1 4.6-5.166 10.36 10.36 0 0 1 5.919-1.816",className:"logo_small_svg__cls-2","data-name":"Path 2947"})),w||(w=n.createElement("path",{id:"logo_small_svg__Path_2948",d:"M255.857 96.638s-3.43-.391-4.85-.391c-2.058 0-3.111.735-3.111 2.18 0 1.568.882 1.935 3.748 2.719 3.527.98 4.8 1.911 4.8 4.777 0 3.675-2.3 5.267-5.61 5.267a36 36 0 0 1-5.487-.662l.27-2.18s3.306.441 5.046.441c2.082 0 3.037-.931 3.037-2.7 0-1.421-.759-1.91-3.331-2.523-3.626-.93-5.193-2.033-5.193-4.948 0-3.381 2.229-4.776 5.585-4.776a37 37 0 0 1 5.315.587Z",className:"logo_small_svg__cls-2","data-name":"Path 2948"})),I||(I=n.createElement("path",{id:"logo_small_svg__Path_2949",d:"M262.967 94.14h4.733l3.748 13.106L275.2 94.14h4.752v16.78H277.2v-14.5h-.145l-4.191 13.816h-2.842l-4.191-13.816h-.145v14.5h-2.719Z",className:"logo_small_svg__cls-2","data-name":"Path 2949"})),x||(x=n.createElement("path",{id:"logo_small_svg__Path_2950",d:"M322.057 94.14H334.3v2.425h-4.728v14.355h-2.743V96.565h-4.777Z",className:"logo_small_svg__cls-2","data-name":"Path 2950"})),B||(B=n.createElement("path",{id:"logo_small_svg__Path_2951",d:"M346.137 94.14c3.332 0 5.12 1.249 5.12 4.361 0 2.033-.637 3.037-1.984 3.772 1.445.563 2.4 1.592 2.4 3.9 0 3.43-2.081 4.752-5.339 4.752h-6.566V94.14Zm-3.65 2.352v4.8h3.6c1.666 0 2.4-.832 2.4-2.474 0-1.617-.833-2.327-2.5-2.327Zm0 7.1v4.973h3.7c1.689 0 2.694-.539 2.694-2.548 0-1.911-1.421-2.425-2.744-2.425Z",className:"logo_small_svg__cls-2","data-name":"Path 2951"})),k||(k=n.createElement("path",{id:"logo_small_svg__Path_2952",d:"M358.414 94.14H369v2.377h-7.864v4.751h6.394v2.332h-6.394v4.924H369v2.4h-10.586Z",className:"logo_small_svg__cls-2","data-name":"Path 2952"})),C||(C=n.createElement("path",{id:"logo_small_svg__Path_2953",d:"M378.747 94.14h5.414l4.164 16.78h-2.744l-1.239-4.92h-5.777l-1.239 4.923h-2.719Zm.361 9.456h4.708l-1.737-7.178h-1.225Z",className:"logo_small_svg__cls-2","data-name":"Path 2953"})),q||(q=n.createElement("path",{id:"logo_small_svg__Path_2954",d:"M397.1 105.947v4.973h-2.719V94.14h6.37c3.7 0 5.683 2.12 5.683 5.843 0 2.376-.956 4.519-2.744 5.352l2.769 5.585h-2.989l-2.426-4.973Zm3.651-9.455H397.1v7.1h3.7c2.057 0 2.841-1.85 2.841-3.589 0-1.9-.934-3.511-2.894-3.511Z",className:"logo_small_svg__cls-2","data-name":"Path 2954"})),L||(L=n.createElement("path",{id:"logo_small_svg__Path_2955",d:"M290.013 94.14h5.413l4.164 16.78h-2.743l-1.239-4.92h-5.777l-1.239 4.923h-2.719Zm.361 9.456h4.707l-1.737-7.178h-1.225Z",className:"logo_small_svg__cls-2","data-name":"Path 2955"})),j||(j=n.createElement("path",{id:"logo_small_svg__Path_2956",d:"M308.362 105.947v4.973h-2.719V94.14h6.369c3.7 0 5.683 2.12 5.683 5.843 0 2.376-.955 4.519-2.743 5.352l2.768 5.585h-2.989l-2.425-4.973Zm3.65-9.455h-3.65v7.1h3.7c2.058 0 2.841-1.85 2.841-3.589-.003-1.903-.931-3.511-2.891-3.511",className:"logo_small_svg__cls-2","data-name":"Path 2956"})),z||(z=n.createElement("path",{id:"logo_small_svg__Path_2957",d:"M130.606 107.643a3.02 3.02 0 0 1-1.18 2.537 5.1 5.1 0 0 1-3.2.91 8 8 0 0 1-3.371-.564v-1.383a9 9 0 0 0 1.652.506 8.7 8.7 0 0 0 1.77.186 3.57 3.57 0 0 0 2.157-.544 1.78 1.78 0 0 0 .725-1.512 1.95 1.95 0 0 0-.257-1.05 2.4 2.4 0 0 0-.86-.754 12 12 0 0 0-1.833-.784 5.84 5.84 0 0 1-2.456-1.458 3.2 3.2 0 0 1-.738-2.2 2.74 2.74 0 0 1 1.071-2.267 4.44 4.44 0 0 1 2.831-.843 8.3 8.3 0 0 1 3.38.675l-.447 1.247a7.6 7.6 0 0 0-2.966-.641 2.88 2.88 0 0 0-1.779.489 1.61 1.61 0 0 0-.64 1.357 2.1 2.1 0 0 0 .236 1.049 2.2 2.2 0 0 0 .8.75 10 10 0 0 0 1.715.754 6.8 6.8 0 0 1 2.667 1.483 2.92 2.92 0 0 1 .723 2.057",className:"logo_small_svg__cls-2","data-name":"Path 2957"})),P||(P=n.createElement("path",{id:"logo_small_svg__Path_2958",d:"M134.447 101.686v5.991a2.4 2.4 0 0 0 .515 1.686 2.1 2.1 0 0 0 1.609.556 2.63 2.63 0 0 0 2.12-.792 4 4 0 0 0 .67-2.587v-4.854h1.4v9.236H139.6l-.2-1.239h-.075a2.8 2.8 0 0 1-1.193 1.045 4 4 0 0 1-1.74.362 3.53 3.53 0 0 1-2.524-.8 3.4 3.4 0 0 1-.839-2.562v-6.042Z",className:"logo_small_svg__cls-2","data-name":"Path 2958"})),D||(D=n.createElement("path",{id:"logo_small_svg__Path_2959",d:"M148.206 111.09a4 4 0 0 1-1.647-.333 3.1 3.1 0 0 1-1.252-1.023h-.1a12 12 0 0 1 .1 1.533v3.8h-1.4v-13.381h1.137l.194 1.264h.067a3.26 3.26 0 0 1 1.256-1.1 3.8 3.8 0 0 1 1.643-.337 3.41 3.41 0 0 1 2.836 1.256 6.68 6.68 0 0 1-.017 7.057 3.42 3.42 0 0 1-2.817 1.264m-.2-8.385a2.48 2.48 0 0 0-2.048.784 4.04 4.04 0 0 0-.649 2.494v.312a4.63 4.63 0 0 0 .649 2.785 2.47 2.47 0 0 0 2.082.839 2.16 2.16 0 0 0 1.875-.969 4.6 4.6 0 0 0 .678-2.671 4.43 4.43 0 0 0-.678-2.651 2.23 2.23 0 0 0-1.915-.923Z",className:"logo_small_svg__cls-2","data-name":"Path 2959"})),U||(U=n.createElement("path",{id:"logo_small_svg__Path_2960",d:"M159.039 111.09a4 4 0 0 1-1.647-.333 3.1 3.1 0 0 1-1.252-1.023h-.1a12 12 0 0 1 .1 1.533v3.8h-1.4v-13.381h1.137l.194 1.264h.067a3.26 3.26 0 0 1 1.256-1.1 3.8 3.8 0 0 1 1.643-.337 3.41 3.41 0 0 1 2.836 1.256 6.68 6.68 0 0 1-.017 7.057 3.42 3.42 0 0 1-2.817 1.264m-.2-8.385a2.48 2.48 0 0 0-2.048.784 4.04 4.04 0 0 0-.649 2.494v.312a4.63 4.63 0 0 0 .649 2.785 2.47 2.47 0 0 0 2.082.839 2.16 2.16 0 0 0 1.875-.969 4.6 4.6 0 0 0 .678-2.671 4.43 4.43 0 0 0-.678-2.651 2.23 2.23 0 0 0-1.911-.923Z",className:"logo_small_svg__cls-2","data-name":"Path 2960"})),W||(W=n.createElement("path",{id:"logo_small_svg__Path_2961",d:"M173.612 106.3a5.1 5.1 0 0 1-1.137 3.527 4 4 0 0 1-3.143 1.268 4.17 4.17 0 0 1-2.2-.581 3.84 3.84 0 0 1-1.483-1.669 5.8 5.8 0 0 1-.522-2.545 5.1 5.1 0 0 1 1.129-3.518 4 4 0 0 1 3.135-1.26 3.9 3.9 0 0 1 3.08 1.29 5.07 5.07 0 0 1 1.141 3.488m-7.036 0a4.4 4.4 0 0 0 .708 2.7 2.81 2.81 0 0 0 4.167 0 4.37 4.37 0 0 0 .712-2.7 4.3 4.3 0 0 0-.712-2.675 2.5 2.5 0 0 0-2.1-.915 2.46 2.46 0 0 0-2.072.9 4.33 4.33 0 0 0-.7 2.69Z",className:"logo_small_svg__cls-2","data-name":"Path 2961"})),K||(K=n.createElement("path",{id:"logo_small_svg__Path_2962",d:"M180.525 101.517a5.5 5.5 0 0 1 1.1.1l-.194 1.3a4.8 4.8 0 0 0-1.011-.127 2.46 2.46 0 0 0-1.917.911 3.32 3.32 0 0 0-.8 2.267v4.955h-1.4v-9.236h1.154l.16 1.71h.068a4.05 4.05 0 0 1 1.238-1.39 2.8 2.8 0 0 1 1.6-.49Z",className:"logo_small_svg__cls-2","data-name":"Path 2962"})),V||(V=n.createElement("path",{id:"logo_small_svg__Path_2963",d:"M187.363 109.936a4.5 4.5 0 0 0 .716-.055 4 4 0 0 0 .548-.114v1.07a2.5 2.5 0 0 1-.67.181 5 5 0 0 1-.8.072q-2.68 0-2.68-2.823v-5.494h-1.323v-.673l1.323-.582.59-1.972h.809v2.141h2.68v1.087h-2.68v5.435a1.87 1.87 0 0 0 .4 1.281 1.38 1.38 0 0 0 1.087.446",className:"logo_small_svg__cls-2","data-name":"Path 2963"})),$||($=n.createElement("path",{id:"logo_small_svg__Path_2964",d:"M194.538 111.09a4.24 4.24 0 0 1-3.231-1.247 4.82 4.82 0 0 1-1.184-3.463 5.36 5.36 0 0 1 1.1-3.548 3.65 3.65 0 0 1 2.954-1.315 3.48 3.48 0 0 1 2.747 1.142 4.38 4.38 0 0 1 1.011 3.013v.885h-6.362a3.66 3.66 0 0 0 .822 2.469 2.84 2.84 0 0 0 2.2.843 7.4 7.4 0 0 0 2.949-.624v1.247a7.4 7.4 0 0 1-1.4.459 8 8 0 0 1-1.6.139Zm-.379-8.4a2.29 2.29 0 0 0-1.774.725 3.34 3.34 0 0 0-.779 2.006h4.828a3.07 3.07 0 0 0-.59-2.027 2.08 2.08 0 0 0-1.685-.706Z",className:"logo_small_svg__cls-2","data-name":"Path 2964"})),H||(H=n.createElement("path",{id:"logo_small_svg__Path_2965",d:"M206.951 109.683h-.076a3.29 3.29 0 0 1-2.9 1.407 3.43 3.43 0 0 1-2.819-1.239 5.45 5.45 0 0 1-1.006-3.522 5.54 5.54 0 0 1 1.011-3.548 3.4 3.4 0 0 1 2.814-1.264 3.36 3.36 0 0 1 2.883 1.365h.109l-.059-.665-.034-.649v-3.759h1.4v13.113h-1.138Zm-2.8.236a2.55 2.55 0 0 0 2.078-.779 3.95 3.95 0 0 0 .644-2.516v-.3a4.64 4.64 0 0 0-.653-2.8 2.48 2.48 0 0 0-2.086-.839 2.14 2.14 0 0 0-1.883.957 4.76 4.76 0 0 0-.653 2.7 4.55 4.55 0 0 0 .649 2.671 2.2 2.2 0 0 0 1.906.906Z",className:"logo_small_svg__cls-2","data-name":"Path 2965"})),Y||(Y=n.createElement("path",{id:"logo_small_svg__Path_2966",d:"M220.712 101.534a3.44 3.44 0 0 1 2.827 1.243 6.65 6.65 0 0 1-.009 7.053 3.42 3.42 0 0 1-2.818 1.26 4 4 0 0 1-1.648-.333 3.1 3.1 0 0 1-1.251-1.023h-.1l-.295 1.188h-1V97.809h1.4V101q0 1.069-.068 1.921h.068a3.32 3.32 0 0 1 2.894-1.387m-.2 1.171a2.44 2.44 0 0 0-2.064.822 6.34 6.34 0 0 0 .017 5.553 2.46 2.46 0 0 0 2.081.839 2.16 2.16 0 0 0 1.922-.94 4.83 4.83 0 0 0 .632-2.7 4.64 4.64 0 0 0-.632-2.689 2.24 2.24 0 0 0-1.959-.885Z",className:"logo_small_svg__cls-2","data-name":"Path 2966"})),Z||(Z=n.createElement("path",{id:"logo_small_svg__Path_2967",d:"M225.758 101.686h1.5l2.023 5.267a20 20 0 0 1 .826 2.6h.067q.109-.431.459-1.471t2.288-6.4h1.5l-3.969 10.518a5.25 5.25 0 0 1-1.378 2.212 2.93 2.93 0 0 1-1.934.653 5.7 5.7 0 0 1-1.264-.143V113.8a5 5 0 0 0 1.037.1 2.136 2.136 0 0 0 2.056-1.618l.514-1.314Z",className:"logo_small_svg__cls-2","data-name":"Path 2967"}))))),components_Logo=()=>n.createElement(logo_small,{height:"40"}),top_bar=()=>({components:{Topbar:u,Logo:components_Logo}});function isNothing(e){return null==e}var J={isNothing,isObject:function js_yaml_isObject(e){return"object"==typeof e&&null!==e},toArray:function toArray(e){return Array.isArray(e)?e:isNothing(e)?[]:[e]},repeat:function repeat(e,t){var r,n="";for(r=0;rs&&(t=n-s+(o=" ... ").length),r-n>s&&(r=n+s-(a=" ...").length),{str:o+e.slice(t,r).replace(/\t/g,"→")+a,pos:n-t+o.length}}function padStart(e,t){return J.repeat(" ",t-e.length)+e}var te=function makeSnippet(e,t){if(t=Object.create(t||null),!e.buffer)return null;t.maxLength||(t.maxLength=79),"number"!=typeof t.indent&&(t.indent=1),"number"!=typeof t.linesBefore&&(t.linesBefore=3),"number"!=typeof t.linesAfter&&(t.linesAfter=2);for(var r,n=/\r?\n|\r|\0/g,i=[0],o=[],a=-1;r=n.exec(e.buffer);)o.push(r.index),i.push(r.index+r[0].length),e.position<=r.index&&a<0&&(a=i.length-2);a<0&&(a=i.length-1);var s,u,c="",f=Math.min(e.line+t.linesAfter,o.length).toString().length,l=t.maxLength-(t.indent+f+3);for(s=1;s<=t.linesBefore&&!(a-s<0);s++)u=getLine(e.buffer,i[a-s],o[a-s],e.position-(i[a]-i[a-s]),l),c=J.repeat(" ",t.indent)+padStart((e.line-s+1).toString(),f)+" | "+u.str+"\n"+c;for(u=getLine(e.buffer,i[a],o[a],e.position,l),c+=J.repeat(" ",t.indent)+padStart((e.line+1).toString(),f)+" | "+u.str+"\n",c+=J.repeat("-",t.indent+f+3+u.pos)+"^\n",s=1;s<=t.linesAfter&&!(a+s>=o.length);s++)u=getLine(e.buffer,i[a+s],o[a+s],e.position-(i[a]-i[a+s]),l),c+=J.repeat(" ",t.indent)+padStart((e.line+s+1).toString(),f)+" | "+u.str+"\n";return c.replace(/\n$/,"")},re=["kind","multi","resolve","construct","instanceOf","predicate","represent","representName","defaultStyle","styleAliases"],ne=["scalar","sequence","mapping"];var ie=function Type$1(e,t){if(t=t||{},Object.keys(t).forEach((function(t){if(-1===re.indexOf(t))throw new ee('Unknown option "'+t+'" is met in definition of "'+e+'" YAML type.')})),this.options=t,this.tag=e,this.kind=t.kind||null,this.resolve=t.resolve||function(){return!0},this.construct=t.construct||function(e){return e},this.instanceOf=t.instanceOf||null,this.predicate=t.predicate||null,this.represent=t.represent||null,this.representName=t.representName||null,this.defaultStyle=t.defaultStyle||null,this.multi=t.multi||!1,this.styleAliases=function compileStyleAliases(e){var t={};return null!==e&&Object.keys(e).forEach((function(r){e[r].forEach((function(e){t[String(e)]=r}))})),t}(t.styleAliases||null),-1===ne.indexOf(this.kind))throw new ee('Unknown kind "'+this.kind+'" is specified for "'+e+'" YAML type.')};function compileList(e,t){var r=[];return e[t].forEach((function(e){var t=r.length;r.forEach((function(r,n){r.tag===e.tag&&r.kind===e.kind&&r.multi===e.multi&&(t=n)})),r[t]=e})),r}function Schema$1(e){return this.extend(e)}Schema$1.prototype.extend=function extend(e){var t=[],r=[];if(e instanceof ie)r.push(e);else if(Array.isArray(e))r=r.concat(e);else{if(!e||!Array.isArray(e.implicit)&&!Array.isArray(e.explicit))throw new ee("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");e.implicit&&(t=t.concat(e.implicit)),e.explicit&&(r=r.concat(e.explicit))}t.forEach((function(e){if(!(e instanceof ie))throw new ee("Specified list of YAML types (or a single Type object) contains a non-Type object.");if(e.loadKind&&"scalar"!==e.loadKind)throw new ee("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");if(e.multi)throw new ee("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.")})),r.forEach((function(e){if(!(e instanceof ie))throw new ee("Specified list of YAML types (or a single Type object) contains a non-Type object.")}));var n=Object.create(Schema$1.prototype);return n.implicit=(this.implicit||[]).concat(t),n.explicit=(this.explicit||[]).concat(r),n.compiledImplicit=compileList(n,"implicit"),n.compiledExplicit=compileList(n,"explicit"),n.compiledTypeMap=function compileMap(){var e,t,r={scalar:{},sequence:{},mapping:{},fallback:{},multi:{scalar:[],sequence:[],mapping:[],fallback:[]}};function collectType(e){e.multi?(r.multi[e.kind].push(e),r.multi.fallback.push(e)):r[e.kind][e.tag]=r.fallback[e.tag]=e}for(e=0,t=arguments.length;e=0?"0b"+e.toString(2):"-0b"+e.toString(2).slice(1)},octal:function(e){return e>=0?"0o"+e.toString(8):"-0o"+e.toString(8).slice(1)},decimal:function(e){return e.toString(10)},hexadecimal:function(e){return e>=0?"0x"+e.toString(16).toUpperCase():"-0x"+e.toString(16).toUpperCase().slice(1)}},defaultStyle:"decimal",styleAliases:{binary:[2,"bin"],octal:[8,"oct"],decimal:[10,"dec"],hexadecimal:[16,"hex"]}}),pe=new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");var de=/^[-+]?[0-9]+e/;var _e=new ie("tag:yaml.org,2002:float",{kind:"scalar",resolve:function resolveYamlFloat(e){return null!==e&&!(!pe.test(e)||"_"===e[e.length-1])},construct:function constructYamlFloat(e){var t,r;return r="-"===(t=e.replace(/_/g,"").toLowerCase())[0]?-1:1,"+-".indexOf(t[0])>=0&&(t=t.slice(1)),".inf"===t?1===r?Number.POSITIVE_INFINITY:Number.NEGATIVE_INFINITY:".nan"===t?NaN:r*parseFloat(t,10)},predicate:function isFloat(e){return"[object Number]"===Object.prototype.toString.call(e)&&(e%1!=0||J.isNegativeZero(e))},represent:function representYamlFloat(e,t){var r;if(isNaN(e))switch(t){case"lowercase":return".nan";case"uppercase":return".NAN";case"camelcase":return".NaN"}else if(Number.POSITIVE_INFINITY===e)switch(t){case"lowercase":return".inf";case"uppercase":return".INF";case"camelcase":return".Inf"}else if(Number.NEGATIVE_INFINITY===e)switch(t){case"lowercase":return"-.inf";case"uppercase":return"-.INF";case"camelcase":return"-.Inf"}else if(J.isNegativeZero(e))return"-0.0";return r=e.toString(10),de.test(r)?r.replace("e",".e"):r},defaultStyle:"lowercase"}),ye=ce.extend({implicit:[fe,le,he,_e]}),me=ye,ge=new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"),ve=new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");var be=new ie("tag:yaml.org,2002:timestamp",{kind:"scalar",resolve:function resolveYamlTimestamp(e){return null!==e&&(null!==ge.exec(e)||null!==ve.exec(e))},construct:function constructYamlTimestamp(e){var t,r,n,i,o,a,s,u,c=0,f=null;if(null===(t=ge.exec(e))&&(t=ve.exec(e)),null===t)throw new Error("Date resolve error");if(r=+t[1],n=+t[2]-1,i=+t[3],!t[4])return new Date(Date.UTC(r,n,i));if(o=+t[4],a=+t[5],s=+t[6],t[7]){for(c=t[7].slice(0,3);c.length<3;)c+="0";c=+c}return t[9]&&(f=6e4*(60*+t[10]+ +(t[11]||0)),"-"===t[9]&&(f=-f)),u=new Date(Date.UTC(r,n,i,o,a,s,c)),f&&u.setTime(u.getTime()-f),u},instanceOf:Date,represent:function representYamlTimestamp(e){return e.toISOString()}});var Se=new ie("tag:yaml.org,2002:merge",{kind:"scalar",resolve:function resolveYamlMerge(e){return"<<"===e||null===e}}),we="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";var Ie=new ie("tag:yaml.org,2002:binary",{kind:"scalar",resolve:function resolveYamlBinary(e){if(null===e)return!1;var t,r,n=0,i=e.length,o=we;for(r=0;r64)){if(t<0)return!1;n+=6}return n%8==0},construct:function constructYamlBinary(e){var t,r,n=e.replace(/[\r\n=]/g,""),i=n.length,o=we,a=0,s=[];for(t=0;t>16&255),s.push(a>>8&255),s.push(255&a)),a=a<<6|o.indexOf(n.charAt(t));return 0===(r=i%4*6)?(s.push(a>>16&255),s.push(a>>8&255),s.push(255&a)):18===r?(s.push(a>>10&255),s.push(a>>2&255)):12===r&&s.push(a>>4&255),new Uint8Array(s)},predicate:function isBinary(e){return"[object Uint8Array]"===Object.prototype.toString.call(e)},represent:function representYamlBinary(e){var t,r,n="",i=0,o=e.length,a=we;for(t=0;t>18&63],n+=a[i>>12&63],n+=a[i>>6&63],n+=a[63&i]),i=(i<<8)+e[t];return 0===(r=o%3)?(n+=a[i>>18&63],n+=a[i>>12&63],n+=a[i>>6&63],n+=a[63&i]):2===r?(n+=a[i>>10&63],n+=a[i>>4&63],n+=a[i<<2&63],n+=a[64]):1===r&&(n+=a[i>>2&63],n+=a[i<<4&63],n+=a[64],n+=a[64]),n}}),xe=Object.prototype.hasOwnProperty,Ee=Object.prototype.toString;var Oe=new ie("tag:yaml.org,2002:omap",{kind:"sequence",resolve:function resolveYamlOmap(e){if(null===e)return!0;var t,r,n,i,o,a=[],s=e;for(t=0,r=s.length;t>10),56320+(e-65536&1023))}for(var ze=new Array(256),Pe=new Array(256),Fe=0;Fe<256;Fe++)ze[Fe]=simpleEscapeSequence(Fe)?1:0,Pe[Fe]=simpleEscapeSequence(Fe);function State$1(e,t){this.input=e,this.filename=t.filename||null,this.schema=t.schema||Me,this.onWarning=t.onWarning||null,this.legacy=t.legacy||!1,this.json=t.json||!1,this.listener=t.listener||null,this.implicitTypes=this.schema.compiledImplicit,this.typeMap=this.schema.compiledTypeMap,this.length=e.length,this.position=0,this.line=0,this.lineStart=0,this.lineIndent=0,this.firstTabInLine=-1,this.documents=[]}function generateError(e,t){var r={name:e.filename,buffer:e.input.slice(0,-1),position:e.position,line:e.line,column:e.position-e.lineStart};return r.snippet=te(r),new ee(t,r)}function throwError(e,t){throw generateError(e,t)}function throwWarning(e,t){e.onWarning&&e.onWarning.call(null,generateError(e,t))}var De={YAML:function handleYamlDirective(e,t,r){var n,i,o;null!==e.version&&throwError(e,"duplication of %YAML directive"),1!==r.length&&throwError(e,"YAML directive accepts exactly one argument"),null===(n=/^([0-9]+)\.([0-9]+)$/.exec(r[0]))&&throwError(e,"ill-formed argument of the YAML directive"),i=parseInt(n[1],10),o=parseInt(n[2],10),1!==i&&throwError(e,"unacceptable YAML version of the document"),e.version=r[0],e.checkLineBreaks=o<2,1!==o&&2!==o&&throwWarning(e,"unsupported YAML version of the document")},TAG:function handleTagDirective(e,t,r){var n,i;2!==r.length&&throwError(e,"TAG directive accepts exactly two arguments"),n=r[0],i=r[1],Te.test(n)||throwError(e,"ill-formed tag handle (first argument) of the TAG directive"),qe.call(e.tagMap,n)&&throwError(e,'there is a previously declared suffix for "'+n+'" tag handle'),Re.test(i)||throwError(e,"ill-formed tag prefix (second argument) of the TAG directive");try{i=decodeURIComponent(i)}catch(t){throwError(e,"tag prefix is malformed: "+i)}e.tagMap[n]=i}};function captureSegment(e,t,r,n){var i,o,a,s;if(t1&&(e.result+=J.repeat("\n",t-1))}function readBlockSequence(e,t){var r,n,i=e.tag,o=e.anchor,a=[],s=!1;if(-1!==e.firstTabInLine)return!1;for(null!==e.anchor&&(e.anchorMap[e.anchor]=a),n=e.input.charCodeAt(e.position);0!==n&&(-1!==e.firstTabInLine&&(e.position=e.firstTabInLine,throwError(e,"tab characters must not be used in indentation")),45===n)&&is_WS_OR_EOL(e.input.charCodeAt(e.position+1));)if(s=!0,e.position++,skipSeparationSpace(e,!0,-1)&&e.lineIndent<=t)a.push(null),n=e.input.charCodeAt(e.position);else if(r=e.line,composeNode(e,t,3,!1,!0),a.push(e.result),skipSeparationSpace(e,!0,-1),n=e.input.charCodeAt(e.position),(e.line===r||e.lineIndent>t)&&0!==n)throwError(e,"bad indentation of a sequence entry");else if(e.lineIndentt?d=1:e.lineIndent===t?d=0:e.lineIndentt?d=1:e.lineIndent===t?d=0:e.lineIndentt)&&(m&&(a=e.line,s=e.lineStart,u=e.position),composeNode(e,t,4,!0,i)&&(m?_=e.result:y=e.result),m||(storeMappingPair(e,h,p,d,_,y,a,s,u),d=_=y=null),skipSeparationSpace(e,!0,-1),c=e.input.charCodeAt(e.position)),(e.line===o||e.lineIndent>t)&&0!==c)throwError(e,"bad indentation of a mapping entry");else if(e.lineIndent=0))break;0===i?throwError(e,"bad explicit indentation width of a block scalar; it cannot be less than one"):c?throwError(e,"repeat of an indentation width identifier"):(f=t+i-1,c=!0)}if(is_WHITE_SPACE(o)){do{o=e.input.charCodeAt(++e.position)}while(is_WHITE_SPACE(o));if(35===o)do{o=e.input.charCodeAt(++e.position)}while(!is_EOL(o)&&0!==o)}for(;0!==o;){for(readLineBreak(e),e.lineIndent=0,o=e.input.charCodeAt(e.position);(!c||e.lineIndentf&&(f=e.lineIndent),is_EOL(o))l++;else{if(e.lineIndent0){for(i=a,o=0;i>0;i--)(a=fromHexCode(s=e.input.charCodeAt(++e.position)))>=0?o=(o<<4)+a:throwError(e,"expected hexadecimal character");e.result+=charFromCodepoint(o),e.position++}else throwError(e,"unknown escape sequence");r=n=e.position}else is_EOL(s)?(captureSegment(e,r,n,!0),writeFoldedLines(e,skipSeparationSpace(e,!1,t)),r=n=e.position):e.position===e.lineStart&&testDocumentSeparator(e)?throwError(e,"unexpected end of the document within a double quoted scalar"):(e.position++,n=e.position)}throwError(e,"unexpected end of the stream within a double quoted scalar")}(e,h)?y=!0:!function readAlias(e){var t,r,n;if(42!==(n=e.input.charCodeAt(e.position)))return!1;for(n=e.input.charCodeAt(++e.position),t=e.position;0!==n&&!is_WS_OR_EOL(n)&&!is_FLOW_INDICATOR(n);)n=e.input.charCodeAt(++e.position);return e.position===t&&throwError(e,"name of an alias node must contain at least one character"),r=e.input.slice(t,e.position),qe.call(e.anchorMap,r)||throwError(e,'unidentified alias "'+r+'"'),e.result=e.anchorMap[r],skipSeparationSpace(e,!0,-1),!0}(e)?function readPlainScalar(e,t,r){var n,i,o,a,s,u,c,f,l=e.kind,h=e.result;if(is_WS_OR_EOL(f=e.input.charCodeAt(e.position))||is_FLOW_INDICATOR(f)||35===f||38===f||42===f||33===f||124===f||62===f||39===f||34===f||37===f||64===f||96===f)return!1;if((63===f||45===f)&&(is_WS_OR_EOL(n=e.input.charCodeAt(e.position+1))||r&&is_FLOW_INDICATOR(n)))return!1;for(e.kind="scalar",e.result="",i=o=e.position,a=!1;0!==f;){if(58===f){if(is_WS_OR_EOL(n=e.input.charCodeAt(e.position+1))||r&&is_FLOW_INDICATOR(n))break}else if(35===f){if(is_WS_OR_EOL(e.input.charCodeAt(e.position-1)))break}else{if(e.position===e.lineStart&&testDocumentSeparator(e)||r&&is_FLOW_INDICATOR(f))break;if(is_EOL(f)){if(s=e.line,u=e.lineStart,c=e.lineIndent,skipSeparationSpace(e,!1,-1),e.lineIndent>=t){a=!0,f=e.input.charCodeAt(e.position);continue}e.position=o,e.line=s,e.lineStart=u,e.lineIndent=c;break}}a&&(captureSegment(e,i,o,!1),writeFoldedLines(e,e.line-s),i=o=e.position,a=!1),is_WHITE_SPACE(f)||(o=e.position+1),f=e.input.charCodeAt(++e.position)}return captureSegment(e,i,o,!1),!!e.result||(e.kind=l,e.result=h,!1)}(e,h,1===r)&&(y=!0,null===e.tag&&(e.tag="?")):(y=!0,null===e.tag&&null===e.anchor||throwError(e,"alias node should not have any properties")),null!==e.anchor&&(e.anchorMap[e.anchor]=e.result)):0===d&&(y=s&&readBlockSequence(e,p))),null===e.tag)null!==e.anchor&&(e.anchorMap[e.anchor]=e.result);else if("?"===e.tag){for(null!==e.result&&"scalar"!==e.kind&&throwError(e,'unacceptable node kind for ! tag; it should be "scalar", not "'+e.kind+'"'),u=0,c=e.implicitTypes.length;u"),null!==e.result&&l.kind!==e.kind&&throwError(e,"unacceptable node kind for !<"+e.tag+'> tag; it should be "'+l.kind+'", not "'+e.kind+'"'),l.resolve(e.result,e.tag)?(e.result=l.construct(e.result,e.tag),null!==e.anchor&&(e.anchorMap[e.anchor]=e.result)):throwError(e,"cannot resolve a node with !<"+e.tag+"> explicit tag")}return null!==e.listener&&e.listener("close",e),null!==e.tag||null!==e.anchor||y}function readDocument(e){var t,r,n,i,o=e.position,a=!1;for(e.version=null,e.checkLineBreaks=e.legacy,e.tagMap=Object.create(null),e.anchorMap=Object.create(null);0!==(i=e.input.charCodeAt(e.position))&&(skipSeparationSpace(e,!0,-1),i=e.input.charCodeAt(e.position),!(e.lineIndent>0||37!==i));){for(a=!0,i=e.input.charCodeAt(++e.position),t=e.position;0!==i&&!is_WS_OR_EOL(i);)i=e.input.charCodeAt(++e.position);for(n=[],(r=e.input.slice(t,e.position)).length<1&&throwError(e,"directive name must not be less than one character in length");0!==i;){for(;is_WHITE_SPACE(i);)i=e.input.charCodeAt(++e.position);if(35===i){do{i=e.input.charCodeAt(++e.position)}while(0!==i&&!is_EOL(i));break}if(is_EOL(i))break;for(t=e.position;0!==i&&!is_WS_OR_EOL(i);)i=e.input.charCodeAt(++e.position);n.push(e.input.slice(t,e.position))}0!==i&&readLineBreak(e),qe.call(De,r)?De[r](e,r,n):throwWarning(e,'unknown document directive "'+r+'"')}skipSeparationSpace(e,!0,-1),0===e.lineIndent&&45===e.input.charCodeAt(e.position)&&45===e.input.charCodeAt(e.position+1)&&45===e.input.charCodeAt(e.position+2)?(e.position+=3,skipSeparationSpace(e,!0,-1)):a&&throwError(e,"directives end mark is expected"),composeNode(e,e.lineIndent-1,4,!1,!0),skipSeparationSpace(e,!0,-1),e.checkLineBreaks&&Ne.test(e.input.slice(o,e.position))&&throwWarning(e,"non-ASCII line breaks are interpreted as content"),e.documents.push(e.result),e.position===e.lineStart&&testDocumentSeparator(e)?46===e.input.charCodeAt(e.position)&&(e.position+=3,skipSeparationSpace(e,!0,-1)):e.position=55296&&n<=56319&&t+1=56320&&r<=57343?1024*(n-55296)+r-56320+65536:n}function needIndentIndicator(e){return/^\n* /.test(e)}function chooseScalarStyle(e,t,r,n,i,o,a,s){var u,c=0,f=null,l=!1,h=!1,p=-1!==n,d=-1,_=function isPlainSafeFirst(e){return isPrintable(e)&&e!==Ve&&!isWhitespace(e)&&45!==e&&63!==e&&58!==e&&44!==e&&91!==e&&93!==e&&123!==e&&125!==e&&35!==e&&38!==e&&42!==e&&33!==e&&124!==e&&61!==e&&62!==e&&39!==e&&34!==e&&37!==e&&64!==e&&96!==e}(codePointAt(e,0))&&function isPlainSafeLast(e){return!isWhitespace(e)&&58!==e}(codePointAt(e,e.length-1));if(t||a)for(u=0;u=65536?u+=2:u++){if(!isPrintable(c=codePointAt(e,u)))return 5;_=_&&isPlainSafe(c,f,s),f=c}else{for(u=0;u=65536?u+=2:u++){if(10===(c=codePointAt(e,u)))l=!0,p&&(h=h||u-d-1>n&&" "!==e[d+1],d=u);else if(!isPrintable(c))return 5;_=_&&isPlainSafe(c,f,s),f=c}h=h||p&&u-d-1>n&&" "!==e[d+1]}return l||h?r>9&&needIndentIndicator(e)?5:a?2===o?5:2:h?4:3:!_||a||i(e)?2===o?5:2:1}function writeScalar(e,t,r,n,i){e.dump=function(){if(0===t.length)return 2===e.quotingType?'""':"''";if(!e.noCompatMode&&(-1!==He.indexOf(t)||Ye.test(t)))return 2===e.quotingType?'"'+t+'"':"'"+t+"'";var o=e.indent*Math.max(1,r),a=-1===e.lineWidth?-1:Math.max(Math.min(e.lineWidth,40),e.lineWidth-o),s=n||e.flowLevel>-1&&r>=e.flowLevel;switch(chooseScalarStyle(t,s,e.indent,a,(function testAmbiguity(t){return function testImplicitResolving(e,t){var r,n;for(r=0,n=e.implicitTypes.length;r"+blockHeader(t,e.indent)+dropEndingNewline(indentString(function foldString(e,t){var r,n,i=/(\n+)([^\n]*)/g,o=(s=e.indexOf("\n"),s=-1!==s?s:e.length,i.lastIndex=s,foldLine(e.slice(0,s),t)),a="\n"===e[0]||" "===e[0];var s;for(;n=i.exec(e);){var u=n[1],c=n[2];r=" "===c[0],o+=u+(a||r||""===c?"":"\n")+foldLine(c,t),a=r}return o}(t,a),o));case 5:return'"'+function escapeString(e){for(var t,r="",n=0,i=0;i=65536?i+=2:i++)n=codePointAt(e,i),!(t=$e[n])&&isPrintable(n)?(r+=e[i],n>=65536&&(r+=e[i+1])):r+=t||encodeHex(n);return r}(t)+'"';default:throw new ee("impossible error: invalid scalar style")}}()}function blockHeader(e,t){var r=needIndentIndicator(e)?String(t):"",n="\n"===e[e.length-1];return r+(n&&("\n"===e[e.length-2]||"\n"===e)?"+":n?"":"-")+"\n"}function dropEndingNewline(e){return"\n"===e[e.length-1]?e.slice(0,-1):e}function foldLine(e,t){if(""===e||" "===e[0])return e;for(var r,n,i=/ [^ ]/g,o=0,a=0,s=0,u="";r=i.exec(e);)(s=r.index)-o>t&&(n=a>o?a:s,u+="\n"+e.slice(o,n),o=n+1),a=s;return u+="\n",e.length-o>t&&a>o?u+=e.slice(o,a)+"\n"+e.slice(a+1):u+=e.slice(o),u.slice(1)}function writeBlockSequence(e,t,r,n){var i,o,a,s="",u=e.tag;for(i=0,o=r.length;i tag resolver accepts not "'+u+'" style');n=s.represent[u](t,u)}e.dump=n}return!0}return!1}function writeNode(e,t,r,n,i,o,a){e.tag=null,e.dump=r,detectType(e,r,!1)||detectType(e,r,!0);var s,u=We.call(e.dump),c=n;n&&(n=e.flowLevel<0||e.flowLevel>t);var f,l,h="[object Object]"===u||"[object Array]"===u;if(h&&(l=-1!==(f=e.duplicates.indexOf(r))),(null!==e.tag&&"?"!==e.tag||l||2!==e.indent&&t>0)&&(i=!1),l&&e.usedDuplicates[f])e.dump="*ref_"+f;else{if(h&&l&&!e.usedDuplicates[f]&&(e.usedDuplicates[f]=!0),"[object Object]"===u)n&&0!==Object.keys(e.dump).length?(!function writeBlockMapping(e,t,r,n){var i,o,a,s,u,c,f="",l=e.tag,h=Object.keys(r);if(!0===e.sortKeys)h.sort();else if("function"==typeof e.sortKeys)h.sort(e.sortKeys);else if(e.sortKeys)throw new ee("sortKeys must be a boolean or a function");for(i=0,o=h.length;i1024)&&(e.dump&&10===e.dump.charCodeAt(0)?c+="?":c+="? "),c+=e.dump,u&&(c+=generateNextLine(e,t)),writeNode(e,t+1,s,!0,u)&&(e.dump&&10===e.dump.charCodeAt(0)?c+=":":c+=": ",f+=c+=e.dump));e.tag=l,e.dump=f||"{}"}(e,t,e.dump,i),l&&(e.dump="&ref_"+f+e.dump)):(!function writeFlowMapping(e,t,r){var n,i,o,a,s,u="",c=e.tag,f=Object.keys(r);for(n=0,i=f.length;n1024&&(s+="? "),s+=e.dump+(e.condenseFlow?'"':"")+":"+(e.condenseFlow?"":" "),writeNode(e,t,a,!1,!1)&&(u+=s+=e.dump));e.tag=c,e.dump="{"+u+"}"}(e,t,e.dump),l&&(e.dump="&ref_"+f+" "+e.dump));else if("[object Array]"===u)n&&0!==e.dump.length?(e.noArrayIndent&&!a&&t>0?writeBlockSequence(e,t-1,e.dump,i):writeBlockSequence(e,t,e.dump,i),l&&(e.dump="&ref_"+f+e.dump)):(!function writeFlowSequence(e,t,r){var n,i,o,a="",s=e.tag;for(n=0,i=r.length;n",e.dump=s+" "+e.dump)}return!0}function getDuplicateReferences(e,t){var r,n,i=[],o=[];for(inspectNode(e,i,o),r=0,n=o.length;r()=>{},downloadConfig=e=>t=>{const{fn:{fetch:r}}=t;return r(e)},getConfigByUrl=(e,t)=>r=>{const{specActions:n,configsActions:i}=r;if(e)return i.downloadConfig(e).then(next,next);function next(i){i instanceof Error||i.status>=400?(n.updateLoadingStatus("failedConfig"),n.updateLoadingStatus("failedConfig"),n.updateUrl(""),console.error(i.statusText+" "+e.url),t(null)):t(((e,t)=>{try{return Ze.load(e)}catch(e){return t&&t.errActions.newThrownErr(new Error(e)),{}}})(i.text,r))}},get=(e,t)=>e.getIn(Array.isArray(t)?t:[t]),Qe={[Ge]:(e,t)=>e.merge((0,o.fromJS)(t.payload)),[Je]:(e,t)=>{const r=t.payload,n=e.get(r);return e.set(r,!n)}};var Xe=__webpack_require__(7248),et=__webpack_require__.n(Xe),tt=__webpack_require__(7666),rt=__webpack_require__.n(tt);const nt=console.error,withErrorBoundary=e=>t=>{const{getComponent:r,fn:i}=e(),o=r("ErrorBoundary"),a=i.getDisplayName(t);class WithErrorBoundary extends n.Component{render(){return n.createElement(o,{targetName:a,getComponent:r,fn:i},n.createElement(t,rt()({},this.props,this.context)))}}var s;return WithErrorBoundary.displayName=`WithErrorBoundary(${a})`,(s=t).prototype&&s.prototype.isReactComponent&&(WithErrorBoundary.prototype.mapStateToProps=t.prototype.mapStateToProps),WithErrorBoundary},fallback=({name:e})=>n.createElement("div",{className:"fallback"},"😱 ",n.createElement("i",null,"Could not render ","t"===e?"this component":e,", see the console."));class ErrorBoundary extends n.Component{static defaultProps={targetName:"this component",getComponent:()=>fallback,fn:{componentDidCatch:nt},children:null};static getDerivedStateFromError(e){return{hasError:!0,error:e}}constructor(...e){super(...e),this.state={hasError:!1,error:null}}componentDidCatch(e,t){this.props.fn.componentDidCatch(e,t)}render(){const{getComponent:e,targetName:t,children:r}=this.props;if(this.state.hasError){const r=e("Fallback");return n.createElement(r,{name:t})}return r}}const it=ErrorBoundary,ot=[top_bar,function configsPlugin(){return{statePlugins:{configs:{reducers:Qe,actions:e,selectors:t}}}},stadalone_layout,(({componentList:e=[],fullOverride:t=!1}={})=>({getSystem:r})=>{const n=t?e:["App","BaseLayout","VersionPragmaFilter","InfoContainer","ServersContainer","SchemesContainer","AuthorizeBtnContainer","FilterContainer","Operations","OperationContainer","parameters","responses","OperationServers","Models","ModelWrapper",...e],i=et()(n,Array(n.length).fill(((e,{fn:t})=>t.withErrorBoundary(e))));return{fn:{componentDidCatch:nt,withErrorBoundary:withErrorBoundary(r)},components:{ErrorBoundary:it,Fallback:fallback},wrapComponents:i}})({fullOverride:!0,componentList:["Topbar","StandaloneLayout","onlineValidatorBadge"]})]})(),r=r.default})())); \ No newline at end of file diff --git a/server/internal/httpapi/docs/swagger-ui/swagger-ui.css b/server/internal/httpapi/docs/swagger-ui/swagger-ui.css new file mode 100644 index 0000000..27ffa53 --- /dev/null +++ b/server/internal/httpapi/docs/swagger-ui/swagger-ui.css @@ -0,0 +1,3 @@ +.swagger-ui{color:#3b4151;font-family:sans-serif/*! normalize.css v7.0.0 | MIT License | github.com/necolas/normalize.css */}.swagger-ui html{line-height:1.15;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}.swagger-ui body{margin:0}.swagger-ui article,.swagger-ui aside,.swagger-ui footer,.swagger-ui header,.swagger-ui nav,.swagger-ui section{display:block}.swagger-ui h1{font-size:2em;margin:.67em 0}.swagger-ui figcaption,.swagger-ui figure,.swagger-ui main{display:block}.swagger-ui figure{margin:1em 40px}.swagger-ui hr{box-sizing:content-box;height:0;overflow:visible}.swagger-ui pre{font-family:monospace,monospace;font-size:1em}.swagger-ui a{background-color:transparent;-webkit-text-decoration-skip:objects}.swagger-ui abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.swagger-ui b,.swagger-ui strong{font-weight:inherit;font-weight:bolder}.swagger-ui code,.swagger-ui kbd,.swagger-ui samp{font-family:monospace,monospace;font-size:1em}.swagger-ui dfn{font-style:italic}.swagger-ui mark{background-color:#ff0;color:#000}.swagger-ui small{font-size:80%}.swagger-ui sub,.swagger-ui sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}.swagger-ui sub{bottom:-.25em}.swagger-ui sup{top:-.5em}.swagger-ui audio,.swagger-ui video{display:inline-block}.swagger-ui audio:not([controls]){display:none;height:0}.swagger-ui img{border-style:none}.swagger-ui svg:not(:root){overflow:hidden}.swagger-ui button,.swagger-ui input,.swagger-ui optgroup,.swagger-ui select,.swagger-ui textarea{font-family:sans-serif;font-size:100%;line-height:1.15;margin:0}.swagger-ui button,.swagger-ui input{overflow:visible}.swagger-ui button,.swagger-ui select{text-transform:none}.swagger-ui [type=reset],.swagger-ui [type=submit],.swagger-ui button,.swagger-ui html [type=button]{-webkit-appearance:button}.swagger-ui [type=button]::-moz-focus-inner,.swagger-ui [type=reset]::-moz-focus-inner,.swagger-ui [type=submit]::-moz-focus-inner,.swagger-ui button::-moz-focus-inner{border-style:none;padding:0}.swagger-ui [type=button]:-moz-focusring,.swagger-ui [type=reset]:-moz-focusring,.swagger-ui [type=submit]:-moz-focusring,.swagger-ui button:-moz-focusring{outline:1px dotted ButtonText}.swagger-ui fieldset{padding:.35em .75em .625em}.swagger-ui legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}.swagger-ui progress{display:inline-block;vertical-align:baseline}.swagger-ui textarea{overflow:auto}.swagger-ui [type=checkbox],.swagger-ui [type=radio]{box-sizing:border-box;padding:0}.swagger-ui [type=number]::-webkit-inner-spin-button,.swagger-ui [type=number]::-webkit-outer-spin-button{height:auto}.swagger-ui [type=search]{-webkit-appearance:textfield;outline-offset:-2px}.swagger-ui [type=search]::-webkit-search-cancel-button,.swagger-ui [type=search]::-webkit-search-decoration{-webkit-appearance:none}.swagger-ui ::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}.swagger-ui details,.swagger-ui menu{display:block}.swagger-ui summary{display:list-item}.swagger-ui canvas{display:inline-block}.swagger-ui [hidden],.swagger-ui template{display:none}.swagger-ui .debug *{outline:1px solid gold}.swagger-ui .debug-white *{outline:1px solid #fff}.swagger-ui .debug-black *{outline:1px solid #000}.swagger-ui .debug-grid{background:transparent url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAYAAADED76LAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTExIDc5LjE1ODMyNSwgMjAxNS8wOS8xMC0wMToxMDoyMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6MTRDOTY4N0U2N0VFMTFFNjg2MzZDQjkwNkQ4MjgwMEIiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6MTRDOTY4N0Q2N0VFMTFFNjg2MzZDQjkwNkQ4MjgwMEIiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTUgKE1hY2ludG9zaCkiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDo3NjcyQkQ3NjY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDo3NjcyQkQ3NzY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PsBS+GMAAAAjSURBVHjaYvz//z8DLsD4gcGXiYEAGBIKGBne//fFpwAgwAB98AaF2pjlUQAAAABJRU5ErkJggg==) repeat 0 0}.swagger-ui .debug-grid-16{background:transparent url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTExIDc5LjE1ODMyNSwgMjAxNS8wOS8xMC0wMToxMDoyMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6ODYyRjhERDU2N0YyMTFFNjg2MzZDQjkwNkQ4MjgwMEIiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6ODYyRjhERDQ2N0YyMTFFNjg2MzZDQjkwNkQ4MjgwMEIiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTUgKE1hY2ludG9zaCkiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDo3NjcyQkQ3QTY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDo3NjcyQkQ3QjY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PvCS01IAAABMSURBVHjaYmR4/5+BFPBfAMFm/MBgx8RAGWCn1AAmSg34Q6kBDKMGMDCwICeMIemF/5QawEipAWwUhwEjMDvbAWlWkvVBwu8vQIABAEwBCph8U6c0AAAAAElFTkSuQmCC) repeat 0 0}.swagger-ui .debug-grid-8-solid{background:#fff url(data:image/jpeg;base64,/9j/4QAYRXhpZgAASUkqAAgAAAAAAAAAAAAAAP/sABFEdWNreQABAAQAAAAAAAD/4QMxaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/PiA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA1LjYtYzExMSA3OS4xNTgzMjUsIDIwMTUvMDkvMTAtMDE6MTA6MjAgICAgICAgICI+IDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+IDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDQyAyMDE1IChNYWNpbnRvc2gpIiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOkIxMjI0OTczNjdCMzExRTZCMkJDRTI0MDgxMDAyMTcxIiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOkIxMjI0OTc0NjdCMzExRTZCMkJDRTI0MDgxMDAyMTcxIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6QjEyMjQ5NzE2N0IzMTFFNkIyQkNFMjQwODEwMDIxNzEiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6QjEyMjQ5NzI2N0IzMTFFNkIyQkNFMjQwODEwMDIxNzEiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz7/7gAOQWRvYmUAZMAAAAAB/9sAhAAbGhopHSlBJiZBQi8vL0JHPz4+P0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHAR0pKTQmND8oKD9HPzU/R0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0dHR0f/wAARCAAIAAgDASIAAhEBAxEB/8QAWQABAQAAAAAAAAAAAAAAAAAAAAYBAQEAAAAAAAAAAAAAAAAAAAIEEAEBAAMBAAAAAAAAAAAAAAABADECA0ERAAEDBQAAAAAAAAAAAAAAAAARITFBUWESIv/aAAwDAQACEQMRAD8AoOnTV1QTD7JJshP3vSM3P//Z) repeat 0 0}.swagger-ui .debug-grid-16-solid{background:#fff url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTExIDc5LjE1ODMyNSwgMjAxNS8wOS8xMC0wMToxMDoyMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTUgKE1hY2ludG9zaCkiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6NzY3MkJEN0U2N0M1MTFFNkIyQkNFMjQwODEwMDIxNzEiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6NzY3MkJEN0Y2N0M1MTFFNkIyQkNFMjQwODEwMDIxNzEiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDo3NjcyQkQ3QzY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDo3NjcyQkQ3RDY3QzUxMUU2QjJCQ0UyNDA4MTAwMjE3MSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pve6J3kAAAAzSURBVHjaYvz//z8D0UDsMwMjSRoYP5Gq4SPNbRjVMEQ1fCRDg+in/6+J1AJUxsgAEGAA31BAJMS0GYEAAAAASUVORK5CYII=) repeat 0 0}.swagger-ui .border-box,.swagger-ui a,.swagger-ui article,.swagger-ui body,.swagger-ui code,.swagger-ui dd,.swagger-ui div,.swagger-ui dl,.swagger-ui dt,.swagger-ui fieldset,.swagger-ui footer,.swagger-ui form,.swagger-ui h1,.swagger-ui h2,.swagger-ui h3,.swagger-ui h4,.swagger-ui h5,.swagger-ui h6,.swagger-ui header,.swagger-ui html,.swagger-ui input[type=email],.swagger-ui input[type=number],.swagger-ui input[type=password],.swagger-ui input[type=tel],.swagger-ui input[type=text],.swagger-ui input[type=url],.swagger-ui legend,.swagger-ui li,.swagger-ui main,.swagger-ui ol,.swagger-ui p,.swagger-ui pre,.swagger-ui section,.swagger-ui table,.swagger-ui td,.swagger-ui textarea,.swagger-ui th,.swagger-ui tr,.swagger-ui ul{box-sizing:border-box}.swagger-ui .aspect-ratio{height:0;position:relative}.swagger-ui .aspect-ratio--16x9{padding-bottom:56.25%}.swagger-ui .aspect-ratio--9x16{padding-bottom:177.77%}.swagger-ui .aspect-ratio--4x3{padding-bottom:75%}.swagger-ui .aspect-ratio--3x4{padding-bottom:133.33%}.swagger-ui .aspect-ratio--6x4{padding-bottom:66.6%}.swagger-ui .aspect-ratio--4x6{padding-bottom:150%}.swagger-ui .aspect-ratio--8x5{padding-bottom:62.5%}.swagger-ui .aspect-ratio--5x8{padding-bottom:160%}.swagger-ui .aspect-ratio--7x5{padding-bottom:71.42%}.swagger-ui .aspect-ratio--5x7{padding-bottom:140%}.swagger-ui .aspect-ratio--1x1{padding-bottom:100%}.swagger-ui .aspect-ratio--object{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%;z-index:100}@media screen and (min-width:30em){.swagger-ui .aspect-ratio-ns{height:0;position:relative}.swagger-ui .aspect-ratio--16x9-ns{padding-bottom:56.25%}.swagger-ui .aspect-ratio--9x16-ns{padding-bottom:177.77%}.swagger-ui .aspect-ratio--4x3-ns{padding-bottom:75%}.swagger-ui .aspect-ratio--3x4-ns{padding-bottom:133.33%}.swagger-ui .aspect-ratio--6x4-ns{padding-bottom:66.6%}.swagger-ui .aspect-ratio--4x6-ns{padding-bottom:150%}.swagger-ui .aspect-ratio--8x5-ns{padding-bottom:62.5%}.swagger-ui .aspect-ratio--5x8-ns{padding-bottom:160%}.swagger-ui .aspect-ratio--7x5-ns{padding-bottom:71.42%}.swagger-ui .aspect-ratio--5x7-ns{padding-bottom:140%}.swagger-ui .aspect-ratio--1x1-ns{padding-bottom:100%}.swagger-ui .aspect-ratio--object-ns{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%;z-index:100}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .aspect-ratio-m{height:0;position:relative}.swagger-ui .aspect-ratio--16x9-m{padding-bottom:56.25%}.swagger-ui .aspect-ratio--9x16-m{padding-bottom:177.77%}.swagger-ui .aspect-ratio--4x3-m{padding-bottom:75%}.swagger-ui .aspect-ratio--3x4-m{padding-bottom:133.33%}.swagger-ui .aspect-ratio--6x4-m{padding-bottom:66.6%}.swagger-ui .aspect-ratio--4x6-m{padding-bottom:150%}.swagger-ui .aspect-ratio--8x5-m{padding-bottom:62.5%}.swagger-ui .aspect-ratio--5x8-m{padding-bottom:160%}.swagger-ui .aspect-ratio--7x5-m{padding-bottom:71.42%}.swagger-ui .aspect-ratio--5x7-m{padding-bottom:140%}.swagger-ui .aspect-ratio--1x1-m{padding-bottom:100%}.swagger-ui .aspect-ratio--object-m{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%;z-index:100}}@media screen and (min-width:60em){.swagger-ui .aspect-ratio-l{height:0;position:relative}.swagger-ui .aspect-ratio--16x9-l{padding-bottom:56.25%}.swagger-ui .aspect-ratio--9x16-l{padding-bottom:177.77%}.swagger-ui .aspect-ratio--4x3-l{padding-bottom:75%}.swagger-ui .aspect-ratio--3x4-l{padding-bottom:133.33%}.swagger-ui .aspect-ratio--6x4-l{padding-bottom:66.6%}.swagger-ui .aspect-ratio--4x6-l{padding-bottom:150%}.swagger-ui .aspect-ratio--8x5-l{padding-bottom:62.5%}.swagger-ui .aspect-ratio--5x8-l{padding-bottom:160%}.swagger-ui .aspect-ratio--7x5-l{padding-bottom:71.42%}.swagger-ui .aspect-ratio--5x7-l{padding-bottom:140%}.swagger-ui .aspect-ratio--1x1-l{padding-bottom:100%}.swagger-ui .aspect-ratio--object-l{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%;z-index:100}}.swagger-ui img{max-width:100%}.swagger-ui .cover{background-size:cover!important}.swagger-ui .contain{background-size:contain!important}@media screen and (min-width:30em){.swagger-ui .cover-ns{background-size:cover!important}.swagger-ui .contain-ns{background-size:contain!important}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .cover-m{background-size:cover!important}.swagger-ui .contain-m{background-size:contain!important}}@media screen and (min-width:60em){.swagger-ui .cover-l{background-size:cover!important}.swagger-ui .contain-l{background-size:contain!important}}.swagger-ui .bg-center{background-position:50%;background-repeat:no-repeat}.swagger-ui .bg-top{background-position:top;background-repeat:no-repeat}.swagger-ui .bg-right{background-position:100%;background-repeat:no-repeat}.swagger-ui .bg-bottom{background-position:bottom;background-repeat:no-repeat}.swagger-ui .bg-left{background-position:0;background-repeat:no-repeat}@media screen and (min-width:30em){.swagger-ui .bg-center-ns{background-position:50%;background-repeat:no-repeat}.swagger-ui .bg-top-ns{background-position:top;background-repeat:no-repeat}.swagger-ui .bg-right-ns{background-position:100%;background-repeat:no-repeat}.swagger-ui .bg-bottom-ns{background-position:bottom;background-repeat:no-repeat}.swagger-ui .bg-left-ns{background-position:0;background-repeat:no-repeat}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .bg-center-m{background-position:50%;background-repeat:no-repeat}.swagger-ui .bg-top-m{background-position:top;background-repeat:no-repeat}.swagger-ui .bg-right-m{background-position:100%;background-repeat:no-repeat}.swagger-ui .bg-bottom-m{background-position:bottom;background-repeat:no-repeat}.swagger-ui .bg-left-m{background-position:0;background-repeat:no-repeat}}@media screen and (min-width:60em){.swagger-ui .bg-center-l{background-position:50%;background-repeat:no-repeat}.swagger-ui .bg-top-l{background-position:top;background-repeat:no-repeat}.swagger-ui .bg-right-l{background-position:100%;background-repeat:no-repeat}.swagger-ui .bg-bottom-l{background-position:bottom;background-repeat:no-repeat}.swagger-ui .bg-left-l{background-position:0;background-repeat:no-repeat}}.swagger-ui .outline{outline:1px solid}.swagger-ui .outline-transparent{outline:1px solid transparent}.swagger-ui .outline-0{outline:0}@media screen and (min-width:30em){.swagger-ui .outline-ns{outline:1px solid}.swagger-ui .outline-transparent-ns{outline:1px solid transparent}.swagger-ui .outline-0-ns{outline:0}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .outline-m{outline:1px solid}.swagger-ui .outline-transparent-m{outline:1px solid transparent}.swagger-ui .outline-0-m{outline:0}}@media screen and (min-width:60em){.swagger-ui .outline-l{outline:1px solid}.swagger-ui .outline-transparent-l{outline:1px solid transparent}.swagger-ui .outline-0-l{outline:0}}.swagger-ui .ba{border-style:solid;border-width:1px}.swagger-ui .bt{border-top-style:solid;border-top-width:1px}.swagger-ui .br{border-right-style:solid;border-right-width:1px}.swagger-ui .bb{border-bottom-style:solid;border-bottom-width:1px}.swagger-ui .bl{border-left-style:solid;border-left-width:1px}.swagger-ui .bn{border-style:none;border-width:0}@media screen and (min-width:30em){.swagger-ui .ba-ns{border-style:solid;border-width:1px}.swagger-ui .bt-ns{border-top-style:solid;border-top-width:1px}.swagger-ui .br-ns{border-right-style:solid;border-right-width:1px}.swagger-ui .bb-ns{border-bottom-style:solid;border-bottom-width:1px}.swagger-ui .bl-ns{border-left-style:solid;border-left-width:1px}.swagger-ui .bn-ns{border-style:none;border-width:0}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .ba-m{border-style:solid;border-width:1px}.swagger-ui .bt-m{border-top-style:solid;border-top-width:1px}.swagger-ui .br-m{border-right-style:solid;border-right-width:1px}.swagger-ui .bb-m{border-bottom-style:solid;border-bottom-width:1px}.swagger-ui .bl-m{border-left-style:solid;border-left-width:1px}.swagger-ui .bn-m{border-style:none;border-width:0}}@media screen and (min-width:60em){.swagger-ui .ba-l{border-style:solid;border-width:1px}.swagger-ui .bt-l{border-top-style:solid;border-top-width:1px}.swagger-ui .br-l{border-right-style:solid;border-right-width:1px}.swagger-ui .bb-l{border-bottom-style:solid;border-bottom-width:1px}.swagger-ui .bl-l{border-left-style:solid;border-left-width:1px}.swagger-ui .bn-l{border-style:none;border-width:0}}.swagger-ui .b--black{border-color:#000}.swagger-ui .b--near-black{border-color:#111}.swagger-ui .b--dark-gray{border-color:#333}.swagger-ui .b--mid-gray{border-color:#555}.swagger-ui .b--gray{border-color:#777}.swagger-ui .b--silver{border-color:#999}.swagger-ui .b--light-silver{border-color:#aaa}.swagger-ui .b--moon-gray{border-color:#ccc}.swagger-ui .b--light-gray{border-color:#eee}.swagger-ui .b--near-white{border-color:#f4f4f4}.swagger-ui .b--white{border-color:#fff}.swagger-ui .b--white-90{border-color:hsla(0,0%,100%,.9)}.swagger-ui .b--white-80{border-color:hsla(0,0%,100%,.8)}.swagger-ui .b--white-70{border-color:hsla(0,0%,100%,.7)}.swagger-ui .b--white-60{border-color:hsla(0,0%,100%,.6)}.swagger-ui .b--white-50{border-color:hsla(0,0%,100%,.5)}.swagger-ui .b--white-40{border-color:hsla(0,0%,100%,.4)}.swagger-ui .b--white-30{border-color:hsla(0,0%,100%,.3)}.swagger-ui .b--white-20{border-color:hsla(0,0%,100%,.2)}.swagger-ui .b--white-10{border-color:hsla(0,0%,100%,.1)}.swagger-ui .b--white-05{border-color:hsla(0,0%,100%,.05)}.swagger-ui .b--white-025{border-color:hsla(0,0%,100%,.025)}.swagger-ui .b--white-0125{border-color:hsla(0,0%,100%,.013)}.swagger-ui .b--black-90{border-color:rgba(0,0,0,.9)}.swagger-ui .b--black-80{border-color:rgba(0,0,0,.8)}.swagger-ui .b--black-70{border-color:rgba(0,0,0,.7)}.swagger-ui .b--black-60{border-color:rgba(0,0,0,.6)}.swagger-ui .b--black-50{border-color:rgba(0,0,0,.5)}.swagger-ui .b--black-40{border-color:rgba(0,0,0,.4)}.swagger-ui .b--black-30{border-color:rgba(0,0,0,.3)}.swagger-ui .b--black-20{border-color:rgba(0,0,0,.2)}.swagger-ui .b--black-10{border-color:rgba(0,0,0,.1)}.swagger-ui .b--black-05{border-color:rgba(0,0,0,.05)}.swagger-ui .b--black-025{border-color:rgba(0,0,0,.025)}.swagger-ui .b--black-0125{border-color:rgba(0,0,0,.013)}.swagger-ui .b--dark-red{border-color:#e7040f}.swagger-ui .b--red{border-color:#ff4136}.swagger-ui .b--light-red{border-color:#ff725c}.swagger-ui .b--orange{border-color:#ff6300}.swagger-ui .b--gold{border-color:#ffb700}.swagger-ui .b--yellow{border-color:gold}.swagger-ui .b--light-yellow{border-color:#fbf1a9}.swagger-ui .b--purple{border-color:#5e2ca5}.swagger-ui .b--light-purple{border-color:#a463f2}.swagger-ui .b--dark-pink{border-color:#d5008f}.swagger-ui .b--hot-pink{border-color:#ff41b4}.swagger-ui .b--pink{border-color:#ff80cc}.swagger-ui .b--light-pink{border-color:#ffa3d7}.swagger-ui .b--dark-green{border-color:#137752}.swagger-ui .b--green{border-color:#19a974}.swagger-ui .b--light-green{border-color:#9eebcf}.swagger-ui .b--navy{border-color:#001b44}.swagger-ui .b--dark-blue{border-color:#00449e}.swagger-ui .b--blue{border-color:#357edd}.swagger-ui .b--light-blue{border-color:#96ccff}.swagger-ui .b--lightest-blue{border-color:#cdecff}.swagger-ui .b--washed-blue{border-color:#f6fffe}.swagger-ui .b--washed-green{border-color:#e8fdf5}.swagger-ui .b--washed-yellow{border-color:#fffceb}.swagger-ui .b--washed-red{border-color:#ffdfdf}.swagger-ui .b--transparent{border-color:transparent}.swagger-ui .b--inherit{border-color:inherit}.swagger-ui .br0{border-radius:0}.swagger-ui .br1{border-radius:.125rem}.swagger-ui .br2{border-radius:.25rem}.swagger-ui .br3{border-radius:.5rem}.swagger-ui .br4{border-radius:1rem}.swagger-ui .br-100{border-radius:100%}.swagger-ui .br-pill{border-radius:9999px}.swagger-ui .br--bottom{border-top-left-radius:0;border-top-right-radius:0}.swagger-ui .br--top{border-bottom-left-radius:0;border-bottom-right-radius:0}.swagger-ui .br--right{border-bottom-left-radius:0;border-top-left-radius:0}.swagger-ui .br--left{border-bottom-right-radius:0;border-top-right-radius:0}@media screen and (min-width:30em){.swagger-ui .br0-ns{border-radius:0}.swagger-ui .br1-ns{border-radius:.125rem}.swagger-ui .br2-ns{border-radius:.25rem}.swagger-ui .br3-ns{border-radius:.5rem}.swagger-ui .br4-ns{border-radius:1rem}.swagger-ui .br-100-ns{border-radius:100%}.swagger-ui .br-pill-ns{border-radius:9999px}.swagger-ui .br--bottom-ns{border-top-left-radius:0;border-top-right-radius:0}.swagger-ui .br--top-ns{border-bottom-left-radius:0;border-bottom-right-radius:0}.swagger-ui .br--right-ns{border-bottom-left-radius:0;border-top-left-radius:0}.swagger-ui .br--left-ns{border-bottom-right-radius:0;border-top-right-radius:0}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .br0-m{border-radius:0}.swagger-ui .br1-m{border-radius:.125rem}.swagger-ui .br2-m{border-radius:.25rem}.swagger-ui .br3-m{border-radius:.5rem}.swagger-ui .br4-m{border-radius:1rem}.swagger-ui .br-100-m{border-radius:100%}.swagger-ui .br-pill-m{border-radius:9999px}.swagger-ui .br--bottom-m{border-top-left-radius:0;border-top-right-radius:0}.swagger-ui .br--top-m{border-bottom-left-radius:0;border-bottom-right-radius:0}.swagger-ui .br--right-m{border-bottom-left-radius:0;border-top-left-radius:0}.swagger-ui .br--left-m{border-bottom-right-radius:0;border-top-right-radius:0}}@media screen and (min-width:60em){.swagger-ui .br0-l{border-radius:0}.swagger-ui .br1-l{border-radius:.125rem}.swagger-ui .br2-l{border-radius:.25rem}.swagger-ui .br3-l{border-radius:.5rem}.swagger-ui .br4-l{border-radius:1rem}.swagger-ui .br-100-l{border-radius:100%}.swagger-ui .br-pill-l{border-radius:9999px}.swagger-ui .br--bottom-l{border-top-left-radius:0;border-top-right-radius:0}.swagger-ui .br--top-l{border-bottom-left-radius:0;border-bottom-right-radius:0}.swagger-ui .br--right-l{border-bottom-left-radius:0;border-top-left-radius:0}.swagger-ui .br--left-l{border-bottom-right-radius:0;border-top-right-radius:0}}.swagger-ui .b--dotted{border-style:dotted}.swagger-ui .b--dashed{border-style:dashed}.swagger-ui .b--solid{border-style:solid}.swagger-ui .b--none{border-style:none}@media screen and (min-width:30em){.swagger-ui .b--dotted-ns{border-style:dotted}.swagger-ui .b--dashed-ns{border-style:dashed}.swagger-ui .b--solid-ns{border-style:solid}.swagger-ui .b--none-ns{border-style:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .b--dotted-m{border-style:dotted}.swagger-ui .b--dashed-m{border-style:dashed}.swagger-ui .b--solid-m{border-style:solid}.swagger-ui .b--none-m{border-style:none}}@media screen and (min-width:60em){.swagger-ui .b--dotted-l{border-style:dotted}.swagger-ui .b--dashed-l{border-style:dashed}.swagger-ui .b--solid-l{border-style:solid}.swagger-ui .b--none-l{border-style:none}}.swagger-ui .bw0{border-width:0}.swagger-ui .bw1{border-width:.125rem}.swagger-ui .bw2{border-width:.25rem}.swagger-ui .bw3{border-width:.5rem}.swagger-ui .bw4{border-width:1rem}.swagger-ui .bw5{border-width:2rem}.swagger-ui .bt-0{border-top-width:0}.swagger-ui .br-0{border-right-width:0}.swagger-ui .bb-0{border-bottom-width:0}.swagger-ui .bl-0{border-left-width:0}@media screen and (min-width:30em){.swagger-ui .bw0-ns{border-width:0}.swagger-ui .bw1-ns{border-width:.125rem}.swagger-ui .bw2-ns{border-width:.25rem}.swagger-ui .bw3-ns{border-width:.5rem}.swagger-ui .bw4-ns{border-width:1rem}.swagger-ui .bw5-ns{border-width:2rem}.swagger-ui .bt-0-ns{border-top-width:0}.swagger-ui .br-0-ns{border-right-width:0}.swagger-ui .bb-0-ns{border-bottom-width:0}.swagger-ui .bl-0-ns{border-left-width:0}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .bw0-m{border-width:0}.swagger-ui .bw1-m{border-width:.125rem}.swagger-ui .bw2-m{border-width:.25rem}.swagger-ui .bw3-m{border-width:.5rem}.swagger-ui .bw4-m{border-width:1rem}.swagger-ui .bw5-m{border-width:2rem}.swagger-ui .bt-0-m{border-top-width:0}.swagger-ui .br-0-m{border-right-width:0}.swagger-ui .bb-0-m{border-bottom-width:0}.swagger-ui .bl-0-m{border-left-width:0}}@media screen and (min-width:60em){.swagger-ui .bw0-l{border-width:0}.swagger-ui .bw1-l{border-width:.125rem}.swagger-ui .bw2-l{border-width:.25rem}.swagger-ui .bw3-l{border-width:.5rem}.swagger-ui .bw4-l{border-width:1rem}.swagger-ui .bw5-l{border-width:2rem}.swagger-ui .bt-0-l{border-top-width:0}.swagger-ui .br-0-l{border-right-width:0}.swagger-ui .bb-0-l{border-bottom-width:0}.swagger-ui .bl-0-l{border-left-width:0}}.swagger-ui .shadow-1{box-shadow:0 0 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-2{box-shadow:0 0 8px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-3{box-shadow:2px 2px 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-4{box-shadow:2px 2px 8px 0 rgba(0,0,0,.2)}.swagger-ui .shadow-5{box-shadow:4px 4px 8px 0 rgba(0,0,0,.2)}@media screen and (min-width:30em){.swagger-ui .shadow-1-ns{box-shadow:0 0 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-2-ns{box-shadow:0 0 8px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-3-ns{box-shadow:2px 2px 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-4-ns{box-shadow:2px 2px 8px 0 rgba(0,0,0,.2)}.swagger-ui .shadow-5-ns{box-shadow:4px 4px 8px 0 rgba(0,0,0,.2)}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .shadow-1-m{box-shadow:0 0 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-2-m{box-shadow:0 0 8px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-3-m{box-shadow:2px 2px 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-4-m{box-shadow:2px 2px 8px 0 rgba(0,0,0,.2)}.swagger-ui .shadow-5-m{box-shadow:4px 4px 8px 0 rgba(0,0,0,.2)}}@media screen and (min-width:60em){.swagger-ui .shadow-1-l{box-shadow:0 0 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-2-l{box-shadow:0 0 8px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-3-l{box-shadow:2px 2px 4px 2px rgba(0,0,0,.2)}.swagger-ui .shadow-4-l{box-shadow:2px 2px 8px 0 rgba(0,0,0,.2)}.swagger-ui .shadow-5-l{box-shadow:4px 4px 8px 0 rgba(0,0,0,.2)}}.swagger-ui .pre{overflow-x:auto;overflow-y:hidden;overflow:scroll}.swagger-ui .top-0{top:0}.swagger-ui .right-0{right:0}.swagger-ui .bottom-0{bottom:0}.swagger-ui .left-0{left:0}.swagger-ui .top-1{top:1rem}.swagger-ui .right-1{right:1rem}.swagger-ui .bottom-1{bottom:1rem}.swagger-ui .left-1{left:1rem}.swagger-ui .top-2{top:2rem}.swagger-ui .right-2{right:2rem}.swagger-ui .bottom-2{bottom:2rem}.swagger-ui .left-2{left:2rem}.swagger-ui .top--1{top:-1rem}.swagger-ui .right--1{right:-1rem}.swagger-ui .bottom--1{bottom:-1rem}.swagger-ui .left--1{left:-1rem}.swagger-ui .top--2{top:-2rem}.swagger-ui .right--2{right:-2rem}.swagger-ui .bottom--2{bottom:-2rem}.swagger-ui .left--2{left:-2rem}.swagger-ui .absolute--fill{bottom:0;left:0;right:0;top:0}@media screen and (min-width:30em){.swagger-ui .top-0-ns{top:0}.swagger-ui .left-0-ns{left:0}.swagger-ui .right-0-ns{right:0}.swagger-ui .bottom-0-ns{bottom:0}.swagger-ui .top-1-ns{top:1rem}.swagger-ui .left-1-ns{left:1rem}.swagger-ui .right-1-ns{right:1rem}.swagger-ui .bottom-1-ns{bottom:1rem}.swagger-ui .top-2-ns{top:2rem}.swagger-ui .left-2-ns{left:2rem}.swagger-ui .right-2-ns{right:2rem}.swagger-ui .bottom-2-ns{bottom:2rem}.swagger-ui .top--1-ns{top:-1rem}.swagger-ui .right--1-ns{right:-1rem}.swagger-ui .bottom--1-ns{bottom:-1rem}.swagger-ui .left--1-ns{left:-1rem}.swagger-ui .top--2-ns{top:-2rem}.swagger-ui .right--2-ns{right:-2rem}.swagger-ui .bottom--2-ns{bottom:-2rem}.swagger-ui .left--2-ns{left:-2rem}.swagger-ui .absolute--fill-ns{bottom:0;left:0;right:0;top:0}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .top-0-m{top:0}.swagger-ui .left-0-m{left:0}.swagger-ui .right-0-m{right:0}.swagger-ui .bottom-0-m{bottom:0}.swagger-ui .top-1-m{top:1rem}.swagger-ui .left-1-m{left:1rem}.swagger-ui .right-1-m{right:1rem}.swagger-ui .bottom-1-m{bottom:1rem}.swagger-ui .top-2-m{top:2rem}.swagger-ui .left-2-m{left:2rem}.swagger-ui .right-2-m{right:2rem}.swagger-ui .bottom-2-m{bottom:2rem}.swagger-ui .top--1-m{top:-1rem}.swagger-ui .right--1-m{right:-1rem}.swagger-ui .bottom--1-m{bottom:-1rem}.swagger-ui .left--1-m{left:-1rem}.swagger-ui .top--2-m{top:-2rem}.swagger-ui .right--2-m{right:-2rem}.swagger-ui .bottom--2-m{bottom:-2rem}.swagger-ui .left--2-m{left:-2rem}.swagger-ui .absolute--fill-m{bottom:0;left:0;right:0;top:0}}@media screen and (min-width:60em){.swagger-ui .top-0-l{top:0}.swagger-ui .left-0-l{left:0}.swagger-ui .right-0-l{right:0}.swagger-ui .bottom-0-l{bottom:0}.swagger-ui .top-1-l{top:1rem}.swagger-ui .left-1-l{left:1rem}.swagger-ui .right-1-l{right:1rem}.swagger-ui .bottom-1-l{bottom:1rem}.swagger-ui .top-2-l{top:2rem}.swagger-ui .left-2-l{left:2rem}.swagger-ui .right-2-l{right:2rem}.swagger-ui .bottom-2-l{bottom:2rem}.swagger-ui .top--1-l{top:-1rem}.swagger-ui .right--1-l{right:-1rem}.swagger-ui .bottom--1-l{bottom:-1rem}.swagger-ui .left--1-l{left:-1rem}.swagger-ui .top--2-l{top:-2rem}.swagger-ui .right--2-l{right:-2rem}.swagger-ui .bottom--2-l{bottom:-2rem}.swagger-ui .left--2-l{left:-2rem}.swagger-ui .absolute--fill-l{bottom:0;left:0;right:0;top:0}}.swagger-ui .cf:after,.swagger-ui .cf:before{content:" ";display:table}.swagger-ui .cf:after{clear:both}.swagger-ui .cf{zoom:1}.swagger-ui .cl{clear:left}.swagger-ui .cr{clear:right}.swagger-ui .cb{clear:both}.swagger-ui .cn{clear:none}@media screen and (min-width:30em){.swagger-ui .cl-ns{clear:left}.swagger-ui .cr-ns{clear:right}.swagger-ui .cb-ns{clear:both}.swagger-ui .cn-ns{clear:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .cl-m{clear:left}.swagger-ui .cr-m{clear:right}.swagger-ui .cb-m{clear:both}.swagger-ui .cn-m{clear:none}}@media screen and (min-width:60em){.swagger-ui .cl-l{clear:left}.swagger-ui .cr-l{clear:right}.swagger-ui .cb-l{clear:both}.swagger-ui .cn-l{clear:none}}.swagger-ui .flex{display:flex}.swagger-ui .inline-flex{display:inline-flex}.swagger-ui .flex-auto{flex:1 1 auto;min-height:0;min-width:0}.swagger-ui .flex-none{flex:none}.swagger-ui .flex-column{flex-direction:column}.swagger-ui .flex-row{flex-direction:row}.swagger-ui .flex-wrap{flex-wrap:wrap}.swagger-ui .flex-nowrap{flex-wrap:nowrap}.swagger-ui .flex-wrap-reverse{flex-wrap:wrap-reverse}.swagger-ui .flex-column-reverse{flex-direction:column-reverse}.swagger-ui .flex-row-reverse{flex-direction:row-reverse}.swagger-ui .items-start{align-items:flex-start}.swagger-ui .items-end{align-items:flex-end}.swagger-ui .items-center{align-items:center}.swagger-ui .items-baseline{align-items:baseline}.swagger-ui .items-stretch{align-items:stretch}.swagger-ui .self-start{align-self:flex-start}.swagger-ui .self-end{align-self:flex-end}.swagger-ui .self-center{align-self:center}.swagger-ui .self-baseline{align-self:baseline}.swagger-ui .self-stretch{align-self:stretch}.swagger-ui .justify-start{justify-content:flex-start}.swagger-ui .justify-end{justify-content:flex-end}.swagger-ui .justify-center{justify-content:center}.swagger-ui .justify-between{justify-content:space-between}.swagger-ui .justify-around{justify-content:space-around}.swagger-ui .content-start{align-content:flex-start}.swagger-ui .content-end{align-content:flex-end}.swagger-ui .content-center{align-content:center}.swagger-ui .content-between{align-content:space-between}.swagger-ui .content-around{align-content:space-around}.swagger-ui .content-stretch{align-content:stretch}.swagger-ui .order-0{order:0}.swagger-ui .order-1{order:1}.swagger-ui .order-2{order:2}.swagger-ui .order-3{order:3}.swagger-ui .order-4{order:4}.swagger-ui .order-5{order:5}.swagger-ui .order-6{order:6}.swagger-ui .order-7{order:7}.swagger-ui .order-8{order:8}.swagger-ui .order-last{order:99999}.swagger-ui .flex-grow-0{flex-grow:0}.swagger-ui .flex-grow-1{flex-grow:1}.swagger-ui .flex-shrink-0{flex-shrink:0}.swagger-ui .flex-shrink-1{flex-shrink:1}@media screen and (min-width:30em){.swagger-ui .flex-ns{display:flex}.swagger-ui .inline-flex-ns{display:inline-flex}.swagger-ui .flex-auto-ns{flex:1 1 auto;min-height:0;min-width:0}.swagger-ui .flex-none-ns{flex:none}.swagger-ui .flex-column-ns{flex-direction:column}.swagger-ui .flex-row-ns{flex-direction:row}.swagger-ui .flex-wrap-ns{flex-wrap:wrap}.swagger-ui .flex-nowrap-ns{flex-wrap:nowrap}.swagger-ui .flex-wrap-reverse-ns{flex-wrap:wrap-reverse}.swagger-ui .flex-column-reverse-ns{flex-direction:column-reverse}.swagger-ui .flex-row-reverse-ns{flex-direction:row-reverse}.swagger-ui .items-start-ns{align-items:flex-start}.swagger-ui .items-end-ns{align-items:flex-end}.swagger-ui .items-center-ns{align-items:center}.swagger-ui .items-baseline-ns{align-items:baseline}.swagger-ui .items-stretch-ns{align-items:stretch}.swagger-ui .self-start-ns{align-self:flex-start}.swagger-ui .self-end-ns{align-self:flex-end}.swagger-ui .self-center-ns{align-self:center}.swagger-ui .self-baseline-ns{align-self:baseline}.swagger-ui .self-stretch-ns{align-self:stretch}.swagger-ui .justify-start-ns{justify-content:flex-start}.swagger-ui .justify-end-ns{justify-content:flex-end}.swagger-ui .justify-center-ns{justify-content:center}.swagger-ui .justify-between-ns{justify-content:space-between}.swagger-ui .justify-around-ns{justify-content:space-around}.swagger-ui .content-start-ns{align-content:flex-start}.swagger-ui .content-end-ns{align-content:flex-end}.swagger-ui .content-center-ns{align-content:center}.swagger-ui .content-between-ns{align-content:space-between}.swagger-ui .content-around-ns{align-content:space-around}.swagger-ui .content-stretch-ns{align-content:stretch}.swagger-ui .order-0-ns{order:0}.swagger-ui .order-1-ns{order:1}.swagger-ui .order-2-ns{order:2}.swagger-ui .order-3-ns{order:3}.swagger-ui .order-4-ns{order:4}.swagger-ui .order-5-ns{order:5}.swagger-ui .order-6-ns{order:6}.swagger-ui .order-7-ns{order:7}.swagger-ui .order-8-ns{order:8}.swagger-ui .order-last-ns{order:99999}.swagger-ui .flex-grow-0-ns{flex-grow:0}.swagger-ui .flex-grow-1-ns{flex-grow:1}.swagger-ui .flex-shrink-0-ns{flex-shrink:0}.swagger-ui .flex-shrink-1-ns{flex-shrink:1}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .flex-m{display:flex}.swagger-ui .inline-flex-m{display:inline-flex}.swagger-ui .flex-auto-m{flex:1 1 auto;min-height:0;min-width:0}.swagger-ui .flex-none-m{flex:none}.swagger-ui .flex-column-m{flex-direction:column}.swagger-ui .flex-row-m{flex-direction:row}.swagger-ui .flex-wrap-m{flex-wrap:wrap}.swagger-ui .flex-nowrap-m{flex-wrap:nowrap}.swagger-ui .flex-wrap-reverse-m{flex-wrap:wrap-reverse}.swagger-ui .flex-column-reverse-m{flex-direction:column-reverse}.swagger-ui .flex-row-reverse-m{flex-direction:row-reverse}.swagger-ui .items-start-m{align-items:flex-start}.swagger-ui .items-end-m{align-items:flex-end}.swagger-ui .items-center-m{align-items:center}.swagger-ui .items-baseline-m{align-items:baseline}.swagger-ui .items-stretch-m{align-items:stretch}.swagger-ui .self-start-m{align-self:flex-start}.swagger-ui .self-end-m{align-self:flex-end}.swagger-ui .self-center-m{align-self:center}.swagger-ui .self-baseline-m{align-self:baseline}.swagger-ui .self-stretch-m{align-self:stretch}.swagger-ui .justify-start-m{justify-content:flex-start}.swagger-ui .justify-end-m{justify-content:flex-end}.swagger-ui .justify-center-m{justify-content:center}.swagger-ui .justify-between-m{justify-content:space-between}.swagger-ui .justify-around-m{justify-content:space-around}.swagger-ui .content-start-m{align-content:flex-start}.swagger-ui .content-end-m{align-content:flex-end}.swagger-ui .content-center-m{align-content:center}.swagger-ui .content-between-m{align-content:space-between}.swagger-ui .content-around-m{align-content:space-around}.swagger-ui .content-stretch-m{align-content:stretch}.swagger-ui .order-0-m{order:0}.swagger-ui .order-1-m{order:1}.swagger-ui .order-2-m{order:2}.swagger-ui .order-3-m{order:3}.swagger-ui .order-4-m{order:4}.swagger-ui .order-5-m{order:5}.swagger-ui .order-6-m{order:6}.swagger-ui .order-7-m{order:7}.swagger-ui .order-8-m{order:8}.swagger-ui .order-last-m{order:99999}.swagger-ui .flex-grow-0-m{flex-grow:0}.swagger-ui .flex-grow-1-m{flex-grow:1}.swagger-ui .flex-shrink-0-m{flex-shrink:0}.swagger-ui .flex-shrink-1-m{flex-shrink:1}}@media screen and (min-width:60em){.swagger-ui .flex-l{display:flex}.swagger-ui .inline-flex-l{display:inline-flex}.swagger-ui .flex-auto-l{flex:1 1 auto;min-height:0;min-width:0}.swagger-ui .flex-none-l{flex:none}.swagger-ui .flex-column-l{flex-direction:column}.swagger-ui .flex-row-l{flex-direction:row}.swagger-ui .flex-wrap-l{flex-wrap:wrap}.swagger-ui .flex-nowrap-l{flex-wrap:nowrap}.swagger-ui .flex-wrap-reverse-l{flex-wrap:wrap-reverse}.swagger-ui .flex-column-reverse-l{flex-direction:column-reverse}.swagger-ui .flex-row-reverse-l{flex-direction:row-reverse}.swagger-ui .items-start-l{align-items:flex-start}.swagger-ui .items-end-l{align-items:flex-end}.swagger-ui .items-center-l{align-items:center}.swagger-ui .items-baseline-l{align-items:baseline}.swagger-ui .items-stretch-l{align-items:stretch}.swagger-ui .self-start-l{align-self:flex-start}.swagger-ui .self-end-l{align-self:flex-end}.swagger-ui .self-center-l{align-self:center}.swagger-ui .self-baseline-l{align-self:baseline}.swagger-ui .self-stretch-l{align-self:stretch}.swagger-ui .justify-start-l{justify-content:flex-start}.swagger-ui .justify-end-l{justify-content:flex-end}.swagger-ui .justify-center-l{justify-content:center}.swagger-ui .justify-between-l{justify-content:space-between}.swagger-ui .justify-around-l{justify-content:space-around}.swagger-ui .content-start-l{align-content:flex-start}.swagger-ui .content-end-l{align-content:flex-end}.swagger-ui .content-center-l{align-content:center}.swagger-ui .content-between-l{align-content:space-between}.swagger-ui .content-around-l{align-content:space-around}.swagger-ui .content-stretch-l{align-content:stretch}.swagger-ui .order-0-l{order:0}.swagger-ui .order-1-l{order:1}.swagger-ui .order-2-l{order:2}.swagger-ui .order-3-l{order:3}.swagger-ui .order-4-l{order:4}.swagger-ui .order-5-l{order:5}.swagger-ui .order-6-l{order:6}.swagger-ui .order-7-l{order:7}.swagger-ui .order-8-l{order:8}.swagger-ui .order-last-l{order:99999}.swagger-ui .flex-grow-0-l{flex-grow:0}.swagger-ui .flex-grow-1-l{flex-grow:1}.swagger-ui .flex-shrink-0-l{flex-shrink:0}.swagger-ui .flex-shrink-1-l{flex-shrink:1}}.swagger-ui .dn{display:none}.swagger-ui .di{display:inline}.swagger-ui .db{display:block}.swagger-ui .dib{display:inline-block}.swagger-ui .dit{display:inline-table}.swagger-ui .dt{display:table}.swagger-ui .dtc{display:table-cell}.swagger-ui .dt-row{display:table-row}.swagger-ui .dt-row-group{display:table-row-group}.swagger-ui .dt-column{display:table-column}.swagger-ui .dt-column-group{display:table-column-group}.swagger-ui .dt--fixed{table-layout:fixed;width:100%}@media screen and (min-width:30em){.swagger-ui .dn-ns{display:none}.swagger-ui .di-ns{display:inline}.swagger-ui .db-ns{display:block}.swagger-ui .dib-ns{display:inline-block}.swagger-ui .dit-ns{display:inline-table}.swagger-ui .dt-ns{display:table}.swagger-ui .dtc-ns{display:table-cell}.swagger-ui .dt-row-ns{display:table-row}.swagger-ui .dt-row-group-ns{display:table-row-group}.swagger-ui .dt-column-ns{display:table-column}.swagger-ui .dt-column-group-ns{display:table-column-group}.swagger-ui .dt--fixed-ns{table-layout:fixed;width:100%}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .dn-m{display:none}.swagger-ui .di-m{display:inline}.swagger-ui .db-m{display:block}.swagger-ui .dib-m{display:inline-block}.swagger-ui .dit-m{display:inline-table}.swagger-ui .dt-m{display:table}.swagger-ui .dtc-m{display:table-cell}.swagger-ui .dt-row-m{display:table-row}.swagger-ui .dt-row-group-m{display:table-row-group}.swagger-ui .dt-column-m{display:table-column}.swagger-ui .dt-column-group-m{display:table-column-group}.swagger-ui .dt--fixed-m{table-layout:fixed;width:100%}}@media screen and (min-width:60em){.swagger-ui .dn-l{display:none}.swagger-ui .di-l{display:inline}.swagger-ui .db-l{display:block}.swagger-ui .dib-l{display:inline-block}.swagger-ui .dit-l{display:inline-table}.swagger-ui .dt-l{display:table}.swagger-ui .dtc-l{display:table-cell}.swagger-ui .dt-row-l{display:table-row}.swagger-ui .dt-row-group-l{display:table-row-group}.swagger-ui .dt-column-l{display:table-column}.swagger-ui .dt-column-group-l{display:table-column-group}.swagger-ui .dt--fixed-l{table-layout:fixed;width:100%}}.swagger-ui .fl{_display:inline;float:left}.swagger-ui .fr{_display:inline;float:right}.swagger-ui .fn{float:none}@media screen and (min-width:30em){.swagger-ui .fl-ns{_display:inline;float:left}.swagger-ui .fr-ns{_display:inline;float:right}.swagger-ui .fn-ns{float:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .fl-m{_display:inline;float:left}.swagger-ui .fr-m{_display:inline;float:right}.swagger-ui .fn-m{float:none}}@media screen and (min-width:60em){.swagger-ui .fl-l{_display:inline;float:left}.swagger-ui .fr-l{_display:inline;float:right}.swagger-ui .fn-l{float:none}}.swagger-ui .sans-serif{font-family:-apple-system,BlinkMacSystemFont,avenir next,avenir,helvetica,helvetica neue,ubuntu,roboto,noto,segoe ui,arial,sans-serif}.swagger-ui .serif{font-family:georgia,serif}.swagger-ui .system-sans-serif{font-family:sans-serif}.swagger-ui .system-serif{font-family:serif}.swagger-ui .code,.swagger-ui code{font-family:Consolas,monaco,monospace}.swagger-ui .courier{font-family:Courier Next,courier,monospace}.swagger-ui .helvetica{font-family:helvetica neue,helvetica,sans-serif}.swagger-ui .avenir{font-family:avenir next,avenir,sans-serif}.swagger-ui .athelas{font-family:athelas,georgia,serif}.swagger-ui .georgia{font-family:georgia,serif}.swagger-ui .times{font-family:times,serif}.swagger-ui .bodoni{font-family:Bodoni MT,serif}.swagger-ui .calisto{font-family:Calisto MT,serif}.swagger-ui .garamond{font-family:garamond,serif}.swagger-ui .baskerville{font-family:baskerville,serif}.swagger-ui .i{font-style:italic}.swagger-ui .fs-normal{font-style:normal}@media screen and (min-width:30em){.swagger-ui .i-ns{font-style:italic}.swagger-ui .fs-normal-ns{font-style:normal}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .i-m{font-style:italic}.swagger-ui .fs-normal-m{font-style:normal}}@media screen and (min-width:60em){.swagger-ui .i-l{font-style:italic}.swagger-ui .fs-normal-l{font-style:normal}}.swagger-ui .normal{font-weight:400}.swagger-ui .b{font-weight:700}.swagger-ui .fw1{font-weight:100}.swagger-ui .fw2{font-weight:200}.swagger-ui .fw3{font-weight:300}.swagger-ui .fw4{font-weight:400}.swagger-ui .fw5{font-weight:500}.swagger-ui .fw6{font-weight:600}.swagger-ui .fw7{font-weight:700}.swagger-ui .fw8{font-weight:800}.swagger-ui .fw9{font-weight:900}@media screen and (min-width:30em){.swagger-ui .normal-ns{font-weight:400}.swagger-ui .b-ns{font-weight:700}.swagger-ui .fw1-ns{font-weight:100}.swagger-ui .fw2-ns{font-weight:200}.swagger-ui .fw3-ns{font-weight:300}.swagger-ui .fw4-ns{font-weight:400}.swagger-ui .fw5-ns{font-weight:500}.swagger-ui .fw6-ns{font-weight:600}.swagger-ui .fw7-ns{font-weight:700}.swagger-ui .fw8-ns{font-weight:800}.swagger-ui .fw9-ns{font-weight:900}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .normal-m{font-weight:400}.swagger-ui .b-m{font-weight:700}.swagger-ui .fw1-m{font-weight:100}.swagger-ui .fw2-m{font-weight:200}.swagger-ui .fw3-m{font-weight:300}.swagger-ui .fw4-m{font-weight:400}.swagger-ui .fw5-m{font-weight:500}.swagger-ui .fw6-m{font-weight:600}.swagger-ui .fw7-m{font-weight:700}.swagger-ui .fw8-m{font-weight:800}.swagger-ui .fw9-m{font-weight:900}}@media screen and (min-width:60em){.swagger-ui .normal-l{font-weight:400}.swagger-ui .b-l{font-weight:700}.swagger-ui .fw1-l{font-weight:100}.swagger-ui .fw2-l{font-weight:200}.swagger-ui .fw3-l{font-weight:300}.swagger-ui .fw4-l{font-weight:400}.swagger-ui .fw5-l{font-weight:500}.swagger-ui .fw6-l{font-weight:600}.swagger-ui .fw7-l{font-weight:700}.swagger-ui .fw8-l{font-weight:800}.swagger-ui .fw9-l{font-weight:900}}.swagger-ui .input-reset{-webkit-appearance:none;-moz-appearance:none}.swagger-ui .button-reset::-moz-focus-inner,.swagger-ui .input-reset::-moz-focus-inner{border:0;padding:0}.swagger-ui .h1{height:1rem}.swagger-ui .h2{height:2rem}.swagger-ui .h3{height:4rem}.swagger-ui .h4{height:8rem}.swagger-ui .h5{height:16rem}.swagger-ui .h-25{height:25%}.swagger-ui .h-50{height:50%}.swagger-ui .h-75{height:75%}.swagger-ui .h-100{height:100%}.swagger-ui .min-h-100{min-height:100%}.swagger-ui .vh-25{height:25vh}.swagger-ui .vh-50{height:50vh}.swagger-ui .vh-75{height:75vh}.swagger-ui .vh-100{height:100vh}.swagger-ui .min-vh-100{min-height:100vh}.swagger-ui .h-auto{height:auto}.swagger-ui .h-inherit{height:inherit}@media screen and (min-width:30em){.swagger-ui .h1-ns{height:1rem}.swagger-ui .h2-ns{height:2rem}.swagger-ui .h3-ns{height:4rem}.swagger-ui .h4-ns{height:8rem}.swagger-ui .h5-ns{height:16rem}.swagger-ui .h-25-ns{height:25%}.swagger-ui .h-50-ns{height:50%}.swagger-ui .h-75-ns{height:75%}.swagger-ui .h-100-ns{height:100%}.swagger-ui .min-h-100-ns{min-height:100%}.swagger-ui .vh-25-ns{height:25vh}.swagger-ui .vh-50-ns{height:50vh}.swagger-ui .vh-75-ns{height:75vh}.swagger-ui .vh-100-ns{height:100vh}.swagger-ui .min-vh-100-ns{min-height:100vh}.swagger-ui .h-auto-ns{height:auto}.swagger-ui .h-inherit-ns{height:inherit}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .h1-m{height:1rem}.swagger-ui .h2-m{height:2rem}.swagger-ui .h3-m{height:4rem}.swagger-ui .h4-m{height:8rem}.swagger-ui .h5-m{height:16rem}.swagger-ui .h-25-m{height:25%}.swagger-ui .h-50-m{height:50%}.swagger-ui .h-75-m{height:75%}.swagger-ui .h-100-m{height:100%}.swagger-ui .min-h-100-m{min-height:100%}.swagger-ui .vh-25-m{height:25vh}.swagger-ui .vh-50-m{height:50vh}.swagger-ui .vh-75-m{height:75vh}.swagger-ui .vh-100-m{height:100vh}.swagger-ui .min-vh-100-m{min-height:100vh}.swagger-ui .h-auto-m{height:auto}.swagger-ui .h-inherit-m{height:inherit}}@media screen and (min-width:60em){.swagger-ui .h1-l{height:1rem}.swagger-ui .h2-l{height:2rem}.swagger-ui .h3-l{height:4rem}.swagger-ui .h4-l{height:8rem}.swagger-ui .h5-l{height:16rem}.swagger-ui .h-25-l{height:25%}.swagger-ui .h-50-l{height:50%}.swagger-ui .h-75-l{height:75%}.swagger-ui .h-100-l{height:100%}.swagger-ui .min-h-100-l{min-height:100%}.swagger-ui .vh-25-l{height:25vh}.swagger-ui .vh-50-l{height:50vh}.swagger-ui .vh-75-l{height:75vh}.swagger-ui .vh-100-l{height:100vh}.swagger-ui .min-vh-100-l{min-height:100vh}.swagger-ui .h-auto-l{height:auto}.swagger-ui .h-inherit-l{height:inherit}}.swagger-ui .tracked{letter-spacing:.1em}.swagger-ui .tracked-tight{letter-spacing:-.05em}.swagger-ui .tracked-mega{letter-spacing:.25em}@media screen and (min-width:30em){.swagger-ui .tracked-ns{letter-spacing:.1em}.swagger-ui .tracked-tight-ns{letter-spacing:-.05em}.swagger-ui .tracked-mega-ns{letter-spacing:.25em}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .tracked-m{letter-spacing:.1em}.swagger-ui .tracked-tight-m{letter-spacing:-.05em}.swagger-ui .tracked-mega-m{letter-spacing:.25em}}@media screen and (min-width:60em){.swagger-ui .tracked-l{letter-spacing:.1em}.swagger-ui .tracked-tight-l{letter-spacing:-.05em}.swagger-ui .tracked-mega-l{letter-spacing:.25em}}.swagger-ui .lh-solid{line-height:1}.swagger-ui .lh-title{line-height:1.25}.swagger-ui .lh-copy{line-height:1.5}@media screen and (min-width:30em){.swagger-ui .lh-solid-ns{line-height:1}.swagger-ui .lh-title-ns{line-height:1.25}.swagger-ui .lh-copy-ns{line-height:1.5}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .lh-solid-m{line-height:1}.swagger-ui .lh-title-m{line-height:1.25}.swagger-ui .lh-copy-m{line-height:1.5}}@media screen and (min-width:60em){.swagger-ui .lh-solid-l{line-height:1}.swagger-ui .lh-title-l{line-height:1.25}.swagger-ui .lh-copy-l{line-height:1.5}}.swagger-ui .link{-webkit-text-decoration:none;text-decoration:none}.swagger-ui .link,.swagger-ui .link:active,.swagger-ui .link:focus,.swagger-ui .link:hover,.swagger-ui .link:link,.swagger-ui .link:visited{transition:color .15s ease-in}.swagger-ui .link:focus{outline:1px dotted currentColor}.swagger-ui .list{list-style-type:none}.swagger-ui .mw-100{max-width:100%}.swagger-ui .mw1{max-width:1rem}.swagger-ui .mw2{max-width:2rem}.swagger-ui .mw3{max-width:4rem}.swagger-ui .mw4{max-width:8rem}.swagger-ui .mw5{max-width:16rem}.swagger-ui .mw6{max-width:32rem}.swagger-ui .mw7{max-width:48rem}.swagger-ui .mw8{max-width:64rem}.swagger-ui .mw9{max-width:96rem}.swagger-ui .mw-none{max-width:none}@media screen and (min-width:30em){.swagger-ui .mw-100-ns{max-width:100%}.swagger-ui .mw1-ns{max-width:1rem}.swagger-ui .mw2-ns{max-width:2rem}.swagger-ui .mw3-ns{max-width:4rem}.swagger-ui .mw4-ns{max-width:8rem}.swagger-ui .mw5-ns{max-width:16rem}.swagger-ui .mw6-ns{max-width:32rem}.swagger-ui .mw7-ns{max-width:48rem}.swagger-ui .mw8-ns{max-width:64rem}.swagger-ui .mw9-ns{max-width:96rem}.swagger-ui .mw-none-ns{max-width:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .mw-100-m{max-width:100%}.swagger-ui .mw1-m{max-width:1rem}.swagger-ui .mw2-m{max-width:2rem}.swagger-ui .mw3-m{max-width:4rem}.swagger-ui .mw4-m{max-width:8rem}.swagger-ui .mw5-m{max-width:16rem}.swagger-ui .mw6-m{max-width:32rem}.swagger-ui .mw7-m{max-width:48rem}.swagger-ui .mw8-m{max-width:64rem}.swagger-ui .mw9-m{max-width:96rem}.swagger-ui .mw-none-m{max-width:none}}@media screen and (min-width:60em){.swagger-ui .mw-100-l{max-width:100%}.swagger-ui .mw1-l{max-width:1rem}.swagger-ui .mw2-l{max-width:2rem}.swagger-ui .mw3-l{max-width:4rem}.swagger-ui .mw4-l{max-width:8rem}.swagger-ui .mw5-l{max-width:16rem}.swagger-ui .mw6-l{max-width:32rem}.swagger-ui .mw7-l{max-width:48rem}.swagger-ui .mw8-l{max-width:64rem}.swagger-ui .mw9-l{max-width:96rem}.swagger-ui .mw-none-l{max-width:none}}.swagger-ui .w1{width:1rem}.swagger-ui .w2{width:2rem}.swagger-ui .w3{width:4rem}.swagger-ui .w4{width:8rem}.swagger-ui .w5{width:16rem}.swagger-ui .w-10{width:10%}.swagger-ui .w-20{width:20%}.swagger-ui .w-25{width:25%}.swagger-ui .w-30{width:30%}.swagger-ui .w-33{width:33%}.swagger-ui .w-34{width:34%}.swagger-ui .w-40{width:40%}.swagger-ui .w-50{width:50%}.swagger-ui .w-60{width:60%}.swagger-ui .w-70{width:70%}.swagger-ui .w-75{width:75%}.swagger-ui .w-80{width:80%}.swagger-ui .w-90{width:90%}.swagger-ui .w-100{width:100%}.swagger-ui .w-third{width:33.3333333333%}.swagger-ui .w-two-thirds{width:66.6666666667%}.swagger-ui .w-auto{width:auto}@media screen and (min-width:30em){.swagger-ui .w1-ns{width:1rem}.swagger-ui .w2-ns{width:2rem}.swagger-ui .w3-ns{width:4rem}.swagger-ui .w4-ns{width:8rem}.swagger-ui .w5-ns{width:16rem}.swagger-ui .w-10-ns{width:10%}.swagger-ui .w-20-ns{width:20%}.swagger-ui .w-25-ns{width:25%}.swagger-ui .w-30-ns{width:30%}.swagger-ui .w-33-ns{width:33%}.swagger-ui .w-34-ns{width:34%}.swagger-ui .w-40-ns{width:40%}.swagger-ui .w-50-ns{width:50%}.swagger-ui .w-60-ns{width:60%}.swagger-ui .w-70-ns{width:70%}.swagger-ui .w-75-ns{width:75%}.swagger-ui .w-80-ns{width:80%}.swagger-ui .w-90-ns{width:90%}.swagger-ui .w-100-ns{width:100%}.swagger-ui .w-third-ns{width:33.3333333333%}.swagger-ui .w-two-thirds-ns{width:66.6666666667%}.swagger-ui .w-auto-ns{width:auto}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .w1-m{width:1rem}.swagger-ui .w2-m{width:2rem}.swagger-ui .w3-m{width:4rem}.swagger-ui .w4-m{width:8rem}.swagger-ui .w5-m{width:16rem}.swagger-ui .w-10-m{width:10%}.swagger-ui .w-20-m{width:20%}.swagger-ui .w-25-m{width:25%}.swagger-ui .w-30-m{width:30%}.swagger-ui .w-33-m{width:33%}.swagger-ui .w-34-m{width:34%}.swagger-ui .w-40-m{width:40%}.swagger-ui .w-50-m{width:50%}.swagger-ui .w-60-m{width:60%}.swagger-ui .w-70-m{width:70%}.swagger-ui .w-75-m{width:75%}.swagger-ui .w-80-m{width:80%}.swagger-ui .w-90-m{width:90%}.swagger-ui .w-100-m{width:100%}.swagger-ui .w-third-m{width:33.3333333333%}.swagger-ui .w-two-thirds-m{width:66.6666666667%}.swagger-ui .w-auto-m{width:auto}}@media screen and (min-width:60em){.swagger-ui .w1-l{width:1rem}.swagger-ui .w2-l{width:2rem}.swagger-ui .w3-l{width:4rem}.swagger-ui .w4-l{width:8rem}.swagger-ui .w5-l{width:16rem}.swagger-ui .w-10-l{width:10%}.swagger-ui .w-20-l{width:20%}.swagger-ui .w-25-l{width:25%}.swagger-ui .w-30-l{width:30%}.swagger-ui .w-33-l{width:33%}.swagger-ui .w-34-l{width:34%}.swagger-ui .w-40-l{width:40%}.swagger-ui .w-50-l{width:50%}.swagger-ui .w-60-l{width:60%}.swagger-ui .w-70-l{width:70%}.swagger-ui .w-75-l{width:75%}.swagger-ui .w-80-l{width:80%}.swagger-ui .w-90-l{width:90%}.swagger-ui .w-100-l{width:100%}.swagger-ui .w-third-l{width:33.3333333333%}.swagger-ui .w-two-thirds-l{width:66.6666666667%}.swagger-ui .w-auto-l{width:auto}}.swagger-ui .overflow-visible{overflow:visible}.swagger-ui .overflow-hidden{overflow:hidden}.swagger-ui .overflow-scroll{overflow:scroll}.swagger-ui .overflow-auto{overflow:auto}.swagger-ui .overflow-x-visible{overflow-x:visible}.swagger-ui .overflow-x-hidden{overflow-x:hidden}.swagger-ui .overflow-x-scroll{overflow-x:scroll}.swagger-ui .overflow-x-auto{overflow-x:auto}.swagger-ui .overflow-y-visible{overflow-y:visible}.swagger-ui .overflow-y-hidden{overflow-y:hidden}.swagger-ui .overflow-y-scroll{overflow-y:scroll}.swagger-ui .overflow-y-auto{overflow-y:auto}@media screen and (min-width:30em){.swagger-ui .overflow-visible-ns{overflow:visible}.swagger-ui .overflow-hidden-ns{overflow:hidden}.swagger-ui .overflow-scroll-ns{overflow:scroll}.swagger-ui .overflow-auto-ns{overflow:auto}.swagger-ui .overflow-x-visible-ns{overflow-x:visible}.swagger-ui .overflow-x-hidden-ns{overflow-x:hidden}.swagger-ui .overflow-x-scroll-ns{overflow-x:scroll}.swagger-ui .overflow-x-auto-ns{overflow-x:auto}.swagger-ui .overflow-y-visible-ns{overflow-y:visible}.swagger-ui .overflow-y-hidden-ns{overflow-y:hidden}.swagger-ui .overflow-y-scroll-ns{overflow-y:scroll}.swagger-ui .overflow-y-auto-ns{overflow-y:auto}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .overflow-visible-m{overflow:visible}.swagger-ui .overflow-hidden-m{overflow:hidden}.swagger-ui .overflow-scroll-m{overflow:scroll}.swagger-ui .overflow-auto-m{overflow:auto}.swagger-ui .overflow-x-visible-m{overflow-x:visible}.swagger-ui .overflow-x-hidden-m{overflow-x:hidden}.swagger-ui .overflow-x-scroll-m{overflow-x:scroll}.swagger-ui .overflow-x-auto-m{overflow-x:auto}.swagger-ui .overflow-y-visible-m{overflow-y:visible}.swagger-ui .overflow-y-hidden-m{overflow-y:hidden}.swagger-ui .overflow-y-scroll-m{overflow-y:scroll}.swagger-ui .overflow-y-auto-m{overflow-y:auto}}@media screen and (min-width:60em){.swagger-ui .overflow-visible-l{overflow:visible}.swagger-ui .overflow-hidden-l{overflow:hidden}.swagger-ui .overflow-scroll-l{overflow:scroll}.swagger-ui .overflow-auto-l{overflow:auto}.swagger-ui .overflow-x-visible-l{overflow-x:visible}.swagger-ui .overflow-x-hidden-l{overflow-x:hidden}.swagger-ui .overflow-x-scroll-l{overflow-x:scroll}.swagger-ui .overflow-x-auto-l{overflow-x:auto}.swagger-ui .overflow-y-visible-l{overflow-y:visible}.swagger-ui .overflow-y-hidden-l{overflow-y:hidden}.swagger-ui .overflow-y-scroll-l{overflow-y:scroll}.swagger-ui .overflow-y-auto-l{overflow-y:auto}}.swagger-ui .static{position:static}.swagger-ui .relative{position:relative}.swagger-ui .absolute{position:absolute}.swagger-ui .fixed{position:fixed}@media screen and (min-width:30em){.swagger-ui .static-ns{position:static}.swagger-ui .relative-ns{position:relative}.swagger-ui .absolute-ns{position:absolute}.swagger-ui .fixed-ns{position:fixed}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .static-m{position:static}.swagger-ui .relative-m{position:relative}.swagger-ui .absolute-m{position:absolute}.swagger-ui .fixed-m{position:fixed}}@media screen and (min-width:60em){.swagger-ui .static-l{position:static}.swagger-ui .relative-l{position:relative}.swagger-ui .absolute-l{position:absolute}.swagger-ui .fixed-l{position:fixed}}.swagger-ui .o-100{opacity:1}.swagger-ui .o-90{opacity:.9}.swagger-ui .o-80{opacity:.8}.swagger-ui .o-70{opacity:.7}.swagger-ui .o-60{opacity:.6}.swagger-ui .o-50{opacity:.5}.swagger-ui .o-40{opacity:.4}.swagger-ui .o-30{opacity:.3}.swagger-ui .o-20{opacity:.2}.swagger-ui .o-10{opacity:.1}.swagger-ui .o-05{opacity:.05}.swagger-ui .o-025{opacity:.025}.swagger-ui .o-0{opacity:0}.swagger-ui .rotate-45{transform:rotate(45deg)}.swagger-ui .rotate-90{transform:rotate(90deg)}.swagger-ui .rotate-135{transform:rotate(135deg)}.swagger-ui .rotate-180{transform:rotate(180deg)}.swagger-ui .rotate-225{transform:rotate(225deg)}.swagger-ui .rotate-270{transform:rotate(270deg)}.swagger-ui .rotate-315{transform:rotate(315deg)}@media screen and (min-width:30em){.swagger-ui .rotate-45-ns{transform:rotate(45deg)}.swagger-ui .rotate-90-ns{transform:rotate(90deg)}.swagger-ui .rotate-135-ns{transform:rotate(135deg)}.swagger-ui .rotate-180-ns{transform:rotate(180deg)}.swagger-ui .rotate-225-ns{transform:rotate(225deg)}.swagger-ui .rotate-270-ns{transform:rotate(270deg)}.swagger-ui .rotate-315-ns{transform:rotate(315deg)}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .rotate-45-m{transform:rotate(45deg)}.swagger-ui .rotate-90-m{transform:rotate(90deg)}.swagger-ui .rotate-135-m{transform:rotate(135deg)}.swagger-ui .rotate-180-m{transform:rotate(180deg)}.swagger-ui .rotate-225-m{transform:rotate(225deg)}.swagger-ui .rotate-270-m{transform:rotate(270deg)}.swagger-ui .rotate-315-m{transform:rotate(315deg)}}@media screen and (min-width:60em){.swagger-ui .rotate-45-l{transform:rotate(45deg)}.swagger-ui .rotate-90-l{transform:rotate(90deg)}.swagger-ui .rotate-135-l{transform:rotate(135deg)}.swagger-ui .rotate-180-l{transform:rotate(180deg)}.swagger-ui .rotate-225-l{transform:rotate(225deg)}.swagger-ui .rotate-270-l{transform:rotate(270deg)}.swagger-ui .rotate-315-l{transform:rotate(315deg)}}.swagger-ui .black-90{color:rgba(0,0,0,.9)}.swagger-ui .black-80{color:rgba(0,0,0,.8)}.swagger-ui .black-70{color:rgba(0,0,0,.7)}.swagger-ui .black-60{color:rgba(0,0,0,.6)}.swagger-ui .black-50{color:rgba(0,0,0,.5)}.swagger-ui .black-40{color:rgba(0,0,0,.4)}.swagger-ui .black-30{color:rgba(0,0,0,.3)}.swagger-ui .black-20{color:rgba(0,0,0,.2)}.swagger-ui .black-10{color:rgba(0,0,0,.1)}.swagger-ui .black-05{color:rgba(0,0,0,.05)}.swagger-ui .white-90{color:hsla(0,0%,100%,.9)}.swagger-ui .white-80{color:hsla(0,0%,100%,.8)}.swagger-ui .white-70{color:hsla(0,0%,100%,.7)}.swagger-ui .white-60{color:hsla(0,0%,100%,.6)}.swagger-ui .white-50{color:hsla(0,0%,100%,.5)}.swagger-ui .white-40{color:hsla(0,0%,100%,.4)}.swagger-ui .white-30{color:hsla(0,0%,100%,.3)}.swagger-ui .white-20{color:hsla(0,0%,100%,.2)}.swagger-ui .white-10{color:hsla(0,0%,100%,.1)}.swagger-ui .black{color:#000}.swagger-ui .near-black{color:#111}.swagger-ui .dark-gray{color:#333}.swagger-ui .mid-gray{color:#555}.swagger-ui .gray{color:#777}.swagger-ui .silver{color:#999}.swagger-ui .light-silver{color:#aaa}.swagger-ui .moon-gray{color:#ccc}.swagger-ui .light-gray{color:#eee}.swagger-ui .near-white{color:#f4f4f4}.swagger-ui .white{color:#fff}.swagger-ui .dark-red{color:#e7040f}.swagger-ui .red{color:#ff4136}.swagger-ui .light-red{color:#ff725c}.swagger-ui .orange{color:#ff6300}.swagger-ui .gold{color:#ffb700}.swagger-ui .yellow{color:gold}.swagger-ui .light-yellow{color:#fbf1a9}.swagger-ui .purple{color:#5e2ca5}.swagger-ui .light-purple{color:#a463f2}.swagger-ui .dark-pink{color:#d5008f}.swagger-ui .hot-pink{color:#ff41b4}.swagger-ui .pink{color:#ff80cc}.swagger-ui .light-pink{color:#ffa3d7}.swagger-ui .dark-green{color:#137752}.swagger-ui .green{color:#19a974}.swagger-ui .light-green{color:#9eebcf}.swagger-ui .navy{color:#001b44}.swagger-ui .dark-blue{color:#00449e}.swagger-ui .blue{color:#357edd}.swagger-ui .light-blue{color:#96ccff}.swagger-ui .lightest-blue{color:#cdecff}.swagger-ui .washed-blue{color:#f6fffe}.swagger-ui .washed-green{color:#e8fdf5}.swagger-ui .washed-yellow{color:#fffceb}.swagger-ui .washed-red{color:#ffdfdf}.swagger-ui .color-inherit{color:inherit}.swagger-ui .bg-black-90{background-color:rgba(0,0,0,.9)}.swagger-ui .bg-black-80{background-color:rgba(0,0,0,.8)}.swagger-ui .bg-black-70{background-color:rgba(0,0,0,.7)}.swagger-ui .bg-black-60{background-color:rgba(0,0,0,.6)}.swagger-ui .bg-black-50{background-color:rgba(0,0,0,.5)}.swagger-ui .bg-black-40{background-color:rgba(0,0,0,.4)}.swagger-ui .bg-black-30{background-color:rgba(0,0,0,.3)}.swagger-ui .bg-black-20{background-color:rgba(0,0,0,.2)}.swagger-ui .bg-black-10{background-color:rgba(0,0,0,.1)}.swagger-ui .bg-black-05{background-color:rgba(0,0,0,.05)}.swagger-ui .bg-white-90{background-color:hsla(0,0%,100%,.9)}.swagger-ui .bg-white-80{background-color:hsla(0,0%,100%,.8)}.swagger-ui .bg-white-70{background-color:hsla(0,0%,100%,.7)}.swagger-ui .bg-white-60{background-color:hsla(0,0%,100%,.6)}.swagger-ui .bg-white-50{background-color:hsla(0,0%,100%,.5)}.swagger-ui .bg-white-40{background-color:hsla(0,0%,100%,.4)}.swagger-ui .bg-white-30{background-color:hsla(0,0%,100%,.3)}.swagger-ui .bg-white-20{background-color:hsla(0,0%,100%,.2)}.swagger-ui .bg-white-10{background-color:hsla(0,0%,100%,.1)}.swagger-ui .bg-black{background-color:#000}.swagger-ui .bg-near-black{background-color:#111}.swagger-ui .bg-dark-gray{background-color:#333}.swagger-ui .bg-mid-gray{background-color:#555}.swagger-ui .bg-gray{background-color:#777}.swagger-ui .bg-silver{background-color:#999}.swagger-ui .bg-light-silver{background-color:#aaa}.swagger-ui .bg-moon-gray{background-color:#ccc}.swagger-ui .bg-light-gray{background-color:#eee}.swagger-ui .bg-near-white{background-color:#f4f4f4}.swagger-ui .bg-white{background-color:#fff}.swagger-ui .bg-transparent{background-color:transparent}.swagger-ui .bg-dark-red{background-color:#e7040f}.swagger-ui .bg-red{background-color:#ff4136}.swagger-ui .bg-light-red{background-color:#ff725c}.swagger-ui .bg-orange{background-color:#ff6300}.swagger-ui .bg-gold{background-color:#ffb700}.swagger-ui .bg-yellow{background-color:gold}.swagger-ui .bg-light-yellow{background-color:#fbf1a9}.swagger-ui .bg-purple{background-color:#5e2ca5}.swagger-ui .bg-light-purple{background-color:#a463f2}.swagger-ui .bg-dark-pink{background-color:#d5008f}.swagger-ui .bg-hot-pink{background-color:#ff41b4}.swagger-ui .bg-pink{background-color:#ff80cc}.swagger-ui .bg-light-pink{background-color:#ffa3d7}.swagger-ui .bg-dark-green{background-color:#137752}.swagger-ui .bg-green{background-color:#19a974}.swagger-ui .bg-light-green{background-color:#9eebcf}.swagger-ui .bg-navy{background-color:#001b44}.swagger-ui .bg-dark-blue{background-color:#00449e}.swagger-ui .bg-blue{background-color:#357edd}.swagger-ui .bg-light-blue{background-color:#96ccff}.swagger-ui .bg-lightest-blue{background-color:#cdecff}.swagger-ui .bg-washed-blue{background-color:#f6fffe}.swagger-ui .bg-washed-green{background-color:#e8fdf5}.swagger-ui .bg-washed-yellow{background-color:#fffceb}.swagger-ui .bg-washed-red{background-color:#ffdfdf}.swagger-ui .bg-inherit{background-color:inherit}.swagger-ui .hover-black:focus,.swagger-ui .hover-black:hover{color:#000}.swagger-ui .hover-near-black:focus,.swagger-ui .hover-near-black:hover{color:#111}.swagger-ui .hover-dark-gray:focus,.swagger-ui .hover-dark-gray:hover{color:#333}.swagger-ui .hover-mid-gray:focus,.swagger-ui .hover-mid-gray:hover{color:#555}.swagger-ui .hover-gray:focus,.swagger-ui .hover-gray:hover{color:#777}.swagger-ui .hover-silver:focus,.swagger-ui .hover-silver:hover{color:#999}.swagger-ui .hover-light-silver:focus,.swagger-ui .hover-light-silver:hover{color:#aaa}.swagger-ui .hover-moon-gray:focus,.swagger-ui .hover-moon-gray:hover{color:#ccc}.swagger-ui .hover-light-gray:focus,.swagger-ui .hover-light-gray:hover{color:#eee}.swagger-ui .hover-near-white:focus,.swagger-ui .hover-near-white:hover{color:#f4f4f4}.swagger-ui .hover-white:focus,.swagger-ui .hover-white:hover{color:#fff}.swagger-ui .hover-black-90:focus,.swagger-ui .hover-black-90:hover{color:rgba(0,0,0,.9)}.swagger-ui .hover-black-80:focus,.swagger-ui .hover-black-80:hover{color:rgba(0,0,0,.8)}.swagger-ui .hover-black-70:focus,.swagger-ui .hover-black-70:hover{color:rgba(0,0,0,.7)}.swagger-ui .hover-black-60:focus,.swagger-ui .hover-black-60:hover{color:rgba(0,0,0,.6)}.swagger-ui .hover-black-50:focus,.swagger-ui .hover-black-50:hover{color:rgba(0,0,0,.5)}.swagger-ui .hover-black-40:focus,.swagger-ui .hover-black-40:hover{color:rgba(0,0,0,.4)}.swagger-ui .hover-black-30:focus,.swagger-ui .hover-black-30:hover{color:rgba(0,0,0,.3)}.swagger-ui .hover-black-20:focus,.swagger-ui .hover-black-20:hover{color:rgba(0,0,0,.2)}.swagger-ui .hover-black-10:focus,.swagger-ui .hover-black-10:hover{color:rgba(0,0,0,.1)}.swagger-ui .hover-white-90:focus,.swagger-ui .hover-white-90:hover{color:hsla(0,0%,100%,.9)}.swagger-ui .hover-white-80:focus,.swagger-ui .hover-white-80:hover{color:hsla(0,0%,100%,.8)}.swagger-ui .hover-white-70:focus,.swagger-ui .hover-white-70:hover{color:hsla(0,0%,100%,.7)}.swagger-ui .hover-white-60:focus,.swagger-ui .hover-white-60:hover{color:hsla(0,0%,100%,.6)}.swagger-ui .hover-white-50:focus,.swagger-ui .hover-white-50:hover{color:hsla(0,0%,100%,.5)}.swagger-ui .hover-white-40:focus,.swagger-ui .hover-white-40:hover{color:hsla(0,0%,100%,.4)}.swagger-ui .hover-white-30:focus,.swagger-ui .hover-white-30:hover{color:hsla(0,0%,100%,.3)}.swagger-ui .hover-white-20:focus,.swagger-ui .hover-white-20:hover{color:hsla(0,0%,100%,.2)}.swagger-ui .hover-white-10:focus,.swagger-ui .hover-white-10:hover{color:hsla(0,0%,100%,.1)}.swagger-ui .hover-inherit:focus,.swagger-ui .hover-inherit:hover{color:inherit}.swagger-ui .hover-bg-black:focus,.swagger-ui .hover-bg-black:hover{background-color:#000}.swagger-ui .hover-bg-near-black:focus,.swagger-ui .hover-bg-near-black:hover{background-color:#111}.swagger-ui .hover-bg-dark-gray:focus,.swagger-ui .hover-bg-dark-gray:hover{background-color:#333}.swagger-ui .hover-bg-mid-gray:focus,.swagger-ui .hover-bg-mid-gray:hover{background-color:#555}.swagger-ui .hover-bg-gray:focus,.swagger-ui .hover-bg-gray:hover{background-color:#777}.swagger-ui .hover-bg-silver:focus,.swagger-ui .hover-bg-silver:hover{background-color:#999}.swagger-ui .hover-bg-light-silver:focus,.swagger-ui .hover-bg-light-silver:hover{background-color:#aaa}.swagger-ui .hover-bg-moon-gray:focus,.swagger-ui .hover-bg-moon-gray:hover{background-color:#ccc}.swagger-ui .hover-bg-light-gray:focus,.swagger-ui .hover-bg-light-gray:hover{background-color:#eee}.swagger-ui .hover-bg-near-white:focus,.swagger-ui .hover-bg-near-white:hover{background-color:#f4f4f4}.swagger-ui .hover-bg-white:focus,.swagger-ui .hover-bg-white:hover{background-color:#fff}.swagger-ui .hover-bg-transparent:focus,.swagger-ui .hover-bg-transparent:hover{background-color:transparent}.swagger-ui .hover-bg-black-90:focus,.swagger-ui .hover-bg-black-90:hover{background-color:rgba(0,0,0,.9)}.swagger-ui .hover-bg-black-80:focus,.swagger-ui .hover-bg-black-80:hover{background-color:rgba(0,0,0,.8)}.swagger-ui .hover-bg-black-70:focus,.swagger-ui .hover-bg-black-70:hover{background-color:rgba(0,0,0,.7)}.swagger-ui .hover-bg-black-60:focus,.swagger-ui .hover-bg-black-60:hover{background-color:rgba(0,0,0,.6)}.swagger-ui .hover-bg-black-50:focus,.swagger-ui .hover-bg-black-50:hover{background-color:rgba(0,0,0,.5)}.swagger-ui .hover-bg-black-40:focus,.swagger-ui .hover-bg-black-40:hover{background-color:rgba(0,0,0,.4)}.swagger-ui .hover-bg-black-30:focus,.swagger-ui .hover-bg-black-30:hover{background-color:rgba(0,0,0,.3)}.swagger-ui .hover-bg-black-20:focus,.swagger-ui .hover-bg-black-20:hover{background-color:rgba(0,0,0,.2)}.swagger-ui .hover-bg-black-10:focus,.swagger-ui .hover-bg-black-10:hover{background-color:rgba(0,0,0,.1)}.swagger-ui .hover-bg-white-90:focus,.swagger-ui .hover-bg-white-90:hover{background-color:hsla(0,0%,100%,.9)}.swagger-ui .hover-bg-white-80:focus,.swagger-ui .hover-bg-white-80:hover{background-color:hsla(0,0%,100%,.8)}.swagger-ui .hover-bg-white-70:focus,.swagger-ui .hover-bg-white-70:hover{background-color:hsla(0,0%,100%,.7)}.swagger-ui .hover-bg-white-60:focus,.swagger-ui .hover-bg-white-60:hover{background-color:hsla(0,0%,100%,.6)}.swagger-ui .hover-bg-white-50:focus,.swagger-ui .hover-bg-white-50:hover{background-color:hsla(0,0%,100%,.5)}.swagger-ui .hover-bg-white-40:focus,.swagger-ui .hover-bg-white-40:hover{background-color:hsla(0,0%,100%,.4)}.swagger-ui .hover-bg-white-30:focus,.swagger-ui .hover-bg-white-30:hover{background-color:hsla(0,0%,100%,.3)}.swagger-ui .hover-bg-white-20:focus,.swagger-ui .hover-bg-white-20:hover{background-color:hsla(0,0%,100%,.2)}.swagger-ui .hover-bg-white-10:focus,.swagger-ui .hover-bg-white-10:hover{background-color:hsla(0,0%,100%,.1)}.swagger-ui .hover-dark-red:focus,.swagger-ui .hover-dark-red:hover{color:#e7040f}.swagger-ui .hover-red:focus,.swagger-ui .hover-red:hover{color:#ff4136}.swagger-ui .hover-light-red:focus,.swagger-ui .hover-light-red:hover{color:#ff725c}.swagger-ui .hover-orange:focus,.swagger-ui .hover-orange:hover{color:#ff6300}.swagger-ui .hover-gold:focus,.swagger-ui .hover-gold:hover{color:#ffb700}.swagger-ui .hover-yellow:focus,.swagger-ui .hover-yellow:hover{color:gold}.swagger-ui .hover-light-yellow:focus,.swagger-ui .hover-light-yellow:hover{color:#fbf1a9}.swagger-ui .hover-purple:focus,.swagger-ui .hover-purple:hover{color:#5e2ca5}.swagger-ui .hover-light-purple:focus,.swagger-ui .hover-light-purple:hover{color:#a463f2}.swagger-ui .hover-dark-pink:focus,.swagger-ui .hover-dark-pink:hover{color:#d5008f}.swagger-ui .hover-hot-pink:focus,.swagger-ui .hover-hot-pink:hover{color:#ff41b4}.swagger-ui .hover-pink:focus,.swagger-ui .hover-pink:hover{color:#ff80cc}.swagger-ui .hover-light-pink:focus,.swagger-ui .hover-light-pink:hover{color:#ffa3d7}.swagger-ui .hover-dark-green:focus,.swagger-ui .hover-dark-green:hover{color:#137752}.swagger-ui .hover-green:focus,.swagger-ui .hover-green:hover{color:#19a974}.swagger-ui .hover-light-green:focus,.swagger-ui .hover-light-green:hover{color:#9eebcf}.swagger-ui .hover-navy:focus,.swagger-ui .hover-navy:hover{color:#001b44}.swagger-ui .hover-dark-blue:focus,.swagger-ui .hover-dark-blue:hover{color:#00449e}.swagger-ui .hover-blue:focus,.swagger-ui .hover-blue:hover{color:#357edd}.swagger-ui .hover-light-blue:focus,.swagger-ui .hover-light-blue:hover{color:#96ccff}.swagger-ui .hover-lightest-blue:focus,.swagger-ui .hover-lightest-blue:hover{color:#cdecff}.swagger-ui .hover-washed-blue:focus,.swagger-ui .hover-washed-blue:hover{color:#f6fffe}.swagger-ui .hover-washed-green:focus,.swagger-ui .hover-washed-green:hover{color:#e8fdf5}.swagger-ui .hover-washed-yellow:focus,.swagger-ui .hover-washed-yellow:hover{color:#fffceb}.swagger-ui .hover-washed-red:focus,.swagger-ui .hover-washed-red:hover{color:#ffdfdf}.swagger-ui .hover-bg-dark-red:focus,.swagger-ui .hover-bg-dark-red:hover{background-color:#e7040f}.swagger-ui .hover-bg-red:focus,.swagger-ui .hover-bg-red:hover{background-color:#ff4136}.swagger-ui .hover-bg-light-red:focus,.swagger-ui .hover-bg-light-red:hover{background-color:#ff725c}.swagger-ui .hover-bg-orange:focus,.swagger-ui .hover-bg-orange:hover{background-color:#ff6300}.swagger-ui .hover-bg-gold:focus,.swagger-ui .hover-bg-gold:hover{background-color:#ffb700}.swagger-ui .hover-bg-yellow:focus,.swagger-ui .hover-bg-yellow:hover{background-color:gold}.swagger-ui .hover-bg-light-yellow:focus,.swagger-ui .hover-bg-light-yellow:hover{background-color:#fbf1a9}.swagger-ui .hover-bg-purple:focus,.swagger-ui .hover-bg-purple:hover{background-color:#5e2ca5}.swagger-ui .hover-bg-light-purple:focus,.swagger-ui .hover-bg-light-purple:hover{background-color:#a463f2}.swagger-ui .hover-bg-dark-pink:focus,.swagger-ui .hover-bg-dark-pink:hover{background-color:#d5008f}.swagger-ui .hover-bg-hot-pink:focus,.swagger-ui .hover-bg-hot-pink:hover{background-color:#ff41b4}.swagger-ui .hover-bg-pink:focus,.swagger-ui .hover-bg-pink:hover{background-color:#ff80cc}.swagger-ui .hover-bg-light-pink:focus,.swagger-ui .hover-bg-light-pink:hover{background-color:#ffa3d7}.swagger-ui .hover-bg-dark-green:focus,.swagger-ui .hover-bg-dark-green:hover{background-color:#137752}.swagger-ui .hover-bg-green:focus,.swagger-ui .hover-bg-green:hover{background-color:#19a974}.swagger-ui .hover-bg-light-green:focus,.swagger-ui .hover-bg-light-green:hover{background-color:#9eebcf}.swagger-ui .hover-bg-navy:focus,.swagger-ui .hover-bg-navy:hover{background-color:#001b44}.swagger-ui .hover-bg-dark-blue:focus,.swagger-ui .hover-bg-dark-blue:hover{background-color:#00449e}.swagger-ui .hover-bg-blue:focus,.swagger-ui .hover-bg-blue:hover{background-color:#357edd}.swagger-ui .hover-bg-light-blue:focus,.swagger-ui .hover-bg-light-blue:hover{background-color:#96ccff}.swagger-ui .hover-bg-lightest-blue:focus,.swagger-ui .hover-bg-lightest-blue:hover{background-color:#cdecff}.swagger-ui .hover-bg-washed-blue:focus,.swagger-ui .hover-bg-washed-blue:hover{background-color:#f6fffe}.swagger-ui .hover-bg-washed-green:focus,.swagger-ui .hover-bg-washed-green:hover{background-color:#e8fdf5}.swagger-ui .hover-bg-washed-yellow:focus,.swagger-ui .hover-bg-washed-yellow:hover{background-color:#fffceb}.swagger-ui .hover-bg-washed-red:focus,.swagger-ui .hover-bg-washed-red:hover{background-color:#ffdfdf}.swagger-ui .hover-bg-inherit:focus,.swagger-ui .hover-bg-inherit:hover{background-color:inherit}.swagger-ui .pa0{padding:0}.swagger-ui .pa1{padding:.25rem}.swagger-ui .pa2{padding:.5rem}.swagger-ui .pa3{padding:1rem}.swagger-ui .pa4{padding:2rem}.swagger-ui .pa5{padding:4rem}.swagger-ui .pa6{padding:8rem}.swagger-ui .pa7{padding:16rem}.swagger-ui .pl0{padding-left:0}.swagger-ui .pl1{padding-left:.25rem}.swagger-ui .pl2{padding-left:.5rem}.swagger-ui .pl3{padding-left:1rem}.swagger-ui .pl4{padding-left:2rem}.swagger-ui .pl5{padding-left:4rem}.swagger-ui .pl6{padding-left:8rem}.swagger-ui .pl7{padding-left:16rem}.swagger-ui .pr0{padding-right:0}.swagger-ui .pr1{padding-right:.25rem}.swagger-ui .pr2{padding-right:.5rem}.swagger-ui .pr3{padding-right:1rem}.swagger-ui .pr4{padding-right:2rem}.swagger-ui .pr5{padding-right:4rem}.swagger-ui .pr6{padding-right:8rem}.swagger-ui .pr7{padding-right:16rem}.swagger-ui .pb0{padding-bottom:0}.swagger-ui .pb1{padding-bottom:.25rem}.swagger-ui .pb2{padding-bottom:.5rem}.swagger-ui .pb3{padding-bottom:1rem}.swagger-ui .pb4{padding-bottom:2rem}.swagger-ui .pb5{padding-bottom:4rem}.swagger-ui .pb6{padding-bottom:8rem}.swagger-ui .pb7{padding-bottom:16rem}.swagger-ui .pt0{padding-top:0}.swagger-ui .pt1{padding-top:.25rem}.swagger-ui .pt2{padding-top:.5rem}.swagger-ui .pt3{padding-top:1rem}.swagger-ui .pt4{padding-top:2rem}.swagger-ui .pt5{padding-top:4rem}.swagger-ui .pt6{padding-top:8rem}.swagger-ui .pt7{padding-top:16rem}.swagger-ui .pv0{padding-bottom:0;padding-top:0}.swagger-ui .pv1{padding-bottom:.25rem;padding-top:.25rem}.swagger-ui .pv2{padding-bottom:.5rem;padding-top:.5rem}.swagger-ui .pv3{padding-bottom:1rem;padding-top:1rem}.swagger-ui .pv4{padding-bottom:2rem;padding-top:2rem}.swagger-ui .pv5{padding-bottom:4rem;padding-top:4rem}.swagger-ui .pv6{padding-bottom:8rem;padding-top:8rem}.swagger-ui .pv7{padding-bottom:16rem;padding-top:16rem}.swagger-ui .ph0{padding-left:0;padding-right:0}.swagger-ui .ph1{padding-left:.25rem;padding-right:.25rem}.swagger-ui .ph2{padding-left:.5rem;padding-right:.5rem}.swagger-ui .ph3{padding-left:1rem;padding-right:1rem}.swagger-ui .ph4{padding-left:2rem;padding-right:2rem}.swagger-ui .ph5{padding-left:4rem;padding-right:4rem}.swagger-ui .ph6{padding-left:8rem;padding-right:8rem}.swagger-ui .ph7{padding-left:16rem;padding-right:16rem}.swagger-ui .ma0{margin:0}.swagger-ui .ma1{margin:.25rem}.swagger-ui .ma2{margin:.5rem}.swagger-ui .ma3{margin:1rem}.swagger-ui .ma4{margin:2rem}.swagger-ui .ma5{margin:4rem}.swagger-ui .ma6{margin:8rem}.swagger-ui .ma7{margin:16rem}.swagger-ui .ml0{margin-left:0}.swagger-ui .ml1{margin-left:.25rem}.swagger-ui .ml2{margin-left:.5rem}.swagger-ui .ml3{margin-left:1rem}.swagger-ui .ml4{margin-left:2rem}.swagger-ui .ml5{margin-left:4rem}.swagger-ui .ml6{margin-left:8rem}.swagger-ui .ml7{margin-left:16rem}.swagger-ui .mr0{margin-right:0}.swagger-ui .mr1{margin-right:.25rem}.swagger-ui .mr2{margin-right:.5rem}.swagger-ui .mr3{margin-right:1rem}.swagger-ui .mr4{margin-right:2rem}.swagger-ui .mr5{margin-right:4rem}.swagger-ui .mr6{margin-right:8rem}.swagger-ui .mr7{margin-right:16rem}.swagger-ui .mb0{margin-bottom:0}.swagger-ui .mb1{margin-bottom:.25rem}.swagger-ui .mb2{margin-bottom:.5rem}.swagger-ui .mb3{margin-bottom:1rem}.swagger-ui .mb4{margin-bottom:2rem}.swagger-ui .mb5{margin-bottom:4rem}.swagger-ui .mb6{margin-bottom:8rem}.swagger-ui .mb7{margin-bottom:16rem}.swagger-ui .mt0{margin-top:0}.swagger-ui .mt1{margin-top:.25rem}.swagger-ui .mt2{margin-top:.5rem}.swagger-ui .mt3{margin-top:1rem}.swagger-ui .mt4{margin-top:2rem}.swagger-ui .mt5{margin-top:4rem}.swagger-ui .mt6{margin-top:8rem}.swagger-ui .mt7{margin-top:16rem}.swagger-ui .mv0{margin-bottom:0;margin-top:0}.swagger-ui .mv1{margin-bottom:.25rem;margin-top:.25rem}.swagger-ui .mv2{margin-bottom:.5rem;margin-top:.5rem}.swagger-ui .mv3{margin-bottom:1rem;margin-top:1rem}.swagger-ui .mv4{margin-bottom:2rem;margin-top:2rem}.swagger-ui .mv5{margin-bottom:4rem;margin-top:4rem}.swagger-ui .mv6{margin-bottom:8rem;margin-top:8rem}.swagger-ui .mv7{margin-bottom:16rem;margin-top:16rem}.swagger-ui .mh0{margin-left:0;margin-right:0}.swagger-ui .mh1{margin-left:.25rem;margin-right:.25rem}.swagger-ui .mh2{margin-left:.5rem;margin-right:.5rem}.swagger-ui .mh3{margin-left:1rem;margin-right:1rem}.swagger-ui .mh4{margin-left:2rem;margin-right:2rem}.swagger-ui .mh5{margin-left:4rem;margin-right:4rem}.swagger-ui .mh6{margin-left:8rem;margin-right:8rem}.swagger-ui .mh7{margin-left:16rem;margin-right:16rem}@media screen and (min-width:30em){.swagger-ui .pa0-ns{padding:0}.swagger-ui .pa1-ns{padding:.25rem}.swagger-ui .pa2-ns{padding:.5rem}.swagger-ui .pa3-ns{padding:1rem}.swagger-ui .pa4-ns{padding:2rem}.swagger-ui .pa5-ns{padding:4rem}.swagger-ui .pa6-ns{padding:8rem}.swagger-ui .pa7-ns{padding:16rem}.swagger-ui .pl0-ns{padding-left:0}.swagger-ui .pl1-ns{padding-left:.25rem}.swagger-ui .pl2-ns{padding-left:.5rem}.swagger-ui .pl3-ns{padding-left:1rem}.swagger-ui .pl4-ns{padding-left:2rem}.swagger-ui .pl5-ns{padding-left:4rem}.swagger-ui .pl6-ns{padding-left:8rem}.swagger-ui .pl7-ns{padding-left:16rem}.swagger-ui .pr0-ns{padding-right:0}.swagger-ui .pr1-ns{padding-right:.25rem}.swagger-ui .pr2-ns{padding-right:.5rem}.swagger-ui .pr3-ns{padding-right:1rem}.swagger-ui .pr4-ns{padding-right:2rem}.swagger-ui .pr5-ns{padding-right:4rem}.swagger-ui .pr6-ns{padding-right:8rem}.swagger-ui .pr7-ns{padding-right:16rem}.swagger-ui .pb0-ns{padding-bottom:0}.swagger-ui .pb1-ns{padding-bottom:.25rem}.swagger-ui .pb2-ns{padding-bottom:.5rem}.swagger-ui .pb3-ns{padding-bottom:1rem}.swagger-ui .pb4-ns{padding-bottom:2rem}.swagger-ui .pb5-ns{padding-bottom:4rem}.swagger-ui .pb6-ns{padding-bottom:8rem}.swagger-ui .pb7-ns{padding-bottom:16rem}.swagger-ui .pt0-ns{padding-top:0}.swagger-ui .pt1-ns{padding-top:.25rem}.swagger-ui .pt2-ns{padding-top:.5rem}.swagger-ui .pt3-ns{padding-top:1rem}.swagger-ui .pt4-ns{padding-top:2rem}.swagger-ui .pt5-ns{padding-top:4rem}.swagger-ui .pt6-ns{padding-top:8rem}.swagger-ui .pt7-ns{padding-top:16rem}.swagger-ui .pv0-ns{padding-bottom:0;padding-top:0}.swagger-ui .pv1-ns{padding-bottom:.25rem;padding-top:.25rem}.swagger-ui .pv2-ns{padding-bottom:.5rem;padding-top:.5rem}.swagger-ui .pv3-ns{padding-bottom:1rem;padding-top:1rem}.swagger-ui .pv4-ns{padding-bottom:2rem;padding-top:2rem}.swagger-ui .pv5-ns{padding-bottom:4rem;padding-top:4rem}.swagger-ui .pv6-ns{padding-bottom:8rem;padding-top:8rem}.swagger-ui .pv7-ns{padding-bottom:16rem;padding-top:16rem}.swagger-ui .ph0-ns{padding-left:0;padding-right:0}.swagger-ui .ph1-ns{padding-left:.25rem;padding-right:.25rem}.swagger-ui .ph2-ns{padding-left:.5rem;padding-right:.5rem}.swagger-ui .ph3-ns{padding-left:1rem;padding-right:1rem}.swagger-ui .ph4-ns{padding-left:2rem;padding-right:2rem}.swagger-ui .ph5-ns{padding-left:4rem;padding-right:4rem}.swagger-ui .ph6-ns{padding-left:8rem;padding-right:8rem}.swagger-ui .ph7-ns{padding-left:16rem;padding-right:16rem}.swagger-ui .ma0-ns{margin:0}.swagger-ui .ma1-ns{margin:.25rem}.swagger-ui .ma2-ns{margin:.5rem}.swagger-ui .ma3-ns{margin:1rem}.swagger-ui .ma4-ns{margin:2rem}.swagger-ui .ma5-ns{margin:4rem}.swagger-ui .ma6-ns{margin:8rem}.swagger-ui .ma7-ns{margin:16rem}.swagger-ui .ml0-ns{margin-left:0}.swagger-ui .ml1-ns{margin-left:.25rem}.swagger-ui .ml2-ns{margin-left:.5rem}.swagger-ui .ml3-ns{margin-left:1rem}.swagger-ui .ml4-ns{margin-left:2rem}.swagger-ui .ml5-ns{margin-left:4rem}.swagger-ui .ml6-ns{margin-left:8rem}.swagger-ui .ml7-ns{margin-left:16rem}.swagger-ui .mr0-ns{margin-right:0}.swagger-ui .mr1-ns{margin-right:.25rem}.swagger-ui .mr2-ns{margin-right:.5rem}.swagger-ui .mr3-ns{margin-right:1rem}.swagger-ui .mr4-ns{margin-right:2rem}.swagger-ui .mr5-ns{margin-right:4rem}.swagger-ui .mr6-ns{margin-right:8rem}.swagger-ui .mr7-ns{margin-right:16rem}.swagger-ui .mb0-ns{margin-bottom:0}.swagger-ui .mb1-ns{margin-bottom:.25rem}.swagger-ui .mb2-ns{margin-bottom:.5rem}.swagger-ui .mb3-ns{margin-bottom:1rem}.swagger-ui .mb4-ns{margin-bottom:2rem}.swagger-ui .mb5-ns{margin-bottom:4rem}.swagger-ui .mb6-ns{margin-bottom:8rem}.swagger-ui .mb7-ns{margin-bottom:16rem}.swagger-ui .mt0-ns{margin-top:0}.swagger-ui .mt1-ns{margin-top:.25rem}.swagger-ui .mt2-ns{margin-top:.5rem}.swagger-ui .mt3-ns{margin-top:1rem}.swagger-ui .mt4-ns{margin-top:2rem}.swagger-ui .mt5-ns{margin-top:4rem}.swagger-ui .mt6-ns{margin-top:8rem}.swagger-ui .mt7-ns{margin-top:16rem}.swagger-ui .mv0-ns{margin-bottom:0;margin-top:0}.swagger-ui .mv1-ns{margin-bottom:.25rem;margin-top:.25rem}.swagger-ui .mv2-ns{margin-bottom:.5rem;margin-top:.5rem}.swagger-ui .mv3-ns{margin-bottom:1rem;margin-top:1rem}.swagger-ui .mv4-ns{margin-bottom:2rem;margin-top:2rem}.swagger-ui .mv5-ns{margin-bottom:4rem;margin-top:4rem}.swagger-ui .mv6-ns{margin-bottom:8rem;margin-top:8rem}.swagger-ui .mv7-ns{margin-bottom:16rem;margin-top:16rem}.swagger-ui .mh0-ns{margin-left:0;margin-right:0}.swagger-ui .mh1-ns{margin-left:.25rem;margin-right:.25rem}.swagger-ui .mh2-ns{margin-left:.5rem;margin-right:.5rem}.swagger-ui .mh3-ns{margin-left:1rem;margin-right:1rem}.swagger-ui .mh4-ns{margin-left:2rem;margin-right:2rem}.swagger-ui .mh5-ns{margin-left:4rem;margin-right:4rem}.swagger-ui .mh6-ns{margin-left:8rem;margin-right:8rem}.swagger-ui .mh7-ns{margin-left:16rem;margin-right:16rem}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .pa0-m{padding:0}.swagger-ui .pa1-m{padding:.25rem}.swagger-ui .pa2-m{padding:.5rem}.swagger-ui .pa3-m{padding:1rem}.swagger-ui .pa4-m{padding:2rem}.swagger-ui .pa5-m{padding:4rem}.swagger-ui .pa6-m{padding:8rem}.swagger-ui .pa7-m{padding:16rem}.swagger-ui .pl0-m{padding-left:0}.swagger-ui .pl1-m{padding-left:.25rem}.swagger-ui .pl2-m{padding-left:.5rem}.swagger-ui .pl3-m{padding-left:1rem}.swagger-ui .pl4-m{padding-left:2rem}.swagger-ui .pl5-m{padding-left:4rem}.swagger-ui .pl6-m{padding-left:8rem}.swagger-ui .pl7-m{padding-left:16rem}.swagger-ui .pr0-m{padding-right:0}.swagger-ui .pr1-m{padding-right:.25rem}.swagger-ui .pr2-m{padding-right:.5rem}.swagger-ui .pr3-m{padding-right:1rem}.swagger-ui .pr4-m{padding-right:2rem}.swagger-ui .pr5-m{padding-right:4rem}.swagger-ui .pr6-m{padding-right:8rem}.swagger-ui .pr7-m{padding-right:16rem}.swagger-ui .pb0-m{padding-bottom:0}.swagger-ui .pb1-m{padding-bottom:.25rem}.swagger-ui .pb2-m{padding-bottom:.5rem}.swagger-ui .pb3-m{padding-bottom:1rem}.swagger-ui .pb4-m{padding-bottom:2rem}.swagger-ui .pb5-m{padding-bottom:4rem}.swagger-ui .pb6-m{padding-bottom:8rem}.swagger-ui .pb7-m{padding-bottom:16rem}.swagger-ui .pt0-m{padding-top:0}.swagger-ui .pt1-m{padding-top:.25rem}.swagger-ui .pt2-m{padding-top:.5rem}.swagger-ui .pt3-m{padding-top:1rem}.swagger-ui .pt4-m{padding-top:2rem}.swagger-ui .pt5-m{padding-top:4rem}.swagger-ui .pt6-m{padding-top:8rem}.swagger-ui .pt7-m{padding-top:16rem}.swagger-ui .pv0-m{padding-bottom:0;padding-top:0}.swagger-ui .pv1-m{padding-bottom:.25rem;padding-top:.25rem}.swagger-ui .pv2-m{padding-bottom:.5rem;padding-top:.5rem}.swagger-ui .pv3-m{padding-bottom:1rem;padding-top:1rem}.swagger-ui .pv4-m{padding-bottom:2rem;padding-top:2rem}.swagger-ui .pv5-m{padding-bottom:4rem;padding-top:4rem}.swagger-ui .pv6-m{padding-bottom:8rem;padding-top:8rem}.swagger-ui .pv7-m{padding-bottom:16rem;padding-top:16rem}.swagger-ui .ph0-m{padding-left:0;padding-right:0}.swagger-ui .ph1-m{padding-left:.25rem;padding-right:.25rem}.swagger-ui .ph2-m{padding-left:.5rem;padding-right:.5rem}.swagger-ui .ph3-m{padding-left:1rem;padding-right:1rem}.swagger-ui .ph4-m{padding-left:2rem;padding-right:2rem}.swagger-ui .ph5-m{padding-left:4rem;padding-right:4rem}.swagger-ui .ph6-m{padding-left:8rem;padding-right:8rem}.swagger-ui .ph7-m{padding-left:16rem;padding-right:16rem}.swagger-ui .ma0-m{margin:0}.swagger-ui .ma1-m{margin:.25rem}.swagger-ui .ma2-m{margin:.5rem}.swagger-ui .ma3-m{margin:1rem}.swagger-ui .ma4-m{margin:2rem}.swagger-ui .ma5-m{margin:4rem}.swagger-ui .ma6-m{margin:8rem}.swagger-ui .ma7-m{margin:16rem}.swagger-ui .ml0-m{margin-left:0}.swagger-ui .ml1-m{margin-left:.25rem}.swagger-ui .ml2-m{margin-left:.5rem}.swagger-ui .ml3-m{margin-left:1rem}.swagger-ui .ml4-m{margin-left:2rem}.swagger-ui .ml5-m{margin-left:4rem}.swagger-ui .ml6-m{margin-left:8rem}.swagger-ui .ml7-m{margin-left:16rem}.swagger-ui .mr0-m{margin-right:0}.swagger-ui .mr1-m{margin-right:.25rem}.swagger-ui .mr2-m{margin-right:.5rem}.swagger-ui .mr3-m{margin-right:1rem}.swagger-ui .mr4-m{margin-right:2rem}.swagger-ui .mr5-m{margin-right:4rem}.swagger-ui .mr6-m{margin-right:8rem}.swagger-ui .mr7-m{margin-right:16rem}.swagger-ui .mb0-m{margin-bottom:0}.swagger-ui .mb1-m{margin-bottom:.25rem}.swagger-ui .mb2-m{margin-bottom:.5rem}.swagger-ui .mb3-m{margin-bottom:1rem}.swagger-ui .mb4-m{margin-bottom:2rem}.swagger-ui .mb5-m{margin-bottom:4rem}.swagger-ui .mb6-m{margin-bottom:8rem}.swagger-ui .mb7-m{margin-bottom:16rem}.swagger-ui .mt0-m{margin-top:0}.swagger-ui .mt1-m{margin-top:.25rem}.swagger-ui .mt2-m{margin-top:.5rem}.swagger-ui .mt3-m{margin-top:1rem}.swagger-ui .mt4-m{margin-top:2rem}.swagger-ui .mt5-m{margin-top:4rem}.swagger-ui .mt6-m{margin-top:8rem}.swagger-ui .mt7-m{margin-top:16rem}.swagger-ui .mv0-m{margin-bottom:0;margin-top:0}.swagger-ui .mv1-m{margin-bottom:.25rem;margin-top:.25rem}.swagger-ui .mv2-m{margin-bottom:.5rem;margin-top:.5rem}.swagger-ui .mv3-m{margin-bottom:1rem;margin-top:1rem}.swagger-ui .mv4-m{margin-bottom:2rem;margin-top:2rem}.swagger-ui .mv5-m{margin-bottom:4rem;margin-top:4rem}.swagger-ui .mv6-m{margin-bottom:8rem;margin-top:8rem}.swagger-ui .mv7-m{margin-bottom:16rem;margin-top:16rem}.swagger-ui .mh0-m{margin-left:0;margin-right:0}.swagger-ui .mh1-m{margin-left:.25rem;margin-right:.25rem}.swagger-ui .mh2-m{margin-left:.5rem;margin-right:.5rem}.swagger-ui .mh3-m{margin-left:1rem;margin-right:1rem}.swagger-ui .mh4-m{margin-left:2rem;margin-right:2rem}.swagger-ui .mh5-m{margin-left:4rem;margin-right:4rem}.swagger-ui .mh6-m{margin-left:8rem;margin-right:8rem}.swagger-ui .mh7-m{margin-left:16rem;margin-right:16rem}}@media screen and (min-width:60em){.swagger-ui .pa0-l{padding:0}.swagger-ui .pa1-l{padding:.25rem}.swagger-ui .pa2-l{padding:.5rem}.swagger-ui .pa3-l{padding:1rem}.swagger-ui .pa4-l{padding:2rem}.swagger-ui .pa5-l{padding:4rem}.swagger-ui .pa6-l{padding:8rem}.swagger-ui .pa7-l{padding:16rem}.swagger-ui .pl0-l{padding-left:0}.swagger-ui .pl1-l{padding-left:.25rem}.swagger-ui .pl2-l{padding-left:.5rem}.swagger-ui .pl3-l{padding-left:1rem}.swagger-ui .pl4-l{padding-left:2rem}.swagger-ui .pl5-l{padding-left:4rem}.swagger-ui .pl6-l{padding-left:8rem}.swagger-ui .pl7-l{padding-left:16rem}.swagger-ui .pr0-l{padding-right:0}.swagger-ui .pr1-l{padding-right:.25rem}.swagger-ui .pr2-l{padding-right:.5rem}.swagger-ui .pr3-l{padding-right:1rem}.swagger-ui .pr4-l{padding-right:2rem}.swagger-ui .pr5-l{padding-right:4rem}.swagger-ui .pr6-l{padding-right:8rem}.swagger-ui .pr7-l{padding-right:16rem}.swagger-ui .pb0-l{padding-bottom:0}.swagger-ui .pb1-l{padding-bottom:.25rem}.swagger-ui .pb2-l{padding-bottom:.5rem}.swagger-ui .pb3-l{padding-bottom:1rem}.swagger-ui .pb4-l{padding-bottom:2rem}.swagger-ui .pb5-l{padding-bottom:4rem}.swagger-ui .pb6-l{padding-bottom:8rem}.swagger-ui .pb7-l{padding-bottom:16rem}.swagger-ui .pt0-l{padding-top:0}.swagger-ui .pt1-l{padding-top:.25rem}.swagger-ui .pt2-l{padding-top:.5rem}.swagger-ui .pt3-l{padding-top:1rem}.swagger-ui .pt4-l{padding-top:2rem}.swagger-ui .pt5-l{padding-top:4rem}.swagger-ui .pt6-l{padding-top:8rem}.swagger-ui .pt7-l{padding-top:16rem}.swagger-ui .pv0-l{padding-bottom:0;padding-top:0}.swagger-ui .pv1-l{padding-bottom:.25rem;padding-top:.25rem}.swagger-ui .pv2-l{padding-bottom:.5rem;padding-top:.5rem}.swagger-ui .pv3-l{padding-bottom:1rem;padding-top:1rem}.swagger-ui .pv4-l{padding-bottom:2rem;padding-top:2rem}.swagger-ui .pv5-l{padding-bottom:4rem;padding-top:4rem}.swagger-ui .pv6-l{padding-bottom:8rem;padding-top:8rem}.swagger-ui .pv7-l{padding-bottom:16rem;padding-top:16rem}.swagger-ui .ph0-l{padding-left:0;padding-right:0}.swagger-ui .ph1-l{padding-left:.25rem;padding-right:.25rem}.swagger-ui .ph2-l{padding-left:.5rem;padding-right:.5rem}.swagger-ui .ph3-l{padding-left:1rem;padding-right:1rem}.swagger-ui .ph4-l{padding-left:2rem;padding-right:2rem}.swagger-ui .ph5-l{padding-left:4rem;padding-right:4rem}.swagger-ui .ph6-l{padding-left:8rem;padding-right:8rem}.swagger-ui .ph7-l{padding-left:16rem;padding-right:16rem}.swagger-ui .ma0-l{margin:0}.swagger-ui .ma1-l{margin:.25rem}.swagger-ui .ma2-l{margin:.5rem}.swagger-ui .ma3-l{margin:1rem}.swagger-ui .ma4-l{margin:2rem}.swagger-ui .ma5-l{margin:4rem}.swagger-ui .ma6-l{margin:8rem}.swagger-ui .ma7-l{margin:16rem}.swagger-ui .ml0-l{margin-left:0}.swagger-ui .ml1-l{margin-left:.25rem}.swagger-ui .ml2-l{margin-left:.5rem}.swagger-ui .ml3-l{margin-left:1rem}.swagger-ui .ml4-l{margin-left:2rem}.swagger-ui .ml5-l{margin-left:4rem}.swagger-ui .ml6-l{margin-left:8rem}.swagger-ui .ml7-l{margin-left:16rem}.swagger-ui .mr0-l{margin-right:0}.swagger-ui .mr1-l{margin-right:.25rem}.swagger-ui .mr2-l{margin-right:.5rem}.swagger-ui .mr3-l{margin-right:1rem}.swagger-ui .mr4-l{margin-right:2rem}.swagger-ui .mr5-l{margin-right:4rem}.swagger-ui .mr6-l{margin-right:8rem}.swagger-ui .mr7-l{margin-right:16rem}.swagger-ui .mb0-l{margin-bottom:0}.swagger-ui .mb1-l{margin-bottom:.25rem}.swagger-ui .mb2-l{margin-bottom:.5rem}.swagger-ui .mb3-l{margin-bottom:1rem}.swagger-ui .mb4-l{margin-bottom:2rem}.swagger-ui .mb5-l{margin-bottom:4rem}.swagger-ui .mb6-l{margin-bottom:8rem}.swagger-ui .mb7-l{margin-bottom:16rem}.swagger-ui .mt0-l{margin-top:0}.swagger-ui .mt1-l{margin-top:.25rem}.swagger-ui .mt2-l{margin-top:.5rem}.swagger-ui .mt3-l{margin-top:1rem}.swagger-ui .mt4-l{margin-top:2rem}.swagger-ui .mt5-l{margin-top:4rem}.swagger-ui .mt6-l{margin-top:8rem}.swagger-ui .mt7-l{margin-top:16rem}.swagger-ui .mv0-l{margin-bottom:0;margin-top:0}.swagger-ui .mv1-l{margin-bottom:.25rem;margin-top:.25rem}.swagger-ui .mv2-l{margin-bottom:.5rem;margin-top:.5rem}.swagger-ui .mv3-l{margin-bottom:1rem;margin-top:1rem}.swagger-ui .mv4-l{margin-bottom:2rem;margin-top:2rem}.swagger-ui .mv5-l{margin-bottom:4rem;margin-top:4rem}.swagger-ui .mv6-l{margin-bottom:8rem;margin-top:8rem}.swagger-ui .mv7-l{margin-bottom:16rem;margin-top:16rem}.swagger-ui .mh0-l{margin-left:0;margin-right:0}.swagger-ui .mh1-l{margin-left:.25rem;margin-right:.25rem}.swagger-ui .mh2-l{margin-left:.5rem;margin-right:.5rem}.swagger-ui .mh3-l{margin-left:1rem;margin-right:1rem}.swagger-ui .mh4-l{margin-left:2rem;margin-right:2rem}.swagger-ui .mh5-l{margin-left:4rem;margin-right:4rem}.swagger-ui .mh6-l{margin-left:8rem;margin-right:8rem}.swagger-ui .mh7-l{margin-left:16rem;margin-right:16rem}}.swagger-ui .na1{margin:-.25rem}.swagger-ui .na2{margin:-.5rem}.swagger-ui .na3{margin:-1rem}.swagger-ui .na4{margin:-2rem}.swagger-ui .na5{margin:-4rem}.swagger-ui .na6{margin:-8rem}.swagger-ui .na7{margin:-16rem}.swagger-ui .nl1{margin-left:-.25rem}.swagger-ui .nl2{margin-left:-.5rem}.swagger-ui .nl3{margin-left:-1rem}.swagger-ui .nl4{margin-left:-2rem}.swagger-ui .nl5{margin-left:-4rem}.swagger-ui .nl6{margin-left:-8rem}.swagger-ui .nl7{margin-left:-16rem}.swagger-ui .nr1{margin-right:-.25rem}.swagger-ui .nr2{margin-right:-.5rem}.swagger-ui .nr3{margin-right:-1rem}.swagger-ui .nr4{margin-right:-2rem}.swagger-ui .nr5{margin-right:-4rem}.swagger-ui .nr6{margin-right:-8rem}.swagger-ui .nr7{margin-right:-16rem}.swagger-ui .nb1{margin-bottom:-.25rem}.swagger-ui .nb2{margin-bottom:-.5rem}.swagger-ui .nb3{margin-bottom:-1rem}.swagger-ui .nb4{margin-bottom:-2rem}.swagger-ui .nb5{margin-bottom:-4rem}.swagger-ui .nb6{margin-bottom:-8rem}.swagger-ui .nb7{margin-bottom:-16rem}.swagger-ui .nt1{margin-top:-.25rem}.swagger-ui .nt2{margin-top:-.5rem}.swagger-ui .nt3{margin-top:-1rem}.swagger-ui .nt4{margin-top:-2rem}.swagger-ui .nt5{margin-top:-4rem}.swagger-ui .nt6{margin-top:-8rem}.swagger-ui .nt7{margin-top:-16rem}@media screen and (min-width:30em){.swagger-ui .na1-ns{margin:-.25rem}.swagger-ui .na2-ns{margin:-.5rem}.swagger-ui .na3-ns{margin:-1rem}.swagger-ui .na4-ns{margin:-2rem}.swagger-ui .na5-ns{margin:-4rem}.swagger-ui .na6-ns{margin:-8rem}.swagger-ui .na7-ns{margin:-16rem}.swagger-ui .nl1-ns{margin-left:-.25rem}.swagger-ui .nl2-ns{margin-left:-.5rem}.swagger-ui .nl3-ns{margin-left:-1rem}.swagger-ui .nl4-ns{margin-left:-2rem}.swagger-ui .nl5-ns{margin-left:-4rem}.swagger-ui .nl6-ns{margin-left:-8rem}.swagger-ui .nl7-ns{margin-left:-16rem}.swagger-ui .nr1-ns{margin-right:-.25rem}.swagger-ui .nr2-ns{margin-right:-.5rem}.swagger-ui .nr3-ns{margin-right:-1rem}.swagger-ui .nr4-ns{margin-right:-2rem}.swagger-ui .nr5-ns{margin-right:-4rem}.swagger-ui .nr6-ns{margin-right:-8rem}.swagger-ui .nr7-ns{margin-right:-16rem}.swagger-ui .nb1-ns{margin-bottom:-.25rem}.swagger-ui .nb2-ns{margin-bottom:-.5rem}.swagger-ui .nb3-ns{margin-bottom:-1rem}.swagger-ui .nb4-ns{margin-bottom:-2rem}.swagger-ui .nb5-ns{margin-bottom:-4rem}.swagger-ui .nb6-ns{margin-bottom:-8rem}.swagger-ui .nb7-ns{margin-bottom:-16rem}.swagger-ui .nt1-ns{margin-top:-.25rem}.swagger-ui .nt2-ns{margin-top:-.5rem}.swagger-ui .nt3-ns{margin-top:-1rem}.swagger-ui .nt4-ns{margin-top:-2rem}.swagger-ui .nt5-ns{margin-top:-4rem}.swagger-ui .nt6-ns{margin-top:-8rem}.swagger-ui .nt7-ns{margin-top:-16rem}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .na1-m{margin:-.25rem}.swagger-ui .na2-m{margin:-.5rem}.swagger-ui .na3-m{margin:-1rem}.swagger-ui .na4-m{margin:-2rem}.swagger-ui .na5-m{margin:-4rem}.swagger-ui .na6-m{margin:-8rem}.swagger-ui .na7-m{margin:-16rem}.swagger-ui .nl1-m{margin-left:-.25rem}.swagger-ui .nl2-m{margin-left:-.5rem}.swagger-ui .nl3-m{margin-left:-1rem}.swagger-ui .nl4-m{margin-left:-2rem}.swagger-ui .nl5-m{margin-left:-4rem}.swagger-ui .nl6-m{margin-left:-8rem}.swagger-ui .nl7-m{margin-left:-16rem}.swagger-ui .nr1-m{margin-right:-.25rem}.swagger-ui .nr2-m{margin-right:-.5rem}.swagger-ui .nr3-m{margin-right:-1rem}.swagger-ui .nr4-m{margin-right:-2rem}.swagger-ui .nr5-m{margin-right:-4rem}.swagger-ui .nr6-m{margin-right:-8rem}.swagger-ui .nr7-m{margin-right:-16rem}.swagger-ui .nb1-m{margin-bottom:-.25rem}.swagger-ui .nb2-m{margin-bottom:-.5rem}.swagger-ui .nb3-m{margin-bottom:-1rem}.swagger-ui .nb4-m{margin-bottom:-2rem}.swagger-ui .nb5-m{margin-bottom:-4rem}.swagger-ui .nb6-m{margin-bottom:-8rem}.swagger-ui .nb7-m{margin-bottom:-16rem}.swagger-ui .nt1-m{margin-top:-.25rem}.swagger-ui .nt2-m{margin-top:-.5rem}.swagger-ui .nt3-m{margin-top:-1rem}.swagger-ui .nt4-m{margin-top:-2rem}.swagger-ui .nt5-m{margin-top:-4rem}.swagger-ui .nt6-m{margin-top:-8rem}.swagger-ui .nt7-m{margin-top:-16rem}}@media screen and (min-width:60em){.swagger-ui .na1-l{margin:-.25rem}.swagger-ui .na2-l{margin:-.5rem}.swagger-ui .na3-l{margin:-1rem}.swagger-ui .na4-l{margin:-2rem}.swagger-ui .na5-l{margin:-4rem}.swagger-ui .na6-l{margin:-8rem}.swagger-ui .na7-l{margin:-16rem}.swagger-ui .nl1-l{margin-left:-.25rem}.swagger-ui .nl2-l{margin-left:-.5rem}.swagger-ui .nl3-l{margin-left:-1rem}.swagger-ui .nl4-l{margin-left:-2rem}.swagger-ui .nl5-l{margin-left:-4rem}.swagger-ui .nl6-l{margin-left:-8rem}.swagger-ui .nl7-l{margin-left:-16rem}.swagger-ui .nr1-l{margin-right:-.25rem}.swagger-ui .nr2-l{margin-right:-.5rem}.swagger-ui .nr3-l{margin-right:-1rem}.swagger-ui .nr4-l{margin-right:-2rem}.swagger-ui .nr5-l{margin-right:-4rem}.swagger-ui .nr6-l{margin-right:-8rem}.swagger-ui .nr7-l{margin-right:-16rem}.swagger-ui .nb1-l{margin-bottom:-.25rem}.swagger-ui .nb2-l{margin-bottom:-.5rem}.swagger-ui .nb3-l{margin-bottom:-1rem}.swagger-ui .nb4-l{margin-bottom:-2rem}.swagger-ui .nb5-l{margin-bottom:-4rem}.swagger-ui .nb6-l{margin-bottom:-8rem}.swagger-ui .nb7-l{margin-bottom:-16rem}.swagger-ui .nt1-l{margin-top:-.25rem}.swagger-ui .nt2-l{margin-top:-.5rem}.swagger-ui .nt3-l{margin-top:-1rem}.swagger-ui .nt4-l{margin-top:-2rem}.swagger-ui .nt5-l{margin-top:-4rem}.swagger-ui .nt6-l{margin-top:-8rem}.swagger-ui .nt7-l{margin-top:-16rem}}.swagger-ui .collapse{border-collapse:collapse;border-spacing:0}.swagger-ui .striped--light-silver:nth-child(odd){background-color:#aaa}.swagger-ui .striped--moon-gray:nth-child(odd){background-color:#ccc}.swagger-ui .striped--light-gray:nth-child(odd){background-color:#eee}.swagger-ui .striped--near-white:nth-child(odd){background-color:#f4f4f4}.swagger-ui .stripe-light:nth-child(odd){background-color:hsla(0,0%,100%,.1)}.swagger-ui .stripe-dark:nth-child(odd){background-color:rgba(0,0,0,.1)}.swagger-ui .strike{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .underline{-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .no-underline{-webkit-text-decoration:none;text-decoration:none}@media screen and (min-width:30em){.swagger-ui .strike-ns{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .underline-ns{-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .no-underline-ns{-webkit-text-decoration:none;text-decoration:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .strike-m{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .underline-m{-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .no-underline-m{-webkit-text-decoration:none;text-decoration:none}}@media screen and (min-width:60em){.swagger-ui .strike-l{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .underline-l{-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .no-underline-l{-webkit-text-decoration:none;text-decoration:none}}.swagger-ui .tl{text-align:left}.swagger-ui .tr{text-align:right}.swagger-ui .tc{text-align:center}.swagger-ui .tj{text-align:justify}@media screen and (min-width:30em){.swagger-ui .tl-ns{text-align:left}.swagger-ui .tr-ns{text-align:right}.swagger-ui .tc-ns{text-align:center}.swagger-ui .tj-ns{text-align:justify}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .tl-m{text-align:left}.swagger-ui .tr-m{text-align:right}.swagger-ui .tc-m{text-align:center}.swagger-ui .tj-m{text-align:justify}}@media screen and (min-width:60em){.swagger-ui .tl-l{text-align:left}.swagger-ui .tr-l{text-align:right}.swagger-ui .tc-l{text-align:center}.swagger-ui .tj-l{text-align:justify}}.swagger-ui .ttc{text-transform:capitalize}.swagger-ui .ttl{text-transform:lowercase}.swagger-ui .ttu{text-transform:uppercase}.swagger-ui .ttn{text-transform:none}@media screen and (min-width:30em){.swagger-ui .ttc-ns{text-transform:capitalize}.swagger-ui .ttl-ns{text-transform:lowercase}.swagger-ui .ttu-ns{text-transform:uppercase}.swagger-ui .ttn-ns{text-transform:none}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .ttc-m{text-transform:capitalize}.swagger-ui .ttl-m{text-transform:lowercase}.swagger-ui .ttu-m{text-transform:uppercase}.swagger-ui .ttn-m{text-transform:none}}@media screen and (min-width:60em){.swagger-ui .ttc-l{text-transform:capitalize}.swagger-ui .ttl-l{text-transform:lowercase}.swagger-ui .ttu-l{text-transform:uppercase}.swagger-ui .ttn-l{text-transform:none}}.swagger-ui .f-6,.swagger-ui .f-headline{font-size:6rem}.swagger-ui .f-5,.swagger-ui .f-subheadline{font-size:5rem}.swagger-ui .f1{font-size:3rem}.swagger-ui .f2{font-size:2.25rem}.swagger-ui .f3{font-size:1.5rem}.swagger-ui .f4{font-size:1.25rem}.swagger-ui .f5{font-size:1rem}.swagger-ui .f6{font-size:.875rem}.swagger-ui .f7{font-size:.75rem}@media screen and (min-width:30em){.swagger-ui .f-6-ns,.swagger-ui .f-headline-ns{font-size:6rem}.swagger-ui .f-5-ns,.swagger-ui .f-subheadline-ns{font-size:5rem}.swagger-ui .f1-ns{font-size:3rem}.swagger-ui .f2-ns{font-size:2.25rem}.swagger-ui .f3-ns{font-size:1.5rem}.swagger-ui .f4-ns{font-size:1.25rem}.swagger-ui .f5-ns{font-size:1rem}.swagger-ui .f6-ns{font-size:.875rem}.swagger-ui .f7-ns{font-size:.75rem}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .f-6-m,.swagger-ui .f-headline-m{font-size:6rem}.swagger-ui .f-5-m,.swagger-ui .f-subheadline-m{font-size:5rem}.swagger-ui .f1-m{font-size:3rem}.swagger-ui .f2-m{font-size:2.25rem}.swagger-ui .f3-m{font-size:1.5rem}.swagger-ui .f4-m{font-size:1.25rem}.swagger-ui .f5-m{font-size:1rem}.swagger-ui .f6-m{font-size:.875rem}.swagger-ui .f7-m{font-size:.75rem}}@media screen and (min-width:60em){.swagger-ui .f-6-l,.swagger-ui .f-headline-l{font-size:6rem}.swagger-ui .f-5-l,.swagger-ui .f-subheadline-l{font-size:5rem}.swagger-ui .f1-l{font-size:3rem}.swagger-ui .f2-l{font-size:2.25rem}.swagger-ui .f3-l{font-size:1.5rem}.swagger-ui .f4-l{font-size:1.25rem}.swagger-ui .f5-l{font-size:1rem}.swagger-ui .f6-l{font-size:.875rem}.swagger-ui .f7-l{font-size:.75rem}}.swagger-ui .measure{max-width:30em}.swagger-ui .measure-wide{max-width:34em}.swagger-ui .measure-narrow{max-width:20em}.swagger-ui .indent{margin-bottom:0;margin-top:0;text-indent:1em}.swagger-ui .small-caps{font-feature-settings:"smcp";font-variant:small-caps}.swagger-ui .truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}@media screen and (min-width:30em){.swagger-ui .measure-ns{max-width:30em}.swagger-ui .measure-wide-ns{max-width:34em}.swagger-ui .measure-narrow-ns{max-width:20em}.swagger-ui .indent-ns{margin-bottom:0;margin-top:0;text-indent:1em}.swagger-ui .small-caps-ns{font-feature-settings:"smcp";font-variant:small-caps}.swagger-ui .truncate-ns{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .measure-m{max-width:30em}.swagger-ui .measure-wide-m{max-width:34em}.swagger-ui .measure-narrow-m{max-width:20em}.swagger-ui .indent-m{margin-bottom:0;margin-top:0;text-indent:1em}.swagger-ui .small-caps-m{font-feature-settings:"smcp";font-variant:small-caps}.swagger-ui .truncate-m{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}}@media screen and (min-width:60em){.swagger-ui .measure-l{max-width:30em}.swagger-ui .measure-wide-l{max-width:34em}.swagger-ui .measure-narrow-l{max-width:20em}.swagger-ui .indent-l{margin-bottom:0;margin-top:0;text-indent:1em}.swagger-ui .small-caps-l{font-feature-settings:"smcp";font-variant:small-caps}.swagger-ui .truncate-l{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}}.swagger-ui .overflow-container{overflow-y:scroll}.swagger-ui .center{margin-left:auto;margin-right:auto}.swagger-ui .mr-auto{margin-right:auto}.swagger-ui .ml-auto{margin-left:auto}@media screen and (min-width:30em){.swagger-ui .center-ns{margin-left:auto;margin-right:auto}.swagger-ui .mr-auto-ns{margin-right:auto}.swagger-ui .ml-auto-ns{margin-left:auto}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .center-m{margin-left:auto;margin-right:auto}.swagger-ui .mr-auto-m{margin-right:auto}.swagger-ui .ml-auto-m{margin-left:auto}}@media screen and (min-width:60em){.swagger-ui .center-l{margin-left:auto;margin-right:auto}.swagger-ui .mr-auto-l{margin-right:auto}.swagger-ui .ml-auto-l{margin-left:auto}}.swagger-ui .clip{position:fixed!important;_position:absolute!important;clip:rect(1px 1px 1px 1px);clip:rect(1px,1px,1px,1px)}@media screen and (min-width:30em){.swagger-ui .clip-ns{position:fixed!important;_position:absolute!important;clip:rect(1px 1px 1px 1px);clip:rect(1px,1px,1px,1px)}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .clip-m{position:fixed!important;_position:absolute!important;clip:rect(1px 1px 1px 1px);clip:rect(1px,1px,1px,1px)}}@media screen and (min-width:60em){.swagger-ui .clip-l{position:fixed!important;_position:absolute!important;clip:rect(1px 1px 1px 1px);clip:rect(1px,1px,1px,1px)}}.swagger-ui .ws-normal{white-space:normal}.swagger-ui .nowrap{white-space:nowrap}.swagger-ui .pre{white-space:pre}@media screen and (min-width:30em){.swagger-ui .ws-normal-ns{white-space:normal}.swagger-ui .nowrap-ns{white-space:nowrap}.swagger-ui .pre-ns{white-space:pre}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .ws-normal-m{white-space:normal}.swagger-ui .nowrap-m{white-space:nowrap}.swagger-ui .pre-m{white-space:pre}}@media screen and (min-width:60em){.swagger-ui .ws-normal-l{white-space:normal}.swagger-ui .nowrap-l{white-space:nowrap}.swagger-ui .pre-l{white-space:pre}}.swagger-ui .v-base{vertical-align:baseline}.swagger-ui .v-mid{vertical-align:middle}.swagger-ui .v-top{vertical-align:top}.swagger-ui .v-btm{vertical-align:bottom}@media screen and (min-width:30em){.swagger-ui .v-base-ns{vertical-align:baseline}.swagger-ui .v-mid-ns{vertical-align:middle}.swagger-ui .v-top-ns{vertical-align:top}.swagger-ui .v-btm-ns{vertical-align:bottom}}@media screen and (min-width:30em)and (max-width:60em){.swagger-ui .v-base-m{vertical-align:baseline}.swagger-ui .v-mid-m{vertical-align:middle}.swagger-ui .v-top-m{vertical-align:top}.swagger-ui .v-btm-m{vertical-align:bottom}}@media screen and (min-width:60em){.swagger-ui .v-base-l{vertical-align:baseline}.swagger-ui .v-mid-l{vertical-align:middle}.swagger-ui .v-top-l{vertical-align:top}.swagger-ui .v-btm-l{vertical-align:bottom}}.swagger-ui .dim{opacity:1;transition:opacity .15s ease-in}.swagger-ui .dim:focus,.swagger-ui .dim:hover{opacity:.5;transition:opacity .15s ease-in}.swagger-ui .dim:active{opacity:.8;transition:opacity .15s ease-out}.swagger-ui .glow{transition:opacity .15s ease-in}.swagger-ui .glow:focus,.swagger-ui .glow:hover{opacity:1;transition:opacity .15s ease-in}.swagger-ui .hide-child .child{opacity:0;transition:opacity .15s ease-in}.swagger-ui .hide-child:active .child,.swagger-ui .hide-child:focus .child,.swagger-ui .hide-child:hover .child{opacity:1;transition:opacity .15s ease-in}.swagger-ui .underline-hover:focus,.swagger-ui .underline-hover:hover{-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .grow{-moz-osx-font-smoothing:grayscale;backface-visibility:hidden;transform:translateZ(0);transition:transform .25s ease-out}.swagger-ui .grow:focus,.swagger-ui .grow:hover{transform:scale(1.05)}.swagger-ui .grow:active{transform:scale(.9)}.swagger-ui .grow-large{-moz-osx-font-smoothing:grayscale;backface-visibility:hidden;transform:translateZ(0);transition:transform .25s ease-in-out}.swagger-ui .grow-large:focus,.swagger-ui .grow-large:hover{transform:scale(1.2)}.swagger-ui .grow-large:active{transform:scale(.95)}.swagger-ui .pointer:hover{cursor:pointer}.swagger-ui .shadow-hover{cursor:pointer;position:relative;transition:all .5s cubic-bezier(.165,.84,.44,1)}.swagger-ui .shadow-hover:after{border-radius:inherit;box-shadow:0 0 16px 2px rgba(0,0,0,.2);content:"";height:100%;left:0;opacity:0;position:absolute;top:0;transition:opacity .5s cubic-bezier(.165,.84,.44,1);width:100%;z-index:-1}.swagger-ui .shadow-hover:focus:after,.swagger-ui .shadow-hover:hover:after{opacity:1}.swagger-ui .bg-animate,.swagger-ui .bg-animate:focus,.swagger-ui .bg-animate:hover{transition:background-color .15s ease-in-out}.swagger-ui .z-0{z-index:0}.swagger-ui .z-1{z-index:1}.swagger-ui .z-2{z-index:2}.swagger-ui .z-3{z-index:3}.swagger-ui .z-4{z-index:4}.swagger-ui .z-5{z-index:5}.swagger-ui .z-999{z-index:999}.swagger-ui .z-9999{z-index:9999}.swagger-ui .z-max{z-index:2147483647}.swagger-ui .z-inherit{z-index:inherit}.swagger-ui .z-initial,.swagger-ui .z-unset{z-index:auto}.swagger-ui .nested-copy-line-height ol,.swagger-ui .nested-copy-line-height p,.swagger-ui .nested-copy-line-height ul{line-height:1.5}.swagger-ui .nested-headline-line-height h1,.swagger-ui .nested-headline-line-height h2,.swagger-ui .nested-headline-line-height h3,.swagger-ui .nested-headline-line-height h4,.swagger-ui .nested-headline-line-height h5,.swagger-ui .nested-headline-line-height h6{line-height:1.25}.swagger-ui .nested-list-reset ol,.swagger-ui .nested-list-reset ul{list-style-type:none;margin-left:0;padding-left:0}.swagger-ui .nested-copy-indent p+p{margin-bottom:0;margin-top:0;text-indent:.1em}.swagger-ui .nested-copy-seperator p+p{margin-top:1.5em}.swagger-ui .nested-img img{display:block;max-width:100%;width:100%}.swagger-ui .nested-links a{color:#357edd;transition:color .15s ease-in}.swagger-ui .nested-links a:focus,.swagger-ui .nested-links a:hover{color:#96ccff;transition:color .15s ease-in}.swagger-ui .wrapper{box-sizing:border-box;margin:0 auto;max-width:1460px;padding:0 20px;width:100%}.swagger-ui .opblock-tag-section{display:flex;flex-direction:column}.swagger-ui .try-out.btn-group{display:flex;flex:.1 2 auto;padding:0}.swagger-ui .try-out__btn{margin-left:1.25rem}.swagger-ui .opblock-tag{align-items:center;border-bottom:1px solid rgba(59,65,81,.3);cursor:pointer;display:flex;padding:10px 20px 10px 10px;transition:all .2s}.swagger-ui .opblock-tag:hover{background:rgba(0,0,0,.02)}.swagger-ui .opblock-tag{color:#3b4151;font-family:sans-serif;font-size:24px;margin:0 0 5px}.swagger-ui .opblock-tag.no-desc span{flex:1}.swagger-ui .opblock-tag svg{transition:all .4s}.swagger-ui .opblock-tag small{color:#3b4151;flex:2;font-family:sans-serif;font-size:14px;font-weight:400;padding:0 10px}.swagger-ui .opblock-tag>div{flex:1 1 150px;font-weight:400;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}@media(max-width:640px){.swagger-ui .opblock-tag small,.swagger-ui .opblock-tag>div{flex:1}}.swagger-ui .opblock-tag .info__externaldocs{text-align:right}.swagger-ui .parameter__type{color:#3b4151;font-family:monospace;font-size:12px;font-weight:600;padding:5px 0}.swagger-ui .parameter-controls{margin-top:.75em}.swagger-ui .examples__title{display:block;font-size:1.1em;font-weight:700;margin-bottom:.75em}.swagger-ui .examples__section{margin-top:1.5em}.swagger-ui .examples__section-header{font-size:.9rem;font-weight:700;margin-bottom:.5rem}.swagger-ui .examples-select{display:inline-block;margin-bottom:.75em}.swagger-ui .examples-select .examples-select-element{width:100%}.swagger-ui .examples-select__section-label{font-size:.9rem;font-weight:700;margin-right:.5rem}.swagger-ui .example__section{margin-top:1.5em}.swagger-ui .example__section-header{font-size:.9rem;font-weight:700;margin-bottom:.5rem}.swagger-ui .view-line-link{cursor:pointer;margin:0 5px;position:relative;top:3px;transition:all .5s;width:20px}.swagger-ui .opblock{border:1px solid #000;border-radius:4px;box-shadow:0 0 3px rgba(0,0,0,.19);margin:0 0 15px}.swagger-ui .opblock .tab-header{display:flex;flex:1}.swagger-ui .opblock .tab-header .tab-item{cursor:pointer;padding:0 40px}.swagger-ui .opblock .tab-header .tab-item:first-of-type{padding:0 40px 0 0}.swagger-ui .opblock .tab-header .tab-item.active h4 span{position:relative}.swagger-ui .opblock .tab-header .tab-item.active h4 span:after{background:grey;bottom:-15px;content:"";height:4px;left:50%;position:absolute;transform:translateX(-50%);width:120%}.swagger-ui .opblock.is-open .opblock-summary{border-bottom:1px solid #000}.swagger-ui .opblock .opblock-section-header{align-items:center;background:hsla(0,0%,100%,.8);box-shadow:0 1px 2px rgba(0,0,0,.1);display:flex;min-height:50px;padding:8px 20px}.swagger-ui .opblock .opblock-section-header>label{align-items:center;color:#3b4151;display:flex;font-family:sans-serif;font-size:12px;font-weight:700;margin:0 0 0 auto}.swagger-ui .opblock .opblock-section-header>label>span{padding:0 10px 0 0}.swagger-ui .opblock .opblock-section-header h4{color:#3b4151;flex:1;font-family:sans-serif;font-size:14px;margin:0}.swagger-ui .opblock .opblock-summary-method{background:#000;border-radius:3px;color:#fff;font-family:sans-serif;font-size:14px;font-weight:700;min-width:80px;padding:6px 0;text-align:center;text-shadow:0 1px 0 rgba(0,0,0,.1)}@media(max-width:768px){.swagger-ui .opblock .opblock-summary-method{font-size:12px}}.swagger-ui .opblock .opblock-summary-operation-id,.swagger-ui .opblock .opblock-summary-path,.swagger-ui .opblock .opblock-summary-path__deprecated{align-items:center;color:#3b4151;display:flex;font-family:monospace;font-size:16px;font-weight:600;word-break:break-word}@media(max-width:768px){.swagger-ui .opblock .opblock-summary-operation-id,.swagger-ui .opblock .opblock-summary-path,.swagger-ui .opblock .opblock-summary-path__deprecated{font-size:12px}}.swagger-ui .opblock .opblock-summary-path{flex-shrink:1}@media(max-width:640px){.swagger-ui .opblock .opblock-summary-path{max-width:100%}}.swagger-ui .opblock .opblock-summary-path__deprecated{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .opblock .opblock-summary-operation-id{font-size:14px}.swagger-ui .opblock .opblock-summary-description{color:#3b4151;font-family:sans-serif;font-size:13px;word-break:break-word}.swagger-ui .opblock .opblock-summary-path-description-wrapper{align-items:center;display:flex;flex-direction:row;flex-wrap:wrap;gap:0 10px;padding:0 10px;width:100%}@media(max-width:550px){.swagger-ui .opblock .opblock-summary-path-description-wrapper{align-items:flex-start;flex-direction:column}}.swagger-ui .opblock .opblock-summary{align-items:center;cursor:pointer;display:flex;padding:5px}.swagger-ui .opblock .opblock-summary .view-line-link{cursor:pointer;margin:0;position:relative;top:2px;transition:all .5s;width:0}.swagger-ui .opblock .opblock-summary:hover .view-line-link{margin:0 5px;width:18px}.swagger-ui .opblock .opblock-summary:hover .view-line-link.copy-to-clipboard{width:24px}.swagger-ui .opblock.opblock-post{background:rgba(73,204,144,.1);border-color:#49cc90}.swagger-ui .opblock.opblock-post .opblock-summary-method{background:#49cc90}.swagger-ui .opblock.opblock-post .opblock-summary{border-color:#49cc90}.swagger-ui .opblock.opblock-post .tab-header .tab-item.active h4 span:after{background:#49cc90}.swagger-ui .opblock.opblock-put{background:rgba(252,161,48,.1);border-color:#fca130}.swagger-ui .opblock.opblock-put .opblock-summary-method{background:#fca130}.swagger-ui .opblock.opblock-put .opblock-summary{border-color:#fca130}.swagger-ui .opblock.opblock-put .tab-header .tab-item.active h4 span:after{background:#fca130}.swagger-ui .opblock.opblock-delete{background:rgba(249,62,62,.1);border-color:#f93e3e}.swagger-ui .opblock.opblock-delete .opblock-summary-method{background:#f93e3e}.swagger-ui .opblock.opblock-delete .opblock-summary{border-color:#f93e3e}.swagger-ui .opblock.opblock-delete .tab-header .tab-item.active h4 span:after{background:#f93e3e}.swagger-ui .opblock.opblock-get{background:rgba(97,175,254,.1);border-color:#61affe}.swagger-ui .opblock.opblock-get .opblock-summary-method{background:#61affe}.swagger-ui .opblock.opblock-get .opblock-summary{border-color:#61affe}.swagger-ui .opblock.opblock-get .tab-header .tab-item.active h4 span:after{background:#61affe}.swagger-ui .opblock.opblock-patch{background:rgba(80,227,194,.1);border-color:#50e3c2}.swagger-ui .opblock.opblock-patch .opblock-summary-method{background:#50e3c2}.swagger-ui .opblock.opblock-patch .opblock-summary{border-color:#50e3c2}.swagger-ui .opblock.opblock-patch .tab-header .tab-item.active h4 span:after{background:#50e3c2}.swagger-ui .opblock.opblock-head{background:rgba(144,18,254,.1);border-color:#9012fe}.swagger-ui .opblock.opblock-head .opblock-summary-method{background:#9012fe}.swagger-ui .opblock.opblock-head .opblock-summary{border-color:#9012fe}.swagger-ui .opblock.opblock-head .tab-header .tab-item.active h4 span:after{background:#9012fe}.swagger-ui .opblock.opblock-options{background:rgba(13,90,167,.1);border-color:#0d5aa7}.swagger-ui .opblock.opblock-options .opblock-summary-method{background:#0d5aa7}.swagger-ui .opblock.opblock-options .opblock-summary{border-color:#0d5aa7}.swagger-ui .opblock.opblock-options .tab-header .tab-item.active h4 span:after{background:#0d5aa7}.swagger-ui .opblock.opblock-deprecated{background:hsla(0,0%,92%,.1);border-color:#ebebeb;opacity:.6}.swagger-ui .opblock.opblock-deprecated .opblock-summary-method{background:#ebebeb}.swagger-ui .opblock.opblock-deprecated .opblock-summary{border-color:#ebebeb}.swagger-ui .opblock.opblock-deprecated .tab-header .tab-item.active h4 span:after{background:#ebebeb}.swagger-ui .opblock .opblock-schemes{padding:8px 20px}.swagger-ui .opblock .opblock-schemes .schemes-title{padding:0 10px 0 0}.swagger-ui .filter .operation-filter-input{border:2px solid #d8dde7;margin:20px 0;padding:10px;width:100%}.swagger-ui .download-url-wrapper .failed,.swagger-ui .filter .failed{color:red}.swagger-ui .download-url-wrapper .loading,.swagger-ui .filter .loading{color:#aaa}.swagger-ui .model-example{margin-top:1em}.swagger-ui .tab{display:flex;list-style:none;padding:0}.swagger-ui .tab li{color:#3b4151;cursor:pointer;font-family:sans-serif;font-size:12px;min-width:60px;padding:0}.swagger-ui .tab li:first-of-type{padding-left:0;padding-right:12px;position:relative}.swagger-ui .tab li:first-of-type:after{background:rgba(0,0,0,.2);content:"";height:100%;position:absolute;right:6px;top:0;width:1px}.swagger-ui .tab li.active{font-weight:700}.swagger-ui .tab li button.tablinks{background:none;border:0;color:inherit;font-family:inherit;font-weight:inherit;padding:0}.swagger-ui .opblock-description-wrapper,.swagger-ui .opblock-external-docs-wrapper,.swagger-ui .opblock-title_normal{color:#3b4151;font-family:sans-serif;font-size:12px;margin:0 0 5px;padding:15px 20px}.swagger-ui .opblock-description-wrapper h4,.swagger-ui .opblock-external-docs-wrapper h4,.swagger-ui .opblock-title_normal h4{color:#3b4151;font-family:sans-serif;font-size:12px;margin:0 0 5px}.swagger-ui .opblock-description-wrapper p,.swagger-ui .opblock-external-docs-wrapper p,.swagger-ui .opblock-title_normal p{color:#3b4151;font-family:sans-serif;font-size:14px;margin:0}.swagger-ui .opblock-external-docs-wrapper h4{padding-left:0}.swagger-ui .execute-wrapper{padding:20px;text-align:right}.swagger-ui .execute-wrapper .btn{padding:8px 40px;width:100%}.swagger-ui .body-param-options{display:flex;flex-direction:column}.swagger-ui .body-param-options .body-param-edit{padding:10px 0}.swagger-ui .body-param-options label{padding:8px 0}.swagger-ui .body-param-options label select{margin:3px 0 0}.swagger-ui .responses-inner{padding:20px}.swagger-ui .responses-inner h4,.swagger-ui .responses-inner h5{color:#3b4151;font-family:sans-serif;font-size:12px;margin:10px 0 5px}.swagger-ui .responses-inner .curl{max-height:400px;min-height:6em;overflow-y:auto}.swagger-ui .response-col_status{color:#3b4151;font-family:sans-serif;font-size:14px}.swagger-ui .response-col_status .response-undocumented{color:#909090;font-family:monospace;font-size:11px;font-weight:600}.swagger-ui .response-col_links{color:#3b4151;font-family:sans-serif;font-size:14px;max-width:40em;padding-left:2em}.swagger-ui .response-col_links .response-undocumented{color:#909090;font-family:monospace;font-size:11px;font-weight:600}.swagger-ui .response-col_links .operation-link{margin-bottom:1.5em}.swagger-ui .response-col_links .operation-link .description{margin-bottom:.5em}.swagger-ui .opblock-body .opblock-loading-animation{display:block;margin:3em auto}.swagger-ui .opblock-body pre.microlight{background:#333;border-radius:4px;font-size:12px;hyphens:auto;margin:0;padding:10px;white-space:pre-wrap;word-break:break-all;word-break:break-word;word-wrap:break-word;color:#fff;font-family:monospace;font-weight:600}.swagger-ui .opblock-body pre.microlight .headerline{display:block}.swagger-ui .highlight-code{position:relative}.swagger-ui .highlight-code>.microlight{max-height:400px;min-height:6em;overflow-y:auto}.swagger-ui .highlight-code>.microlight code{white-space:pre-wrap!important;word-break:break-all}.swagger-ui .curl-command{position:relative}.swagger-ui .download-contents{align-items:center;background:#7d8293;border:none;border-radius:4px;bottom:10px;color:#fff;display:flex;font-family:sans-serif;font-size:14px;font-weight:600;height:30px;justify-content:center;padding:5px;position:absolute;right:10px;text-align:center}.swagger-ui .scheme-container{background:#fff;box-shadow:0 1px 2px 0 rgba(0,0,0,.15);margin:0 0 20px;padding:30px 0}.swagger-ui .scheme-container .schemes{align-items:flex-end;display:flex;flex-wrap:wrap;gap:10px;justify-content:space-between}.swagger-ui .scheme-container .schemes>.schemes-server-container{display:flex;flex-wrap:wrap;gap:10px}.swagger-ui .scheme-container .schemes>.schemes-server-container>label{color:#3b4151;display:flex;flex-direction:column;font-family:sans-serif;font-size:12px;font-weight:700;margin:-20px 15px 0 0}.swagger-ui .scheme-container .schemes>.schemes-server-container>label select{min-width:130px;text-transform:uppercase}.swagger-ui .scheme-container .schemes:not(:has(.schemes-server-container)){justify-content:flex-end}.swagger-ui .scheme-container .schemes .auth-wrapper{flex:none;justify-content:start}.swagger-ui .scheme-container .schemes .auth-wrapper .authorize{display:flex;flex-wrap:nowrap;margin:0;padding-right:20px}.swagger-ui .loading-container{align-items:center;display:flex;flex-direction:column;justify-content:center;margin-top:1em;min-height:1px;padding:40px 0 60px}.swagger-ui .loading-container .loading{position:relative}.swagger-ui .loading-container .loading:after{color:#3b4151;content:"loading";font-family:sans-serif;font-size:10px;font-weight:700;left:50%;position:absolute;text-transform:uppercase;top:50%;transform:translate(-50%,-50%)}.swagger-ui .loading-container .loading:before{animation:rotation 1s linear infinite,opacity .5s;backface-visibility:hidden;border:2px solid rgba(85,85,85,.1);border-radius:100%;border-top-color:rgba(0,0,0,.6);content:"";display:block;height:60px;left:50%;margin:-30px;opacity:1;position:absolute;top:50%;width:60px}@keyframes rotation{to{transform:rotate(1turn)}}.swagger-ui .response-controls{display:flex;padding-top:1em}.swagger-ui .response-control-media-type{margin-right:1em}.swagger-ui .response-control-media-type--accept-controller select{border-color:green}.swagger-ui .response-control-media-type__accept-message{color:green;font-size:.7em}.swagger-ui .response-control-examples__title,.swagger-ui .response-control-media-type__title{display:block;font-size:.7em;margin-bottom:.2em}@keyframes blinker{50%{opacity:0}}.swagger-ui .hidden{display:none}.swagger-ui .no-margin{border:none;height:auto;margin:0;padding:0}.swagger-ui .float-right{float:right}.swagger-ui .svg-assets{height:0;position:absolute;width:0}.swagger-ui section h3{color:#3b4151;font-family:sans-serif}.swagger-ui a.nostyle{display:inline}.swagger-ui a.nostyle,.swagger-ui a.nostyle:visited{color:inherit;cursor:pointer;text-decoration:inherit}.swagger-ui .fallback{color:#aaa;padding:1em}.swagger-ui .version-pragma{height:100%;padding:5em 0}.swagger-ui .version-pragma__message{display:flex;font-size:1.2em;height:100%;justify-content:center;line-height:1.5em;padding:0 .6em;text-align:center}.swagger-ui .version-pragma__message>div{flex:1;max-width:55ch}.swagger-ui .version-pragma__message code{background-color:#dedede;padding:4px 4px 2px;white-space:pre}.swagger-ui .opblock-link{font-weight:400}.swagger-ui .opblock-link.shown{font-weight:700}.swagger-ui span.token-string{color:#555}.swagger-ui span.token-not-formatted{color:#555;font-weight:700}.swagger-ui .btn{background:transparent;border:2px solid grey;border-radius:4px;box-shadow:0 1px 2px rgba(0,0,0,.1);color:#3b4151;font-family:sans-serif;font-size:14px;font-weight:700;padding:5px 23px;transition:all .3s}.swagger-ui .btn.btn-sm{font-size:12px;padding:4px 23px}.swagger-ui .btn[disabled]{cursor:not-allowed;opacity:.3}.swagger-ui .btn:hover{box-shadow:0 0 5px rgba(0,0,0,.3)}.swagger-ui .btn.cancel{background-color:transparent;border-color:#ff6060;color:#ff6060;font-family:sans-serif}.swagger-ui .btn.authorize{background-color:transparent;border-color:#49cc90;color:#49cc90;display:inline;line-height:1}.swagger-ui .btn.authorize span{float:left;padding:4px 20px 0 0}.swagger-ui .btn.authorize svg{fill:#49cc90}.swagger-ui .btn.execute{background-color:#4990e2;border-color:#4990e2;color:#fff}.swagger-ui .btn-group{display:flex;padding:30px}.swagger-ui .btn-group .btn{flex:1}.swagger-ui .btn-group .btn:first-child{border-radius:4px 0 0 4px}.swagger-ui .btn-group .btn:last-child{border-radius:0 4px 4px 0}.swagger-ui .authorization__btn{background:none;border:none;padding:0 0 0 10px}.swagger-ui .authorization__btn .locked{opacity:1}.swagger-ui .authorization__btn .unlocked{opacity:.4}.swagger-ui .model-box-control,.swagger-ui .models-control,.swagger-ui .opblock-summary-control{all:inherit;border-bottom:0;cursor:pointer;flex:1;padding:0}.swagger-ui .model-box-control:focus,.swagger-ui .models-control:focus,.swagger-ui .opblock-summary-control:focus{outline:auto}.swagger-ui .expand-methods,.swagger-ui .expand-operation{background:none;border:none}.swagger-ui .expand-methods svg,.swagger-ui .expand-operation svg{height:20px;width:20px}.swagger-ui .expand-methods{padding:0 10px}.swagger-ui .expand-methods:hover svg{fill:#404040}.swagger-ui .expand-methods svg{transition:all .3s;fill:#707070}.swagger-ui button{cursor:pointer}.swagger-ui button.invalid{animation:shake .4s 1;background:#feebeb;border-color:#f93e3e}.swagger-ui .copy-to-clipboard{align-items:center;background:#7d8293;border:none;border-radius:4px;bottom:10px;display:flex;height:30px;justify-content:center;position:absolute;right:100px;width:30px}.swagger-ui .copy-to-clipboard button{background:url("data:image/svg+xml;charset=utf-8,") 50% no-repeat;border:none;flex-grow:1;flex-shrink:1;height:25px}.swagger-ui .copy-to-clipboard:active{background:#5e626f}.swagger-ui .opblock-control-arrow{background:none;border:none;text-align:center}.swagger-ui .curl-command .copy-to-clipboard{bottom:5px;height:20px;right:10px;width:20px}.swagger-ui .curl-command .copy-to-clipboard button{height:18px}.swagger-ui .opblock .opblock-summary .view-line-link.copy-to-clipboard{height:26px;position:static}.swagger-ui select{-webkit-appearance:none;-moz-appearance:none;appearance:none;background:#f7f7f7 url("data:image/svg+xml;charset=utf-8,") right 10px center no-repeat;background-size:20px;border:2px solid #41444e;border-radius:4px;box-shadow:0 1px 2px 0 rgba(0,0,0,.25);color:#3b4151;font-family:sans-serif;font-size:14px;font-weight:700;padding:5px 40px 5px 10px}.swagger-ui select[multiple]{background:#f7f7f7;margin:5px 0;padding:5px}.swagger-ui select.invalid{animation:shake .4s 1;background:#feebeb;border-color:#f93e3e}.swagger-ui .opblock-body select{min-width:230px}@media(max-width:768px){.swagger-ui .opblock-body select{min-width:180px}}@media(max-width:640px){.swagger-ui .opblock-body select{min-width:100%;width:100%}}.swagger-ui label{color:#3b4151;font-family:sans-serif;font-size:12px;font-weight:700;margin:0 0 5px}.swagger-ui input[type=email],.swagger-ui input[type=file],.swagger-ui input[type=password],.swagger-ui input[type=search],.swagger-ui input[type=text]{line-height:1}@media(max-width:768px){.swagger-ui input[type=email],.swagger-ui input[type=file],.swagger-ui input[type=password],.swagger-ui input[type=search],.swagger-ui input[type=text]{max-width:175px}}.swagger-ui input[type=email],.swagger-ui input[type=file],.swagger-ui input[type=password],.swagger-ui input[type=search],.swagger-ui input[type=text],.swagger-ui textarea{background:#fff;border:1px solid #d9d9d9;border-radius:4px;margin:5px 0;min-width:100px;padding:8px 10px}.swagger-ui input[type=email].invalid,.swagger-ui input[type=file].invalid,.swagger-ui input[type=password].invalid,.swagger-ui input[type=search].invalid,.swagger-ui input[type=text].invalid,.swagger-ui textarea.invalid{animation:shake .4s 1;background:#feebeb;border-color:#f93e3e}.swagger-ui input[disabled],.swagger-ui select[disabled],.swagger-ui textarea[disabled]{background-color:#fafafa;color:#888;cursor:not-allowed}.swagger-ui select[disabled]{border-color:#888}.swagger-ui textarea[disabled]{background-color:#41444e;color:#fff}@keyframes shake{10%,90%{transform:translate3d(-1px,0,0)}20%,80%{transform:translate3d(2px,0,0)}30%,50%,70%{transform:translate3d(-4px,0,0)}40%,60%{transform:translate3d(4px,0,0)}}.swagger-ui textarea{background:hsla(0,0%,100%,.8);border:none;border-radius:4px;color:#3b4151;font-family:monospace;font-size:12px;font-weight:600;min-height:280px;outline:none;padding:10px;width:100%}.swagger-ui textarea:focus{border:2px solid #61affe}.swagger-ui textarea.curl{background:#41444e;border-radius:4px;color:#fff;font-family:monospace;font-size:12px;font-weight:600;margin:0;min-height:100px;padding:10px;resize:none}.swagger-ui .checkbox{color:#303030;padding:5px 0 10px;transition:opacity .5s}.swagger-ui .checkbox label{display:flex}.swagger-ui .checkbox p{color:#3b4151;font-family:monospace;font-style:italic;font-weight:400!important;font-weight:600;margin:0!important}.swagger-ui .checkbox input[type=checkbox]{display:none}.swagger-ui .checkbox input[type=checkbox]+label>.item{background:#e8e8e8;border-radius:1px;box-shadow:0 0 0 2px #e8e8e8;cursor:pointer;display:inline-block;flex:none;height:16px;margin:0 8px 0 0;padding:5px;position:relative;top:3px;width:16px}.swagger-ui .checkbox input[type=checkbox]+label>.item:active{transform:scale(.9)}.swagger-ui .checkbox input[type=checkbox]:checked+label>.item{background:#e8e8e8 url("data:image/svg+xml;charset=utf-8,") 50% no-repeat}.swagger-ui .dialog-ux{bottom:0;left:0;position:fixed;right:0;top:0;z-index:9999}.swagger-ui .dialog-ux .backdrop-ux{background:rgba(0,0,0,.8);bottom:0;left:0;position:fixed;right:0;top:0}.swagger-ui .dialog-ux .modal-ux{background:#fff;border:1px solid #ebebeb;border-radius:4px;box-shadow:0 10px 30px 0 rgba(0,0,0,.2);left:50%;max-width:650px;min-width:300px;position:absolute;top:50%;transform:translate(-50%,-50%);width:100%;z-index:9999}.swagger-ui .dialog-ux .modal-ux-content{max-height:540px;overflow-y:auto;padding:20px}.swagger-ui .dialog-ux .modal-ux-content p{color:#41444e;color:#3b4151;font-family:sans-serif;font-size:12px;margin:0 0 5px}.swagger-ui .dialog-ux .modal-ux-content h4{color:#3b4151;font-family:sans-serif;font-size:18px;font-weight:600;margin:15px 0 0}.swagger-ui .dialog-ux .modal-ux-header{align-items:center;border-bottom:1px solid #ebebeb;display:flex;padding:12px 0}.swagger-ui .dialog-ux .modal-ux-header .close-modal{-webkit-appearance:none;-moz-appearance:none;appearance:none;background:none;border:none;padding:0 10px}.swagger-ui .dialog-ux .modal-ux-header h3{color:#3b4151;flex:1;font-family:sans-serif;font-size:20px;font-weight:600;margin:0;padding:0 20px}.swagger-ui .model{color:#3b4151;font-family:monospace;font-size:12px;font-weight:300;font-weight:600}.swagger-ui .model .deprecated span,.swagger-ui .model .deprecated td{color:#a0a0a0!important}.swagger-ui .model .deprecated>td:first-of-type{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .model-toggle{cursor:pointer;display:inline-block;font-size:10px;margin:auto .3em;position:relative;top:6px;transform:rotate(90deg);transform-origin:50% 50%;transition:transform .15s ease-in}.swagger-ui .model-toggle.collapsed{transform:rotate(0deg)}.swagger-ui .model-toggle:after{background:url("data:image/svg+xml;charset=utf-8,") 50% no-repeat;background-size:100%;content:"";display:block;height:20px;width:20px}.swagger-ui .model-jump-to-path{cursor:pointer;position:relative}.swagger-ui .model-jump-to-path .view-line-link{cursor:pointer;position:absolute;top:-.4em}.swagger-ui .model-title{position:relative}.swagger-ui .model-title:hover .model-hint{visibility:visible}.swagger-ui .model-hint{background:rgba(0,0,0,.7);border-radius:4px;color:#ebebeb;padding:.1em .5em;position:absolute;top:-1.8em;visibility:hidden;white-space:nowrap}.swagger-ui .model p{margin:0 0 1em}.swagger-ui .model .property{color:#999;font-style:italic}.swagger-ui .model .property.primitive{color:#6b6b6b}.swagger-ui .model .external-docs,.swagger-ui table.model tr.description{color:#666;font-weight:400}.swagger-ui table.model tr.description td:first-child,.swagger-ui table.model tr.property-row.required td:first-child{font-weight:700}.swagger-ui table.model tr.property-row td{vertical-align:top}.swagger-ui table.model tr.property-row td:first-child{padding-right:.2em}.swagger-ui table.model tr.property-row .star{color:red}.swagger-ui table.model tr.extension{color:#777}.swagger-ui table.model tr.extension td:last-child{vertical-align:top}.swagger-ui table.model tr.external-docs td:first-child{font-weight:700}.swagger-ui table.model tr .renderedMarkdown p:first-child{margin-top:0}.swagger-ui section.models{border:1px solid rgba(59,65,81,.3);border-radius:4px;margin:30px 0}.swagger-ui section.models .pointer{cursor:pointer}.swagger-ui section.models.is-open{padding:0 0 20px}.swagger-ui section.models.is-open h4{border-bottom:1px solid rgba(59,65,81,.3);margin:0 0 5px}.swagger-ui section.models h4{align-items:center;color:#606060;cursor:pointer;display:flex;font-family:sans-serif;font-size:16px;margin:0;padding:10px 20px 10px 10px;transition:all .2s}.swagger-ui section.models h4 svg{transition:all .4s}.swagger-ui section.models h4 span{flex:1}.swagger-ui section.models h4:hover{background:rgba(0,0,0,.02)}.swagger-ui section.models h5{color:#707070;font-family:sans-serif;font-size:16px;margin:0 0 10px}.swagger-ui section.models .model-jump-to-path{position:relative;top:5px}.swagger-ui section.models .model-container{background:rgba(0,0,0,.05);border-radius:4px;margin:0 20px 15px;position:relative;transition:all .5s}.swagger-ui section.models .model-container:hover{background:rgba(0,0,0,.07)}.swagger-ui section.models .model-container:first-of-type{margin:20px}.swagger-ui section.models .model-container:last-of-type{margin:0 20px}.swagger-ui section.models .model-container .models-jump-to-path{opacity:.65;position:absolute;right:5px;top:8px}.swagger-ui section.models .model-box{background:none}.swagger-ui .model-box{background:rgba(0,0,0,.1);border-radius:4px;display:inline-block;padding:10px}.swagger-ui .model-box .model-jump-to-path{position:relative;top:4px}.swagger-ui .model-box.deprecated{opacity:.5}.swagger-ui .model-title{color:#505050;font-family:sans-serif;font-size:16px}.swagger-ui .model-title img{bottom:0;margin-left:1em;position:relative}.swagger-ui .model-deprecated-warning{color:#f93e3e;font-family:sans-serif;font-size:16px;font-weight:600;margin-right:1em}.swagger-ui span>span.model .brace-close{padding:0 0 0 10px}.swagger-ui .prop-name{display:inline-block;margin-right:1em}.swagger-ui .prop-type{color:#55a}.swagger-ui .prop-enum{display:block}.swagger-ui .prop-format{color:#606060}.swagger-ui .servers>label{color:#3b4151;font-family:sans-serif;font-size:12px;margin:-20px 15px 0 0}.swagger-ui .servers>label select{max-width:100%;min-width:130px;width:100%}.swagger-ui .servers h4.message{padding-bottom:2em}.swagger-ui .servers table tr{width:30em}.swagger-ui .servers table td{display:inline-block;max-width:15em;padding-bottom:10px;padding-top:10px;vertical-align:middle}.swagger-ui .servers table td:first-of-type{padding-right:1em}.swagger-ui .servers table td input{height:100%;width:100%}.swagger-ui .servers .computed-url{margin:2em 0}.swagger-ui .servers .computed-url code{display:inline-block;font-size:16px;margin:0 1em;padding:4px}.swagger-ui .servers-title{font-size:12px;font-weight:700}.swagger-ui .operation-servers h4.message{margin-bottom:2em}.swagger-ui table{border-collapse:collapse;padding:0 10px;width:100%}.swagger-ui table.model tbody tr td{padding:0;vertical-align:top}.swagger-ui table.model tbody tr td:first-of-type{padding:0 0 0 2em;width:174px}.swagger-ui table.headers td{color:#3b4151;font-family:monospace;font-size:12px;font-weight:300;font-weight:600;vertical-align:middle}.swagger-ui table.headers .header-example{color:#999;font-style:italic}.swagger-ui table tbody tr td{padding:10px 0 0;vertical-align:top}.swagger-ui table tbody tr td:first-of-type{min-width:6em;padding:10px 0}.swagger-ui table thead tr td,.swagger-ui table thead tr th{border-bottom:1px solid rgba(59,65,81,.2);color:#3b4151;font-family:sans-serif;font-size:12px;font-weight:700;padding:12px 0;text-align:left}.swagger-ui .parameters-col_description{margin-bottom:2em;width:99%}.swagger-ui .parameters-col_description input{max-width:340px;width:100%}.swagger-ui .parameters-col_description select{border-width:1px}.swagger-ui .parameters-col_description .markdown p,.swagger-ui .parameters-col_description .renderedMarkdown p{margin:0}.swagger-ui .parameter__name{color:#3b4151;font-family:sans-serif;font-size:16px;font-weight:400;margin-right:.75em}.swagger-ui .parameter__name.required{font-weight:700}.swagger-ui .parameter__name.required span{color:red}.swagger-ui .parameter__name.required:after{color:rgba(255,0,0,.6);content:"required";font-size:10px;padding:5px;position:relative;top:-6px}.swagger-ui .parameter__extension,.swagger-ui .parameter__in{color:grey;font-family:monospace;font-size:12px;font-style:italic;font-weight:600}.swagger-ui .parameter__deprecated{color:red;font-family:monospace;font-size:12px;font-style:italic;font-weight:600}.swagger-ui .parameter__empty_value_toggle{display:block;font-size:13px;padding-bottom:12px;padding-top:5px}.swagger-ui .parameter__empty_value_toggle input{margin-right:7px;width:auto}.swagger-ui .parameter__empty_value_toggle.disabled{opacity:.7}.swagger-ui .table-container{padding:20px}.swagger-ui .response-col_description{width:99%}.swagger-ui .response-col_description .markdown p,.swagger-ui .response-col_description .renderedMarkdown p{margin:0}.swagger-ui .response-col_links{min-width:6em}.swagger-ui .response__extension{color:grey;font-family:monospace;font-size:12px;font-style:italic;font-weight:600}.swagger-ui .topbar{background-color:#1b1b1b;padding:10px 0}.swagger-ui .topbar .topbar-wrapper{align-items:center;display:flex;flex-wrap:wrap;gap:10px}@media(max-width:550px){.swagger-ui .topbar .topbar-wrapper{align-items:start;flex-direction:column}}.swagger-ui .topbar a{align-items:center;color:#fff;display:flex;flex:1;font-family:sans-serif;font-size:1.5em;font-weight:700;max-width:300px;-webkit-text-decoration:none;text-decoration:none}.swagger-ui .topbar a span{margin:0;padding:0 10px}.swagger-ui .topbar .download-url-wrapper{display:flex;flex:3;justify-content:flex-end}.swagger-ui .topbar .download-url-wrapper input[type=text]{border:2px solid #62a03f;border-radius:4px 0 0 4px;margin:0;max-width:100%;outline:none;width:100%}.swagger-ui .topbar .download-url-wrapper .select-label{align-items:center;color:#f0f0f0;display:flex;margin:0;max-width:600px;width:100%}.swagger-ui .topbar .download-url-wrapper .select-label span{flex:1;font-size:16px;padding:0 10px 0 0;text-align:right}.swagger-ui .topbar .download-url-wrapper .select-label select{border:2px solid #62a03f;box-shadow:none;flex:2;outline:none;width:100%}.swagger-ui .topbar .download-url-wrapper .download-url-button{background:#62a03f;border:none;border-radius:0 4px 4px 0;color:#fff;font-family:sans-serif;font-size:16px;font-weight:700;padding:4px 30px}@media(max-width:550px){.swagger-ui .topbar .download-url-wrapper{width:100%}}.swagger-ui .info{margin:50px 0}.swagger-ui .info.failed-config{margin-left:auto;margin-right:auto;max-width:880px;text-align:center}.swagger-ui .info hgroup.main{margin:0 0 20px}.swagger-ui .info hgroup.main a{font-size:12px}.swagger-ui .info pre{font-size:14px}.swagger-ui .info li,.swagger-ui .info p,.swagger-ui .info table{color:#3b4151;font-family:sans-serif;font-size:14px}.swagger-ui .info h1,.swagger-ui .info h2,.swagger-ui .info h3,.swagger-ui .info h4,.swagger-ui .info h5{color:#3b4151;font-family:sans-serif}.swagger-ui .info a{color:#4990e2;font-family:sans-serif;font-size:14px;transition:all .4s}.swagger-ui .info a:hover{color:#1f69c0}.swagger-ui .info>div{margin:0 0 5px}.swagger-ui .info .base-url{color:#3b4151;font-family:monospace;font-size:12px;font-weight:300!important;font-weight:600;margin:0}.swagger-ui .info .title{color:#3b4151;font-family:sans-serif;font-size:36px;margin:0}.swagger-ui .info .title small{background:#7d8492;border-radius:57px;display:inline-block;font-size:10px;margin:0 0 0 5px;padding:2px 4px;position:relative;top:-5px;vertical-align:super}.swagger-ui .info .title small.version-stamp{background-color:#89bf04}.swagger-ui .info .title small pre{color:#fff;font-family:sans-serif;margin:0;padding:0}.swagger-ui .auth-btn-wrapper{display:flex;justify-content:center;padding:10px 0}.swagger-ui .auth-btn-wrapper .btn-done{margin-right:1em}.swagger-ui .auth-wrapper{display:flex;flex:1;justify-content:flex-end}.swagger-ui .auth-wrapper .authorize{margin-left:10px;margin-right:10px;padding-right:20px}.swagger-ui .auth-container{border-bottom:1px solid #ebebeb;margin:0 0 10px;padding:10px 20px}.swagger-ui .auth-container:last-of-type{border:0;margin:0;padding:10px 20px}.swagger-ui .auth-container h4{margin:5px 0 15px!important}.swagger-ui .auth-container .wrapper{margin:0;padding:0}.swagger-ui .auth-container input[type=password],.swagger-ui .auth-container input[type=text]{min-width:230px}.swagger-ui .auth-container .errors{background-color:#fee;border-radius:4px;color:red;color:#3b4151;font-family:monospace;font-size:12px;font-weight:600;margin:1em;padding:10px}.swagger-ui .auth-container .errors b{margin-right:1em;text-transform:capitalize}.swagger-ui .scopes h2{color:#3b4151;font-family:sans-serif;font-size:14px}.swagger-ui .scopes h2 a{color:#4990e2;cursor:pointer;font-size:12px;padding-left:10px;-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .scope-def{padding:0 0 20px}.swagger-ui .errors-wrapper{animation:scaleUp .5s;background:rgba(249,62,62,.1);border:2px solid #f93e3e;border-radius:4px;margin:20px;padding:10px 20px}.swagger-ui .errors-wrapper .error-wrapper{margin:0 0 10px}.swagger-ui .errors-wrapper .errors h4{color:#3b4151;font-family:monospace;font-size:14px;font-weight:600;margin:0}.swagger-ui .errors-wrapper .errors small{color:#606060}.swagger-ui .errors-wrapper .errors .message{white-space:pre-line}.swagger-ui .errors-wrapper .errors .message.thrown{max-width:100%}.swagger-ui .errors-wrapper .errors .error-line{cursor:pointer;-webkit-text-decoration:underline;text-decoration:underline}.swagger-ui .errors-wrapper hgroup{align-items:center;display:flex}.swagger-ui .errors-wrapper hgroup h4{color:#3b4151;flex:1;font-family:sans-serif;font-size:20px;margin:0}@keyframes scaleUp{0%{opacity:0;transform:scale(.8)}to{opacity:1;transform:scale(1)}}.swagger-ui .Resizer.vertical.disabled{display:none}.swagger-ui .markdown p,.swagger-ui .markdown pre,.swagger-ui .renderedMarkdown p,.swagger-ui .renderedMarkdown pre{margin:1em auto;word-break:break-all;word-break:break-word}.swagger-ui .markdown pre,.swagger-ui .renderedMarkdown pre{background:none;color:#000;font-weight:400;padding:0;white-space:pre-wrap}.swagger-ui .markdown code,.swagger-ui .renderedMarkdown code{background:rgba(0,0,0,.05);border-radius:4px;color:#9012fe;font-family:monospace;font-size:14px;font-weight:600;padding:5px 7px}.swagger-ui .markdown pre>code,.swagger-ui .renderedMarkdown pre>code{display:block}.swagger-ui .json-schema-2020-12{background-color:rgba(0,0,0,.05);border-radius:4px;margin:0 20px 15px;padding:12px 0 12px 20px}.swagger-ui .json-schema-2020-12:first-of-type{margin:20px}.swagger-ui .json-schema-2020-12:last-of-type{margin:0 20px}.swagger-ui .json-schema-2020-12--embedded{background-color:inherit;padding-bottom:0;padding-left:inherit;padding-right:inherit;padding-top:0}.swagger-ui .json-schema-2020-12-body{border-left:1px dashed rgba(0,0,0,.1);margin:2px 0}.swagger-ui .json-schema-2020-12-body--collapsed{display:none}.swagger-ui .json-schema-2020-12-accordion{border:none;outline:none;padding-left:0}.swagger-ui .json-schema-2020-12-accordion__children{display:inline-block}.swagger-ui .json-schema-2020-12-accordion__icon{display:inline-block;height:18px;vertical-align:bottom;width:18px}.swagger-ui .json-schema-2020-12-accordion__icon--expanded{transform:rotate(-90deg);transform-origin:50% 50%;transition:transform .15s ease-in}.swagger-ui .json-schema-2020-12-accordion__icon--collapsed{transform:rotate(0deg);transform-origin:50% 50%;transition:transform .15s ease-in}.swagger-ui .json-schema-2020-12-accordion__icon svg{height:20px;width:20px}.swagger-ui .json-schema-2020-12-expand-deep-button{border:none;color:#505050;color:#afaeae;font-family:sans-serif;font-size:12px;padding-right:0}.swagger-ui .json-schema-2020-12-keyword{margin:5px 0}.swagger-ui .json-schema-2020-12-keyword__children{border-left:1px dashed rgba(0,0,0,.1);margin:0 0 0 20px;padding:0}.swagger-ui .json-schema-2020-12-keyword__children--collapsed{display:none}.swagger-ui .json-schema-2020-12-keyword__name{font-size:12px;font-weight:700;margin-left:20px}.swagger-ui .json-schema-2020-12-keyword__name--primary{color:#3b4151;font-style:normal}.swagger-ui .json-schema-2020-12-keyword__name--secondary{color:#6b6b6b;font-style:italic}.swagger-ui .json-schema-2020-12-keyword__value{color:#6b6b6b;font-size:12px;font-style:italic;font-weight:400}.swagger-ui .json-schema-2020-12-keyword__value--primary{color:#3b4151;font-style:normal}.swagger-ui .json-schema-2020-12-keyword__value--secondary{color:#6b6b6b;font-style:italic}.swagger-ui .json-schema-2020-12-keyword__value--const,.swagger-ui .json-schema-2020-12-keyword__value--warning{border:1px dashed #6b6b6b;border-radius:4px;color:#3b4151;color:#6b6b6b;display:inline-block;font-family:monospace;font-style:normal;font-weight:600;line-height:1.5;margin-left:10px;padding:1px 4px}.swagger-ui .json-schema-2020-12-keyword__value--warning{border:1px dashed red;color:red}.swagger-ui .json-schema-2020-12-keyword__name--secondary+.json-schema-2020-12-keyword__value--secondary:before{content:"="}.swagger-ui .json-schema-2020-12__attribute{color:#3b4151;font-family:monospace;font-size:12px;padding-left:10px;text-transform:lowercase}.swagger-ui .json-schema-2020-12__attribute--primary{color:#55a}.swagger-ui .json-schema-2020-12__attribute--muted{color:gray}.swagger-ui .json-schema-2020-12__attribute--warning{color:red}.swagger-ui .json-schema-2020-12-keyword--\$vocabulary ul{border-left:1px dashed rgba(0,0,0,.1);margin:0 0 0 20px}.swagger-ui .json-schema-2020-12-\$vocabulary-uri{margin-left:35px}.swagger-ui .json-schema-2020-12-\$vocabulary-uri--disabled{-webkit-text-decoration:line-through;text-decoration:line-through}.swagger-ui .json-schema-2020-12-keyword--description{color:#6b6b6b;font-size:12px;margin-left:20px}.swagger-ui .json-schema-2020-12-keyword--description p{margin:0}.swagger-ui .json-schema-2020-12__title{color:#505050;display:inline-block;font-family:sans-serif;font-size:12px;font-weight:700;line-height:normal}.swagger-ui .json-schema-2020-12__title .json-schema-2020-12-keyword__name{margin:0}.swagger-ui .json-schema-2020-12-property{margin:7px 0}.swagger-ui .json-schema-2020-12-property .json-schema-2020-12__title{color:#3b4151;font-family:monospace;font-size:12px;font-weight:600;vertical-align:middle}.swagger-ui .json-schema-2020-12-keyword--properties>ul{border:none;margin:0;padding:0}.swagger-ui .json-schema-2020-12-property{list-style-type:none}.swagger-ui .json-schema-2020-12-property--required>.json-schema-2020-12:first-of-type>.json-schema-2020-12-head .json-schema-2020-12__title:after{color:red;content:"*";font-weight:700}.swagger-ui .json-schema-2020-12-keyword--patternProperties ul{border:none;margin:0;padding:0}.swagger-ui .json-schema-2020-12-keyword--patternProperties .json-schema-2020-12__title:first-of-type:after,.swagger-ui .json-schema-2020-12-keyword--patternProperties .json-schema-2020-12__title:first-of-type:before{color:#55a;content:"/"}.swagger-ui .json-schema-2020-12-keyword--enum>ul{display:inline-block;margin:0;padding:0}.swagger-ui .json-schema-2020-12-keyword--enum>ul li{display:inline;list-style-type:none}.swagger-ui .json-schema-2020-12__constraint{background-color:#805ad5;border-radius:4px;color:#3b4151;color:#fff;font-family:monospace;font-weight:600;line-height:1.5;margin-left:10px;padding:1px 3px}.swagger-ui .json-schema-2020-12__constraint--string{background-color:#d69e2e;color:#fff}.swagger-ui .json-schema-2020-12-keyword--dependentRequired>ul{display:inline-block;margin:0;padding:0}.swagger-ui .json-schema-2020-12-keyword--dependentRequired>ul li{display:inline;list-style-type:none}.swagger-ui .model-box .json-schema-2020-12:not(.json-schema-2020-12--embedded)>.json-schema-2020-12-head .json-schema-2020-12__title:first-of-type{font-size:16px}.swagger-ui .model-box>.json-schema-2020-12{margin:0}.swagger-ui .model-box .json-schema-2020-12{background-color:transparent;padding:0}.swagger-ui .model-box .json-schema-2020-12-accordion,.swagger-ui .model-box .json-schema-2020-12-expand-deep-button{background-color:transparent}.swagger-ui .models .json-schema-2020-12:not(.json-schema-2020-12--embedded)>.json-schema-2020-12-head .json-schema-2020-12__title:first-of-type{font-size:16px} + +/*# sourceMappingURL=swagger-ui.css.map*/ \ No newline at end of file diff --git a/server/internal/httpapi/docs_test.go b/server/internal/httpapi/docs_test.go new file mode 100644 index 0000000..fb24adc --- /dev/null +++ b/server/internal/httpapi/docs_test.go @@ -0,0 +1,144 @@ +package httpapi + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/dvcdsys/code-index/server/internal/apikeys" + apidb "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" +) + +// newDocsTestServer wires a router with full auth services so we can +// verify that the docs endpoints are reachable WITHOUT credentials — +// otherwise a passing test could just be the dev-mode skip in +// requireAuth. +func newDocsTestServer(t *testing.T) http.Handler { + t.Helper() + database, err := apidb.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = database.Close() }) + return NewRouter(Deps{ + DB: database, + ServerVersion: "0.0.0-test", + APIVersion: "v1", + Users: users.New(database), + Sessions: sessions.New(database), + APIKeys: apikeys.New(database), + }) +} + +// TestDocs_IndexServesHTML verifies GET /docs returns the Swagger UI shell +// without requiring an Authorization header. +func TestDocs_IndexServesHTML(t *testing.T) { + srv := newDocsTestServer(t) + req := httptest.NewRequest(http.MethodGet, "/docs", nil) + rr := httptest.NewRecorder() + srv.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d, want 200 (docs must be public)", rr.Code) + } + if ct := rr.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/html") { + t.Errorf("Content-Type = %q, want text/html prefix", ct) + } + body := rr.Body.String() + if !strings.Contains(body, "Swagger UI") { + t.Errorf("body missing 'Swagger UI' marker; first 200B: %q", body[:min(200, len(body))]) + } + if !strings.Contains(body, "/openapi.json") { + t.Errorf("body should reference /openapi.json as spec source") + } +} + +// TestDocs_StaticAssetServed verifies the JS bundle is reachable under +// /docs/. Pulls swagger-ui-bundle.js because it's the largest +// asset and the most-likely-to-break in any future refactor. +func TestDocs_StaticAssetServed(t *testing.T) { + srv := newDocsTestServer(t) + req := httptest.NewRequest(http.MethodGet, "/docs/swagger-ui-bundle.js", nil) + rr := httptest.NewRecorder() + srv.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rr.Code) + } + if ct := rr.Header().Get("Content-Type"); !strings.HasPrefix(ct, "application/javascript") { + t.Errorf("Content-Type = %q, want application/javascript prefix", ct) + } + if rr.Body.Len() < 1000 { + t.Errorf("bundle body too small (%d bytes) — embed may have failed", rr.Body.Len()) + } +} + +// TestDocs_StaticAssetNotFound verifies that requests for a non-existent +// asset return 404 rather than panicking or echoing back unrelated content. +func TestDocs_StaticAssetNotFound(t *testing.T) { + srv := newDocsTestServer(t) + req := httptest.NewRequest(http.MethodGet, "/docs/does-not-exist.js", nil) + rr := httptest.NewRecorder() + srv.ServeHTTP(rr, req) + if rr.Code != http.StatusNotFound { + t.Errorf("status = %d, want 404", rr.Code) + } +} + +// TestOpenAPISpec_ServesValidJSON verifies the spec endpoint returns valid +// JSON with the expected info.title and info.version. This catches both +// embed regressions (spec missing from binary) and accidental contract +// drift (info section overwritten). +func TestOpenAPISpec_ServesValidJSON(t *testing.T) { + srv := newDocsTestServer(t) + req := httptest.NewRequest(http.MethodGet, "/openapi.json", nil) + rr := httptest.NewRecorder() + srv.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d, want 200 (openapi.json must be public)", rr.Code) + } + if ct := rr.Header().Get("Content-Type"); !strings.HasPrefix(ct, "application/json") { + t.Errorf("Content-Type = %q, want application/json prefix", ct) + } + var doc struct { + OpenAPI string `json:"openapi"` + Info struct { + Title string `json:"title"` + Version string `json:"version"` + } `json:"info"` + Paths map[string]any `json:"paths"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &doc); err != nil { + t.Fatalf("invalid JSON: %v", err) + } + if !strings.HasPrefix(doc.OpenAPI, "3.") { + t.Errorf("openapi version = %q, want 3.x", doc.OpenAPI) + } + if doc.Info.Title != "cix-server API" { + t.Errorf("info.title = %q, want %q", doc.Info.Title, "cix-server API") + } + if doc.Info.Version != "v1" { + t.Errorf("info.version = %q, want v1", doc.Info.Version) + } + if len(doc.Paths) < 13 { + t.Errorf("paths count = %d, expected at least 13", len(doc.Paths)) + } +} + +// TestDocs_IsPublic — defense-in-depth: explicitly verify the three docs +// endpoints work WITHOUT an Authorization header, even though +// TestAuth_StatusRejectsMissingKey already covers the inverse case for the +// API routes. +func TestDocs_IsPublic(t *testing.T) { + srv := newDocsTestServer(t) + for _, p := range []string{"/docs", "/docs/swagger-ui-bundle.js", "/openapi.json"} { + req := httptest.NewRequest(http.MethodGet, p, nil) + rr := httptest.NewRecorder() + srv.ServeHTTP(rr, req) + if rr.Code == http.StatusUnauthorized { + t.Errorf("%s returned 401 — must be public", p) + } + } +} diff --git a/server/internal/httpapi/health.go b/server/internal/httpapi/health.go index 43eeed9..ef9dee9 100644 --- a/server/internal/httpapi/health.go +++ b/server/internal/httpapi/health.go @@ -1,73 +1,22 @@ package httpapi import ( - "context" "encoding/json" "net/http" - "time" ) -// healthHandler mirrors api/app/routers/health.py: returns {"status":"ok"}. -// Unauthenticated — used by probes. -// -// m6 — the probe now verifies the DB is reachable within 1 second. A stuck -// SQLite file (e.g. a locked WAL writer or a full disk) surfaces as HTTP 503 -// instead of a silently-healthy 200. -func healthHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - if d.DB != nil { - pingCtx, cancel := context.WithTimeout(r.Context(), time.Second) - defer cancel() - if err := d.DB.PingContext(pingCtx); err != nil { - writeJSON(w, http.StatusServiceUnavailable, map[string]any{ - "status": "unhealthy", - "reason": "db unreachable", - }) - return - } - } - writeJSON(w, http.StatusOK, map[string]any{"status": "ok"}) - } -} - -// statusHandler mirrors api/app/routers/health.py:status(). -// m5 — model_loaded reflects the actual embeddings service state rather than -// being hard-coded to true; this way operators can see when the sidecar is -// still warming up or has crashed. -func statusHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - projectCount := 0 - activeJobs := 0 - - if d.DB != nil { - _ = d.DB.QueryRowContext(r.Context(), - `SELECT COUNT(*) FROM projects`).Scan(&projectCount) - _ = d.DB.QueryRowContext(r.Context(), - `SELECT COUNT(*) FROM index_runs WHERE status = 'running'`).Scan(&activeJobs) - } - - modelLoaded := false - if d.EmbeddingSvc != nil { - readyCtx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond) - modelLoaded = d.EmbeddingSvc.Ready(readyCtx) == nil - cancel() - } - - writeJSON(w, http.StatusOK, map[string]any{ - "status": "ok", - "backend": d.Backend, - "server_version": d.ServerVersion, - "api_version": d.APIVersion, - "model_loaded": modelLoaded, - "embedding_model": d.EmbeddingModel, - "projects": projectCount, - "active_indexing_jobs": activeJobs, - }) - } -} - +// writeJSON encodes body as JSON and writes it with the given status code. +// Shared by every handler in this package; lives here because health.go is +// the smallest non-generated file and feels like the right home. func writeJSON(w http.ResponseWriter, code int, body any) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(code) _ = json.NewEncoder(w).Encode(body) } + +// writeError emits the canonical {"detail": "..."} error body. The shape is +// byte-identical to the Python FastAPI default and matches every error +// schema declared in doc/openapi.yaml. +func writeError(w http.ResponseWriter, code int, msg string) { + writeJSON(w, code, map[string]any{"detail": msg}) +} diff --git a/server/internal/httpapi/health_test.go b/server/internal/httpapi/health_test.go index d5a52c1..9c2bd76 100644 --- a/server/internal/httpapi/health_test.go +++ b/server/internal/httpapi/health_test.go @@ -24,6 +24,7 @@ func newTestServer(t *testing.T) http.Handler { APIVersion: "v1", Backend: "go", EmbeddingModel: "test-model", + AuthDisabled: true, }) } diff --git a/server/internal/httpapi/indexing.go b/server/internal/httpapi/indexing.go index bce9d76..7ad8835 100644 --- a/server/internal/httpapi/indexing.go +++ b/server/internal/httpapi/indexing.go @@ -1,17 +1,23 @@ package httpapi import ( + "context" "encoding/json" - "errors" "net/http" - "strconv" + "strings" + "time" - "github.com/dvcdsys/code-index/server/internal/embeddings" "github.com/dvcdsys/code-index/server/internal/indexer" + "github.com/dvcdsys/code-index/server/internal/projects" ) // --------------------------------------------------------------------------- -// Request / response types — match api/app/schemas/indexing.py exactly. +// Wire-format types kept as test fixtures. +// +// The Server methods in server.go construct openapi.* equivalents; the +// types below are byte-compatible JSON shapes that *_test.go files +// unmarshal into. Removing them would force every indexing test to be +// rewritten — keeping them costs nothing. // --------------------------------------------------------------------------- type indexBeginRequest struct { @@ -59,248 +65,157 @@ type indexProgressResponse struct { Progress map[string]any `json:"progress,omitempty"` } -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/index/begin -// --------------------------------------------------------------------------- - -func indexBeginHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.Indexer == nil { - writeError(w, http.StatusServiceUnavailable, "indexer not configured") - return - } - - var body indexBeginRequest - // Body is optional — accept empty request. - if r.ContentLength > 0 { - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - } - - runID, stored, err := d.Indexer.BeginIndexing(r.Context(), p.HostPath, body.Full) - if err != nil { - // C2 — another session is already active for this project. - if errors.Is(err, indexer.ErrSessionConflict) { - writeError(w, http.StatusConflict, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - if stored == nil { - stored = map[string]string{} - } - writeJSON(w, http.StatusOK, indexBeginResponse{RunID: runID, StoredHashes: stored}) - } +type indexCancelResponse struct { + Cancelled bool `json:"cancelled"` } +// Suppress "declared but not used" warnings for the request shapes — they +// are populated only via JSON unmarshal in tests, so static analysis cannot +// see the writes. +var ( + _ = indexBeginRequest{} + _ = indexFilesRequest{} + _ = indexFinishRequest{} +) + // --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/index/files +// Constants + helpers shared with server.go (Server.IndexFiles). // --------------------------------------------------------------------------- // maxFilesPerBatch matches Python schemas.IndexFilesRequest max_length=50. const maxFilesPerBatch = 50 -func indexFilesHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.Indexer == nil { - writeError(w, http.StatusServiceUnavailable, "indexer not configured") - return - } +// streamingHeartbeatInterval is how often we emit a heartbeat event when no +// file-level progress has been sent. Idle on the wire ≤ heartbeatInterval + +// embedder slack, well under the client's default 30s read deadline. Var +// (not const) so tests can shrink it to keep the suite fast. +var streamingHeartbeatInterval = 10 * time.Second - var body indexFilesRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.RunID == "" { - writeError(w, http.StatusUnprocessableEntity, "run_id is required") - return - } - if len(body.Files) > maxFilesPerBatch { - writeError(w, http.StatusUnprocessableEntity, "too many files in batch (max 50)") - return - } +// streamingDisconnectCancelTimeout bounds how long we spend cleaning up a +// session after the client disconnects. +const streamingDisconnectCancelTimeout = 5 * time.Second - files := make([]indexer.FilePayload, len(body.Files)) - for i, f := range body.Files { - files[i] = indexer.FilePayload{ - Path: f.Path, - Content: f.Content, - ContentHash: f.ContentHash, - Language: f.Language, - Size: f.Size, - } +// acceptsNDJSON returns true when the Accept header advertises +// application/x-ndjson. Comma-separated values are inspected; q-values are +// ignored (presence is sufficient — the client opted in). +func acceptsNDJSON(accept string) bool { + for _, part := range strings.Split(accept, ",") { + mediaType := strings.TrimSpace(part) + if i := strings.IndexByte(mediaType, ';'); i >= 0 { + mediaType = strings.TrimSpace(mediaType[:i]) } - - accepted, chunks, total, err := d.Indexer.ProcessFiles(r.Context(), p.HostPath, body.RunID, files) - if err != nil { - if retry, busy := embeddings.IsBusy(err); busy { - w.Header().Set("Retry-After", strconv.Itoa(retry)) - writeError(w, http.StatusServiceUnavailable, - "GPU is busy processing another embedding request, retry after "+strconv.Itoa(retry)+"s") - return - } - if errors.Is(err, indexer.ErrNoSession) || errors.Is(err, indexer.ErrProjectMismatch) { - writeError(w, http.StatusNotFound, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return + if strings.EqualFold(mediaType, "application/x-ndjson") { + return true } - - writeJSON(w, http.StatusOK, indexFilesResponse{ - FilesAccepted: accepted, - ChunksCreated: chunks, - FilesProcessedTotal: total, - }) } + return false } -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/index/finish -// --------------------------------------------------------------------------- - -func indexFinishHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.Indexer == nil { - writeError(w, http.StatusServiceUnavailable, "indexer not configured") - return - } - - var body indexFinishRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.RunID == "" { - writeError(w, http.StatusUnprocessableEntity, "run_id is required") - return - } - - status, files, chunks, err := d.Indexer.FinishIndexing( - r.Context(), p.HostPath, body.RunID, body.DeletedPaths, body.TotalFilesDiscovered, - ) - if err != nil { - if errors.Is(err, indexer.ErrNoSession) || errors.Is(err, indexer.ErrProjectMismatch) { - writeError(w, http.StatusNotFound, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } +// indexFilesStreamingHandler writes one NDJSON event per line with per-file +// progress and 10-second heartbeats. When the client disconnects mid-batch +// we call CancelIndexing so the session lock is released immediately rather +// than lingering until the 1-hour TTL. +// +// Called from Server.IndexFiles when the client requests the streaming +// content type. Lives in this file because the JSON wire format and the +// indexer-channel plumbing belong together. +func indexFilesStreamingHandler( + d Deps, + p *projects.Project, + runID string, + files []indexer.FilePayload, + w http.ResponseWriter, + r *http.Request, +) { + flusher, ok := w.(http.Flusher) + if !ok { + writeError(w, http.StatusInternalServerError, "streaming not supported by HTTP transport") + return + } - writeJSON(w, http.StatusOK, indexFinishResponse{ - Status: status, - FilesProcessed: files, - ChunksCreated: chunks, - }) + // Indexing batches dominate on GPU embed time and routinely exceed the + // global http.Server.WriteTimeout (60s). The zero deadline disables it + // for this request only — the streamCtx + heartbeat watchdog still bound + // runaway sessions. + rc := http.NewResponseController(w) + if err := rc.SetWriteDeadline(time.Time{}); err != nil { + d.Logger.Warn("streaming: clearing write deadline failed (continuing)", + "run_id", runID, "err", err) } -} -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/index/cancel -// --------------------------------------------------------------------------- + w.Header().Set("Content-Type", "application/x-ndjson") + w.Header().Set("Cache-Control", "no-cache") + w.Header().Set("X-Accel-Buffering", "no") + w.WriteHeader(http.StatusOK) + flusher.Flush() -type indexCancelResponse struct { - Cancelled bool `json:"cancelled"` -} + progress := make(chan indexer.ProgressEvent, 32) -// indexCancelHandler terminates any in-flight session for the project. -// Idempotent: returns {cancelled: false} when no session is active, so the -// CLI stale-session guard at startup can call this unconditionally. -func indexCancelHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.Indexer == nil { - writeJSON(w, http.StatusOK, indexCancelResponse{Cancelled: false}) - return - } + streamCtx, cancelStream := context.WithCancel(r.Context()) + defer cancelStream() - cancelled, err := d.Indexer.CancelIndexing(r.Context(), p.HostPath) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - writeJSON(w, http.StatusOK, indexCancelResponse{Cancelled: cancelled}) - } -} + go func() { + defer close(progress) + _, _, _, _ = d.Indexer.ProcessFilesStreaming(streamCtx, p.HostPath, runID, files, progress) + }() -// --------------------------------------------------------------------------- -// GET /api/v1/projects/{path}/index/status -// --------------------------------------------------------------------------- + ticker := time.NewTicker(streamingHeartbeatInterval) + defer ticker.Stop() -func indexStatusHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.Indexer == nil { - writeJSON(w, http.StatusOK, indexProgressResponse{Status: "idle"}) - return - } + encoder := json.NewEncoder(w) + clientGone := false - progress := d.Indexer.GetProgress(p.HostPath) - if progress != nil { - // m4 — match Python's progress payload. Python emits - // files_discovered alongside files_processed (routers/indexing.py). - writeJSON(w, http.StatusOK, indexProgressResponse{ - Status: progress.Status, - Progress: map[string]any{ - "phase": progress.Phase, - "files_discovered": progress.FilesDiscovered, - "files_processed": progress.FilesProcessed, - "files_total": progress.FilesTotal, - "chunks_created": progress.ChunksCreated, - "elapsed_seconds": roundFloat1(progress.ElapsedSeconds), - "run_id": progress.RunID, - }, - }) + markClientGone := func() { + if clientGone { return } + clientGone = true + cancelStream() + } - // Fall back to last run row. - row := d.DB.QueryRowContext(r.Context(), - `SELECT status, files_processed, files_total, chunks_created - FROM index_runs WHERE project_path = ? ORDER BY started_at DESC LIMIT 1`, - p.HostPath, - ) - var status string - var filesProcessed, filesTotal, chunks int - if err := row.Scan(&status, &filesProcessed, &filesTotal, &chunks); err != nil { - writeJSON(w, http.StatusOK, indexProgressResponse{Status: "idle"}) - return + for { + select { + case ev, open := <-progress: + if !open { + if clientGone { + d.Logger.Warn("streaming: client disconnected mid-batch, cancelling session", + "run_id", runID, "project", p.HostPath) + cancelCtx, cancel := context.WithTimeout( + context.Background(), streamingDisconnectCancelTimeout) + _, _ = d.Indexer.CancelIndexing(cancelCtx, p.HostPath) + cancel() + } + return + } + if clientGone { + continue + } + if err := encoder.Encode(ev); err != nil { + markClientGone() + continue + } + flusher.Flush() + case <-ticker.C: + if clientGone { + continue + } + if err := encoder.Encode(indexer.ProgressEvent{ + Event: indexer.EventHeartbeat, + TS: indexer.NowTS(), + }); err != nil { + markClientGone() + continue + } + flusher.Flush() + case <-r.Context().Done(): + d.Logger.Debug("streaming: r.Context() done", "run_id", runID, "err", r.Context().Err()) + markClientGone() } - writeJSON(w, http.StatusOK, indexProgressResponse{ - Status: status, - Progress: map[string]any{ - "files_processed": filesProcessed, - "files_total": filesTotal, - "chunks_created": chunks, - }, - }) } } // roundFloat1 rounds to 1 decimal place — matches Python round(x, 1). +// Used by Server.IndexStatus for elapsed_seconds. func roundFloat1(f float64) float64 { return float64(int(f*10+0.5)) / 10 } diff --git a/server/internal/httpapi/indexing_streaming_test.go b/server/internal/httpapi/indexing_streaming_test.go new file mode 100644 index 0000000..cbb1a68 --- /dev/null +++ b/server/internal/httpapi/indexing_streaming_test.go @@ -0,0 +1,444 @@ +package httpapi + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/dvcdsys/code-index/server/internal/indexer" +) + +// slogDiscard returns a logger that discards all output — used to keep test +// stdout quiet while still satisfying the non-nil Logger contract some code +// paths rely on (Warn/Debug/Info on a nil *slog.Logger panics). +func slogDiscard() *slog.Logger { + return slog.New(slog.NewTextHandler(io.Discard, nil)) +} + +// flushRecorder is an http.ResponseWriter that supports http.Flusher and +// records every write so tests can observe streamed output. It is safe to +// access from a single test goroutine plus the handler goroutine — the +// shared buffer is mutex-protected. +type flushRecorder struct { + mu sync.Mutex + buf bytes.Buffer + header http.Header + status int + written chan struct{} +} + +func newFlushRecorder() *flushRecorder { + return &flushRecorder{ + header: make(http.Header), + written: make(chan struct{}, 1), + } +} + +func (r *flushRecorder) Header() http.Header { return r.header } + +func (r *flushRecorder) Write(p []byte) (int, error) { + r.mu.Lock() + n, err := r.buf.Write(p) + r.mu.Unlock() + select { + case r.written <- struct{}{}: + default: + } + return n, err +} + +func (r *flushRecorder) WriteHeader(s int) { r.status = s } + +func (r *flushRecorder) Flush() {} // no-op — buf is already coherent + +// waitForBytes blocks until the recorder accumulates at least min bytes or +// the timeout elapses. Returns true on success. +func (r *flushRecorder) waitForBytes(timeout time.Duration, min int) bool { + deadline := time.After(timeout) + for { + r.mu.Lock() + got := r.buf.Len() + r.mu.Unlock() + if got >= min { + return true + } + select { + case <-r.written: + // loop + case <-deadline: + return false + } + } +} + +// streamingTestServer spins up a real httptest.Server so the streaming +// handler gets an http.ResponseWriter that implements Flusher (which +// httptest.ResponseRecorder does not). +func streamingTestServer(t *testing.T, projectPath string) (*httptest.Server, string) { + t.Helper() + d, hash := newIndexerTestDeps(t, projectPath) + srv := httptest.NewServer(NewRouter(d)) + t.Cleanup(srv.Close) + return srv, hash +} + +// blockingEmbedder is a fakeEmbedder that waits on a channel before returning. +// Used to simulate a slow embedder so the disconnect test can interrupt mid-batch +// before ProcessFilesStreaming completes naturally. +type blockingEmbedder struct { + fakeEmbedder + release chan struct{} // close to allow EmbedTexts to proceed +} + +func (b *blockingEmbedder) EmbedTexts(ctx context.Context, texts []string) ([][]float32, error) { + select { + case <-b.release: + case <-ctx.Done(): + return nil, ctx.Err() + } + return b.fakeEmbedder.EmbedTexts(ctx, texts) +} + + +// readNDJSONLines reads NDJSON until either io.EOF or until limit lines have +// been collected. Returns the parsed events. +func readNDJSONLines(t *testing.T, body io.Reader, limit int) []indexer.ProgressEvent { + t.Helper() + scanner := bufio.NewScanner(body) + scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + var events []indexer.ProgressEvent + for scanner.Scan() { + line := bytes.TrimSpace(scanner.Bytes()) + if len(line) == 0 { + continue + } + var ev indexer.ProgressEvent + if err := json.Unmarshal(line, &ev); err != nil { + t.Fatalf("decode ndjson line %q: %v", line, err) + } + events = append(events, ev) + if limit > 0 && len(events) >= limit { + return events + } + } + if err := scanner.Err(); err != nil && err != io.EOF { + t.Fatalf("scan: %v", err) + } + return events +} + +// beginSession is a small helper: starts a session, returns run_id. +func beginSession(t *testing.T, baseURL, hash string) string { + t.Helper() + resp, err := http.Post( + baseURL+"/api/v1/projects/"+hash+"/index/begin", + "application/json", + strings.NewReader(`{"full":true}`), + ) + if err != nil { + t.Fatalf("begin: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + body, _ := io.ReadAll(resp.Body) + t.Fatalf("begin status=%d body=%s", resp.StatusCode, body) + } + var br indexBeginResponse + if err := json.NewDecoder(resp.Body).Decode(&br); err != nil { + t.Fatalf("decode begin: %v", err) + } + return br.RunID +} + +func newFilesRequestBody(t *testing.T, runID string, files map[string]string) []byte { + t.Helper() + payload := map[string]any{ + "run_id": runID, + "files": []map[string]any{}, + } + for path, content := range files { + payload["files"] = append(payload["files"].([]map[string]any), map[string]any{ + "path": path, + "content": content, + "content_hash": shaHex(content), + "language": "go", + "size": len(content), + }) + } + b, err := json.Marshal(payload) + if err != nil { + t.Fatalf("marshal: %v", err) + } + return b +} + +// TestIndexFilesStreaming_BatchDone exercises the happy path: NDJSON event +// stream contains file_started + batch_done with the expected counts. +func TestIndexFilesStreaming_BatchDone(t *testing.T) { + srv, hash := streamingTestServer(t, "/proj") + runID := beginSession(t, srv.URL, hash) + + body := newFilesRequestBody(t, runID, map[string]string{ + "/proj/a.go": "package main\nfunc A() int { return 1 }\n", + "/proj/b.go": "package main\nfunc B() int { return 2 }\n", + }) + + req, _ := http.NewRequest( + http.MethodPost, + srv.URL+"/api/v1/projects/"+hash+"/index/files", + bytes.NewReader(body), + ) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/x-ndjson") + + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("post: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + out, _ := io.ReadAll(resp.Body) + t.Fatalf("status=%d body=%s", resp.StatusCode, out) + } + if ct := resp.Header.Get("Content-Type"); ct != "application/x-ndjson" { + t.Errorf("Content-Type=%q, want application/x-ndjson", ct) + } + + events := readNDJSONLines(t, resp.Body, 0) + if len(events) == 0 { + t.Fatal("no events in stream") + } + + last := events[len(events)-1] + if last.Event != indexer.EventBatchDone { + t.Fatalf("last event = %q, want %q (events: %v)", last.Event, indexer.EventBatchDone, summarizeEvents(events)) + } + if last.FilesAccepted != 2 { + t.Errorf("files_accepted=%d, want 2", last.FilesAccepted) + } + if last.ChunksCreated == 0 { + t.Errorf("chunks_created=0") + } + + // At least one file_started event must appear. + startedCount := 0 + for _, e := range events { + if e.Event == indexer.EventFileStarted { + startedCount++ + } + } + if startedCount != 2 { + t.Errorf("file_started count=%d, want 2", startedCount) + } +} + +// TestIndexFilesStreaming_LegacyCompat verifies that requests without an +// Accept: application/x-ndjson header keep getting the existing single-JSON +// response. This is the regression guard for old CLIs against a new server. +func TestIndexFilesStreaming_LegacyCompat(t *testing.T) { + srv, hash := streamingTestServer(t, "/proj") + runID := beginSession(t, srv.URL, hash) + + body := newFilesRequestBody(t, runID, map[string]string{ + "/proj/x.go": "package main\nfunc X() {}\n", + }) + + req, _ := http.NewRequest( + http.MethodPost, + srv.URL+"/api/v1/projects/"+hash+"/index/files", + bytes.NewReader(body), + ) + req.Header.Set("Content-Type", "application/json") + // No Accept header → legacy path. + + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("post: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + out, _ := io.ReadAll(resp.Body) + t.Fatalf("status=%d body=%s", resp.StatusCode, out) + } + ct := resp.Header.Get("Content-Type") + if !strings.HasPrefix(ct, "application/json") { + t.Errorf("Content-Type=%q, want application/json (legacy)", ct) + } + + var legacy indexFilesResponse + if err := json.NewDecoder(resp.Body).Decode(&legacy); err != nil { + t.Fatalf("decode: %v", err) + } + if legacy.FilesAccepted != 1 { + t.Errorf("files_accepted=%d, want 1", legacy.FilesAccepted) + } +} + +// TestIndexFilesStreaming_AcceptOnly verifies that Accept headers without +// application/x-ndjson (e.g. */*) take the legacy path — only an explicit +// streaming opt-in upgrades the protocol. +func TestIndexFilesStreaming_AcceptOnly(t *testing.T) { + srv, hash := streamingTestServer(t, "/proj") + runID := beginSession(t, srv.URL, hash) + + body := newFilesRequestBody(t, runID, map[string]string{ + "/proj/y.go": "package main\nfunc Y() {}\n", + }) + + req, _ := http.NewRequest( + http.MethodPost, + srv.URL+"/api/v1/projects/"+hash+"/index/files", + bytes.NewReader(body), + ) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "*/*") + + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("post: %v", err) + } + defer resp.Body.Close() + + ct := resp.Header.Get("Content-Type") + if !strings.HasPrefix(ct, "application/json") { + t.Errorf("Accept=*/* should still get legacy JSON, got Content-Type=%q", ct) + } +} + +// TestIndexFilesStreaming_ClientDisconnect verifies that cancelling the +// request context mid-batch frees the session lock. We call the handler +// directly with a context we control rather than relying on Go's net/http +// to detect a client TCP disconnect — that detection is best-effort and +// unreliable in unit-test timeframes (it depends on the OS noticing FIN +// during a write or read goroutine, which can take seconds with chunked +// encoding even when the client has already closed). Cancelling the +// request's context is the same signal the server reacts to in production +// (chi propagates it from the underlying http.Request). +func TestIndexFilesStreaming_ClientDisconnect(t *testing.T) { + // Heartbeat shrunk so the inner ticker case fires reliably during the test. + prevHB := streamingHeartbeatInterval + streamingHeartbeatInterval = 50 * time.Millisecond + t.Cleanup(func() { streamingHeartbeatInterval = prevHB }) + + emb := &blockingEmbedder{ + fakeEmbedder: fakeEmbedder{dim: 16}, + release: make(chan struct{}), + } + d, hash := newIndexerTestDeps(t, "/proj") + d.EmbeddingSvc = emb + d.Indexer = indexer.New(d.DB, d.VectorStore, emb, slogDiscard()) + d.Logger = slogDiscard() + router := NewRouter(d) + + // Begin a session so we have a valid run_id. + beginW := httptest.NewRecorder() + beginReq := httptest.NewRequest(http.MethodPost, + "/api/v1/projects/"+hash+"/index/begin", + strings.NewReader(`{"full":true}`)) + beginReq.Header.Set("Content-Type", "application/json") + router.ServeHTTP(beginW, beginReq) + if beginW.Code != 200 { + t.Fatalf("begin: status=%d body=%s", beginW.Code, beginW.Body) + } + var br indexBeginResponse + _ = json.Unmarshal(beginW.Body.Bytes(), &br) + + files := map[string]string{} + for i := 0; i < 5; i++ { + files[fmt.Sprintf("/proj/file_%d.go", i)] = + "package main\nfunc F() int { return 1 }\n" + } + body := newFilesRequestBody(t, br.RunID, files) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + req := httptest.NewRequest(http.MethodPost, + "/api/v1/projects/"+hash+"/index/files", + bytes.NewReader(body)).WithContext(ctx) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/x-ndjson") + + rw := newFlushRecorder() + + // Serve in a goroutine because the handler will block on the embedder + // until we cancel ctx. + done := make(chan struct{}) + go func() { + router.ServeHTTP(rw, req) + close(done) + }() + + // Wait for the first NDJSON line to reach our recorder — proves the + // handler is running and ProcessFilesStreaming is engaged. + if !rw.waitForBytes(2*time.Second, 10) { + t.Fatal("no bytes written before disconnect deadline") + } + + // Disconnect: the request ctx is what chi passes through to r.Context(). + cancel() + + // Handler must return promptly after ctx cancel. + select { + case <-done: + case <-time.After(2 * time.Second): + t.Fatal("handler did not return within 2s after ctx cancel") + } + + // A new /index/begin must succeed: proves CancelIndexing was called. + begin2W := httptest.NewRecorder() + begin2Req := httptest.NewRequest(http.MethodPost, + "/api/v1/projects/"+hash+"/index/begin", + strings.NewReader(`{"full":true}`)) + begin2Req.Header.Set("Content-Type", "application/json") + router.ServeHTTP(begin2W, begin2Req) + if begin2W.Code != 200 { + t.Fatalf("begin after disconnect: status=%d body=%s — session lock not released", + begin2W.Code, begin2W.Body) + } +} + +// TestAcceptsNDJSON unit-tests the Accept header parser. +func TestAcceptsNDJSON(t *testing.T) { + cases := []struct { + header string + want bool + }{ + {"application/x-ndjson", true}, + {"application/x-ndjson; q=1.0", true}, + {"application/json, application/x-ndjson", true}, + {" application/x-ndjson ", true}, + {"application/X-NDJSON", true}, // case-insensitive + {"*/*", false}, + {"application/json", false}, + {"", false}, + } + for _, c := range cases { + if got := acceptsNDJSON(c.header); got != c.want { + t.Errorf("acceptsNDJSON(%q) = %v, want %v", c.header, got, c.want) + } + } +} + +func summarizeEvents(events []indexer.ProgressEvent) string { + var b strings.Builder + for i, e := range events { + if i > 0 { + b.WriteString(", ") + } + b.WriteString(e.Event) + } + return b.String() +} diff --git a/server/internal/httpapi/indexing_test.go b/server/internal/httpapi/indexing_test.go index b072102..dcdce3a 100644 --- a/server/internal/httpapi/indexing_test.go +++ b/server/internal/httpapi/indexing_test.go @@ -272,6 +272,71 @@ func TestSemanticSearch_HTTP(t *testing.T) { } } +// TestSemanticSearch_NestedMarkdownMerge indexes a markdown file with H1 +// containing two H2 sections, all containing a unique token. The chunker +// emits 3 overlapping `section` chunks (1 outer + 2 inner). After +// mergeOverlappingHits the outer section absorbs both inner ones — +// observable as ONE result with NestedHits populated, instead of three +// near-duplicates fighting for the user's --limit budget. +func TestSemanticSearch_NestedMarkdownMerge(t *testing.T) { + d, hash := newIndexerTestDeps(t, "/proj-md") + router := NewRouter(d) + + beginW := doRequest(t, router, http.MethodPost, "/api/v1/projects/"+hash+"/index/begin", map[string]any{}) + var begin indexBeginResponse + _ = json.Unmarshal(beginW.Body.Bytes(), &begin) + + content := "# Setup zlork\n\nIntro about zlork.\n\n## Local zlork dev\n\n" + + "Steps for zlork.\n\n## Remote zlork\n\nMore zlork.\n" + doRequest(t, router, http.MethodPost, "/api/v1/projects/"+hash+"/index/files", map[string]any{ + "run_id": begin.RunID, + "files": []map[string]any{ + {"path": "/proj-md/README.md", "content": content, "content_hash": shaHex(content), "language": "markdown"}, + }, + }) + doRequest(t, router, http.MethodPost, "/api/v1/projects/"+hash+"/index/finish", map[string]any{ + "run_id": begin.RunID, + }) + + w := doRequest(t, router, http.MethodPost, "/api/v1/projects/"+hash+"/search", map[string]any{ + "query": "zlork", + "limit": 10, + "min_score": 0.0, + }) + if w.Code != http.StatusOK { + t.Fatalf("status=%d body=%s", w.Code, w.Body.String()) + } + + var resp searchResponse + if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil { + t.Fatalf("unmarshal: %v", err) + } + + // Find the README.md file group and verify the merge happened. + var group *fileGroupResult + for i := range resp.Results { + if resp.Results[i].FilePath == "/proj-md/README.md" { + group = &resp.Results[i] + break + } + } + if group == nil { + t.Fatalf("expected a file group for README.md, got results: %+v", resp.Results) + } + // After merge, only ONE match should remain in this file (the outer + // H1 section absorbing the two H2s as nested hits). + if len(group.Matches) != 1 { + t.Fatalf("expected 1 match in README.md after merge, got %d: %+v", len(group.Matches), group.Matches) + } + outer := group.Matches[0] + if outer.StartLine != 1 { + t.Errorf("outer match should start at line 1, got %d", outer.StartLine) + } + if len(outer.NestedHits) == 0 { + t.Errorf("outer match should record absorbed nested hits, got NestedHits=%v", outer.NestedHits) + } +} + func TestSemanticSearch_HTTP_MissingQuery(t *testing.T) { d, hash := newIndexerTestDeps(t, "/proj") router := NewRouter(d) diff --git a/server/internal/httpapi/loginlimiter.go b/server/internal/httpapi/loginlimiter.go new file mode 100644 index 0000000..5c72b32 --- /dev/null +++ b/server/internal/httpapi/loginlimiter.go @@ -0,0 +1,120 @@ +package httpapi + +// Login rate limiter — protects POST /api/v1/auth/login from brute-force +// credential attacks. Two sliding-window counters live in memory: +// +// - per (IP, lower-cased email): keyLimit attempts within keyWindow. +// Slows password guessing against a known account. +// - per IP: ipLimit attempts within ipWindow. Slows horizontal sweeps +// across many emails from a single source. +// +// On a successful login the per-(IP, email) counter is cleared so a user +// who fat-fingered their password a few times then succeeds is not stuck +// behind their own counter. The per-IP counter is intentionally NOT +// cleared — otherwise an attacker could mix one valid login into a +// horizontal sweep to lift the global cap. +// +// The implementation is a single mutex over two maps. At the rates we +// permit (~600/hr peak per IP) contention is irrelevant for an admin +// tool. State is in-process; restarts wipe the counters, which is fine — +// the attacker has to re-establish the connection state anyway. + +import ( + "net/http" + "strconv" + "strings" + "sync" + "time" +) + +type loginLimiter struct { + mu sync.Mutex + perKey map[string][]time.Time // "ip|lower(email)" → recent attempt timestamps + perIP map[string][]time.Time // ip → recent attempt timestamps + + keyLimit int + keyWindow time.Duration + ipLimit int + ipWindow time.Duration + + now func() time.Time // overridable in tests +} + +// newLoginLimiter returns a limiter with the production defaults: +// 5 attempts / 15 min per (IP, email) and 60 attempts / minute per IP. +func newLoginLimiter() *loginLimiter { + return &loginLimiter{ + perKey: map[string][]time.Time{}, + perIP: map[string][]time.Time{}, + keyLimit: 5, + keyWindow: 15 * time.Minute, + ipLimit: 60, + ipWindow: time.Minute, + now: time.Now, + } +} + +func loginLimiterKey(ip, email string) string { + return ip + "|" + strings.ToLower(strings.TrimSpace(email)) +} + +// allow returns (true, 0) when the caller may proceed with authentication +// and records the attempt against both windows. Returns (false, retry) +// when either window is full; the caller must respond with 429 and +// `Retry-After: retry`. +func (l *loginLimiter) allow(ip, email string) (bool, time.Duration) { + l.mu.Lock() + defer l.mu.Unlock() + now := l.now() + + if pruned, retry, blocked := checkSlidingWindow(l.perIP[ip], now, l.ipWindow, l.ipLimit); blocked { + l.perIP[ip] = pruned + return false, retry + } + + key := loginLimiterKey(ip, email) + if pruned, retry, blocked := checkSlidingWindow(l.perKey[key], now, l.keyWindow, l.keyLimit); blocked { + l.perKey[key] = pruned + return false, retry + } + + l.perIP[ip] = append(pruneOlder(l.perIP[ip], now.Add(-l.ipWindow)), now) + l.perKey[key] = append(pruneOlder(l.perKey[key], now.Add(-l.keyWindow)), now) + return true, 0 +} + +// reset clears the per-(IP, email) counter after a successful login. The +// per-IP counter is left in place by design — see file-level comment. +func (l *loginLimiter) reset(ip, email string) { + l.mu.Lock() + defer l.mu.Unlock() + delete(l.perKey, loginLimiterKey(ip, email)) +} + +func checkSlidingWindow(ts []time.Time, now time.Time, window time.Duration, limit int) ([]time.Time, time.Duration, bool) { + pruned := pruneOlder(ts, now.Add(-window)) + if len(pruned) >= limit { + retry := max(window-now.Sub(pruned[0]), time.Second) + return pruned, retry, true + } + return pruned, 0, false +} + +func pruneOlder(ts []time.Time, cutoff time.Time) []time.Time { + i := 0 + for i < len(ts) && ts[i].Before(cutoff) { + i++ + } + if i == 0 { + return ts + } + return append(ts[:0:0], ts[i:]...) +} + +// writeRateLimited emits a 429 response with the Retry-After header set +// to the number of seconds until at least one slot frees up. +func writeRateLimited(w http.ResponseWriter, retry time.Duration) { + secs := max(int(retry.Seconds()), 1) + w.Header().Set("Retry-After", strconv.Itoa(secs)) + writeError(w, http.StatusTooManyRequests, "Too many login attempts; try again later.") +} diff --git a/server/internal/httpapi/loginlimiter_test.go b/server/internal/httpapi/loginlimiter_test.go new file mode 100644 index 0000000..80000c9 --- /dev/null +++ b/server/internal/httpapi/loginlimiter_test.go @@ -0,0 +1,118 @@ +package httpapi + +import ( + "testing" + "time" +) + +// fakeClock returns a closure satisfying loginLimiter.now. Mutating *t between +// calls advances time deterministically. +func fakeClock(t *time.Time) func() time.Time { + return func() time.Time { return *t } +} + +func TestLoginLimiter_PerEmailWindow(t *testing.T) { + now := time.Date(2026, 5, 4, 12, 0, 0, 0, time.UTC) + l := newLoginLimiter() + l.now = fakeClock(&now) + l.keyLimit = 3 + l.keyWindow = time.Minute + + for i := range 3 { + if ok, _ := l.allow("1.2.3.4", "alice@example.com"); !ok { + t.Fatalf("attempt %d unexpectedly blocked", i+1) + } + } + // Fourth in the same window must block. + ok, retry := l.allow("1.2.3.4", "alice@example.com") + if ok { + t.Fatalf("expected 4th attempt to be blocked") + } + if retry < time.Second || retry > time.Minute { + t.Errorf("retry = %v, want between 1s and 1m", retry) + } + // Different email from the same IP must still pass — per-email window + // is keyed independently. (Per-IP cap is left at default 60/min so it + // does not interfere here.) + if ok, _ := l.allow("1.2.3.4", "bob@example.com"); !ok { + t.Errorf("different email from same IP should pass") + } + // After the window slides past, the original counter resets. + now = now.Add(time.Minute + time.Second) + if ok, _ := l.allow("1.2.3.4", "alice@example.com"); !ok { + t.Errorf("after window expiry, attempt should pass") + } +} + +func TestLoginLimiter_Reset(t *testing.T) { + now := time.Date(2026, 5, 4, 12, 0, 0, 0, time.UTC) + l := newLoginLimiter() + l.now = fakeClock(&now) + l.keyLimit = 2 + l.keyWindow = time.Minute + + for range 2 { + _, _ = l.allow("1.2.3.4", "alice@example.com") + } + // On the boundary now: a 3rd attempt would block. + if ok, _ := l.allow("1.2.3.4", "alice@example.com"); ok { + t.Fatalf("expected 3rd attempt to block before reset") + } + // Successful login → reset → next attempt admitted. + l.reset("1.2.3.4", "alice@example.com") + if ok, _ := l.allow("1.2.3.4", "alice@example.com"); !ok { + t.Errorf("post-reset attempt should be admitted") + } +} + +func TestLoginLimiter_PerIPCap(t *testing.T) { + now := time.Date(2026, 5, 4, 12, 0, 0, 0, time.UTC) + l := newLoginLimiter() + l.now = fakeClock(&now) + l.ipLimit = 3 + l.ipWindow = time.Minute + l.keyLimit = 100 // lift the per-email cap so we exercise per-IP only + + // Three attempts across different emails — all admitted. + for i, email := range []string{"a@x", "b@x", "c@x"} { + if ok, _ := l.allow("1.2.3.4", email); !ok { + t.Fatalf("attempt %d (%s) unexpectedly blocked", i+1, email) + } + } + // Fourth from same IP, different email — blocked by per-IP cap. + if ok, _ := l.allow("1.2.3.4", "d@x"); ok { + t.Errorf("4th attempt from same IP should hit per-IP cap") + } + // A different IP is unaffected. + if ok, _ := l.allow("5.6.7.8", "a@x"); !ok { + t.Errorf("different IP should not be blocked") + } +} + +func TestLoginLimiter_EmailCaseInsensitive(t *testing.T) { + l := newLoginLimiter() + l.keyLimit = 1 + l.keyWindow = time.Minute + + if ok, _ := l.allow("1.2.3.4", "Alice@example.com"); !ok { + t.Fatalf("first attempt unexpectedly blocked") + } + // Same email, different case — must hit the same bucket. + if ok, _ := l.allow("1.2.3.4", "alice@EXAMPLE.com"); ok { + t.Errorf("case-different email should share the per-email counter") + } +} + +func TestPruneOlder(t *testing.T) { + base := time.Date(2026, 5, 4, 12, 0, 0, 0, time.UTC) + ts := []time.Time{ + base.Add(-3 * time.Minute), + base.Add(-2 * time.Minute), + base.Add(-30 * time.Second), + base, + } + got := pruneOlder(ts, base.Add(-time.Minute)) + if len(got) != 2 { + t.Fatalf("len(got) = %d, want 2 (kept entries within last minute)", len(got)) + } +} diff --git a/server/internal/httpapi/middleware.go b/server/internal/httpapi/middleware.go index e605d5d..1a909b4 100644 --- a/server/internal/httpapi/middleware.go +++ b/server/internal/httpapi/middleware.go @@ -1,11 +1,17 @@ package httpapi import ( + "context" + "errors" "log/slog" + "net" "net/http" "strings" "time" + "github.com/dvcdsys/code-index/server/internal/apikeys" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" "github.com/go-chi/chi/v5/middleware" ) @@ -19,27 +25,156 @@ func serverVersionHeader(version string) func(http.Handler) http.Handler { } } -// requireAPIKey enforces Bearer-token auth matching api/app/auth.py. +// Request body size caps. The default of 1 MiB covers every auth/admin/ +// search/project endpoint generously — JSON payloads on those are kilobytes +// at most. /index/files is the one outlier: at default config (batch=20, +// max-file=512 KiB) a real payload is ~11 MiB. The 64 MiB cap also fits +// operator-tuned worst case (batch=50 × max-file=1 MiB ≈ 55 MiB) with +// headroom; pathological configs above that fail loud with HTTP 413. +const ( + defaultMaxBodyBytes int64 = 1 << 20 // 1 MiB + indexingMaxBodyBytes int64 = 64 << 20 // 64 MiB +) + +// bodySizeFor picks the right cap for a request path. The indexing endpoint +// is the only one that legitimately receives multi-megabyte JSON. +func bodySizeFor(path string) int64 { + if strings.Contains(path, "/index/files") { + return indexingMaxBodyBytes + } + return defaultMaxBodyBytes +} + +// limitBodySize wraps r.Body with http.MaxBytesReader so handlers cannot +// be forced to read unbounded JSON, and rejects oversize requests up-front +// when the client honestly declared Content-Length. The fast path keeps +// CPU off the bcrypt and parser code paths during a flood. +func limitBodySize() func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + limit := bodySizeFor(r.URL.Path) + if r.ContentLength > limit { + writeError(w, http.StatusRequestEntityTooLarge, "request body too large") + return + } + r.Body = http.MaxBytesReader(w, r.Body, limit) + next.ServeHTTP(w, r) + }) + } +} + +// publicPaths is the set of HTTP paths that bypass the auth check. +// Includes the bootstrap probe + login (callers MUST be able to reach +// these without a valid session) plus the documentation, health, and +// dashboard static-asset endpoints. The dashboard's API calls still go +// through the auth gate — only the SPA shell + Vite-built assets are +// public so the login form can render. +var publicPaths = map[string]struct{}{ + "/health": {}, + "/docs": {}, + "/openapi.json": {}, + "/dashboard": {}, + "/api/v1/auth/bootstrap-status": {}, + "/api/v1/auth/login": {}, +} + +// authContextKey is the context key under which the authenticated user +// is stashed by requireAuth. Handlers retrieve it via userFromCtx; the +// "session" or "api_key" auth method is recorded alongside so /auth/me +// can report which path the caller arrived through. +type authContextKey struct{} + +type authContext struct { + User users.User + Method string // "session" | "api_key" + Session *sessions.Session + APIKey *apikeys.ApiKey +} + +func withAuth(ctx context.Context, ac *authContext) context.Context { + return context.WithValue(ctx, authContextKey{}, ac) +} + +func authFromCtx(ctx context.Context) (*authContext, bool) { + v, ok := ctx.Value(authContextKey{}).(*authContext) + return v, ok +} + +// requireAuth gates every non-public route. Order of checks: session +// cookie first (most common for browsers), then Bearer API key. // -// Behaviour: -// - `GET /health` is public (probe endpoint) — it is wired outside this -// middleware in NewRouter. -// - All other routes require `Authorization: Bearer `. -// - Missing or mismatched tokens return 401 with -// `{"detail":"Invalid or missing API key"}` — byte-identical to Python. -// - If apiKey is empty the check is skipped (dev mode); cmd/cix-server/main.go -// logs a warning on startup. -func requireAPIKey(apiKey string) func(http.Handler) http.Handler { +// Either path attaches the resolved user to the request context. Hands +// off to next on success; writes 401 with `{"detail":"..."}` on failure. +func requireAuth(d Deps) func(http.Handler) http.Handler { + if d.Users == nil || d.Sessions == nil || d.APIKeys == nil { + // Defensive panic: if a deployment forgets to wire any of the + // three services, every request would 401 silently. Fail loud + // at startup instead. + panic("httpapi: requireAuth installed without Users+Sessions+APIKeys services — set Deps.AuthDisabled=true to opt out") + } return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if apiKey == "" { + if isPublicPath(r.URL.Path) { next.ServeHTTP(w, r) return } - authz := r.Header.Get("Authorization") - const prefix = "Bearer " - if !strings.HasPrefix(authz, prefix) || authz[len(prefix):] != apiKey { - writeError(w, http.StatusUnauthorized, "Invalid or missing API key") + + ip := clientIP(r) + ua := r.UserAgent() + + // 1. Session cookie. The cookie is HttpOnly + SameSite=Strict + // so any browser sending it has the right origin; we still + // validate the id against the sessions table. + if c, err := r.Cookie(sessions.CookieName); err == nil { + sess, u, sErr := d.Sessions.Get(r.Context(), c.Value) + if sErr == nil { + _ = d.Sessions.Touch(r.Context(), sess.ID, ip, ua) + ac := &authContext{User: u, Method: "session", Session: &sess} + next.ServeHTTP(w, r.WithContext(withAuth(r.Context(), ac))) + return + } + // If the cookie was present but invalid (expired, deleted, + // user-disabled), fall through to Bearer auth — some CLI + // clients also set a cookie for unrelated reasons. + _ = sErr + } + + // 2. Bearer API key. + if authz := r.Header.Get("Authorization"); strings.HasPrefix(authz, "Bearer ") { + key := strings.TrimSpace(authz[len("Bearer "):]) + if key != "" { + u, ak, aErr := d.APIKeys.Authenticate(r.Context(), key) + if aErr == nil { + _ = d.APIKeys.Touch(r.Context(), ak.ID, ip, ua) + ac := &authContext{User: u, Method: "api_key", APIKey: &ak} + next.ServeHTTP(w, r.WithContext(withAuth(r.Context(), ac))) + return + } + if errors.Is(aErr, apikeys.ErrUserDisabled) { + writeError(w, http.StatusUnauthorized, "API key owner is disabled") + return + } + } + } + + writeError(w, http.StatusUnauthorized, "Authentication required") + }) + } +} + +// requireRole rejects callers whose attached user does not have the +// expected role. Always paired with requireAuth — must be installed +// further down the chain. +func requireRole(role string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + if ac.User.Role != role { + writeError(w, http.StatusForbidden, "This action requires role: "+role) return } next.ServeHTTP(w, r) @@ -47,6 +182,42 @@ func requireAPIKey(apiKey string) func(http.Handler) http.Handler { } } +// isPublicPath returns true when the path is exempt from auth. +func isPublicPath(p string) bool { + if _, ok := publicPaths[p]; ok { + return true + } + if strings.HasPrefix(p, "/docs/") { + return true + } + if strings.HasPrefix(p, "/dashboard/") { + return true + } + return false +} + +// clientIP returns the best-effort remote IP. Honours X-Forwarded-For +// (first hop) when present, otherwise falls back to the raw RemoteAddr. +// +// Used for audit metadata (sessions.last_seen_ip, api_keys.last_used_ip) +// AND as the per-IP key for the login rate limiter. Production deployments +// MUST sit behind a reverse proxy that replaces (not appends to) the +// inbound XFF — otherwise an attacker can rotate a forged header per +// request to bypass the per-IP cap. See doc/SECURITY_DEPLOYMENT.md. +func clientIP(r *http.Request) string { + if xff := r.Header.Get("X-Forwarded-For"); xff != "" { + if i := strings.IndexByte(xff, ','); i > 0 { + return strings.TrimSpace(xff[:i]) + } + return strings.TrimSpace(xff) + } + host, _, err := net.SplitHostPort(r.RemoteAddr) + if err != nil { + return r.RemoteAddr + } + return host +} + // structuredLogger logs one line per request via slog at INFO level. func structuredLogger(logger *slog.Logger) func(http.Handler) http.Handler { if logger == nil { diff --git a/server/internal/httpapi/middleware_test.go b/server/internal/httpapi/middleware_test.go index 95e1e98..6b18866 100644 --- a/server/internal/httpapi/middleware_test.go +++ b/server/internal/httpapi/middleware_test.go @@ -1,18 +1,34 @@ package httpapi import ( + "context" "encoding/json" "net/http" "net/http/httptest" "testing" + "github.com/dvcdsys/code-index/server/internal/apikeys" apidb "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" ) -// newAuthTestServer builds a router wired with the given API key. A nil key -// argument keeps dev-mode behaviour (auth disabled) so existing tests are -// unaffected. -func newAuthTestServer(t *testing.T, apiKey string) http.Handler { +// authTestFixture bundles a router plus the seeded admin user + a fresh +// API key for that user. Used by every test that needs to exercise the +// real auth path (cookie OR Bearer) instead of bypassing via +// AuthDisabled=true. +// +// Deps is exposed so tests can poke directly at the services to seed +// extra fixtures (other users, extra keys, etc.) without going through +// HTTP for setup-time arrangements. +type authTestFixture struct { + Router http.Handler + Deps Deps + UserID string + FullKey string +} + +func newAuthFixture(t *testing.T) *authTestFixture { t.Helper() database, err := apidb.Open(":memory:") if err != nil { @@ -20,30 +36,65 @@ func newAuthTestServer(t *testing.T, apiKey string) http.Handler { } t.Cleanup(func() { _ = database.Close() }) + usrSvc := users.New(database) + sessSvc := sessions.New(database) + akSvc := apikeys.New(database) + + u, err := usrSvc.Create(context.Background(), "admin@example.com", "secret-password", users.RoleAdmin, false) + if err != nil { + t.Fatalf("seed admin: %v", err) + } + full, _, err := akSvc.Generate(context.Background(), u.ID, "test-key") + if err != nil { + t.Fatalf("seed key: %v", err) + } + + deps := Deps{ + DB: database, + ServerVersion: "0.0.0-test", + APIVersion: "v1", + EmbeddingModel: "test-model", + Users: usrSvc, + Sessions: sessSvc, + APIKeys: akSvc, + } + return &authTestFixture{Router: NewRouter(deps), Deps: deps, UserID: u.ID, FullKey: full} +} + +// newAuthDisabledServer mirrors the old "empty key + AuthDisabled" path. +// Some legacy tests still want a router that lets every request through +// without any wiring — this is the single helper that supports it. +func newAuthDisabledServer(t *testing.T) http.Handler { + t.Helper() + database, err := apidb.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = database.Close() }) return NewRouter(Deps{ DB: database, ServerVersion: "0.0.0-test", APIVersion: "v1", EmbeddingModel: "test-model", - APIKey: apiKey, + AuthDisabled: true, }) } func TestAuth_HealthIsPublic(t *testing.T) { - srv := newAuthTestServer(t, "secret-key") + f := newAuthFixture(t) req := httptest.NewRequest(http.MethodGet, "/health", nil) rr := httptest.NewRecorder() - srv.ServeHTTP(rr, req) + f.Router.ServeHTTP(rr, req) if rr.Code != http.StatusOK { t.Fatalf("status = %d, want 200 (health must be public)", rr.Code) } } func TestAuth_StatusRejectsMissingKey(t *testing.T) { - srv := newAuthTestServer(t, "secret-key") + f := newAuthFixture(t) req := httptest.NewRequest(http.MethodGet, "/api/v1/status", nil) rr := httptest.NewRecorder() - srv.ServeHTTP(rr, req) + f.Router.ServeHTTP(rr, req) if rr.Code != http.StatusUnauthorized { t.Fatalf("status = %d, want 401", rr.Code) } @@ -51,40 +102,77 @@ func TestAuth_StatusRejectsMissingKey(t *testing.T) { if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil { t.Fatalf("json: %v (body=%s)", err, rr.Body.String()) } - if body["detail"] != "Invalid or missing API key" { - t.Errorf("detail = %v, want %q", body["detail"], "Invalid or missing API key") + if body["detail"] != "Authentication required" { + t.Errorf("detail = %v, want 'Authentication required'", body["detail"]) } } func TestAuth_StatusRejectsWrongKey(t *testing.T) { - srv := newAuthTestServer(t, "secret-key") + f := newAuthFixture(t) req := httptest.NewRequest(http.MethodGet, "/api/v1/status", nil) - req.Header.Set("Authorization", "Bearer not-the-right-key") + req.Header.Set("Authorization", "Bearer cix_not-the-right-key-at-all-1234567890ab") rr := httptest.NewRecorder() - srv.ServeHTTP(rr, req) + f.Router.ServeHTTP(rr, req) if rr.Code != http.StatusUnauthorized { t.Fatalf("status = %d, want 401", rr.Code) } } func TestAuth_StatusAcceptsCorrectKey(t *testing.T) { - srv := newAuthTestServer(t, "secret-key") + f := newAuthFixture(t) req := httptest.NewRequest(http.MethodGet, "/api/v1/status", nil) - req.Header.Set("Authorization", "Bearer secret-key") + req.Header.Set("Authorization", "Bearer "+f.FullKey) rr := httptest.NewRecorder() - srv.ServeHTTP(rr, req) + f.Router.ServeHTTP(rr, req) if rr.Code != http.StatusOK { t.Fatalf("status = %d, want 200; body=%s", rr.Code, rr.Body.String()) } } -func TestAuth_EmptyKeySkipsCheck(t *testing.T) { - // Dev mode: no key configured => auth middleware passes through. - srv := newAuthTestServer(t, "") +// TestAuth_DisabledFlagSkipsCheck — explicit dev-mode opt-out via +// AuthDisabled. With the flag on, NewRouter omits the requireAuth +// middleware entirely so every endpoint succeeds without credentials. +func TestAuth_DisabledFlagSkipsCheck(t *testing.T) { + srv := newAuthDisabledServer(t) req := httptest.NewRequest(http.MethodGet, "/api/v1/status", nil) rr := httptest.NewRecorder() srv.ServeHTTP(rr, req) if rr.Code != http.StatusOK { - t.Fatalf("status = %d, want 200 in dev mode", rr.Code) + t.Fatalf("status = %d, want 200 with AuthDisabled=true", rr.Code) + } +} + +// TestLimitBodySize_RejectsLargePayloadAtLogin sends a request with a +// declared Content-Length above the default 1 MiB cap and expects 413 +// before the login handler ever runs. Crucially, this fires at the +// public /auth/login path so an unauthenticated attacker cannot force +// the server to read an unbounded body. +func TestLimitBodySize_RejectsLargePayloadAtLogin(t *testing.T) { + f := newAuthFixture(t) + // The body itself doesn't matter — the middleware checks + // Content-Length first and returns 413 without reading. + req := httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", http.NoBody) + req.ContentLength = (2 << 20) // 2 MiB > 1 MiB default + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusRequestEntityTooLarge { + t.Fatalf("status = %d, want 413 (body=%s)", rr.Code, rr.Body.String()) + } +} + +// TestLimitBodySize_AllowsLargerIndexingPayload confirms the per-route +// override: the indexing endpoint accepts payloads up to 32 MiB, well +// past the 1 MiB default. Sending exactly 2 MiB should pass the size +// check and reach the auth handler (which 401s for an unauthenticated +// request — but past the 413 gate, which is what we're testing). +func TestLimitBodySize_AllowsLargerIndexingPayload(t *testing.T) { + f := newAuthFixture(t) + req := httptest.NewRequest(http.MethodPost, "/api/v1/projects/abc123/index/files", http.NoBody) + req.ContentLength = (2 << 20) // 2 MiB + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code == http.StatusRequestEntityTooLarge { + t.Fatalf("indexing endpoint should not 413 at 2 MiB (got %d)", rr.Code) } } diff --git a/server/internal/httpapi/openapi/gen.go b/server/internal/httpapi/openapi/gen.go new file mode 100644 index 0000000..f9d926d --- /dev/null +++ b/server/internal/httpapi/openapi/gen.go @@ -0,0 +1,9 @@ +// Package openapi contains the generated server types and chi-compatible +// ServerInterface for the cix-server HTTP API. The single source of truth is +// doc/openapi.yaml at the repo root; this directory holds nothing but the +// generator config (oapi.yaml) and the generated output (openapi.gen.go). +// +// Regenerate with `make openapi-gen` (from server/) or `go generate ./...`. +package openapi + +//go:generate go tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=oapi.yaml ../../../../doc/openapi.yaml diff --git a/server/internal/httpapi/openapi/oapi.yaml b/server/internal/httpapi/openapi/oapi.yaml new file mode 100644 index 0000000..5997eeb --- /dev/null +++ b/server/internal/httpapi/openapi/oapi.yaml @@ -0,0 +1,12 @@ +# oapi-codegen v2 config — see https://github.com/oapi-codegen/oapi-codegen +# Run via `go generate` from gen.go (or `make openapi-gen` from server/). +package: openapi +output: openapi.gen.go +generate: + models: true + chi-server: true + embedded-spec: true +output-options: + skip-prune: true +compatibility: + always-prefix-enum-values: false diff --git a/server/internal/httpapi/openapi/openapi.gen.go b/server/internal/httpapi/openapi/openapi.gen.go new file mode 100644 index 0000000..a7b29ae --- /dev/null +++ b/server/internal/httpapi/openapi/openapi.gen.go @@ -0,0 +1,3028 @@ +// Package openapi provides primitives to interact with the openapi HTTP API. +// +// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.7.0 DO NOT EDIT. +package openapi + +import ( + "bytes" + "compress/flate" + "context" + "encoding/base64" + "errors" + "fmt" + "net/http" + "net/url" + "path" + "strings" + "time" + + "github.com/getkin/kin-openapi/openapi3" + "github.com/go-chi/chi/v5" + "github.com/oapi-codegen/runtime" + openapi_types "github.com/oapi-codegen/runtime/types" +) + +const ( + BearerAuthScopes bearerAuthContextKey = "bearerAuth.Scopes" +) + +// Defines values for CreateUserRequestRole. +const ( + CreateUserRequestRoleAdmin CreateUserRequestRole = "admin" + CreateUserRequestRoleViewer CreateUserRequestRole = "viewer" +) + +// Valid indicates whether the value is a known member of the CreateUserRequestRole enum. +func (e CreateUserRequestRole) Valid() bool { + switch e { + case CreateUserRequestRoleAdmin: + return true + case CreateUserRequestRoleViewer: + return true + default: + return false + } +} + +// Defines values for HealthResponseStatus. +const ( + HealthResponseStatusOk HealthResponseStatus = "ok" + HealthResponseStatusUnhealthy HealthResponseStatus = "unhealthy" +) + +// Valid indicates whether the value is a known member of the HealthResponseStatus enum. +func (e HealthResponseStatus) Valid() bool { + switch e { + case HealthResponseStatusOk: + return true + case HealthResponseStatusUnhealthy: + return true + default: + return false + } +} + +// Defines values for IndexFinishResponseStatus. +const ( + IndexFinishResponseStatusCompleted IndexFinishResponseStatus = "completed" +) + +// Valid indicates whether the value is a known member of the IndexFinishResponseStatus enum. +func (e IndexFinishResponseStatus) Valid() bool { + switch e { + case IndexFinishResponseStatusCompleted: + return true + default: + return false + } +} + +// Defines values for IndexProgressEventEvent. +const ( + IndexProgressEventEventBatchDone IndexProgressEventEvent = "batch_done" + IndexProgressEventEventError IndexProgressEventEvent = "error" + IndexProgressEventEventFileChunked IndexProgressEventEvent = "file_chunked" + IndexProgressEventEventFileDone IndexProgressEventEvent = "file_done" + IndexProgressEventEventFileEmbedded IndexProgressEventEvent = "file_embedded" + IndexProgressEventEventFileError IndexProgressEventEvent = "file_error" + IndexProgressEventEventFileStarted IndexProgressEventEvent = "file_started" + IndexProgressEventEventHeartbeat IndexProgressEventEvent = "heartbeat" +) + +// Valid indicates whether the value is a known member of the IndexProgressEventEvent enum. +func (e IndexProgressEventEvent) Valid() bool { + switch e { + case IndexProgressEventEventBatchDone: + return true + case IndexProgressEventEventError: + return true + case IndexProgressEventEventFileChunked: + return true + case IndexProgressEventEventFileDone: + return true + case IndexProgressEventEventFileEmbedded: + return true + case IndexProgressEventEventFileError: + return true + case IndexProgressEventEventFileStarted: + return true + case IndexProgressEventEventHeartbeat: + return true + default: + return false + } +} + +// Defines values for IndexProgressInfoPhase. +const ( + IndexProgressInfoPhaseCompleted IndexProgressInfoPhase = "completed" + IndexProgressInfoPhaseReceiving IndexProgressInfoPhase = "receiving" +) + +// Valid indicates whether the value is a known member of the IndexProgressInfoPhase enum. +func (e IndexProgressInfoPhase) Valid() bool { + switch e { + case IndexProgressInfoPhaseCompleted: + return true + case IndexProgressInfoPhaseReceiving: + return true + default: + return false + } +} + +// Defines values for IndexProgressResponseStatus. +const ( + IndexProgressResponseStatusCancelled IndexProgressResponseStatus = "cancelled" + IndexProgressResponseStatusCompleted IndexProgressResponseStatus = "completed" + IndexProgressResponseStatusFailed IndexProgressResponseStatus = "failed" + IndexProgressResponseStatusIdle IndexProgressResponseStatus = "idle" + IndexProgressResponseStatusIndexing IndexProgressResponseStatus = "indexing" + IndexProgressResponseStatusRunning IndexProgressResponseStatus = "running" +) + +// Valid indicates whether the value is a known member of the IndexProgressResponseStatus enum. +func (e IndexProgressResponseStatus) Valid() bool { + switch e { + case IndexProgressResponseStatusCancelled: + return true + case IndexProgressResponseStatusCompleted: + return true + case IndexProgressResponseStatusFailed: + return true + case IndexProgressResponseStatusIdle: + return true + case IndexProgressResponseStatusIndexing: + return true + case IndexProgressResponseStatusRunning: + return true + default: + return false + } +} + +// Defines values for MeResponseAuthMethod. +const ( + MeResponseAuthMethodApiKey MeResponseAuthMethod = "api_key" + MeResponseAuthMethodSession MeResponseAuthMethod = "session" +) + +// Valid indicates whether the value is a known member of the MeResponseAuthMethod enum. +func (e MeResponseAuthMethod) Valid() bool { + switch e { + case MeResponseAuthMethodApiKey: + return true + case MeResponseAuthMethodSession: + return true + default: + return false + } +} + +// Defines values for ProjectStatus. +const ( + ProjectStatusCreated ProjectStatus = "created" + ProjectStatusError ProjectStatus = "error" + ProjectStatusIndexed ProjectStatus = "indexed" + ProjectStatusIndexing ProjectStatus = "indexing" +) + +// Valid indicates whether the value is a known member of the ProjectStatus enum. +func (e ProjectStatus) Valid() bool { + switch e { + case ProjectStatusCreated: + return true + case ProjectStatusError: + return true + case ProjectStatusIndexed: + return true + case ProjectStatusIndexing: + return true + default: + return false + } +} + +// Defines values for ReferenceItemChunkType. +const ( + Reference ReferenceItemChunkType = "reference" +) + +// Valid indicates whether the value is a known member of the ReferenceItemChunkType enum. +func (e ReferenceItemChunkType) Valid() bool { + switch e { + case Reference: + return true + default: + return false + } +} + +// Defines values for RuntimeConfigSource. +const ( + Db RuntimeConfigSource = "db" + Env RuntimeConfigSource = "env" + Recommended RuntimeConfigSource = "recommended" +) + +// Valid indicates whether the value is a known member of the RuntimeConfigSource enum. +func (e RuntimeConfigSource) Valid() bool { + switch e { + case Db: + return true + case Env: + return true + case Recommended: + return true + default: + return false + } +} + +// Defines values for SidecarStatusState. +const ( + SidecarStatusStateDisabled SidecarStatusState = "disabled" + SidecarStatusStateFailed SidecarStatusState = "failed" + SidecarStatusStateRestarting SidecarStatusState = "restarting" + SidecarStatusStateRunning SidecarStatusState = "running" + SidecarStatusStateStarting SidecarStatusState = "starting" +) + +// Valid indicates whether the value is a known member of the SidecarStatusState enum. +func (e SidecarStatusState) Valid() bool { + switch e { + case SidecarStatusStateDisabled: + return true + case SidecarStatusStateFailed: + return true + case SidecarStatusStateRestarting: + return true + case SidecarStatusStateRunning: + return true + case SidecarStatusStateStarting: + return true + default: + return false + } +} + +// Defines values for StatusResponseStatus. +const ( + StatusResponseStatusOk StatusResponseStatus = "ok" +) + +// Valid indicates whether the value is a known member of the StatusResponseStatus enum. +func (e StatusResponseStatus) Valid() bool { + switch e { + case StatusResponseStatusOk: + return true + default: + return false + } +} + +// Defines values for UpdateUserRequestRole. +const ( + UpdateUserRequestRoleAdmin UpdateUserRequestRole = "admin" + UpdateUserRequestRoleViewer UpdateUserRequestRole = "viewer" +) + +// Valid indicates whether the value is a known member of the UpdateUserRequestRole enum. +func (e UpdateUserRequestRole) Valid() bool { + switch e { + case UpdateUserRequestRoleAdmin: + return true + case UpdateUserRequestRoleViewer: + return true + default: + return false + } +} + +// Defines values for UserRole. +const ( + UserRoleAdmin UserRole = "admin" + UserRoleViewer UserRole = "viewer" +) + +// Valid indicates whether the value is a known member of the UserRole enum. +func (e UserRole) Valid() bool { + switch e { + case UserRoleAdmin: + return true + case UserRoleViewer: + return true + default: + return false + } +} + +// Defines values for UserWithStatsRole. +const ( + UserWithStatsRoleAdmin UserWithStatsRole = "admin" + UserWithStatsRoleViewer UserWithStatsRole = "viewer" +) + +// Valid indicates whether the value is a known member of the UserWithStatsRole enum. +func (e UserWithStatsRole) Valid() bool { + switch e { + case UserWithStatsRoleAdmin: + return true + case UserWithStatsRoleViewer: + return true + default: + return false + } +} + +// Defines values for ListApiKeysParamsOwner. +const ( + All ListApiKeysParamsOwner = "all" +) + +// Valid indicates whether the value is a known member of the ListApiKeysParamsOwner enum. +func (e ListApiKeysParamsOwner) Valid() bool { + switch e { + case All: + return true + default: + return false + } +} + +// Defines values for IndexFilesParamsAccept. +const ( + Applicationjson IndexFilesParamsAccept = "application/json" + ApplicationxNdjson IndexFilesParamsAccept = "application/x-ndjson" +) + +// Valid indicates whether the value is a known member of the IndexFilesParamsAccept enum. +func (e IndexFilesParamsAccept) Valid() bool { + switch e { + case Applicationjson: + return true + case ApplicationxNdjson: + return true + default: + return false + } +} + +// ApiKey defines model for ApiKey. +type ApiKey struct { + CreatedAt time.Time `json:"created_at"` + Id string `json:"id"` + LastUsedAt *time.Time `json:"last_used_at,omitempty"` + LastUsedIp *string `json:"last_used_ip,omitempty"` + LastUsedUa *string `json:"last_used_ua,omitempty"` + Name string `json:"name"` + OwnerUserId string `json:"owner_user_id"` + + // Prefix Display-only prefix of the full key (e.g. `cix_a1b2c3d4`). + // Long enough to recognise in lists, short enough that it + // cannot reconstruct the original. + Prefix string `json:"prefix"` + Revoked bool `json:"revoked"` + RevokedAt *time.Time `json:"revoked_at,omitempty"` +} + +// ApiKeyCreated defines model for ApiKeyCreated. +type ApiKeyCreated struct { + ApiKey ApiKey `json:"api_key"` + + // FullKey The plaintext key value. **Returned exactly once.** Store it + // securely — there is no way to retrieve it later. + FullKey string `json:"full_key"` +} + +// ApiKeyListResponse defines model for ApiKeyListResponse. +type ApiKeyListResponse struct { + ApiKeys []ApiKey `json:"api_keys"` + Total int `json:"total"` +} + +// BootstrapStatusResponse defines model for BootstrapStatusResponse. +type BootstrapStatusResponse struct { + // NeedsBootstrap True when the users table is empty. + NeedsBootstrap bool `json:"needs_bootstrap"` +} + +// ChangePasswordRequest defines model for ChangePasswordRequest. +type ChangePasswordRequest struct { + CurrentPassword string `json:"current_password"` + + // NewPassword Minimum 8 characters. No upper bound. + NewPassword string `json:"new_password"` +} + +// CreateApiKeyRequest defines model for CreateApiKeyRequest. +type CreateApiKeyRequest struct { + // Name Human-friendly label shown in the dashboard. The full key + // value is generated server-side and returned exactly once. + Name string `json:"name"` +} + +// CreateProjectRequest defines model for CreateProjectRequest. +type CreateProjectRequest struct { + HostPath string `json:"host_path"` +} + +// CreateUserRequest defines model for CreateUserRequest. +type CreateUserRequest struct { + Email openapi_types.Email `json:"email"` + + // InitialPassword One-time password the new user must change on first login. + // The admin shares this out-of-band. + InitialPassword string `json:"initial_password"` + Role CreateUserRequestRole `json:"role"` +} + +// CreateUserRequestRole defines model for CreateUserRequest.Role. +type CreateUserRequestRole string + +// DefinitionItem defines model for DefinitionItem. +type DefinitionItem struct { + EndLine int `json:"end_line"` + FilePath string `json:"file_path"` + Kind string `json:"kind"` + Language string `json:"language"` + Line int `json:"line"` + Name string `json:"name"` + ParentName *string `json:"parent_name,omitempty"` + Signature *string `json:"signature,omitempty"` +} + +// DefinitionRequest defines model for DefinitionRequest. +type DefinitionRequest struct { + FilePath *string `json:"file_path,omitempty"` + Kind *string `json:"kind,omitempty"` + Limit *int `json:"limit,omitempty"` + Symbol string `json:"symbol"` +} + +// DefinitionResponse defines model for DefinitionResponse. +type DefinitionResponse struct { + Results []DefinitionItem `json:"results"` + Total int `json:"total"` +} + +// DirEntry defines model for DirEntry. +type DirEntry struct { + FileCount int `json:"file_count"` + Path string `json:"path"` +} + +// Error defines model for Error. +type Error struct { + Detail string `json:"detail"` +} + +// FileGroupResult defines model for FileGroupResult. +type FileGroupResult struct { + BestScore float32 `json:"best_score"` + FilePath string `json:"file_path"` + Language *string `json:"language,omitempty"` + Matches []FileMatch `json:"matches"` +} + +// FileMatch defines model for FileMatch. +type FileMatch struct { + ChunkType string `json:"chunk_type"` + Content string `json:"content"` + EndLine int `json:"end_line"` + NestedHits *[]NestedHit `json:"nested_hits,omitempty"` + Score float32 `json:"score"` + StartLine int `json:"start_line"` + SymbolName *string `json:"symbol_name,omitempty"` +} + +// FilePayload defines model for FilePayload. +type FilePayload struct { + // Content UTF-8 text. Binary files should not be submitted. + Content string `json:"content"` + + // ContentHash SHA-256 hex digest of `content`. + ContentHash string `json:"content_hash"` + Language *string `json:"language,omitempty"` + Path string `json:"path"` + Size int `json:"size"` +} + +// FileResultItem defines model for FileResultItem. +type FileResultItem struct { + FilePath string `json:"file_path"` + + // Language Detected language, or null if undetected. + Language *string `json:"language"` +} + +// FileSearchRequest defines model for FileSearchRequest. +type FileSearchRequest struct { + Limit *int `json:"limit,omitempty"` + + // Query Substring matched against `file_path`. + Query string `json:"query"` +} + +// FileSearchResponse defines model for FileSearchResponse. +type FileSearchResponse struct { + Results []FileResultItem `json:"results"` + Total int `json:"total"` +} + +// HealthResponse defines model for HealthResponse. +type HealthResponse struct { + // Reason Set only when `status` is `unhealthy`. + Reason *string `json:"reason,omitempty"` + Status HealthResponseStatus `json:"status"` +} + +// HealthResponseStatus defines model for HealthResponse.Status. +type HealthResponseStatus string + +// IndexBeginRequest defines model for IndexBeginRequest. +type IndexBeginRequest struct { + // Full When true, wipes existing project state before opening the session. + Full *bool `json:"full,omitempty"` +} + +// IndexBeginResponse defines model for IndexBeginResponse. +type IndexBeginResponse struct { + RunId string `json:"run_id"` + + // StoredHashes Map from file path → SHA-256 of currently-stored content. Empty + // when the project has never been indexed (or `full:true` was passed). + StoredHashes map[string]string `json:"stored_hashes"` +} + +// IndexCancelResponse defines model for IndexCancelResponse. +type IndexCancelResponse struct { + Cancelled bool `json:"cancelled"` +} + +// IndexFilesRequest defines model for IndexFilesRequest. +type IndexFilesRequest struct { + Files []FilePayload `json:"files"` + RunId string `json:"run_id"` +} + +// IndexFilesResponse defines model for IndexFilesResponse. +type IndexFilesResponse struct { + ChunksCreated int `json:"chunks_created"` + FilesAccepted int `json:"files_accepted"` + FilesProcessedTotal int `json:"files_processed_total"` +} + +// IndexFinishRequest defines model for IndexFinishRequest. +type IndexFinishRequest struct { + DeletedPaths *[]string `json:"deleted_paths,omitempty"` + RunId string `json:"run_id"` + TotalFilesDiscovered *int `json:"total_files_discovered,omitempty"` +} + +// IndexFinishResponse defines model for IndexFinishResponse. +type IndexFinishResponse struct { + ChunksCreated int `json:"chunks_created"` + FilesProcessed int `json:"files_processed"` + Status IndexFinishResponseStatus `json:"status"` +} + +// IndexFinishResponseStatus defines model for IndexFinishResponse.Status. +type IndexFinishResponseStatus string + +// IndexProgressEvent One event in the NDJSON stream emitted by `POST /index/files` when +// the client sends `Accept: application/x-ndjson`. The `event` field +// discriminates the variant; other fields are populated as relevant. +type IndexProgressEvent struct { + BatchSize *int `json:"batch_size,omitempty"` + Chunks *int `json:"chunks,omitempty"` + ChunksCreated *int `json:"chunks_created,omitempty"` + EmbedMs *int64 `json:"embed_ms,omitempty"` + Event IndexProgressEventEvent `json:"event"` + Fatal *bool `json:"fatal,omitempty"` + FileIndex *int `json:"file_index,omitempty"` + FilesAccepted *int `json:"files_accepted,omitempty"` + FilesProcessedTotal *int `json:"files_processed_total,omitempty"` + Message *string `json:"message,omitempty"` + Path *string `json:"path,omitempty"` + RunId *string `json:"run_id,omitempty"` + Ts *time.Time `json:"ts,omitempty"` +} + +// IndexProgressEventEvent defines model for IndexProgressEvent.Event. +type IndexProgressEventEvent string + +// IndexProgressInfo Progress payload. The active-session variant carries every field; +// the historical-fallback variant only carries `files_processed`, +// `files_total`, and `chunks_created`. +type IndexProgressInfo struct { + ChunksCreated *int `json:"chunks_created,omitempty"` + ElapsedSeconds *float64 `json:"elapsed_seconds,omitempty"` + FilesDiscovered *int `json:"files_discovered,omitempty"` + FilesProcessed *int `json:"files_processed,omitempty"` + FilesTotal *int `json:"files_total,omitempty"` + Phase *IndexProgressInfoPhase `json:"phase,omitempty"` + RunId *string `json:"run_id,omitempty"` +} + +// IndexProgressInfoPhase defines model for IndexProgressInfo.Phase. +type IndexProgressInfoPhase string + +// IndexProgressResponse defines model for IndexProgressResponse. +type IndexProgressResponse struct { + // Progress Progress payload. The active-session variant carries every field; + // the historical-fallback variant only carries `files_processed`, + // `files_total`, and `chunks_created`. + Progress *IndexProgressInfo `json:"progress,omitempty"` + + // Status `idle` — no session ever / fallback unavailable. + // `indexing` — session active. + // `completed`/`cancelled`/`failed`/`running` — last-run status from `index_runs`. + Status IndexProgressResponseStatus `json:"status"` +} + +// IndexProgressResponseStatus `idle` — no session ever / fallback unavailable. +// `indexing` — session active. +// `completed`/`cancelled`/`failed`/`running` — last-run status from `index_runs`. +type IndexProgressResponseStatus string + +// LoginRequest defines model for LoginRequest. +type LoginRequest struct { + Email openapi_types.Email `json:"email"` + Password string `json:"password"` +} + +// LoginResponse defines model for LoginResponse. +type LoginResponse struct { + User User `json:"user"` +} + +// MeResponse defines model for MeResponse. +type MeResponse struct { + // AuthMethod Tells the dashboard whether to surface "logout" (session) or + // hide it (api_key access — there's nothing to log out of). + AuthMethod MeResponseAuthMethod `json:"auth_method"` + User User `json:"user"` +} + +// MeResponseAuthMethod Tells the dashboard whether to surface "logout" (session) or +// hide it (api_key access — there's nothing to log out of). +type MeResponseAuthMethod string + +// ModelEntry defines model for ModelEntry. +type ModelEntry struct { + // Id HF repo ID derived from the cache directory name (e.g. owner/model). + Id string `json:"id"` + + // Path Absolute path to the .gguf file on disk. + Path string `json:"path"` + SizeBytes int64 `json:"size_bytes"` +} + +// ModelList defines model for ModelList. +type ModelList struct { + // CacheDir The CIX_GGUF_CACHE_DIR that was scanned. Empty list with non-empty cache_dir = no .gguf files found. + CacheDir string `json:"cache_dir"` + Models []ModelEntry `json:"models"` +} + +// NestedHit defines model for NestedHit. +type NestedHit struct { + ChunkType string `json:"chunk_type"` + EndLine int `json:"end_line"` + Score float32 `json:"score"` + StartLine int `json:"start_line"` + SymbolName *string `json:"symbol_name,omitempty"` +} + +// Project defines model for Project. +type Project struct { + // ChromaPath Resolved chromem-go collection directory for this project. NULL when not computed. + ChromaPath *string `json:"chroma_path,omitempty"` + ChromaSizeBytes *int64 `json:"chroma_size_bytes,omitempty"` + + // ContainerPath Path inside the container (often equal to host_path). + ContainerPath string `json:"container_path"` + CreatedAt time.Time `json:"created_at"` + + // HostPath Absolute filesystem path on the operator's machine. + HostPath string `json:"host_path"` + + // IndexedWithModel Embedding model identifier active when this project was last + // (re)indexed. NULL on rows that pre-date drift tracking — the + // dashboard treats NULL as "Unknown" rather than as drift. + IndexedWithModel *string `json:"indexed_with_model,omitempty"` + Languages []string `json:"languages"` + LastIndexedAt *time.Time `json:"last_indexed_at"` + + // PathHash First 16 hex chars of SHA1(host_path) — stable URL identifier. + PathHash string `json:"path_hash"` + Settings ProjectSettings `json:"settings"` + + // SqlitePath Resolved SQLite database path for the active model. NULL on dashboards that don't expose storage info. + SqlitePath *string `json:"sqlite_path,omitempty"` + SqliteSizeBytes *int64 `json:"sqlite_size_bytes,omitempty"` + Stats ProjectStats `json:"stats"` + Status ProjectStatus `json:"status"` + UpdatedAt time.Time `json:"updated_at"` +} + +// ProjectStatus defines model for Project.Status. +type ProjectStatus string + +// ProjectListResponse defines model for ProjectListResponse. +type ProjectListResponse struct { + Projects []Project `json:"projects"` + Total int `json:"total"` +} + +// ProjectSettings defines model for ProjectSettings. +type ProjectSettings struct { + ExcludePatterns []string `json:"exclude_patterns"` + MaxFileSize int `json:"max_file_size"` +} + +// ProjectStats defines model for ProjectStats. +type ProjectStats struct { + IndexedFiles int `json:"indexed_files"` + TotalChunks int `json:"total_chunks"` + TotalFiles int `json:"total_files"` + TotalSymbols int `json:"total_symbols"` +} + +// ProjectSummary defines model for ProjectSummary. +type ProjectSummary struct { + HostPath string `json:"host_path"` + Languages []string `json:"languages"` + + // PathHash First 16 hex chars of SHA1(host_path) — stable URL identifier. + PathHash string `json:"path_hash"` + RecentSymbols []SymbolEntry `json:"recent_symbols"` + Status string `json:"status"` + TopDirectories []DirEntry `json:"top_directories"` + TotalChunks int `json:"total_chunks"` + TotalFiles int `json:"total_files"` + TotalSymbols int `json:"total_symbols"` +} + +// ReferenceItem defines model for ReferenceItem. +type ReferenceItem struct { + ChunkType ReferenceItemChunkType `json:"chunk_type"` + + // Content Always empty — see endpoint description. + Content string `json:"content"` + + // EndLine Always equal to `start_line` (refs table stores tokens, not ranges). + EndLine int `json:"end_line"` + FilePath string `json:"file_path"` + Language string `json:"language"` + StartLine int `json:"start_line"` + SymbolName string `json:"symbol_name"` +} + +// ReferenceItemChunkType defines model for ReferenceItem.ChunkType. +type ReferenceItemChunkType string + +// ReferenceRequest defines model for ReferenceRequest. +type ReferenceRequest struct { + FilePath *string `json:"file_path,omitempty"` + Limit *int `json:"limit,omitempty"` + Symbol string `json:"symbol"` +} + +// ReferenceResponse defines model for ReferenceResponse. +type ReferenceResponse struct { + Results []ReferenceItem `json:"results"` + Total int `json:"total"` +} + +// RestartAccepted defines model for RestartAccepted. +type RestartAccepted struct { + // RestartId Opaque ID; future versions may expose per-restart progress under this id. + RestartId string `json:"restart_id"` +} + +// RuntimeConfig defines model for RuntimeConfig. +type RuntimeConfig struct { + // EmbeddingModel HF repo ID or absolute filesystem path to a .gguf file. + EmbeddingModel string `json:"embedding_model"` + LlamaBatchSize int `json:"llama_batch_size"` + LlamaCtxSize int `json:"llama_ctx_size"` + + // LlamaNGpuLayers -1 = all layers (Metal/CUDA), 0 = CPU only. + LlamaNGpuLayers int `json:"llama_n_gpu_layers"` + + // LlamaNThreads 0 = let llama-server auto-detect. + LlamaNThreads int `json:"llama_n_threads"` + MaxEmbeddingConcurrency int `json:"max_embedding_concurrency"` + Recommended *RuntimeConfigRecommended `json:"recommended,omitempty"` + + // Source Per-field origin label so the dashboard can render a "DB" / + // "Env" / "Recommended" pill next to each value. Keys match the + // other field names: `embedding_model`, `llama_ctx_size`, ... + Source map[string]RuntimeConfigSource `json:"source"` + + // UpdatedAt When the runtime_settings row was last written, or null when only env/recommended are in effect. + UpdatedAt *time.Time `json:"updated_at,omitempty"` + + // UpdatedBy Who issued the last PUT, captured from the active session. + UpdatedBy *string `json:"updated_by,omitempty"` +} + +// RuntimeConfigSource defines model for RuntimeConfig.Source. +type RuntimeConfigSource string + +// RuntimeConfigRecommended defines model for RuntimeConfigRecommended. +type RuntimeConfigRecommended struct { + EmbeddingModel string `json:"embedding_model"` + LlamaBatchSize int `json:"llama_batch_size"` + LlamaCtxSize int `json:"llama_ctx_size"` + LlamaNGpuLayers int `json:"llama_n_gpu_layers"` + LlamaNThreads int `json:"llama_n_threads"` + MaxEmbeddingConcurrency int `json:"max_embedding_concurrency"` +} + +// RuntimeConfigUpdate All fields optional. Send a value to set/replace the override for +// that field, send `""` (string fields) or `0` (numeric fields) to +// CLEAR the override (next read falls back to env / recommended). +// Omitted fields keep their current value. +type RuntimeConfigUpdate struct { + EmbeddingModel *string `json:"embedding_model,omitempty"` + LlamaBatchSize *int `json:"llama_batch_size,omitempty"` + LlamaCtxSize *int `json:"llama_ctx_size,omitempty"` + LlamaNGpuLayers *int `json:"llama_n_gpu_layers,omitempty"` + LlamaNThreads *int `json:"llama_n_threads,omitempty"` + MaxEmbeddingConcurrency *int `json:"max_embedding_concurrency,omitempty"` +} + +// SemanticSearchRequest defines model for SemanticSearchRequest. +type SemanticSearchRequest struct { + // Excludes Blacklist — drop results whose path matches any prefix or substring. + Excludes *[]string `json:"excludes,omitempty"` + Languages *[]string `json:"languages,omitempty"` + + // Limit Maximum number of FILE groups (not chunks) to return. + Limit *int `json:"limit,omitempty"` + + // MinScore Minimum cosine similarity. Omit for server default (0.4 for + // CodeRankEmbed-Q8). Send `0` explicitly to disable the floor. + MinScore *float32 `json:"min_score,omitempty"` + + // Paths Whitelist — keep only results whose path matches any prefix or substring. + Paths *[]string `json:"paths,omitempty"` + Query string `json:"query"` +} + +// SemanticSearchResponse defines model for SemanticSearchResponse. +type SemanticSearchResponse struct { + // QueryTimeMs Wall-clock query latency, rounded to 1 decimal place. + QueryTimeMs float64 `json:"query_time_ms"` + Results []FileGroupResult `json:"results"` + Total int `json:"total"` +} + +// Session defines model for Session. +type Session struct { + CreatedAt time.Time `json:"created_at"` + ExpiresAt time.Time `json:"expires_at"` + Id string `json:"id"` + + // IsCurrent True for the session carrying this request. + IsCurrent bool `json:"is_current"` + LastSeenAt time.Time `json:"last_seen_at"` + LastSeenIp *string `json:"last_seen_ip,omitempty"` + LastSeenUa *string `json:"last_seen_ua,omitempty"` +} + +// SessionListResponse defines model for SessionListResponse. +type SessionListResponse struct { + Sessions []Session `json:"sessions"` + Total int `json:"total"` +} + +// SidecarStatus defines model for SidecarStatus. +type SidecarStatus struct { + // InFlight Embedding queue depth at the moment of sampling. + InFlight int `json:"in_flight"` + LastError *string `json:"last_error,omitempty"` + Model *string `json:"model,omitempty"` + + // Pid 0 when no child process is alive (failed / disabled). + Pid *int `json:"pid,omitempty"` + Ready bool `json:"ready"` + + // RestartInFlight True between accept of POST /sidecar/restart and respawn completion. + RestartInFlight *bool `json:"restart_in_flight,omitempty"` + State SidecarStatusState `json:"state"` + UptimeSeconds *int `json:"uptime_seconds,omitempty"` +} + +// SidecarStatusState defines model for SidecarStatus.State. +type SidecarStatusState string + +// StatusResponse defines model for StatusResponse. +type StatusResponse struct { + // ActiveIndexingJobs Currently-running `index_runs` rows. + ActiveIndexingJobs int `json:"active_indexing_jobs"` + ApiVersion string `json:"api_version"` + + // Backend Backend identifier (e.g. `go`). + Backend string `json:"backend"` + + // EmbeddingModel Hugging Face model id (e.g. `awhiteside/CodeRankEmbed-Q8_0-GGUF`). + EmbeddingModel string `json:"embedding_model"` + + // LatestVersion Latest released server version (without the `server/v` prefix, + // e.g. `0.5.1`). Null until the first successful poll completes. + LatestVersion *string `json:"latest_version,omitempty"` + + // ModelLoaded Whether the llama-server sidecar reports ready within 500 ms. + // False when the sidecar is starting or has crashed. + ModelLoaded bool `json:"model_loaded"` + + // Projects Total registered projects. + Projects int `json:"projects"` + + // ReleaseUrl GitHub release page URL for `latest_version`. Null when unknown. + ReleaseUrl *string `json:"release_url,omitempty"` + ServerVersion string `json:"server_version"` + Status StatusResponseStatus `json:"status"` + + // UpdateAvailable True when the version-check service has found a `server/v*` + // release on GitHub strictly newer than the running server. + // Field is omitted entirely when version-check is not wired + // (set `CIX_VERSION_CHECK_ENABLED=false` to disable polling). + UpdateAvailable *bool `json:"update_available,omitempty"` + VersionCheck *VersionCheckStatus `json:"version_check,omitempty"` +} + +// StatusResponseStatus defines model for StatusResponse.Status. +type StatusResponseStatus string + +// SymbolEntry defines model for SymbolEntry. +type SymbolEntry struct { + FilePath string `json:"file_path"` + Kind string `json:"kind"` + Language string `json:"language"` + Name string `json:"name"` +} + +// SymbolResultItem defines model for SymbolResultItem. +type SymbolResultItem struct { + EndLine int `json:"end_line"` + FilePath string `json:"file_path"` + Kind string `json:"kind"` + Language string `json:"language"` + Line int `json:"line"` + Name string `json:"name"` + ParentName *string `json:"parent_name,omitempty"` + Signature *string `json:"signature,omitempty"` +} + +// SymbolSearchRequest defines model for SymbolSearchRequest. +type SymbolSearchRequest struct { + Kinds *[]string `json:"kinds,omitempty"` + Limit *int `json:"limit,omitempty"` + Query string `json:"query"` +} + +// SymbolSearchResponse defines model for SymbolSearchResponse. +type SymbolSearchResponse struct { + Results []SymbolResultItem `json:"results"` + Total int `json:"total"` +} + +// UpdateProjectRequest defines model for UpdateProjectRequest. +type UpdateProjectRequest struct { + Settings *ProjectSettings `json:"settings,omitempty"` +} + +// UpdateUserRequest defines model for UpdateUserRequest. +type UpdateUserRequest struct { + // Disabled When true, the user can no longer authenticate. Refused for + // the last enabled admin when set to true. + Disabled *bool `json:"disabled,omitempty"` + + // Role New role for the user. Refused for the last enabled admin + // when set to `viewer`. + Role *UpdateUserRequestRole `json:"role,omitempty"` +} + +// UpdateUserRequestRole New role for the user. Refused for the last enabled admin +// when set to `viewer`. +type UpdateUserRequestRole string + +// User defines model for User. +type User struct { + CreatedAt time.Time `json:"created_at"` + + // Disabled True when `disabled_at` is set. Disabled users cannot + // authenticate via password OR API key. + Disabled bool `json:"disabled"` + DisabledAt *time.Time `json:"disabled_at,omitempty"` + Email openapi_types.Email `json:"email"` + Id string `json:"id"` + MustChangePassword bool `json:"must_change_password"` + Role UserRole `json:"role"` + UpdatedAt time.Time `json:"updated_at"` +} + +// UserRole defines model for User.Role. +type UserRole string + +// UserListResponse defines model for UserListResponse. +type UserListResponse struct { + Total int `json:"total"` + Users []UserWithStats `json:"users"` +} + +// UserWithStats defines model for UserWithStats. +type UserWithStats struct { + // ActiveSessionsCount Count of non-expired sessions for this user. + ActiveSessionsCount int `json:"active_sessions_count"` + + // ApiKeysCount Count of non-revoked API keys owned by this user. + ApiKeysCount int `json:"api_keys_count"` + CreatedAt time.Time `json:"created_at"` + + // Disabled True when `disabled_at` is set. Disabled users cannot + // authenticate via password OR API key. + Disabled bool `json:"disabled"` + DisabledAt *time.Time `json:"disabled_at,omitempty"` + Email openapi_types.Email `json:"email"` + Id string `json:"id"` + + // LastLoginAt Most recent session creation timestamp (RFC3339). + // Null if the user has never logged in. + LastLoginAt *time.Time `json:"last_login_at,omitempty"` + MustChangePassword bool `json:"must_change_password"` + Role UserWithStatsRole `json:"role"` + UpdatedAt time.Time `json:"updated_at"` +} + +// UserWithStatsRole defines model for UserWithStats.Role. +type UserWithStatsRole string + +// VersionCheckStatus defines model for VersionCheckStatus. +type VersionCheckStatus struct { + // CheckedAt Last poll timestamp (UTC, RFC 3339). Null before the first poll. + CheckedAt *time.Time `json:"checked_at,omitempty"` + + // Enabled Whether the periodic GitHub poll is running. + Enabled bool `json:"enabled"` + + // Error Last error message, if the most recent poll failed. Null on success. + Error *string `json:"error,omitempty"` +} + +// ProjectHash defines model for ProjectHash. +type ProjectHash = string + +// Conflict defines model for Conflict. +type Conflict = Error + +// Forbidden defines model for Forbidden. +type Forbidden = Error + +// IndexerUnavailable defines model for IndexerUnavailable. +type IndexerUnavailable = Error + +// InternalError defines model for InternalError. +type InternalError = Error + +// NotFound defines model for NotFound. +type NotFound = Error + +// Unauthorized defines model for Unauthorized. +type Unauthorized = Error + +// Unprocessable defines model for Unprocessable. +type Unprocessable = Error + +// bearerAuthContextKey is the context key for bearerAuth security scheme +type bearerAuthContextKey string + +// ListApiKeysParams defines parameters for ListApiKeys. +type ListApiKeysParams struct { + // Owner `all` — admin-only, returns every key in the system. + // Anything else (or unset) returns the caller's keys. + Owner *ListApiKeysParamsOwner `form:"owner,omitempty" json:"owner,omitempty"` +} + +// ListApiKeysParamsOwner defines parameters for ListApiKeys. +type ListApiKeysParamsOwner string + +// IndexFilesParams defines parameters for IndexFiles. +type IndexFilesParams struct { + // Accept `application/x-ndjson` switches to a streamed response + // (one `IndexProgressEvent` per line). Default: `application/json`. + Accept *IndexFilesParamsAccept `json:"Accept,omitempty"` +} + +// IndexFilesParamsAccept defines parameters for IndexFiles. +type IndexFilesParamsAccept string + +// PutRuntimeConfigJSONRequestBody defines body for PutRuntimeConfig for application/json ContentType. +type PutRuntimeConfigJSONRequestBody = RuntimeConfigUpdate + +// CreateUserJSONRequestBody defines body for CreateUser for application/json ContentType. +type CreateUserJSONRequestBody = CreateUserRequest + +// UpdateUserJSONRequestBody defines body for UpdateUser for application/json ContentType. +type UpdateUserJSONRequestBody = UpdateUserRequest + +// CreateApiKeyJSONRequestBody defines body for CreateApiKey for application/json ContentType. +type CreateApiKeyJSONRequestBody = CreateApiKeyRequest + +// ChangePasswordJSONRequestBody defines body for ChangePassword for application/json ContentType. +type ChangePasswordJSONRequestBody = ChangePasswordRequest + +// LoginJSONRequestBody defines body for Login for application/json ContentType. +type LoginJSONRequestBody = LoginRequest + +// CreateProjectJSONRequestBody defines body for CreateProject for application/json ContentType. +type CreateProjectJSONRequestBody = CreateProjectRequest + +// UpdateProjectJSONRequestBody defines body for UpdateProject for application/json ContentType. +type UpdateProjectJSONRequestBody = UpdateProjectRequest + +// IndexBeginJSONRequestBody defines body for IndexBegin for application/json ContentType. +type IndexBeginJSONRequestBody = IndexBeginRequest + +// IndexFilesJSONRequestBody defines body for IndexFiles for application/json ContentType. +type IndexFilesJSONRequestBody = IndexFilesRequest + +// IndexFinishJSONRequestBody defines body for IndexFinish for application/json ContentType. +type IndexFinishJSONRequestBody = IndexFinishRequest + +// SemanticSearchJSONRequestBody defines body for SemanticSearch for application/json ContentType. +type SemanticSearchJSONRequestBody = SemanticSearchRequest + +// SearchDefinitionsJSONRequestBody defines body for SearchDefinitions for application/json ContentType. +type SearchDefinitionsJSONRequestBody = DefinitionRequest + +// SearchFilesJSONRequestBody defines body for SearchFiles for application/json ContentType. +type SearchFilesJSONRequestBody = FileSearchRequest + +// SearchReferencesJSONRequestBody defines body for SearchReferences for application/json ContentType. +type SearchReferencesJSONRequestBody = ReferenceRequest + +// SearchSymbolsJSONRequestBody defines body for SearchSymbols for application/json ContentType. +type SearchSymbolsJSONRequestBody = SymbolSearchRequest + +// ServerInterface represents all server handlers. +type ServerInterface interface { + // List GGUF model files cached on disk (admin only) + // (GET /api/v1/admin/models) + ListModels(w http.ResponseWriter, r *http.Request) + // Read effective runtime config (admin only) + // (GET /api/v1/admin/runtime-config) + GetRuntimeConfig(w http.ResponseWriter, r *http.Request) + // Save runtime config overrides (admin only) + // (PUT /api/v1/admin/runtime-config) + PutRuntimeConfig(w http.ResponseWriter, r *http.Request) + // Restart the llama-server sidecar (admin only) + // (POST /api/v1/admin/sidecar/restart) + RestartSidecar(w http.ResponseWriter, r *http.Request) + // Sidecar process status (admin only) + // (GET /api/v1/admin/sidecar/status) + GetSidecarStatus(w http.ResponseWriter, r *http.Request) + // List all users (admin only) + // (GET /api/v1/admin/users) + ListUsers(w http.ResponseWriter, r *http.Request) + // Invite a new user (admin only) + // (POST /api/v1/admin/users) + CreateUser(w http.ResponseWriter, r *http.Request) + // Delete a user (admin only) + // (DELETE /api/v1/admin/users/{id}) + DeleteUser(w http.ResponseWriter, r *http.Request, id string) + // Change role or disabled flag (admin only) + // (PATCH /api/v1/admin/users/{id}) + UpdateUser(w http.ResponseWriter, r *http.Request, id string) + // List my API keys (or all keys if admin) + // (GET /api/v1/api-keys) + ListApiKeys(w http.ResponseWriter, r *http.Request, params ListApiKeysParams) + // Issue a new API key + // (POST /api/v1/api-keys) + CreateApiKey(w http.ResponseWriter, r *http.Request) + // Revoke an API key + // (DELETE /api/v1/api-keys/{id}) + RevokeApiKey(w http.ResponseWriter, r *http.Request, id string) + // Whether the dashboard needs first-run bootstrap (public) + // (GET /api/v1/auth/bootstrap-status) + GetBootstrapStatus(w http.ResponseWriter, r *http.Request) + // Change the current user's password + // (POST /api/v1/auth/change-password) + ChangePassword(w http.ResponseWriter, r *http.Request) + // Exchange email + password for a session cookie (public) + // (POST /api/v1/auth/login) + Login(w http.ResponseWriter, r *http.Request) + // End the current session + // (POST /api/v1/auth/logout) + Logout(w http.ResponseWriter, r *http.Request) + // Current authenticated user + // (GET /api/v1/auth/me) + GetMe(w http.ResponseWriter, r *http.Request) + // Active sessions of the current user + // (GET /api/v1/auth/sessions) + ListMySessions(w http.ResponseWriter, r *http.Request) + // End one of my sessions (sign out a single device) + // (DELETE /api/v1/auth/sessions/{id}) + DeleteMySession(w http.ResponseWriter, r *http.Request, id string) + // List all registered projects + // (GET /api/v1/projects) + ListProjects(w http.ResponseWriter, r *http.Request) + // Register a new project + // (POST /api/v1/projects) + CreateProject(w http.ResponseWriter, r *http.Request) + // Delete a project and all its indexed data (admin only) + // (DELETE /api/v1/projects/{path}) + DeleteProject(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Get one project by hash + // (GET /api/v1/projects/{path}) + GetProject(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Patch project settings (admin only) + // (PATCH /api/v1/projects/{path}) + UpdateProject(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Open an indexing session + // (POST /api/v1/projects/{path}/index/begin) + IndexBegin(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Cancel any active indexing session (idempotent) + // (POST /api/v1/projects/{path}/index/cancel) + IndexCancel(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Submit a batch of files (max 50) + // (POST /api/v1/projects/{path}/index/files) + IndexFiles(w http.ResponseWriter, r *http.Request, path ProjectHash, params IndexFilesParams) + // Commit the indexing session + // (POST /api/v1/projects/{path}/index/finish) + IndexFinish(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Live progress of the current run, or last completed run + // (GET /api/v1/projects/{path}/index/status) + IndexStatus(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Semantic (vector) search + // (POST /api/v1/projects/{path}/search) + SemanticSearch(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Go-to-definition by symbol name + // (POST /api/v1/projects/{path}/search/definitions) + SearchDefinitions(w http.ResponseWriter, r *http.Request, path ProjectHash) + // File-path substring search + // (POST /api/v1/projects/{path}/search/files) + SearchFiles(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Find references to a symbol + // (POST /api/v1/projects/{path}/search/references) + SearchReferences(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Symbol search by name (prefix/substring) + // (POST /api/v1/projects/{path}/search/symbols) + SearchSymbols(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Project overview (top dirs, recent symbols, totals) + // (GET /api/v1/projects/{path}/summary) + GetProjectSummary(w http.ResponseWriter, r *http.Request, path ProjectHash) + // Server / sidecar status (authenticated) + // (GET /api/v1/status) + GetStatus(w http.ResponseWriter, r *http.Request) + // Liveness probe (public) + // (GET /health) + GetHealth(w http.ResponseWriter, r *http.Request) +} + +// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint. + +type Unimplemented struct{} + +// List GGUF model files cached on disk (admin only) +// (GET /api/v1/admin/models) +func (_ Unimplemented) ListModels(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Read effective runtime config (admin only) +// (GET /api/v1/admin/runtime-config) +func (_ Unimplemented) GetRuntimeConfig(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Save runtime config overrides (admin only) +// (PUT /api/v1/admin/runtime-config) +func (_ Unimplemented) PutRuntimeConfig(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Restart the llama-server sidecar (admin only) +// (POST /api/v1/admin/sidecar/restart) +func (_ Unimplemented) RestartSidecar(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Sidecar process status (admin only) +// (GET /api/v1/admin/sidecar/status) +func (_ Unimplemented) GetSidecarStatus(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// List all users (admin only) +// (GET /api/v1/admin/users) +func (_ Unimplemented) ListUsers(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Invite a new user (admin only) +// (POST /api/v1/admin/users) +func (_ Unimplemented) CreateUser(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Delete a user (admin only) +// (DELETE /api/v1/admin/users/{id}) +func (_ Unimplemented) DeleteUser(w http.ResponseWriter, r *http.Request, id string) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Change role or disabled flag (admin only) +// (PATCH /api/v1/admin/users/{id}) +func (_ Unimplemented) UpdateUser(w http.ResponseWriter, r *http.Request, id string) { + w.WriteHeader(http.StatusNotImplemented) +} + +// List my API keys (or all keys if admin) +// (GET /api/v1/api-keys) +func (_ Unimplemented) ListApiKeys(w http.ResponseWriter, r *http.Request, params ListApiKeysParams) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Issue a new API key +// (POST /api/v1/api-keys) +func (_ Unimplemented) CreateApiKey(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Revoke an API key +// (DELETE /api/v1/api-keys/{id}) +func (_ Unimplemented) RevokeApiKey(w http.ResponseWriter, r *http.Request, id string) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Whether the dashboard needs first-run bootstrap (public) +// (GET /api/v1/auth/bootstrap-status) +func (_ Unimplemented) GetBootstrapStatus(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Change the current user's password +// (POST /api/v1/auth/change-password) +func (_ Unimplemented) ChangePassword(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Exchange email + password for a session cookie (public) +// (POST /api/v1/auth/login) +func (_ Unimplemented) Login(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// End the current session +// (POST /api/v1/auth/logout) +func (_ Unimplemented) Logout(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Current authenticated user +// (GET /api/v1/auth/me) +func (_ Unimplemented) GetMe(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Active sessions of the current user +// (GET /api/v1/auth/sessions) +func (_ Unimplemented) ListMySessions(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// End one of my sessions (sign out a single device) +// (DELETE /api/v1/auth/sessions/{id}) +func (_ Unimplemented) DeleteMySession(w http.ResponseWriter, r *http.Request, id string) { + w.WriteHeader(http.StatusNotImplemented) +} + +// List all registered projects +// (GET /api/v1/projects) +func (_ Unimplemented) ListProjects(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Register a new project +// (POST /api/v1/projects) +func (_ Unimplemented) CreateProject(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Delete a project and all its indexed data (admin only) +// (DELETE /api/v1/projects/{path}) +func (_ Unimplemented) DeleteProject(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Get one project by hash +// (GET /api/v1/projects/{path}) +func (_ Unimplemented) GetProject(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Patch project settings (admin only) +// (PATCH /api/v1/projects/{path}) +func (_ Unimplemented) UpdateProject(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Open an indexing session +// (POST /api/v1/projects/{path}/index/begin) +func (_ Unimplemented) IndexBegin(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Cancel any active indexing session (idempotent) +// (POST /api/v1/projects/{path}/index/cancel) +func (_ Unimplemented) IndexCancel(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Submit a batch of files (max 50) +// (POST /api/v1/projects/{path}/index/files) +func (_ Unimplemented) IndexFiles(w http.ResponseWriter, r *http.Request, path ProjectHash, params IndexFilesParams) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Commit the indexing session +// (POST /api/v1/projects/{path}/index/finish) +func (_ Unimplemented) IndexFinish(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Live progress of the current run, or last completed run +// (GET /api/v1/projects/{path}/index/status) +func (_ Unimplemented) IndexStatus(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Semantic (vector) search +// (POST /api/v1/projects/{path}/search) +func (_ Unimplemented) SemanticSearch(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Go-to-definition by symbol name +// (POST /api/v1/projects/{path}/search/definitions) +func (_ Unimplemented) SearchDefinitions(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// File-path substring search +// (POST /api/v1/projects/{path}/search/files) +func (_ Unimplemented) SearchFiles(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Find references to a symbol +// (POST /api/v1/projects/{path}/search/references) +func (_ Unimplemented) SearchReferences(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Symbol search by name (prefix/substring) +// (POST /api/v1/projects/{path}/search/symbols) +func (_ Unimplemented) SearchSymbols(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Project overview (top dirs, recent symbols, totals) +// (GET /api/v1/projects/{path}/summary) +func (_ Unimplemented) GetProjectSummary(w http.ResponseWriter, r *http.Request, path ProjectHash) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Server / sidecar status (authenticated) +// (GET /api/v1/status) +func (_ Unimplemented) GetStatus(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Liveness probe (public) +// (GET /health) +func (_ Unimplemented) GetHealth(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// ServerInterfaceWrapper converts contexts to parameters. +type ServerInterfaceWrapper struct { + Handler ServerInterface + HandlerMiddlewares []MiddlewareFunc + ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error) +} + +type MiddlewareFunc func(http.Handler) http.Handler + +// ListModels operation middleware +func (siw *ServerInterfaceWrapper) ListModels(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListModels(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetRuntimeConfig operation middleware +func (siw *ServerInterfaceWrapper) GetRuntimeConfig(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetRuntimeConfig(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// PutRuntimeConfig operation middleware +func (siw *ServerInterfaceWrapper) PutRuntimeConfig(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.PutRuntimeConfig(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// RestartSidecar operation middleware +func (siw *ServerInterfaceWrapper) RestartSidecar(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.RestartSidecar(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetSidecarStatus operation middleware +func (siw *ServerInterfaceWrapper) GetSidecarStatus(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetSidecarStatus(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// ListUsers operation middleware +func (siw *ServerInterfaceWrapper) ListUsers(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListUsers(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// CreateUser operation middleware +func (siw *ServerInterfaceWrapper) CreateUser(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.CreateUser(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// DeleteUser operation middleware +func (siw *ServerInterfaceWrapper) DeleteUser(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "id" ------------- + var id string + + err = runtime.BindStyledParameterWithOptions("simple", "id", chi.URLParam(r, "id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "id", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.DeleteUser(w, r, id) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// UpdateUser operation middleware +func (siw *ServerInterfaceWrapper) UpdateUser(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "id" ------------- + var id string + + err = runtime.BindStyledParameterWithOptions("simple", "id", chi.URLParam(r, "id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "id", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.UpdateUser(w, r, id) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// ListApiKeys operation middleware +func (siw *ServerInterfaceWrapper) ListApiKeys(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + // Parameter object where we will unmarshal all parameters from the context + var params ListApiKeysParams + + // ------------- Optional query parameter "owner" ------------- + + err = runtime.BindQueryParameterWithOptions("form", true, false, "owner", r.URL.Query(), ¶ms.Owner, runtime.BindQueryParameterOptions{Type: "string", Format: ""}) + if err != nil { + var requiredError *runtime.RequiredParameterError + if errors.As(err, &requiredError) { + siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "owner"}) + } else { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "owner", Err: err}) + } + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListApiKeys(w, r, params) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// CreateApiKey operation middleware +func (siw *ServerInterfaceWrapper) CreateApiKey(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.CreateApiKey(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// RevokeApiKey operation middleware +func (siw *ServerInterfaceWrapper) RevokeApiKey(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "id" ------------- + var id string + + err = runtime.BindStyledParameterWithOptions("simple", "id", chi.URLParam(r, "id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "id", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.RevokeApiKey(w, r, id) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetBootstrapStatus operation middleware +func (siw *ServerInterfaceWrapper) GetBootstrapStatus(w http.ResponseWriter, r *http.Request) { + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetBootstrapStatus(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// ChangePassword operation middleware +func (siw *ServerInterfaceWrapper) ChangePassword(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ChangePassword(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// Login operation middleware +func (siw *ServerInterfaceWrapper) Login(w http.ResponseWriter, r *http.Request) { + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.Login(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// Logout operation middleware +func (siw *ServerInterfaceWrapper) Logout(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.Logout(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetMe operation middleware +func (siw *ServerInterfaceWrapper) GetMe(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetMe(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// ListMySessions operation middleware +func (siw *ServerInterfaceWrapper) ListMySessions(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListMySessions(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// DeleteMySession operation middleware +func (siw *ServerInterfaceWrapper) DeleteMySession(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "id" ------------- + var id string + + err = runtime.BindStyledParameterWithOptions("simple", "id", chi.URLParam(r, "id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "id", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.DeleteMySession(w, r, id) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// ListProjects operation middleware +func (siw *ServerInterfaceWrapper) ListProjects(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListProjects(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// CreateProject operation middleware +func (siw *ServerInterfaceWrapper) CreateProject(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.CreateProject(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// DeleteProject operation middleware +func (siw *ServerInterfaceWrapper) DeleteProject(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.DeleteProject(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetProject operation middleware +func (siw *ServerInterfaceWrapper) GetProject(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetProject(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// UpdateProject operation middleware +func (siw *ServerInterfaceWrapper) UpdateProject(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.UpdateProject(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// IndexBegin operation middleware +func (siw *ServerInterfaceWrapper) IndexBegin(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.IndexBegin(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// IndexCancel operation middleware +func (siw *ServerInterfaceWrapper) IndexCancel(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.IndexCancel(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// IndexFiles operation middleware +func (siw *ServerInterfaceWrapper) IndexFiles(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + // Parameter object where we will unmarshal all parameters from the context + var params IndexFilesParams + + headers := r.Header + + // ------------- Optional header parameter "Accept" ------------- + if valueList, found := headers[http.CanonicalHeaderKey("Accept")]; found { + var Accept IndexFilesParamsAccept + n := len(valueList) + if n != 1 { + siw.ErrorHandlerFunc(w, r, &TooManyValuesForParamError{ParamName: "Accept", Count: n}) + return + } + + err = runtime.BindStyledParameterWithOptions("simple", "Accept", valueList[0], &Accept, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: false, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "Accept", Err: err}) + return + } + + params.Accept = &Accept + + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.IndexFiles(w, r, path, params) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// IndexFinish operation middleware +func (siw *ServerInterfaceWrapper) IndexFinish(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.IndexFinish(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// IndexStatus operation middleware +func (siw *ServerInterfaceWrapper) IndexStatus(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.IndexStatus(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// SemanticSearch operation middleware +func (siw *ServerInterfaceWrapper) SemanticSearch(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SemanticSearch(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// SearchDefinitions operation middleware +func (siw *ServerInterfaceWrapper) SearchDefinitions(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SearchDefinitions(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// SearchFiles operation middleware +func (siw *ServerInterfaceWrapper) SearchFiles(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SearchFiles(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// SearchReferences operation middleware +func (siw *ServerInterfaceWrapper) SearchReferences(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SearchReferences(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// SearchSymbols operation middleware +func (siw *ServerInterfaceWrapper) SearchSymbols(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SearchSymbols(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetProjectSummary operation middleware +func (siw *ServerInterfaceWrapper) GetProjectSummary(w http.ResponseWriter, r *http.Request) { + + var err error + _ = err + + // ------------- Path parameter "path" ------------- + var path ProjectHash + + err = runtime.BindStyledParameterWithOptions("simple", "path", chi.URLParam(r, "path"), &path, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err}) + return + } + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetProjectSummary(w, r, path) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetStatus operation middleware +func (siw *ServerInterfaceWrapper) GetStatus(w http.ResponseWriter, r *http.Request) { + + ctx := r.Context() + + ctx = context.WithValue(ctx, BearerAuthScopes, []string{}) + + r = r.WithContext(ctx) + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetStatus(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +// GetHealth operation middleware +func (siw *ServerInterfaceWrapper) GetHealth(w http.ResponseWriter, r *http.Request) { + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetHealth(w, r) + })) + + for _, middleware := range siw.HandlerMiddlewares { + handler = middleware(handler) + } + + handler.ServeHTTP(w, r) +} + +type UnescapedCookieParamError struct { + ParamName string + Err error +} + +func (e *UnescapedCookieParamError) Error() string { + return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName) +} + +func (e *UnescapedCookieParamError) Unwrap() error { + return e.Err +} + +type UnmarshalingParamError struct { + ParamName string + Err error +} + +func (e *UnmarshalingParamError) Error() string { + return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error()) +} + +func (e *UnmarshalingParamError) Unwrap() error { + return e.Err +} + +type RequiredParamError struct { + ParamName string +} + +func (e *RequiredParamError) Error() string { + return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName) +} + +type RequiredHeaderError struct { + ParamName string + Err error +} + +func (e *RequiredHeaderError) Error() string { + return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName) +} + +func (e *RequiredHeaderError) Unwrap() error { + return e.Err +} + +type InvalidParamFormatError struct { + ParamName string + Err error +} + +func (e *InvalidParamFormatError) Error() string { + return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error()) +} + +func (e *InvalidParamFormatError) Unwrap() error { + return e.Err +} + +type TooManyValuesForParamError struct { + ParamName string + Count int +} + +func (e *TooManyValuesForParamError) Error() string { + return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count) +} + +// Handler creates http.Handler with routing matching OpenAPI spec. +func Handler(si ServerInterface) http.Handler { + return HandlerWithOptions(si, ChiServerOptions{}) +} + +type ChiServerOptions struct { + BaseURL string + BaseRouter chi.Router + Middlewares []MiddlewareFunc + ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error) +} + +// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux. +func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler { + return HandlerWithOptions(si, ChiServerOptions{ + BaseRouter: r, + }) +} + +func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler { + return HandlerWithOptions(si, ChiServerOptions{ + BaseURL: baseURL, + BaseRouter: r, + }) +} + +// HandlerWithOptions creates http.Handler with additional options +func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler { + r := options.BaseRouter + + if r == nil { + r = chi.NewRouter() + } + if options.ErrorHandlerFunc == nil { + options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) { + http.Error(w, err.Error(), http.StatusBadRequest) + } + } + wrapper := ServerInterfaceWrapper{ + Handler: si, + HandlerMiddlewares: options.Middlewares, + ErrorHandlerFunc: options.ErrorHandlerFunc, + } + + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/admin/models", wrapper.ListModels) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/admin/runtime-config", wrapper.GetRuntimeConfig) + }) + r.Group(func(r chi.Router) { + r.Put(options.BaseURL+"/api/v1/admin/runtime-config", wrapper.PutRuntimeConfig) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/admin/sidecar/restart", wrapper.RestartSidecar) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/admin/sidecar/status", wrapper.GetSidecarStatus) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/admin/users", wrapper.ListUsers) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/admin/users", wrapper.CreateUser) + }) + r.Group(func(r chi.Router) { + r.Delete(options.BaseURL+"/api/v1/admin/users/{id}", wrapper.DeleteUser) + }) + r.Group(func(r chi.Router) { + r.Patch(options.BaseURL+"/api/v1/admin/users/{id}", wrapper.UpdateUser) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/api-keys", wrapper.ListApiKeys) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/api-keys", wrapper.CreateApiKey) + }) + r.Group(func(r chi.Router) { + r.Delete(options.BaseURL+"/api/v1/api-keys/{id}", wrapper.RevokeApiKey) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/auth/bootstrap-status", wrapper.GetBootstrapStatus) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/auth/change-password", wrapper.ChangePassword) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/auth/login", wrapper.Login) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/auth/logout", wrapper.Logout) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/auth/me", wrapper.GetMe) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/auth/sessions", wrapper.ListMySessions) + }) + r.Group(func(r chi.Router) { + r.Delete(options.BaseURL+"/api/v1/auth/sessions/{id}", wrapper.DeleteMySession) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/projects", wrapper.ListProjects) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects", wrapper.CreateProject) + }) + r.Group(func(r chi.Router) { + r.Delete(options.BaseURL+"/api/v1/projects/{path}", wrapper.DeleteProject) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/projects/{path}", wrapper.GetProject) + }) + r.Group(func(r chi.Router) { + r.Patch(options.BaseURL+"/api/v1/projects/{path}", wrapper.UpdateProject) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/index/begin", wrapper.IndexBegin) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/index/cancel", wrapper.IndexCancel) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/index/files", wrapper.IndexFiles) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/index/finish", wrapper.IndexFinish) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/projects/{path}/index/status", wrapper.IndexStatus) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/search", wrapper.SemanticSearch) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/search/definitions", wrapper.SearchDefinitions) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/search/files", wrapper.SearchFiles) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/search/references", wrapper.SearchReferences) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/api/v1/projects/{path}/search/symbols", wrapper.SearchSymbols) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/projects/{path}/summary", wrapper.GetProjectSummary) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/api/v1/status", wrapper.GetStatus) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/health", wrapper.GetHealth) + }) + + return r +} + +// Base64 encoded, compressed with deflate, json marshaled OpenAPI spec. +// Stored as a slice of fixed-width chunks rather than one concatenated +// const string: with thousands of chunks the chained `+` fold is several +// times slower for the Go compiler than parsing a slice literal. +var swaggerSpec = []string{ + "7H3bchs5kuivZHA3YiQvSclu91zU0Q+yZLd92m17JXtnz5nqwwKrkiRGRaAaQEnidjhin/YDNvYL50tO", + "IAHUhUSRlC3ZPRPnyRarCpdEZiLv+esgk8tSChRGD05+HZRMsSUaVPTXOyX/ipl5yfTC/pmjzhQvDZdi", + "cDJ4wZU28Pj3sMBbyBZMaZAzSC9fnj4+WEhtJiUzi8N0DJeIiUi5MKgEK45KN6ge22HfMbNIx4kYDAfc", + "Dmq/GQwHgi2x+UvhLxVXmA9OjKpwONDZApfMrghv2bIs7KvfTv+QP8n+hI/ZN7M/Hj99Mhjar+2Ug5PB", + "//0LG82OR3/6+dfHv//4z4PhwKxK+5E2iov54OPHj3YSXUqhkTZ+JsWs4Jmx/8+kMCjov6wsC54xC4Cj", + "v2oLhV9bi/lnhbPByeCfjhqQHrmn+ui5UlK5ibpQvEAtK5UhsEIhy1eAt1wbDQc4no8Bl4wXYNgVisPB", + "x+HghVRTnucoHn5hp5VZoDB2VMyHMK0MFCy70mAWCOFEQMkC7cJeiRxvUX0Q7Jrxgk3tmTz0CmlOLuag", + "UV3zDEFIA5kUMz6vLLbQshzSuTEefEUfxIKJvMCcloQK0L05HLyR5oWsRP4FEcpCY0ZzfhwOPghWmYVU", + "/D/wC6zhJ661PRipgItrVvAcTt+9gitcubWUSmao9ZdBk59YMZNqaZEVf6lQG5jKfGXXtvTLrLF5xrHI", + "9cCO4Ye1s56W/EdcEXdUskRluGMSmUJLGxNGK7dz2P8NcmZwZPgSN/nMcMAJ+hs/F0ybSaW3DyaqwlOW", + "Y4NbRuGlHeUOH1Rsrw8cX45sQN4IVHYoNenZYqlwxm83r5FzrsuCrUZSFCtwL9l7xHKZWVUUFmk8M0wz", + "fjthj6dPsm/yp+nhOBGvpZgDClnNF2AkKMzkXHCNwAUUlo0OQS+kMvU7C2aAm0RkTFjysB8IbVSVGZpQ", + "Kj7nghXuQtrYgsJreYXt7U2lLJCJ1sPPOMCP7ZvuLxZV1uHqD6AG5rCNg836fq6HllN71drlOSQ+c69v", + "4jIr+eTKIfk2IvOk8HE4sGcTvuge6PsFQlkwe9/fGjq+a1ZUOIZHjy7QVEpgDnjLMlOsQIoMx48ewaWR", + "CulkNGaVwmIFf/vP/7FnYn/WICTcsJU7Y6M4XtuXoWAGVfSs1kAZdtdadj+MXnNtLrww0Aso+j83uNT7", + "g8zPx5Ri7m9pWNFCJguxOaq+1etB+CS29mdSGm0UKy8NM5Xu34BAzPVkGl6PnJ+qEG4WKIgkLOppMBZt", + "7UHgsjSrcQPwmgDW1rw+S2zJZwsm5viOaX0jVX7hmHOEzVZKobDipHvR/rbk4jWKuVkMTh7H2BTedF5f", + "v50EX1ZL+CNJrSyz0u4Y3kioyhIVTO2dabfYmuSPuzBsY5Fri4jun4jR4Ufv7gPH7W7hZbVkYjRTHEVe", + "rKBgUywsq7sRlvXZc8uZXkwlU/kY3rdYaSKIGO1RzlGgstzACysjzXMEJuw9GSNTorOtgF/HAbv0/o17", + "5aJ357UOEblO1mZqXu2f7oNG1TsXydkdvu1+id3gghvOii349VY4jg/hFToQgTdETLCstLGYJ+YIUsCM", + "1KhCzrkYJ8KeFcuXXIBeMIVW2uYaZGVGcjaaMpFvHMMfYxeVdIIVimpJHMSOOBgOrjneoGoBqQeeYfMb", + "e/VDx6B8jjN6XYpXBpcREIt8UnCBMYY3HMx4gX2HPRxccdEnN4l5xeZxmaR/tl4xpmRExb3PNZ8LZiqF", + "u3HS39S09Pb+/LqGDUBa29gO2F70/VTo8SU3Dn9nrCrM4OTxMeGWZY+Dk+NhBHR6tZzKYicPXgOG/2rX", + "9vruLIW6Ksz+d+4aLm67e7ftdm0TYRXbruFzrp4Lo1Y9Z5TJyuk524G8H9fz6NQaOLaiWvXtLidH41ne", + "9kn8e7GRX/ACf1CyKi8IMJtzTFGbic6kI5eatc4KSeKqH1BUy+k+TGArrS+ZyRa4P4bYtf9kv9lEjjUA", + "tCm3taFmyj7QuOE3xZlFJa4m7ovIRlq68Maz7SxUoLaawILfgVDe0DcvuYnRyB1OThumzJa1Ofrv46vr", + "zKIZrMMlA2jCyoZtWPadwju2KiSLaDwtQK8Zcd6/GP0RrPIyhmdcMLUCiwPayldVkZNdZYqgq+mSG4P5", + "OCYl+NEni6jp9PLl6ejJt85ymvM5akOmU/9RGh1xK/r3Eo3m/4F3ZHMe1xtod/bih+wDt2MFcQlgf/Je", + "sxCgwczKqeGVIUgFVpkGPoNK5P75+M4qdudW3nYH261dIlPZovcO3rxMn+y8TH+pUEU06Mtq6hYMjsfk", + "wOaMC20grVecju8ojbu5dm3uvm7gNVz4gjfwS2SF2boT5u2Ka0BHA2SDItU31aRGp1ZRSiuxoEFXccp0", + "r7blbXk1GA7qr3bL236E2HbIyP0M53yL9FcVRQfxZqzQuG4G/TNp9JYo4IaXqJ2jwSKZd8iAXQXCFGdS", + "IcgShX1oVReNWnMpetT+rUvuPYVK9BkKtZHK3mNM+wud5TnJcqx41xlj48t1u28JMyWXxL3B0gz87b/+", + "GwLvlTPwSnuxGrk5wXO6MTxflmaViNoKEkC0YBoEXqOCKaLVtXO8xRwOpILUHgNxnRRumCblD/PDjnkq", + "wGgdrR0w1rfeiw5nTGRY9AM3o+dF3FK5brio3+2dztKy3qp73I0vhCuZxLbbV+6zb483WUSDJHdhdDU0", + "3cp2basXiFa20JOssZhu5+U024RlGZZ3eN97QjCffAo/XJtzuL7ovlm2wERw3X/H5ViglTEtMXXPfIMW", + "P/EsPWefuHXnXGfyGtVueMZxYOc+7/fwazDv/mDzzrDEQtDd+7rYnHYDAXoB8E7JuUKtn19HZeC3AgHt", + "o2BOfHP+vy7fvgFtFLIloJN8YbqC9N3by/dwRJzwiNaT0g2aCPtZVnA7iEaRa0hPCVFPoO3kux2J/K9a", + "itTZKVOaNXWeuERYBFB8yQUz6DzP10xxJsx3IM0ClffYAVMIpSyrguyZTIPCAq+ZMI79rqmlVqiaBMl4", + "82wcDLc9ayPG5ju4nGI+cXRRq05cmN8/HcRQAcMRBEwgGY+UoJqEJzRv8ydNkTd/55I0JPeMFP7hYIFM", + "mSmSwua27N9yL/wcob0Z63okWu4tGppOud+A12V/d2B5m68uUes7KztbhAqj9/XRrptC6XR20tErMZOb", + "ZBSeQumuPIfjLDP8GkdeqgoYDRlTilu57BpJ5cQi/85R0YJbwYBnrBjNWFFMWXZVf0Uia/g0XYNwOkyE", + "/41gnQ7Jvp92sTiNEcldOSAWrLRnqjGTIl+DtqysStZj8bkLm/8ETtva/h6GtwXTHcu5wgz5tUWM4VYO", + "vQX5Pu7Cnf5rqPRv7JKqNlGxc8V0kTLleYEp+VeFDLI9YR0cQY1fVRPJM6boLRdr474LHzlMts9r2KRH", + "aS1SpkfpjHH3H1UJUX9fMG1GqhLg1ujEdDfHRFVCe4wMh2AXTN4It4bOUQxbEqxlYNz9x0/3WarXa7lN", + "67qDy2hvz2WPG2arF9Gvsg+FKo1qF/p80BERij6MTfgTbvGOV2YxWaJZyIhf7D0Whe46J62oQPe4kaAr", + "NWMZQjIo5FxWJhnAgUe0Q5AqEQuek9v/wDvEwd42WjeRAr/TIKRZkNoqoZBzkJUBOTvsopMfdDCs4wJi", + "9Px5gBt2QBEFo8yx6PEV8Aj0Xr4AhaWEV+eQo+LXmDuyITGLZRaqXGFmpFqBYEv0QTMUQHK0tJMdjuPI", + "aSIWytOplkVlvN5sJE0zns+rmVOnpYCc66u4PYT/B06mK4NxCegOYjypcd4+1xq1F5yveTSAwEJnknMV", + "j1U5e/Xvkx9++PBicnZ69vL55PzVhYsTskq8zpgQmHuDAMUUwQ03CxBSjCgWAurR4XvLTxsYaRd9FwUR", + "ncf+WnMLV3a5K/zIw9auY+BqDP93dVBsd0L85nwGzWbC4mLg8LEIMWAouWSTOJFcoJaFJUR6C5ejuYRM", + "FgVm9oUWPc6kco58b0caw5sPr187S6MLWl2W1X4W7GFY0h2orGfItlojhWFcoOrZ6TvLBbigCBFiOOF9", + "OJAzgwLwl4oVlk80kd9xv8gnxEx2AkF62BQR3EobXDqOJZ3aao+SGal+p2HJsgUXOI7HdJAdb2JJe0IU", + "tDnVc1K5yChvXwCeozB8xlF5MSjETDXHTCzEyjqJOFB46Gfxhy8FKHmjHa8pFY4sDCBXfGbAKJZd2an8", + "1ZaI5sa0GrjRbgymIRl8EFdC3ohkAIq5u3TBhH1EY7mrb49IUOf9uKNVhwJIA/Q+J3TVHlqPsyyeZ7CW", + "ZuDEUhem9uHidet0xnfKBBgONBrDxXwnT/Ys4zK8bj/9peAGdzGLy399ze1JM8OmTPsb1nGIoBs6FGsQ", + "pT59jy65FL8zgLel1AhWN2RzBC5mci8G4pd5rwzEitF7g4zejRvBasNlS9j3+LXVclGV+R35SsTrGTyc", + "DcPZ4IxtSmnhSgDAsLHNdSJzW8vbJJotF9L2WNSQSbO3HBGuuXtyx9Xzb/PHrdPJpiJ1mxVVTmRjifSO", + "HGjJbifOYHZ3T/fGzOvDbdtPQPg1yd0fa+0V2W5vcMbuxuC4z9t3GtoJUfqOgGlPNFzb09qi1yfaBrJq", + "uWQxdWdbpOcnX02/nRtFYYbCtI9iL2K9pPd7pP4284y4UMpJED75HZxzdfBaH3/47WFqH9uu2XCbXXfR", + "eisabwJx4xxjmH6BM1QoMoxHwHRVq8bG6D+K3my9cUqnxQ1b+Yh8b5VDQJGXkgsDrXejIm9bjYuPGyT6", + "tNGtUjhQOAvpAOSt1mDkFQo9JEVGMTFH3Rb9947x3RrfdK+6YjvqZ3esWVeDbM2zI2SoRoVPjNrdjCf6", + "9ssH57Y2cV+RQV0S+YKBQRdIh33aclFt7ISwIWZ9e1uyXyqEV+ffwawylUK4RqW5FFaxXAVRvEQ18qNA", + "sN1TgJpX/3nMGrS5lbCK6C4qYeXZM0pzjVmlvZbap8a2zIhSAevTn40E1rJlxSMSC7Zkk643tT6zxzH8", + "dF9k5vZO74vJvKwmBVv5rPTuhkaP4XtgRQHuBTj4CQ0rjs4+nJ8eDuEYvoezdx/ITRbnSmEOs1DI8sgE", + "dogCDdCLI5/YyyojRy7wcDzYRZZWqGwOJpPCBR5lq90QUJjJ5RJF7hB2K2G1MeOi9Z1lDJQSvC2YKlxG", + "+ZQY4fWgO3fsZlozEaEakdPSZ1GGpCS5ZvHPmACFRBMMksH5s2QAR4lIBs/Ftf0vJIPW4pMBlLwoQOCt", + "sUiJLFuEfMIfcaVdhKSzkbQiAsgCrk8gXaOHdAhpFwnTIYzH0SCtdaUyFk63QFAO7JOgC4KSN7XhB24U", + "NwZFE7FKRiJy2qK4PmqBmGIYuACczTxSfZolJSx6uootWgLXukKXkkQrfPfh/RAyVlqm1nIpeENEK/Tv", + "bqG164xog/ij1L1JjtuoJ8KCalTfyTsvupS1k43uxf72YXn7srm9WNUdmc0uhfjrHNrOs/pAOB0TVYsQ", + "ASRLx9XGcIkiB+aYBPkV0RwpLAuWOdu1vEaleI4wkyoRZE+jMYYUpgRpMkgGKRz4CGw3/KGl3/Q4hQNR", + "LVHxrP7dyEScvX5+etEd+4AYloUGudQ1kFPdMjBxDUfQovvDcSLe+ngqv5crxNIOx1UIUfUsLxKnEcHU", + "3cbeCObuNvFtYvK+36xj9v7ftTB990dbMX/X57EojUtcMmF4tiPy35uRIqLDs4JlV+Q0tPpZrmQJXlKF", + "m4UMtl+fSARMNAUQFOiQBGB5710s8p9myI+mAq4HVN9S3rRz4YGcwYtXr5/DXMmq1HBAjizSpg99on6l", + "xB7CERdNjlg8UTuTmgsEzZe8YIqb1RgsxZDR3MtjftlwcDx+6gj7TOZ4wcQV+W1G//rHQ88ZLBXjbVnw", + "jJuCSgrknCqRuJIThZS+pMBuD2YdBrt+y3KD9akTMdOF/9BHX2eT3E9ayDr29ymANMKEZKBlDBqsKEZZ", + "IbMroDepaoPIVkNQsiLBx0h4DDlmfMkKID7dlX56o8c+JSmlnbD4QMrncA0kceC6GJR7KSqDtyVXqO+j", + "EA3XE3/l9BSGCI6qEAKWMaVWLlGE61BhJ5Yp4v0eGlHcaaHNV3cpakMf7FXUJhZy0vHdtKC7tocOuLac", + "8nYvjofkHQzDHnc+o6RIPec2g8klzzFj6rI2NK+7Oiazgs8XZpuv/JcKK4QcS7MA5orsLOXSSjRyBpot", + "y8Kzue2XBIEdQyZzPJwmHiscM+Ych8gLyBa8yMFHkwLXwAqr9Ry4OEI4CndDfrh7jVS+ra82kLfp9IOM", + "iGuK5gZRgAujtiBy0fXancRRsC25Ih26ZDcCfChkT36Ws4R3zc0+NNIbP91//cjujzqKMuy+x+Xq9d46", + "4PcOPNOtKgBt2EKmKCbuqGnjlNVJ8BlP/iqnkZvorE738iDohJxSNMbuU2Yln3jTX7cA4fXjGPeyYj+K", + "CA4+cw/aYSS+ytVcpvHYmd22vWo+t9t6YVWdEKUShmU3ViyxmHS0LhpNjkc//PDhRc+09r7Wpr3p7qyv", + "6TllXDDdlL7z78PBDTcLWTnaT93Do+vUizvDRLjlHY+/HT9OD8fwpioKsMpf4QQy8tXpikI9Z1UBpSyK", + "gPSo9wxvIWBMCsm8tr9hy/GBM9i18nm6I4upMhpchUa7IS7g2+NjWNoFvGCFblVMCh9xDYGmrFC3YBoy", + "xfQC8465qUWqbX/+GnewTBoUzrk2qDCHuojmHmyJzmVSqQjG/MDNy2oazg5KNnfOTnvLp92DT/3R0D4r", + "F3O0X7gJwbKNP/tl0PaHeUw6RSa3Va/yk46yBWZXdZ1IexQUmwmswchHaSICHKQADxk7NZVAEngTQqu8", + "1U+E0pNUg+wFmR25Bul1eUvWVMiMFtNdCFU0M3BjuWEiDjQaSM9e/fvk355fXL56+2Zy9vL52Y+T529O", + "n71+fv49pfOmbU3F0gAX88M+RPKzTWi2XeLEv7mXz+y7/q7vTTgL7GzjVLuMcY3ghhHDUit2JMq9o9dA", + "yyN+bzVwtrkd9/Mnbqn0s81B6HazrWDC/y+Z9Iklkxxod5ht7DSfbSW5Q42He9LKO1u7L6fsBi5+Qb+s", + "M+7uqgb3yWGZH3un3FoRrhZ9ezw/VEghFEgkp5aQUEgxd87BunTyGC5wVlm5yJubvdsFBQ3vi73RHWGv", + "ASNp6D7GHgq7dVf0Bm+oEHOtnNs1dSaG+Ly+woGfOHXl4daSr/apHbcJYJ888/m2jf5zaG76NLw0YYYq", + "dmg0Yzj3P/oSlq7kayLahwPXnDVV+t5ehCrFfeBvzfPpoc53qTUYZ+HLSpuJqyDYKUPYjy97H+Y9RNJy", + "d+G7LdECela8LUY2onl2sWu7TWVLZjFhw96M0U71Z24Wdczy1uQbN/ZWZtcZz6quRfF2Njj5yz6JZsMe", + "vTdYc5rycmuKr/0Z5MxlLZE5Kw8GPN0kpxDX2EsBvsLVfpP5isSBrjSlo1HdgDvMSMYfKpAZ9cT/JEn7", + "zFyhAW+VtIhl/2MxVhu2LOHg4sXZN9988ycrNL/xtaNq/t3UdSnkfI45UDHOT/TBr5fvjR7SBiA3seXn", + "j8NBRDiPRBVidtUTpvDa8nxSmVuQ+PD+bAgXL87AwcPpdb7uT6Nz268+PQzB3zPble0SFZc5z4K2RQvl", + "OmhXcYNWbQaM7JSegS8eMAxHvGxhCE3hDFx+41IE88InRDmIPi5Fim9WKW5Wl5aIQ0VEplCdVtFcJkcj", + "vnAQMA3pqa/ZT7h8As/oa0iq4+NvMqsvnr57Nfnx+f+mHzAd+Kr1BC96tYHfwpjSFcfn0UoFL9+/f0dU", + "GoSFNOO33gySgvauIMhkjiNS1CBnuJSWSlzRWqvLgkMVe4LTlcGRj55mmZJar9mF9HdumpbamCbCBe9w", + "AekRK/nR9eOjUIfL8OxKU8GlEkVOZjyfNt7VREP1EUYe9xumcj3iwrJUZrhdja+8WzCRa1r9P/0TtHpd", + "cCloSzcSSqZYUWBB8hz564Ibf4Gg2RK98c6snLHtxH44gkePnil5QzLHURP39OjRSaiV4ndmRz0itpa6", + "nFLX7ONfEgGNTELROhqYgJfGlG+p2IOUV9wdUGAqvniKf0ICkDB2HFYZuWR2YwWVcSbXohV5La9kSxz5", + "WC3vt9FjuAzXgpJFYYeYSWWhCI+fQs5WuokQInEyOHzcxs9ev4IjuDz/kXa7DXs98/OYa8/M8x5LATdM", + "25l9pFJTZCYAruQjyzhTHwLGFLo055HOZGlJR7gwsynaYcIdxEXOr3leESiCUZJRtBWZ6IgruYI1DjHe", + "VdOCZ3VINbm4HS4EFnB4AukPz9/Dkav0lg79n7nMNNXeoL9kiYKVfLxiy6J+pY0EdZn0kcd2+2kfrtgj", + "It3GmYxOP7x/OTl/delMRa78mL7ipXYxcc7e5Os7rJrw8IMcr7GQpXPFCF9vn8ENU2TX4trfhIcEijra", + "LRhGDVNGO7Rlwsegd0rFmwAknQha6LO3b99fvr84fTc5Pf/p1ZvJ859OX71O4V8g+vTd6eXln99enKcu", + "ggdzpzq5m8npTAczqTLnPvY0XVNNt6z24RhOocA5y1Z+LZ5vpqT5SAEMZgr1osnJ4xr4spTKVxNioLmY", + "F5iIFMX1qD6vNAg2bbmG+QUG5uI1UmB5rpAajhBy+V/TOmshdUE+OiTXgi6oDpwb0nesmCKE2j9g9bcP", + "F69B49weo4bMXpHFaghaBgNxIIkGiQ27QmCQ/mrn/JjCh4vXiajbPvkWGa5Mw6NHs/16PD16NE7EmUti", + "tkdPeLGj4xPB5pLqSRHCeeuffdDF/fD1kVtxt9TUQgpZKbdcX18qhQWyHNVJIjQK8kJurzwF+oa7MAzX", + "2sgpFRQCnQiBNwUXOMqRjD9WcHY1sCwcNktppeAEAD30xJGItC7ElPqaWo4WHx+D952N4W2RB9bjToBC", + "0YQEt/BEuC25QoPrPXLSQ5ij8684LPfYOqKSXWE/AeRUD1rbP06LwgtMde8rS8PN9UZ9cvSClXgC6a+J", + "rwWdDE4gGTg27iUtx8aTwUd7sB2OGFDJRbze2s1YsdznNUNdI7OuZ9TEJxerRNSFjX5NfOFON/t4PPaz", + "WRGHG/LANRKLJctBbQZ3zrmPw4FnxIOTwTfj4/E3g1YET81oLeUeNeUZ5miiIS1X2vGtbuGItNU+QYMU", + "CCiMWlk5tx1MDx+0ZWjELVqh0b/TUNvJR859V/LsyrJb6ViK9pm/C3aNFHlopTtoQvqt3AULJtYKVgTm", + "7cqE8FbOUDuxvBunSCwRR9TDpXTZ/2Xly8ERO9LeSOVS7LkUr3IrhXNtfgolKDot1Z4cH99br6em2Eek", + "39MZo5K5DoAFvTQcPD1+3DdovcqjTpMs+uib3R81LdlI5g85jgQJsOjhV+JKgmRucb58Chy4q8xSx6HF", + "ZDbXjZnmZztgFzF9sPkoq9M/ogh64THQ8zOXd+6/9R3S4OD8GYWq/+2//puCUu2/7bBUJz+0nJl1tdRW", + "j7VQmHgIZVFpcqdR+HUKS1a6DICCmDrF7ZN0/zsdEgS2pQbYByE5AOrcgERsTw4gvtoKle3i5g9outkz", + "D4ih3YkiWPrcCZ7XuHYuXwdZL5DlPvNgc0m7sHQ4KKsoElIsn+7NkhjDCx+7HcKfg2rhtYpEWIlG+VDo", + "Jrb6e+JV/SHVlrwIJ35AY+XXc4ka3rx9DyF+pu2mD1dRg4ZB5wKNVi4ymAgvkBANbgTjzAzlsrRiFN59", + "eB9DwHdVBAFpp8+kCx26f9zzofMfu5YLqyd8/Jro75aVf2mkHw6ePnmyzzTtDoVdUrlkmwQSUFPfmaGv", + "IRMZ96SOUNO5soyWMBXXousOvjnWZN6TlTkcgkHVLpjq2bZVBVuxbsN2DJlX5JxS74J5OvsbJyLcKE+O", + "nwBfLjHnzGCx+s7Z05xG29mQr+xnJMgpCWVOgQtxE+62qeNj6E//yCgmNMmAY3glRi4srKUfTEPM9Ho4", + "YSDIG+5NfG5bz5W6rEpU11xLZbedCGrBNLV8ZpQrfo0CvCwW6gXBQZrxW1DobF1O2PWKiLdZHMYo3OeY", + "+sjJzQvmyf1R2Fo2a7wTqGNQ9TtfjMq+dV88bGPPOspU12GaFimsdk5cPeADt7xcyJEsN2695jqIxn19", + "KjU38UxePNsQRLqxtQ/IibsTRaDonoAWrNQL+ZWEZb/KOhLXc4+7wr/27UXBbiXyD95D92Dw3vBNxi4/", + "jeprayZWgHIGu93SXfRCanWqQ0MW6nS9XZxTh30jO27W2ti9bzfF4xpmBSPXWxpzFnvLph2P2PsUE7Fh", + "/+Nms6HeBotuugE+kPi12W5wL+Hr8b2iYFQx9sW1vqCwdfyn3V/UvdbvQzp7Ja65QcvvA2Z9Eg85+pXn", + "H5uOBxEvN9MZy6n6Se1F/p1unOoWUYPTO0Ti0MtuwL5AoBjCntMXNcJ2kOZprFuSK4z8JU/56e4v6gbo", + "3fNyqwW211lRsKGzU2sKmeB2wz5E0AUguuiTLq0NW3Sz7s79mWyAWbReX+vMltIgSNVJFYyEcflmCa6Q", + "Ruwsm8CzB2I+m5FtX1jz62M+XuH77aLlPTAf19DYheI1yJLTzXYXPuT9m1sFGdc2WA82aGKt2DsrCldz", + "nSaiLuvD2kLtDGZXuNrA3FOxcoW0sdBIbodKaDSH9afOnlwUxPaIyxG6E0W66NWaJMk3O2hTYR2OVhSx", + "gMKfHxA/Iz2+I9j6I66+toC2XDVRUxb+zDVw1sBn7iw7WBRQpl9ea9uEHz2qG7Q/euQ6V02ucJV2Gj4H", + "nGg5kN537GR6IW907e5jkMlyBdPKGCno/mOQDFzZo8YHlDi7wkpWTo7TiC4UjKy2ySA4oMdw2UQqUA0A", + "/7nDP+fvcylEab+U53uvP6Sc123f/YUlvW5T/x48zj5X7PtsmUzrKohkHqXjqBvhgTsFMYuSxGC89+Ba", + "XmEwGN8IL3+dCn9Bt95hYpWIK1xZ6exaXvmghxLVktnN1XZhJW+sOmoJz6GdC3BYMnWFeSKcq9vHmFD8", + "sXdrsCrnVMmZU0hbqZCMC/nQkkgiWoE4PjCGIkuYMbgsTcsi5+qYNOasp8eP45Ynu4Ia4R9CUNote7pF", + "/L3InhcBEfbHyli0zk4vXPprMhCIuZ7UnyaDE4rz/5g23tlO+Iz30W7wXOceI3Ubb8uCCUYF5nWmXD/C", + "xjsLB8mA6StfGivYNUmaLQvpIqAgFnrziBwq14xmyS3HJStZMjgcwxvZTm7gUtShUD0Ot2dhxw9v6Vqb", + "atv1Xr/qDU2dcM3ByV9+bqNJO2C1OQg6UGdroE429dHCQUlxY53ruTKLCCY5s8WoHcIfv7v/DRWfURyE", + "t+Y3JpYhuLh5UlRSgTftR+Q+04mImlTS4AOwVBBkQRcFF8Ko5Ywu50Q47cw0MYatsg8hpLLeR3DfWSy+", + "ougVyqo/HEPtiDOyyhaNfON4rdRIsXyxgL3oHU/TvmvSCR7klu9Mcqd7/mmsj4IHUfW56tA96SotD1Gw", + "YbTyM3bgL9nY+rH2bR1YPXQ2wvQSzeiMEOgEWuGr3zv/Cs+da+W7Otb1u0RcsiVecoPfX1Im7nfwjpnF", + "90epvbYbgZbw0zdZ86EIfVjvtDGLcTfdRK5WJIxUGdIQ65jt+ayPlWciEAyjjh/RgBiC0cPgZqdB1RfW", + "87ttpyI89nVIpHCtCHNvmW9QINaC2WdvOB5zENBgCGtYcDjYJqp8/NJE1XNxPL/1dmkf2N3Ep84kBQys", + "bXfve8P1x9riKyZZWbcCdkfUuSVMaEVay/q50EZVmXFvTl3UOsWVubiLTog55cr1UvB38BO7HZ3O8fvj", + "tIcM7JL34ZEBC+ripZ9wlh1W91zkHT7X9P/aAWeX0bwzwoqYDzPGhXZ5g3C3fmY3t/CVcAXjoIdDbQRG", + "XQmraTe90hIxZwZhVin6QbBrPnfi2BQXnFTvOOfqkdJ+wgeN1sNtfOKsdfvcx2mH8dp5ni4HdPeBt0sx", + "bT12JyxF0umcyBRMY0MqG6HNiOREFxKciLRdRIoq0rZKXIUWne0qVjVGhFzjROhSGqjEjC15wZly7i7t", + "e+g2Van8bWeVVd0u2+UiazfrdvVFdK4um4JRD+eqjlTLijmsPaQ/wz7XQZjTDqXq+gTbeLk35kTsFTFv", + "Tg3Qr6aq3weX/Tz127JlKdDCe7lqwH+g+VxQ48aQdQE5XvMMt1+M7do5vUbzd03RkQfD4ljnnggWh/yP", + "z7Iyf+vWvf2jVz4NI8TRREMBIqWFWuCuf2qbl2MG19Bg6CEtrmuVIr6wybVuodR/pJ9tcHVe84cNnjpt", + "mtQ5SyPXnVwkVrhiV3jLtct8/xTp+B5Q9MJjpjcglzWGRZAzwg981tA2E/Jp7Rkbw7mSLnWuBg9pk9xo", + "8H1fhqBwpoeuDeqCMrSGibB3dh2Xqcdwjk60tjcLClnNF84y5wovhKysdrhAImpzCIUnUjsVCpvnpj8s", + "oE1we0YGUBrjVOarw9+yM/az8aaOLAgHSS6poqCz9C2tKOGvzzPbYXp9cXy98D/+ghznS13f93AqP1DC", + "ZUNdlK9E3Zvid01XNorN27wSIPXSDrglsqNN76FOkNeXqEwM6IXiwqV5h7Dj0J06EQfrXeOG0Gkad/id", + "J/IWHU8RXNiITITmhcuiqTPpaxTtjxh52Hs1WoHpC9uTtmB5yBUoPxvbf5MhJPdAVe+oCUqgqTrHZjdj", + "678wfZrtFIOJ9/MocWtIAoNUVWLCfcAoRfWz0ioGdc7ZiJqNUb6IxTV/8SbiIHUPJu6H9DCoyi6blsjZ", + "d1cGBjkWho3hHdPaRT0QWqeJMBJueNmwJSpPG8y8gQeMwVId1XgMzSYiBEs5wc/w4ay+zQQtUn1I0mxP", + "uFstlyWKL6dRfilpWbRuAr9RqhbthGRv7Ftv8/1lOUKddbHrKyv6qA+iKaLaZSZvSxTANjfc4iB1c949", + "OEjGROaKFT8EC6HFGkmumE2LX+MkSn9NBm4lBeYt7zufAUtEONIbpuGK21eGkPqyq5wqWSE9c+fsrGxn", + "r1+RlU97FykXkOMM1YiqMFQlFd1gitLeuaGaDHNGyU4uTN0X/pNVkUOB7BoToSoBhcyuNFhhhLrPSFVL", + "E01N5MejhawUvH//upcBnTmoPzRXcNNsNe86oIdggdB34e9EXHWrd9jlaHyDDRzwHJeltAA9/EQSqfuk", + "PgSFXKLI7RVLaXP2TiXF1ftKNUyxkA7XvOPC8u/6Ph4nInR9+fbYp7CXZIMuCioo8ehRU8JD4FwaTif9", + "6NGJ76a0vfKGFYgVZmghS/r9J9XaSMQB1Vqg4hol5dYIbFLSu/U3fOWNwzH8uS5MzroVNlxMV2zlvtxG", + "p04I96V2IrU33KJfWLAFGkl9BC3mPnGYXG/2bBKxVtU8QtYvfO/aHTG/O6qcSGAespjX+/BAjMI5wPRw", + "DOeu8u1JpAxJKwLYAbOxYDtYxmOA1znQcBBbf2+c8AMJWP7QvooutIk1xJaiYGl6ELgyuXSs9L+aib05", + "J2T0tBQhFcu3KMxwcDL4NRnQw2RwkrgSzBT9ZS/NYTJwbIGeqdFj+skyMvphybgYzyX9SB8Sc0sGJ4+H", + "yaBpNpYMTp4cf0zE5kTUPMpPFB3VdZeyIz6JDhAqI+01wjBxVcknS/v3t0/ja8qlwE9aUM106EWj6ccn", + "x09+Pzp+Onryh/eP/3Dy5NuT4+P/kwzWP3WwqmcmrjsJSbwEvnrqibc1J4OTb57+oX7ZS5OYT6gSqX16", + "bPfnbrf9cbDDBqIpuNyFvwRPjUM0h3lw4KtkU/M81uLlDiETQVvWcNAUqHFKm7QbBS5cyMHWG4SysD9T", + "nnhY1SF4BYQ0vunA2wtwdNT67ahWPZdcU1ewr6Q8PCwwvPJRp8ZQX9Qf3n2oM66nlV6NgcrN2f8OIb1A", + "o1ajU3tXpvUt7Wo8h8QDXc3nqC3O3DBu4MCX1fIZ+q3go9ZY3c1slDH/uJafXE2X3KxLURoOluwWvj3+", + "dMFPcL24P8kvKjHQFA96U9oZvu5V6Vaw2ziRyaWrNfP3yzN865XfDsf4THPDGR3JmrH9sywOO8Lyibmw", + "jhmHVLuTOrdtyXOK6a5buPu4nXLBNKZDSN0tm3OdyWtUmB/VF+4RXbj2ne4FTSU9sWClvZQ9fwqhPkHX", + "cmxPyMjSEtGtzrZe1Xi9kVVI8aPCppQ3la5JBn6hbgVrax3Dq1nbB5oIqo8tYcE1pRswChpwRQEdtElw", + "4XmBTVm+CDN6+CSAjtiyI/7CnW2IGraKn93A4VcJhnltNeAa39ZCkFTlGohTxnFQEqmgW5xCPs9vtoW+", + "NLUdeShLBdVzcc531ymU0hMqco9b6U/JW75kBkEgU6jNSCCfL6ayUuAWlghfjq6NvL/TkC2UXOJyNJeQ", + "yaJAF6wNF74fK1OYCLuk0YwXLgZmuoK0bkxrqZkKRaZWVPW9XYe+gdno7cWo7teaCGLEh0NIQ1PgFA6m", + "oQvw0JXVpHe4mB/WoX6+ZW/qSjIaywaWqFz4tJFWTxuR1ca32iW4MKsr2YVOURvfBp+WS3aZ1urr6t36", + "JBEAo7rc2t/+67/X2+emx+OnKRxkrOBTRWbUmVSw0UrXjRO66FJLXVfQiXIzycjisofZVF4jvHxz+WfX", + "WXftw1JqTlY1+7XrxO3eSkTa6aFKdUS39IuNMJxu+9oHEoDiHaK/sAzU06g3xvQ6iEQBKL6we2jU8+Xc", + "Nv9oqk2kGtUQrjEzUgH5KK2cZtVkYuVtfScRBy3FxFcvtvrNTgVmXcglscLSB+lBtVrt7SKkNtkJY9kT", + "/apPQJEDt5lDz2xbV4//Yato5t45ynFGVYJ8kPVDqD2ODM5bEz0M7TczfCW6by+gn+Z/8rcNtEH/D0jm", + "3TAjOTJy1OzY3pMufg98k7lPwN17dtPEsDbY9x8CX+3YX/Weai9gD3z1fiqz+MdHVwuZEVXZrkXJz+Ky", + "CmeoUGQP51Vs5z8V0qGD9m08UkdpqZXZkdLISYJvdTo28opykVKPVyTecfqvL/3uS5STfBy6PsL337vG", + "E/SXF5ZLWVaF86trwcsSjQZahfOse+wGBrOqcEW4QeFIIcutWE3Z7VVhvqur7+sFfTeTRSFvoCqdjbGW", + "kxyAgWrms9w5/mjQnCvMTDxROSB9fSgPVPc3TPCV6Ls1fz95t6Dwj0/VlF4f9uv9rkQbn0bWPgL9Ya+g", + "Sz/JAylMkc6sX1pdinVQ3XYRBbD/o+OrA0xgcdMViUpw4OwcR/XNdHhX5A0T/Loriv7Sv/nwYcZhppir", + "IDz6uwlSCt4CeY3qmuMNHBhZ2guJclVcX8SQu0JWX334EPH2LRTYszCONz4t0bCcGXYSesMN2x0mmmrn", + "1EdjGNKgfQnNWNlmSmhl2YJi7g/Sdi/y9HAIolpOUYGc2dt/I+3NGeXqd1ohyKFAee2m+Kuc6p6M6i9Q", + "2HlnlRtf2dkbuO8jVfbSwfmohnRdp7kdermGXVP0/MG1+tmrXFLLqSCvkkG7TJI/a1fJi2ULuPzX19wg", + "yWlcwONEOPdKE/v57fE3PqSrO3LdfMiFtoT2QnV3Id9J0E56/gxK0kkYL/QYfGe4v/3n/4CQa43uQvup", + "XZWRXjpoPCCGuBm2u0UJltyKzASJ+7aW3WUJTS+oAxzPxxbmlajp+HBrqY3X/BoFeXMsvsVKadSI2B2l", + "25LzLz9b6chhWCyy7rLVMtHivBzlaDDr9C5xHdnUdZ1br0uklVSqGJwMjkgA86va6MJJAHBVsz3x2mXr", + "JpDObePj8NfedOIZZqvM8r2ziw/nh50vHZ/f/Nhd/MOWhWjYyK0u09FxxTU1qBnc/7059PuFQhyR47Th", + "m6WSRmYkBYcM9+C82hzh9N0ryGVWLVEYQsHmq1xm0e34rMqhq4rgy6UMm/IrLtdruJ7i70el3PLIOuqs", + "MVeGYckEm6NdVetTKua6+a2vgFhX2+q2q6zzPsnX8vrV0eX5j3aO1rihGt3Hnz/+vwAAAP//", +} + +// decodeSpec returns the embedded OpenAPI spec as raw JSON bytes, +// after base64-decoding and flate-decompressing the embedded blob. +func decodeSpec() ([]byte, error) { + encoded := strings.Join(swaggerSpec, "") + compressed, err := base64.StdEncoding.DecodeString(encoded) + if err != nil { + return nil, fmt.Errorf("error base64 decoding spec: %w", err) + } + zr := flate.NewReader(bytes.NewReader(compressed)) + var buf bytes.Buffer + if _, err := buf.ReadFrom(zr); err != nil { + return nil, fmt.Errorf("read flate: %w", err) + } + if err := zr.Close(); err != nil { + return nil, fmt.Errorf("close flate reader: %w", err) + } + + return buf.Bytes(), nil +} + +var rawSpec = decodeSpecCached() + +// a naive cache of the decoded OpenAPI spec +func decodeSpecCached() func() ([]byte, error) { + data, err := decodeSpec() + return func() ([]byte, error) { + return data, err + } +} + +// Constructs a synthetic filesystem for resolving external references when loading openapi specifications. +func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) { + res := make(map[string]func() ([]byte, error)) + if len(pathToFile) > 0 { + res[pathToFile] = rawSpec + } + + return res +} + +// GetSpec returns the OpenAPI specification corresponding to the generated +// code in this file. External references in the spec are resolved through +// PathToRawSpec; externally-referenced files must be embedded in their +// corresponding Go packages (via the import-mapping feature). URL-based +// external refs are not supported. +func GetSpec() (swagger *openapi3.T, err error) { + resolvePath := PathToRawSpec("") + + loader := openapi3.NewLoader() + loader.IsExternalRefsAllowed = true + loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) { + pathToFile := url.String() + pathToFile = path.Clean(pathToFile) + getSpec, ok := resolvePath[pathToFile] + if !ok { + err1 := fmt.Errorf("path not found: %s", pathToFile) + return nil, err1 + } + return getSpec() + } + var specData []byte + specData, err = rawSpec() + if err != nil { + return + } + swagger, err = loader.LoadFromData(specData) + if err != nil { + return + } + return +} + +// GetSpecJSON returns the raw JSON bytes of the embedded OpenAPI +// specification: decompressed but not unmarshaled. External references +// are not resolved here; the bytes are the spec exactly as embedded by +// codegen. The result is cached at package init time, so repeated calls +// are cheap. +func GetSpecJSON() ([]byte, error) { + return rawSpec() +} + +// GetSwagger returns the OpenAPI specification corresponding to the +// generated code in this file. +// +// Deprecated: GetSwagger predates kin-openapi renaming openapi3.Swagger +// to openapi3.T. Use [GetSpec] instead. This wrapper is retained for +// backwards compatibility. +func GetSwagger() (*openapi3.T, error) { + return GetSpec() +} diff --git a/server/internal/httpapi/openapi/spec_test.go b/server/internal/httpapi/openapi/spec_test.go new file mode 100644 index 0000000..d4ca6ca --- /dev/null +++ b/server/internal/httpapi/openapi/spec_test.go @@ -0,0 +1,37 @@ +package openapi + +import ( + "testing" +) + +// TestSpecLoadsAndValidates exercises the embedded spec loader. If +// doc/openapi.yaml drifts from a parseable OpenAPI 3.x document, this +// fails before any handler test does. +func TestSpecLoadsAndValidates(t *testing.T) { + swagger, err := GetSwagger() + if err != nil { + t.Fatalf("GetSwagger: %v", err) + } + if swagger == nil || swagger.Info == nil { + t.Fatal("nil swagger or info section") + } + if got := swagger.Info.Title; got != "cix-server API" { + t.Errorf("info.title = %q, want %q", got, "cix-server API") + } + if got := swagger.Info.Version; got != "v1" { + t.Errorf("info.version = %q, want %q", got, "v1") + } + + // Sanity: every operation in the ServerInterface has a matching path + // in the spec. We check by counting operations rather than naming + // each one — keeps the test from drifting whenever an endpoint is + // added. + if swagger.Paths == nil { + t.Fatal("paths section missing") + } + pathCount := swagger.Paths.Len() + const wantMin = 13 // 18 endpoints share a few path keys (CRUD on same path) + if pathCount < wantMin { + t.Errorf("paths.len() = %d, expected at least %d (spec may have lost endpoints)", pathCount, wantMin) + } +} diff --git a/server/internal/httpapi/projects.go b/server/internal/httpapi/projects.go index fce9286..ed9b8b9 100644 --- a/server/internal/httpapi/projects.go +++ b/server/internal/httpapi/projects.go @@ -1,18 +1,10 @@ package httpapi -import ( - "encoding/json" - "errors" - "net/http" - - "github.com/go-chi/chi/v5" - - "github.com/dvcdsys/code-index/server/internal/projects" -) - -// --------------------------------------------------------------------------- -// JSON request / response types (match Python schemas exactly) -// --------------------------------------------------------------------------- +// JSON request / response types kept for tests that unmarshal handler +// responses into them. Wire-compatible with the generated openapi types in +// internal/httpapi/openapi — every JSON tag matches doc/openapi.yaml. The +// Server struct in server.go now drives the actual HTTP responses; these +// types remain only as stable test fixtures. type projectSettingsJSON struct { ExcludePatterns []string `json:"exclude_patterns"` @@ -27,15 +19,15 @@ type projectStatsJSON struct { } type projectResponse struct { - HostPath string `json:"host_path"` - ContainerPath string `json:"container_path"` - Languages []string `json:"languages"` - Settings projectSettingsJSON `json:"settings"` - Stats projectStatsJSON `json:"stats"` - Status string `json:"status"` - CreatedAt string `json:"created_at"` - UpdatedAt string `json:"updated_at"` - LastIndexedAt *string `json:"last_indexed_at"` + HostPath string `json:"host_path"` + ContainerPath string `json:"container_path"` + Languages []string `json:"languages"` + Settings projectSettingsJSON `json:"settings"` + Stats projectStatsJSON `json:"stats"` + Status string `json:"status"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` + LastIndexedAt *string `json:"last_indexed_at"` } type projectListResponse struct { @@ -51,163 +43,8 @@ type updateProjectRequest struct { Settings *projectSettingsJSON `json:"settings"` } -// --------------------------------------------------------------------------- -// Converters -// --------------------------------------------------------------------------- - -func projectToResponse(p *projects.Project) projectResponse { - langs := p.Languages - if langs == nil { - langs = []string{} - } - return projectResponse{ - HostPath: p.HostPath, - ContainerPath: p.ContainerPath, - Languages: langs, - Settings: projectSettingsJSON{ - ExcludePatterns: p.Settings.ExcludePatterns, - MaxFileSize: p.Settings.MaxFileSize, - }, - Stats: projectStatsJSON{ - TotalFiles: p.Stats.TotalFiles, - IndexedFiles: p.Stats.IndexedFiles, - TotalChunks: p.Stats.TotalChunks, - TotalSymbols: p.Stats.TotalSymbols, - }, - Status: p.Status, - CreatedAt: p.CreatedAt, - UpdatedAt: p.UpdatedAt, - LastIndexedAt: p.LastIndexedAt, - } -} - -// --------------------------------------------------------------------------- -// Handlers -// --------------------------------------------------------------------------- - -// POST /api/v1/projects -func createProjectHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - var body createProjectRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.HostPath == "" { - writeError(w, http.StatusUnprocessableEntity, "host_path is required") - return - } - - p, err := projects.Create(r.Context(), d.DB, projects.CreateRequest{HostPath: body.HostPath}) - if err != nil { - if errors.Is(err, projects.ErrConflict) { - writeError(w, http.StatusConflict, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - writeJSON(w, http.StatusCreated, projectToResponse(p)) - } -} - -// GET /api/v1/projects -func listProjectsHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - list, err := projects.List(r.Context(), d.DB) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - resp := make([]projectResponse, 0, len(list)) - for i := range list { - resp = append(resp, projectToResponse(&list[i])) - } - writeJSON(w, http.StatusOK, projectListResponse{Projects: resp, Total: len(resp)}) - } -} - -// GET /api/v1/projects/{path} -func getProjectHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - pathHash := chi.URLParam(r, "path") - p, err := projects.GetByHash(r.Context(), d.DB, pathHash) - if err != nil { - if errors.Is(err, projects.ErrNotFound) { - writeError(w, http.StatusNotFound, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - writeJSON(w, http.StatusOK, projectToResponse(p)) - } -} - -// PATCH /api/v1/projects/{path} -func patchProjectHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - pathHash := chi.URLParam(r, "path") - p, err := projects.GetByHash(r.Context(), d.DB, pathHash) - if err != nil { - if errors.Is(err, projects.ErrNotFound) { - writeError(w, http.StatusNotFound, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - - var body updateProjectRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - - var settingsPtr *projects.Settings - if body.Settings != nil { - s := projects.Settings{ - ExcludePatterns: body.Settings.ExcludePatterns, - MaxFileSize: body.Settings.MaxFileSize, - } - settingsPtr = &s - } - - updated, err := projects.Patch(r.Context(), d.DB, p.HostPath, projects.UpdateRequest{Settings: settingsPtr}) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - writeJSON(w, http.StatusOK, projectToResponse(updated)) - } -} - -// DELETE /api/v1/projects/{path} -func deleteProjectHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - pathHash := chi.URLParam(r, "path") - p, err := projects.GetByHash(r.Context(), d.DB, pathHash) - if err != nil { - if errors.Is(err, projects.ErrNotFound) { - writeError(w, http.StatusNotFound, err.Error()) - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - - if err := projects.Delete(r.Context(), d.DB, p.HostPath); err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - w.WriteHeader(http.StatusNoContent) - } -} - -// --------------------------------------------------------------------------- -// Error helper -// --------------------------------------------------------------------------- - -func writeError(w http.ResponseWriter, code int, msg string) { - writeJSON(w, code, map[string]any{"detail": msg}) -} +// ensure the request shapes are referenced even when only read by tests. +var ( + _ = createProjectRequest{} + _ = updateProjectRequest{} +) diff --git a/server/internal/httpapi/projects_test.go b/server/internal/httpapi/projects_test.go index 4738cca..6ad0da7 100644 --- a/server/internal/httpapi/projects_test.go +++ b/server/internal/httpapi/projects_test.go @@ -20,7 +20,9 @@ func newTestDeps(t *testing.T) Deps { t.Fatalf("open test db: %v", err) } t.Cleanup(func() { d.Close() }) - return Deps{DB: d} + // AuthDisabled=true matches the historical behaviour of these tests + // (no Authorization header sent). Production wiring sets a real key. + return Deps{DB: d, AuthDisabled: true} } func doRequest(t *testing.T, router http.Handler, method, path string, body any) *httptest.ResponseRecorder { diff --git a/server/internal/httpapi/router.go b/server/internal/httpapi/router.go index a1b7dfd..a279c29 100644 --- a/server/internal/httpapi/router.go +++ b/server/internal/httpapi/router.go @@ -1,6 +1,8 @@ // Package httpapi wires the chi router and HTTP handlers for the Go server. -// Phase 1: /health and /api/v1/status. -// Phase 2: project CRUD + symbol/definition/reference/file search + summary. +// +// All routes are described in doc/openapi.yaml; the generated chi shim in +// internal/httpapi/openapi mounts them onto the router and dispatches to +// methods on the Server struct (see server.go). package httpapi import ( @@ -9,9 +11,15 @@ import ( "log/slog" "net/http" + "github.com/dvcdsys/code-index/server/internal/apikeys" "github.com/dvcdsys/code-index/server/internal/embeddings" + "github.com/dvcdsys/code-index/server/internal/httpapi/openapi" "github.com/dvcdsys/code-index/server/internal/indexer" + "github.com/dvcdsys/code-index/server/internal/runtimecfg" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" "github.com/dvcdsys/code-index/server/internal/vectorstore" + "github.com/dvcdsys/code-index/server/internal/versioncheck" "github.com/go-chi/chi/v5" "github.com/go-chi/chi/v5/middleware" ) @@ -38,10 +46,16 @@ type Deps struct { Backend string EmbeddingModel string Logger *slog.Logger - // APIKey is the shared secret compared against the `Authorization: Bearer` - // header. When empty the server runs in dev mode and skips auth — matches - // the behaviour advertised in cmd/cix-server/main.go's startup warning. - APIKey string + // AuthDisabled, when true, omits the auth middleware entirely — every + // route becomes reachable without credentials. Off by default. Toggle + // via CIX_AUTH_DISABLED=true (config.go) for local dev or tests. + AuthDisabled bool + // Users / Sessions / APIKeys back the dashboard auth model. Required + // in production; tests may pass nil + AuthDisabled=true to skip the + // gate. + Users *users.Service + Sessions *sessions.Service + APIKeys *apikeys.Service // EmbeddingSvc is the in-process embeddings service. May be nil when the // server is started with CIX_EMBEDDINGS_ENABLED=false (e.g. in router // tests). Phase 5 uses it for semantic search. @@ -52,34 +66,24 @@ type Deps struct { // Indexer drives the three-phase index protocol (Phase 5). Nil-safe: the // indexing endpoints return 503 when absent. Indexer *indexer.Service + // RuntimeCfg backs the dashboard's /admin/runtime-config endpoints. Nil + // in router-only tests; admin handlers return 503 when absent. + RuntimeCfg *runtimecfg.Service + // VersionCheck polls GitHub for newer server releases. Nil = feature + // off; GetStatus then omits the version-check fields entirely. + VersionCheck *versioncheck.Service } -// NewRouter builds the chi router with middleware and all Phase 1+2 routes. +// NewRouter builds the chi router with middleware and the generated +// OpenAPI-derived routes. // // Project paths contain slashes that cannot be embedded in plain URL segments. // We follow the Python approach of SHA1-hashing them (first 16 hex chars) and // using the hash as the URL key. See internal/projects.HashPath for details. // -// Route list: -// -// GET /health -// GET /api/v1/status -// POST /api/v1/projects create project -// GET /api/v1/projects list projects -// GET /api/v1/projects/{path} get project by hash -// PATCH /api/v1/projects/{path} patch project settings -// DELETE /api/v1/projects/{path} delete project -// POST /api/v1/projects/{path}/search/symbols symbol name search -// POST /api/v1/projects/{path}/search/definitions go-to-definition -// POST /api/v1/projects/{path}/search/references find references -// POST /api/v1/projects/{path}/search/files file path search -// POST /api/v1/projects/{path}/search semantic search -// POST /api/v1/projects/{path}/index/begin start indexing session -// POST /api/v1/projects/{path}/index/files stream files -// POST /api/v1/projects/{path}/index/finish commit session -// POST /api/v1/projects/{path}/index/cancel idempotent cancel -// GET /api/v1/projects/{path}/index/status progress / last run -// GET /api/v1/projects/{path}/summary project summary +// Auth: every route except `GET /health` lives behind the `requireAPIKey` +// middleware. The generated chi-server mounts under a sub-router so the gate +// stays in one place. func NewRouter(d Deps) http.Handler { r := chi.NewRouter() @@ -87,46 +91,41 @@ func NewRouter(d Deps) http.Handler { r.Use(middleware.Recoverer) r.Use(serverVersionHeader(d.ServerVersion)) r.Use(structuredLogger(d.Logger)) - - // Public probe — no auth, matches Python api/app/routers/health.py. - r.Get("/health", healthHandler(d)) - - // Everything else lives behind the API-key middleware so the gate matches - // Python's `Depends(verify_api_key)` applied in each router module. - r.Group(func(pr chi.Router) { - pr.Use(requireAPIKey(d.APIKey)) - - // Phase 1 — status probe (authenticated, unlike /health). - pr.Get("/api/v1/status", statusHandler(d)) - - // Phase 2 — project CRUD. - pr.Post("/api/v1/projects", createProjectHandler(d)) - pr.Get("/api/v1/projects", listProjectsHandler(d)) - - // Project-scoped routes: {path} is a 16-char SHA1 hash of the host_path. - pr.Get("/api/v1/projects/{path}", getProjectHandler(d)) - pr.Patch("/api/v1/projects/{path}", patchProjectHandler(d)) - pr.Delete("/api/v1/projects/{path}", deleteProjectHandler(d)) - - // Phase 2 — search endpoints. - pr.Post("/api/v1/projects/{path}/search/symbols", symbolSearchHandler(d)) - pr.Post("/api/v1/projects/{path}/search/definitions", definitionSearchHandler(d)) - pr.Post("/api/v1/projects/{path}/search/references", referenceSearchHandler(d)) - pr.Post("/api/v1/projects/{path}/search/files", fileSearchHandler(d)) - - // Phase 5 — semantic search. - pr.Post("/api/v1/projects/{path}/search", semanticSearchHandler(d)) - - // Phase 5 — three-phase indexing protocol. - pr.Post("/api/v1/projects/{path}/index/begin", indexBeginHandler(d)) - pr.Post("/api/v1/projects/{path}/index/files", indexFilesHandler(d)) - pr.Post("/api/v1/projects/{path}/index/finish", indexFinishHandler(d)) - pr.Post("/api/v1/projects/{path}/index/cancel", indexCancelHandler(d)) - pr.Get("/api/v1/projects/{path}/index/status", indexStatusHandler(d)) - - // Phase 2 — summary. - pr.Get("/api/v1/projects/{path}/summary", projectSummaryHandler(d)) - }) + r.Use(limitBodySize()) + + srv := &Server{Deps: d, loginLimiter: newLoginLimiter()} + + // Auth — the middleware is installed unless AuthDisabled is true. Every + // authenticated route accepts EITHER an active session cookie OR a + // Bearer API key; admin-only routes additionally require role=admin. + // requireAuth skips public paths (see isPublicPath in middleware.go): + // /health, /docs, /docs/*, /openapi.json plus the bootstrap-status and + // login endpoints. + if !d.AuthDisabled { + r.Use(requireAuth(d)) + } else if d.Logger != nil { + // Loud signal — every authenticated request will pass without checks. + // The startup banner in main.go also logs this; we duplicate here so + // router-only test runs surface the same warning. + d.Logger.Warn("auth disabled (CIX_AUTH_DISABLED=true) — every endpoint is reachable without an API key") + } + + // Documentation — Swagger UI shell + the embedded OpenAPI spec served + // from the bytes in openapi.gen.go. Both are public regardless of auth. + r.Get("/docs", docsIndexHandler) + r.Get("/docs/*", docsAssetsHandler) + r.Get("/openapi.json", openapiSpecHandler) + + // Dashboard — embedded React SPA (Vite build under + // internal/httpapi/dashboard/dist). Static assets are public; every API + // call the SPA makes still travels through requireAuth above, so the + // pages render but show the login screen until /auth/me succeeds. + r.Get("/dashboard", dashboardIndexHandler) + r.Get("/dashboard/*", dashboardAssetsHandler) + + // All API operations — chi.HandlerFromMux walks the spec and registers + // one chi route per OpenAPI operation, dispatching to Server methods. + openapi.HandlerFromMux(srv, r) return r } diff --git a/server/internal/httpapi/search.go b/server/internal/httpapi/search.go index befd16e..62242f8 100644 --- a/server/internal/httpapi/search.go +++ b/server/internal/httpapi/search.go @@ -1,24 +1,25 @@ package httpapi import ( + "context" "database/sql" - "encoding/json" "errors" "net/http" "path/filepath" "sort" "strings" - "time" "github.com/go-chi/chi/v5" - "github.com/dvcdsys/code-index/server/internal/embeddings" - "github.com/dvcdsys/code-index/server/internal/langdetect" "github.com/dvcdsys/code-index/server/internal/projects" "github.com/dvcdsys/code-index/server/internal/symbolindex" "github.com/dvcdsys/code-index/server/internal/vectorstore" ) +// --------------------------------------------------------------------------- +// vectorStoreResult / dedupe — used by SemanticSearch fan-out (server.go). +// --------------------------------------------------------------------------- + // vectorStoreResult wraps a vectorstore.SearchResult so fan-out can dedupe by // (file_path, start_line, end_line) across multiple language-scoped queries. type vectorStoreResult struct { @@ -37,9 +38,9 @@ func wrapResults(rs []vectorstore.SearchResult) []vectorStoreResult { // Preserves the relative order of the first-seen instances. func dedupByLocation(rs []vectorStoreResult) []vectorStoreResult { type key struct { - fp string - start int - end int + fp string + start int + end int } seen := make(map[key]int, len(rs)) out := rs[:0] @@ -58,7 +59,12 @@ func dedupByLocation(rs []vectorStoreResult) []vectorStoreResult { } // --------------------------------------------------------------------------- -// Request / response types (match Python schemas/search.py exactly) +// Wire-format types kept as test fixtures. +// +// Server.* methods in server.go emit the openapi.* equivalents; these inline +// types mirror the same JSON tags so existing *_test.go can still +// `json.Unmarshal` into them. Do not add new fields here — extend the +// OpenAPI spec instead. // --------------------------------------------------------------------------- type symbolSearchRequest struct { @@ -99,10 +105,10 @@ type fileSearchResponse struct { } type definitionRequest struct { - Symbol string `json:"symbol"` - Kind string `json:"kind"` - FilePath string `json:"file_path"` - Limit int `json:"limit"` + Symbol string `json:"symbol"` + Kind string `json:"kind"` + FilePath string `json:"file_path"` + Limit int `json:"limit"` } type definitionItem struct { @@ -165,9 +171,20 @@ type projectSummaryResponse struct { RecentSymbols []symbolEntry `json:"recent_symbols"` } +// Suppress "unused" warnings — the request shapes are populated by +// json.Unmarshal in tests, which static analysis cannot see. +var ( + _ = symbolSearchRequest{} + _ = fileSearchRequest{} + _ = definitionRequest{} + _ = referenceRequest{} +) + // --------------------------------------------------------------------------- // resolveProjectFromHash looks up the project by URL path hash. -// Returns the project or writes a 404 and returns nil. +// Returns the project or writes a 404 and returns nil. Shared by Server +// methods (server.go) — kept here because the chi.URLParam dependency +// belongs with the search/path-handling code. // --------------------------------------------------------------------------- func resolveProjectFromHash(w http.ResponseWriter, r *http.Request, d Deps) *projects.Project { @@ -185,327 +202,11 @@ func resolveProjectFromHash(w http.ResponseWriter, r *http.Request, d Deps) *pro } // --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/search/symbols -// --------------------------------------------------------------------------- - -func symbolSearchHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - - var body symbolSearchRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.Query == "" { - writeError(w, http.StatusUnprocessableEntity, "query is required") - return - } - if body.Limit <= 0 { - body.Limit = 20 - } - - symbols, err := symbolindex.SearchByName(r.Context(), d.DB, p.HostPath, body.Query, body.Kinds, body.Limit) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - - results := make([]symbolResultItem, 0, len(symbols)) - for _, s := range symbols { - results = append(results, symbolResultItem{ - Name: s.Name, - Kind: s.Kind, - FilePath: s.FilePath, - Line: s.Line, - EndLine: s.EndLine, - Language: s.Language, - Signature: s.Signature, - ParentName: s.ParentName, - }) - } - writeJSON(w, http.StatusOK, symbolSearchResponse{Results: results, Total: len(results)}) - } -} - -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/search/definitions -// --------------------------------------------------------------------------- - -func definitionSearchHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - - var body definitionRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.Symbol == "" { - writeError(w, http.StatusUnprocessableEntity, "symbol is required") - return - } - if body.Limit <= 0 { - body.Limit = 10 - } - - syms, err := symbolindex.SearchDefinitions(r.Context(), d.DB, p.HostPath, body.Symbol, body.Kind, body.FilePath, body.Limit) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - - results := make([]definitionItem, 0, len(syms)) - for _, s := range syms { - results = append(results, definitionItem{ - Name: s.Name, - Kind: s.Kind, - FilePath: s.FilePath, - Line: s.Line, - EndLine: s.EndLine, - Language: s.Language, - Signature: s.Signature, - ParentName: s.ParentName, - }) - } - writeJSON(w, http.StatusOK, definitionResponse{Results: results, Total: len(results)}) - } -} - -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/search/references -// --------------------------------------------------------------------------- - -func referenceSearchHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - - var body referenceRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.Symbol == "" { - writeError(w, http.StatusUnprocessableEntity, "symbol is required") - return - } - if body.Limit <= 0 { - body.Limit = 50 - } - - refs, err := symbolindex.SearchReferences(r.Context(), d.DB, p.HostPath, body.Symbol, body.FilePath, body.Limit) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - - // m3 — the refs table stores only token locations (name, file, line, - // col) so `Content` is intentionally empty and `EndLine == StartLine`. - // Matches the Python `ReferenceIndexService` shape. Clients that need - // source snippets should follow up with a semantic search or a - // file-read; populating Content here would require a full-file - // re-read on every request and was deemed too costly. - results := make([]referenceItem, 0, len(refs)) - for _, ref := range refs { - results = append(results, referenceItem{ - FilePath: ref.FilePath, - StartLine: ref.Line, - EndLine: ref.Line, - Content: "", - ChunkType: "reference", - SymbolName: ref.Name, - Language: ref.Language, - }) - } - writeJSON(w, http.StatusOK, referenceResponse{Results: results, Total: len(results)}) - } -} - -// --------------------------------------------------------------------------- -// POST /api/v1/projects/{path}/search/files -// --------------------------------------------------------------------------- - -func fileSearchHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - - var body fileSearchRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if body.Query == "" { - writeError(w, http.StatusUnprocessableEntity, "query is required") - return - } - if body.Limit <= 0 { - body.Limit = 20 - } - - var results []fileResultItem - { - rows, err := d.DB.QueryContext(r.Context(), - `SELECT file_path FROM file_hashes WHERE project_path = ? AND file_path LIKE ? ORDER BY file_path LIMIT ?`, - p.HostPath, "%"+body.Query+"%", body.Limit, - ) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - for rows.Next() { - var fp string - if err := rows.Scan(&fp); err != nil { - rows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - lang := langdetect.Detect(fp) - var langPtr *string - if lang != "" { - langPtr = &lang - } - results = append(results, fileResultItem{FilePath: fp, Language: langPtr}) - } - // m1 — a WAL / IO error during iteration would otherwise return a - // partial list with HTTP 200 and no hint that anything went wrong. - if err := rows.Err(); err != nil { - rows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - rows.Close() - } - if results == nil { - results = []fileResultItem{} - } - writeJSON(w, http.StatusOK, fileSearchResponse{Results: results, Total: len(results)}) - } -} - -// --------------------------------------------------------------------------- -// GET /api/v1/projects/{path}/summary -// --------------------------------------------------------------------------- - -func projectSummaryHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - - // Top directories — from file_hashes. - dirCount := map[string]int{} - { - rows, err := d.DB.QueryContext(r.Context(), - `SELECT file_path FROM file_hashes WHERE project_path = ?`, p.HostPath, - ) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - for rows.Next() { - var fp string - if err := rows.Scan(&fp); err != nil { - rows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - // Mirrors Python path bucketing logic. - parts := splitPath(fp) - var key string - if len(parts) > 3 { - key = joinPath(parts[:4]) - } else if len(parts) > 1 { - key = joinPath(parts[:2]) - } - if key != "" { - dirCount[key]++ - } - } - if err := rows.Err(); err != nil { // m1 - rows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - rows.Close() - } - - topDirs := topN(dirCount, 10) - - // Recent symbols. - var recentSyms []symbolEntry - { - symRows, err := d.DB.QueryContext(r.Context(), - `SELECT name, kind, file_path, language FROM symbols WHERE project_path = ? LIMIT 20`, - p.HostPath, - ) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - for symRows.Next() { - var s symbolEntry - if err := symRows.Scan(&s.Name, &s.Kind, &s.FilePath, &s.Language); err != nil { - symRows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - recentSyms = append(recentSyms, s) - } - if err := symRows.Err(); err != nil { // m1 - symRows.Close() - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - symRows.Close() - } - if recentSyms == nil { - recentSyms = []symbolEntry{} - } - - // Total symbol count. - var totalSymbols int - _ = d.DB.QueryRowContext(r.Context(), - `SELECT COUNT(*) FROM symbols WHERE project_path = ?`, p.HostPath, - ).Scan(&totalSymbols) - - langs := p.Languages - if langs == nil { - langs = []string{} - } - - writeJSON(w, http.StatusOK, projectSummaryResponse{ - HostPath: p.HostPath, - Status: p.Status, - Languages: langs, - TotalFiles: p.Stats.TotalFiles, - TotalChunks: p.Stats.TotalChunks, - TotalSymbols: totalSymbols, - TopDirectories: topDirs, - RecentSymbols: recentSyms, - }) - } -} - -// --------------------------------------------------------------------------- -// Path helpers — mirror Python Path(fp).parts logic +// Path helpers — mirror Python Path(fp).parts logic. Used by +// Server.GetProjectSummary to bucket file paths into top-level directories. // --------------------------------------------------------------------------- func splitPath(fp string) []string { - // filepath.SplitList is for PATH env — use manual split. - // We want to split by "/" for consistency with Python pathlib. var parts []string for { dir, base := filepath.Split(fp) @@ -534,259 +235,246 @@ func joinPath(parts []string) string { return result } -// topN returns the top-n directory entries by count. -func topN(m map[string]int, n int) []dirEntry { - type kv struct { - k string - v int - } - var kvs []kv - for k, v := range m { - kvs = append(kvs, kv{k, v}) - } - // Sort descending. - for i := 1; i < len(kvs); i++ { - j := i - for j > 0 && kvs[j].v > kvs[j-1].v { - kvs[j], kvs[j-1] = kvs[j-1], kvs[j] - j-- - } - } - if n > len(kvs) { - n = len(kvs) - } - out := make([]dirEntry, n) - for i := 0; i < n; i++ { - out[i] = dirEntry{Path: kvs[i].k, FileCount: kvs[i].v} - } - return out -} - -// Ensure symbolindex and sql are used (avoid import cycle in future if moved). -var _ = (*sql.DB)(nil) -var _ = symbolindex.Symbol{} +// Ensure symbolindex and sql are referenced (compile-time guard against +// accidental import removal during refactors). +var ( + _ = (*sql.DB)(nil) + _ = symbolindex.Symbol{} +) // --------------------------------------------------------------------------- -// Semantic search — POST /api/v1/projects/{path}/search +// Internal types used by the semantic-search fan-out / merge / group-by-file +// pipeline. The public wire format lives in openapi.SemanticSearchResponse; +// these types describe the intermediate state inside Server.SemanticSearch. // --------------------------------------------------------------------------- -type searchRequest struct { - Query string `json:"query"` - Limit int `json:"limit"` - Languages []string `json:"languages"` - Paths []string `json:"paths"` - // MinScore is a pointer so we can distinguish "not provided" from an - // explicit zero. Python uses a Pydantic default (0.1) which also allows - // explicit 0 through — mirror that here. m2 fix. - MinScore *float32 `json:"min_score,omitempty"` -} - +// searchResultItem is the per-chunk match used INTERNALLY during retrieval. +// It is not exposed in the JSON response — the wire format groups matches +// by file (see fileGroupResult). The merge step (mergeOverlappingHits) +// works on this struct, then groupByFile lifts the survivors into +// file-grouped results. type searchResultItem struct { - FilePath string `json:"file_path"` + FilePath string `json:"-"` + StartLine int `json:"start_line"` + EndLine int `json:"end_line"` + Content string `json:"content"` + Score float32 `json:"score"` + ChunkType string `json:"chunk_type"` + SymbolName string `json:"symbol_name,omitempty"` + Language string `json:"-"` + NestedHits []nestedHit `json:"nested_hits,omitempty"` +} + +// nestedHit records a chunk that was merged INTO another result by +// mergeOverlappingHits (e.g. an H2 section absorbed into its containing H1). +type nestedHit struct { StartLine int `json:"start_line"` EndLine int `json:"end_line"` - Content string `json:"content"` - Score float32 `json:"score"` + SymbolName string `json:"symbol_name,omitempty"` ChunkType string `json:"chunk_type"` - SymbolName string `json:"symbol_name"` - Language string `json:"language"` + Score float32 `json:"score"` } +// fileMatch is one search hit inside a file group. +type fileMatch struct { + StartLine int `json:"start_line"` + EndLine int `json:"end_line"` + Content string `json:"content"` + Score float32 `json:"score"` + ChunkType string `json:"chunk_type"` + SymbolName string `json:"symbol_name,omitempty"` + NestedHits []nestedHit `json:"nested_hits,omitempty"` +} + +// fileGroupResult is the top-level unit of search output: one file with +// every match inside it that passed min_score. +type fileGroupResult struct { + FilePath string `json:"file_path"` + Language string `json:"language,omitempty"` + BestScore float32 `json:"best_score"` + Matches []fileMatch `json:"matches"` +} + +// searchResponse is the JSON-unmarshal target used by tests. Server.SemanticSearch +// emits openapi.SemanticSearchResponse, which is byte-identical on the wire. type searchResponse struct { - Results []searchResultItem `json:"results"` - Total int `json:"total"` - QueryTimeMS float64 `json:"query_time_ms"` + Results []fileGroupResult `json:"results"` + Total int `json:"total"` + QueryTimeMS float64 `json:"query_time_ms"` } -// semanticSearchHandler implements POST /api/v1/projects/{path}/search, -// matching api/app/routers/search.py semantic_search behaviour: -// - embed query with prefix -// - query vectorstore with limit*2 and optional where(language) -// - post-filter by min_score + paths (prefix OR substring) -// - trim to limit, round query_time_ms to 1 decimal -func semanticSearchHandler(d Deps) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - p := resolveProjectFromHash(w, r, d) - if p == nil { - return - } - if d.VectorStore == nil || d.EmbeddingSvc == nil { - writeError(w, http.StatusServiceUnavailable, "semantic search not configured") - return - } +// --------------------------------------------------------------------------- +// Constants + helpers shared with server.go (Server.SemanticSearch). +// --------------------------------------------------------------------------- - var body searchRequest - if err := json.NewDecoder(r.Body).Decode(&body); err != nil { - writeError(w, http.StatusUnprocessableEntity, "invalid request body") - return - } - if strings.TrimSpace(body.Query) == "" { - writeError(w, http.StatusUnprocessableEntity, "query is required") - return - } - if body.Limit <= 0 { - body.Limit = 10 - } - // m2 — only apply default when the caller did not send the field. - // Explicit 0 means "return everything above the HNSW floor". - minScore := float32(0.1) - if body.MinScore != nil { - minScore = *body.MinScore - } +// maxFanoutSearch is the language-count threshold above which we drop +// per-language pre-filter and fall back to a single over-fetched query +// with post-filter. +const maxFanoutSearch = 4 - start := time.Now() +// maxFactorSearch caps the windowed retrieval expansion. With limit=10 +// and factor=16 we top out at 160 raw results. +const maxFactorSearch = 16 - qEmb, err := d.EmbeddingSvc.EmbedQuery(r.Context(), body.Query) +// groupByFile lifts merged per-chunk results into per-file groups, sorted by +// best score descending (with a stable tie-break on file_path). +func groupByFile(items []searchResultItem) []fileGroupResult { + if len(items) == 0 { + return nil + } + indexByPath := map[string]int{} + var groups []fileGroupResult + for _, it := range items { + idx, ok := indexByPath[it.FilePath] + if !ok { + groups = append(groups, fileGroupResult{ + FilePath: it.FilePath, + Language: it.Language, + BestScore: it.Score, + }) + idx = len(groups) - 1 + indexByPath[it.FilePath] = idx + } + g := &groups[idx] + if it.Score > g.BestScore { + g.BestScore = it.Score + } + g.Matches = append(g.Matches, fileMatch{ + StartLine: it.StartLine, + EndLine: it.EndLine, + Content: it.Content, + Score: it.Score, + ChunkType: it.ChunkType, + SymbolName: it.SymbolName, + NestedHits: it.NestedHits, + }) + } + for i := range groups { + ms := groups[i].Matches + sort.SliceStable(ms, func(a, b int) bool { + return ms[a].StartLine < ms[b].StartLine + }) + } + sort.SliceStable(groups, func(i, j int) bool { + if groups[i].BestScore != groups[j].BestScore { + return groups[i].BestScore > groups[j].BestScore + } + return groups[i].FilePath < groups[j].FilePath + }) + return groups +} + +// fetchVectorResults performs the per-language fan-out vector-store query +// at the given limit and returns deduped, score-sorted results. +// +// The fan-out strategy: 0 languages → single query; 1 language → single +// query with where-filter; 2..maxFanout → N queries with per-language +// where-filter, deduped and re-sorted by score; >maxFanout → single +// oversized query, post-filter handled by caller (filterToSearchItems with +// applyPostLangFilter=true). +func fetchVectorResults( + ctx context.Context, + store *vectorstore.Store, + projectPath string, + qEmb []float32, + n int, + languages []string, +) ([]vectorStoreResult, error) { + switch { + case len(languages) == 0: + r1, err := store.Search(ctx, projectPath, qEmb, n, nil) if err != nil { - if retry, busy := embeddings.IsBusy(err); busy { - w.Header().Set("Retry-After", strconvItoa(retry)) - writeError(w, http.StatusServiceUnavailable, - "GPU is busy processing another embedding request, retry after "+strconvItoa(retry)+"s") - return - } - if errors.Is(err, embeddings.ErrDisabled) { - writeError(w, http.StatusServiceUnavailable, "embeddings disabled") - return - } - writeError(w, http.StatusInternalServerError, err.Error()) - return + return nil, err } - - // M4 — multi-language fan-out. chromem-go's `where` map cannot express - // "language IN (go, python)" natively, so: - // - 0 languages: single query, no where filter. - // - 1 language: single query with `where={"language": lang}` — same - // HNSW-level pre-filter as Python. - // - ≥2 languages: N independent queries (one per language) merged and - // deduped by document ID. Preserves pre-filter semantics so the top - // results are not starved by unrelated languages when the collection - // is large. - const maxFanout = 4 - - var allResults []vectorStoreResult - switch { - case len(body.Languages) == 0: - r1, err := d.VectorStore.Search(r.Context(), p.HostPath, qEmb, body.Limit*2, nil) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - allResults = wrapResults(r1) - case len(body.Languages) == 1: - r1, err := d.VectorStore.Search(r.Context(), p.HostPath, qEmb, body.Limit*2, - map[string]string{"language": body.Languages[0]}) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - allResults = wrapResults(r1) - case len(body.Languages) <= maxFanout: - // Per-language fan-out; merge and dedupe. - for _, lang := range body.Languages { - rPart, err := d.VectorStore.Search(r.Context(), p.HostPath, qEmb, body.Limit*2, - map[string]string{"language": lang}) - if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return - } - allResults = append(allResults, wrapResults(rPart)...) - } - allResults = dedupByLocation(allResults) - // Sort by descending score — merged slices arrive pre-sorted per - // partition but out of order across partitions. - sort.SliceStable(allResults, func(i, j int) bool { - return allResults[i].r.Score > allResults[j].r.Score - }) - default: - // Too many languages for fan-out — fall back to post-filter with a - // generous over-fetch to minimise starvation. - rAll, err := d.VectorStore.Search(r.Context(), p.HostPath, qEmb, - body.Limit*len(body.Languages)*2, nil) + return wrapResults(r1), nil + case len(languages) == 1: + r1, err := store.Search(ctx, projectPath, qEmb, n, + map[string]string{"language": languages[0]}) + if err != nil { + return nil, err + } + return wrapResults(r1), nil + case len(languages) <= maxFanoutSearch: + var combined []vectorStoreResult + for _, lang := range languages { + rPart, err := store.Search(ctx, projectPath, qEmb, n, + map[string]string{"language": lang}) if err != nil { - writeError(w, http.StatusInternalServerError, err.Error()) - return + return nil, err } - allResults = wrapResults(rAll) + combined = append(combined, wrapResults(rPart)...) } - - // Post-filter for the >maxFanout path needs a language set. - langSet := map[string]struct{}{} - for _, l := range body.Languages { - langSet[l] = struct{}{} + combined = dedupByLocation(combined) + sort.SliceStable(combined, func(i, j int) bool { + return combined[i].r.Score > combined[j].r.Score + }) + return combined, nil + default: + rAll, err := store.Search(ctx, projectPath, qEmb, n*len(languages), nil) + if err != nil { + return nil, err } - applyPostLangFilter := len(body.Languages) > maxFanout + return wrapResults(rAll), nil + } +} - filtered := make([]searchResultItem, 0, len(allResults)) - for _, wrapped := range allResults { - res := wrapped.r - if res.Score < minScore { +// filterToSearchItems applies min-score, language post-filter, path +// whitelist (paths), and path blacklist (excludes). It does NOT truncate — +// the merge step needs the full filtered set to identify all overlaps +// before deciding which to drop. +func filterToSearchItems( + wrapped []vectorStoreResult, + minScore float32, + paths []string, + excludes []string, + langSet map[string]struct{}, + applyPostLangFilter bool, +) []searchResultItem { + filtered := make([]searchResultItem, 0, len(wrapped)) + for _, w := range wrapped { + res := w.r + if res.Score < minScore { + continue + } + if applyPostLangFilter { + if _, ok := langSet[res.Language]; !ok { continue } - if applyPostLangFilter { - if _, ok := langSet[res.Language]; !ok { - continue + } + if len(paths) > 0 { + matched := false + for _, pfx := range paths { + if strings.HasPrefix(res.FilePath, pfx) || strings.Contains(res.FilePath, pfx) { + matched = true + break } } - if len(body.Paths) > 0 { - matched := false - for _, pfx := range body.Paths { - if strings.HasPrefix(res.FilePath, pfx) || strings.Contains(res.FilePath, pfx) { - matched = true - break - } - } - if !matched { - continue + if !matched { + continue + } + } + if len(excludes) > 0 { + excluded := false + for _, pfx := range excludes { + if strings.HasPrefix(res.FilePath, pfx) || strings.Contains(res.FilePath, pfx) { + excluded = true + break } } - filtered = append(filtered, searchResultItem{ - FilePath: res.FilePath, - StartLine: res.StartLine, - EndLine: res.EndLine, - Content: res.Content, - Score: res.Score, - ChunkType: res.ChunkType, - SymbolName: res.SymbolName, - Language: res.Language, - }) - if len(filtered) >= body.Limit { - break + if excluded { + continue } } - - elapsedMS := float64(time.Since(start).Microseconds()) / 1000.0 - elapsedMS = float64(int(elapsedMS*10+0.5)) / 10 - - writeJSON(w, http.StatusOK, searchResponse{ - Results: filtered, - Total: len(filtered), - QueryTimeMS: elapsedMS, + filtered = append(filtered, searchResultItem{ + FilePath: res.FilePath, + StartLine: res.StartLine, + EndLine: res.EndLine, + Content: res.Content, + Score: res.Score, + ChunkType: res.ChunkType, + SymbolName: res.SymbolName, + Language: res.Language, }) } -} - -// strconvItoa avoids pulling strconv just for one call in this file — mirrors -// the pattern used elsewhere in the package. -func strconvItoa(n int) string { - // strconv is already imported elsewhere in the package? No — keep inline. - // Use fmt-free int-to-string. - if n == 0 { - return "0" - } - neg := n < 0 - if neg { - n = -n - } - var buf [20]byte - i := len(buf) - for n > 0 { - i-- - buf[i] = byte('0' + n%10) - n /= 10 - } - if neg { - i-- - buf[i] = '-' - } - return string(buf[i:]) + return filtered } diff --git a/server/internal/httpapi/search_filter_test.go b/server/internal/httpapi/search_filter_test.go new file mode 100644 index 0000000..8c28758 --- /dev/null +++ b/server/internal/httpapi/search_filter_test.go @@ -0,0 +1,85 @@ +package httpapi + +import ( + "testing" + + "github.com/dvcdsys/code-index/server/internal/vectorstore" +) + +func mkRawResult(path string, score float32) vectorStoreResult { + return vectorStoreResult{ + r: vectorstore.SearchResult{ + FilePath: path, + StartLine: 1, + EndLine: 10, + Content: "stub", + Score: score, + Language: "go", + }, + } +} + +func TestFilterToSearchItems_ExcludesPrefixDropsMatchingPaths(t *testing.T) { + raw := []vectorStoreResult{ + mkRawResult("/proj/server/cmd/cix-server/main.go", 0.9), + mkRawResult("/proj/bench/fixtures/sample.py", 0.85), + mkRawResult("/proj/legacy/python-api/scripts/profile_vram.py", 0.8), + mkRawResult("/proj/cli/main.go", 0.7), + } + + out := filterToSearchItems(raw, 0.0, nil, []string{"/proj/bench", "/proj/legacy"}, nil, false) + if len(out) != 2 { + t.Fatalf("want 2 results after exclude, got %d", len(out)) + } + for _, r := range out { + if r.FilePath == "/proj/bench/fixtures/sample.py" || r.FilePath == "/proj/legacy/python-api/scripts/profile_vram.py" { + t.Errorf("excluded path leaked through: %s", r.FilePath) + } + } +} + +func TestFilterToSearchItems_ExcludesSubstringMatch(t *testing.T) { + // Substring match parity with --in: an exclude of "fixtures" drops any + // path that contains the substring, not just a prefix match. + raw := []vectorStoreResult{ + mkRawResult("/proj/server/cmd/cix-server/main.go", 0.9), + mkRawResult("/proj/bench/fixtures/sample.py", 0.85), + } + out := filterToSearchItems(raw, 0.0, nil, []string{"fixtures"}, nil, false) + if len(out) != 1 { + t.Fatalf("want 1 after substring exclude, got %d", len(out)) + } + if out[0].FilePath != "/proj/server/cmd/cix-server/main.go" { + t.Errorf("unexpected survivor: %s", out[0].FilePath) + } +} + +func TestFilterToSearchItems_ExcludesAndPathsCombined(t *testing.T) { + // --in narrows to a directory; --exclude further trims a subdirectory. + raw := []vectorStoreResult{ + mkRawResult("/proj/server/internal/httpapi/search.go", 0.9), + mkRawResult("/proj/server/internal/httpapi/search_test.go", 0.85), + mkRawResult("/proj/cli/cmd/search.go", 0.8), + } + out := filterToSearchItems(raw, 0.0, + []string{"/proj/server"}, + []string{"_test.go"}, + nil, false) + if len(out) != 1 { + t.Fatalf("want 1 after path+exclude, got %d", len(out)) + } + if out[0].FilePath != "/proj/server/internal/httpapi/search.go" { + t.Errorf("unexpected survivor: %s", out[0].FilePath) + } +} + +func TestFilterToSearchItems_NilExcludesIsNoop(t *testing.T) { + raw := []vectorStoreResult{ + mkRawResult("/a.go", 0.9), + mkRawResult("/b.go", 0.8), + } + out := filterToSearchItems(raw, 0.0, nil, nil, nil, false) + if len(out) != 2 { + t.Errorf("nil excludes must not drop anything; got %d", len(out)) + } +} diff --git a/server/internal/httpapi/search_merge.go b/server/internal/httpapi/search_merge.go new file mode 100644 index 0000000..36250d9 --- /dev/null +++ b/server/internal/httpapi/search_merge.go @@ -0,0 +1,138 @@ +package httpapi + +import "sort" + +// mergeOverlappingHits collapses search results that come from the same file +// when one's line range fully contains another's, or when same-symbol pieces +// of a split chunk happen to be adjacent. The "outer" hit survives, picks up +// the best score across the merged set, and records inner hits as +// NestedHits so the renderer can show them as breadcrumbs. +// +// Why this matters +// +// Tree-sitter emits nested chunks by design: a class chunk wraps its method +// chunks; a markdown H1 section wraps its H2 sub-sections; a Python class +// wraps inner functions. Without merging, a vector-search query that hits +// strongly inside one of those nested chunks tends to also hit (slightly +// less strongly) the parent chunk that textually contains the same lines, +// and the user's --limit budget gets eaten by N copies of essentially the +// same code region. +// +// Adjacency rule (the splitChunk leftover): when a function is too long for +// a single chunk, splitChunk emits piece 1 with the symbol metadata and +// pieces 2..N as anonymous `block`s. If a query happens to hit BOTH the +// named first piece AND the anonymous tail, those two ranges are exactly +// adjacent (piece1.EndLine + 1 == piece2.StartLine). We merge those too — +// the anonymous tail "belongs" to the named symbol on the same file. +// +// Cross-file results are NEVER merged: two functions with the same name in +// two different files are legitimately separate hits. +// +// The function does not truncate to any limit — that's the caller's job +// after this returns. Output is sorted by descending merged score. +func mergeOverlappingHits(items []searchResultItem) []searchResultItem { + if len(items) <= 1 { + return items + } + + // Group indices by file path. Keeping indices (not copies) so we can + // edit items[parentIdx] in-place to grow its NestedHits. + byFile := map[string][]int{} + for i := range items { + byFile[items[i].FilePath] = append(byFile[items[i].FilePath], i) + } + + consumed := make([]bool, len(items)) + + for _, idxs := range byFile { + if len(idxs) <= 1 { + continue + } + + // Sort by range size descending (largest first → potential parent), + // tiebreak by start line ascending so the iteration order is stable + // and biggest-encloses-everything-inside-it semantics fall out + // naturally. + sort.Slice(idxs, func(a, b int) bool { + ia, ib := items[idxs[a]], items[idxs[b]] + sa := ia.EndLine - ia.StartLine + sb := ib.EndLine - ib.StartLine + if sa != sb { + return sa > sb + } + return ia.StartLine < ib.StartLine + }) + + for ai := 0; ai < len(idxs); ai++ { + parentIdx := idxs[ai] + if consumed[parentIdx] { + continue + } + parent := items[parentIdx] + + for _, childIdx := range idxs[ai+1:] { + if consumed[childIdx] { + continue + } + child := items[childIdx] + if !shouldMerge(parent, child) { + continue + } + consumed[childIdx] = true + if child.Score > parent.Score { + parent.Score = child.Score + } + parent.NestedHits = append(parent.NestedHits, nestedHit{ + StartLine: child.StartLine, + EndLine: child.EndLine, + SymbolName: child.SymbolName, + ChunkType: child.ChunkType, + Score: child.Score, + }) + } + items[parentIdx] = parent + } + } + + out := make([]searchResultItem, 0, len(items)) + for i := range items { + if !consumed[i] { + out = append(out, items[i]) + } + } + + sort.SliceStable(out, func(i, j int) bool { + return out[i].Score > out[j].Score + }) + return out +} + +// shouldMerge returns true when child should be absorbed into parent. +// Two cases trigger a merge — see mergeOverlappingHits doc-comment for +// the rationale. +func shouldMerge(parent, child searchResultItem) bool { + if parent.FilePath != child.FilePath { + return false + } + // Case 1: parent's range strictly contains child's range. We require a + // strict containment (i.e. it's NOT the same range) to avoid merging + // duplicates from per-language fan-out — those should be deduped at the + // vector-store layer, not here. + if parent.StartLine <= child.StartLine && parent.EndLine >= child.EndLine { + if parent.StartLine != child.StartLine || parent.EndLine != child.EndLine { + return true + } + } + // Case 2: same-symbol adjacent ranges. After splitChunk, only the + // first piece keeps SymbolName, so the typical pattern is + // {symbol=run, lines 61..195} + {symbol="" tail block, lines 196..198}. + // Adjacency by itself isn't enough — we need at least one to carry the + // symbol so we know they're related; otherwise we'd merge unrelated + // neighbouring chunks. + if parent.SymbolName != "" || child.SymbolName != "" { + if parent.EndLine+1 == child.StartLine || child.EndLine+1 == parent.StartLine { + return true + } + } + return false +} diff --git a/server/internal/httpapi/search_merge_test.go b/server/internal/httpapi/search_merge_test.go new file mode 100644 index 0000000..8634428 --- /dev/null +++ b/server/internal/httpapi/search_merge_test.go @@ -0,0 +1,262 @@ +package httpapi + +import ( + "testing" +) + +func mkItem(file string, start, end int, score float32, symbol, kind string) searchResultItem { + return searchResultItem{ + FilePath: file, + StartLine: start, + EndLine: end, + Score: score, + SymbolName: symbol, + ChunkType: kind, + Language: "go", + } +} + +// TestMerge_NestedSections: H1 (1-200) wraps H2 (27-80), which wraps H3 (29-50). +// All three matched the query — output should be the H1 chunk with +// 2 nested hits, score = max of all three. +func TestMerge_NestedSections(t *testing.T) { + items := []searchResultItem{ + mkItem("README.md", 1, 200, 0.30, "", "section"), + mkItem("README.md", 27, 80, 0.45, "", "section"), + mkItem("README.md", 29, 50, 0.50, "", "section"), + } + out := mergeOverlappingHits(items) + if len(out) != 1 { + t.Fatalf("want 1 merged result, got %d", len(out)) + } + got := out[0] + if got.StartLine != 1 || got.EndLine != 200 { + t.Errorf("expected outer range 1-200, got %d-%d", got.StartLine, got.EndLine) + } + if got.Score != 0.50 { + t.Errorf("merged score = %v, want max=0.50", got.Score) + } + if len(got.NestedHits) != 2 { + t.Fatalf("want 2 nested hits, got %d", len(got.NestedHits)) + } +} + +// TestMerge_SameSymbolAdjacent: splitChunk emitted run() as +// - lines 61-195, function:run +// - lines 196-198, block, no symbol +// Merge the second into the first. +func TestMerge_SameSymbolAdjacent(t *testing.T) { + items := []searchResultItem{ + mkItem("main.go", 61, 195, 0.40, "run", "function"), + mkItem("main.go", 196, 198, 0.30, "", "block"), + } + out := mergeOverlappingHits(items) + if len(out) != 1 { + t.Fatalf("want 1 merged result, got %d", len(out)) + } + if out[0].StartLine != 61 || out[0].EndLine != 195 { + // Parent absorbs child; parent's range stays as-is. + t.Errorf("merged range = %d-%d, want 61-195", out[0].StartLine, out[0].EndLine) + } + if out[0].SymbolName != "run" { + t.Errorf("symbol lost: got %q, want run", out[0].SymbolName) + } +} + +// TestMerge_SiblingsNotMerged: two H2 sections in same file at separate +// non-overlapping ranges → keep both. +func TestMerge_SiblingsNotMerged(t *testing.T) { + items := []searchResultItem{ + mkItem("doc.md", 10, 30, 0.40, "", "section"), + mkItem("doc.md", 50, 90, 0.45, "", "section"), + } + out := mergeOverlappingHits(items) + if len(out) != 2 { + t.Fatalf("siblings should stay separate, got %d results", len(out)) + } +} + +// TestMerge_DifferentFiles: same line range, different files → not merged. +func TestMerge_DifferentFiles(t *testing.T) { + items := []searchResultItem{ + mkItem("a.go", 10, 30, 0.40, "fn", "function"), + mkItem("b.go", 10, 30, 0.45, "fn", "function"), + } + out := mergeOverlappingHits(items) + if len(out) != 2 { + t.Fatalf("cross-file dupes shouldn't merge, got %d", len(out)) + } +} + +// TestMerge_ExactDuplicateNotAbsorbed: same range twice (e.g. fan-out +// hiccup) — these should be deduped upstream (dedupByLocation), not by +// merge. We treat them as siblings here. +func TestMerge_ExactDuplicateNotAbsorbed(t *testing.T) { + items := []searchResultItem{ + mkItem("x.go", 1, 100, 0.30, "Foo", "class"), + mkItem("x.go", 1, 100, 0.40, "Foo", "class"), + } + out := mergeOverlappingHits(items) + if len(out) != 2 { + t.Errorf("exact duplicates should NOT be merged here (dedup is a separate step), got %d", len(out)) + } +} + +// TestMerge_RescoreUsesMax: parent had lower score than child → merged +// result inherits child's higher score. +func TestMerge_RescoreUsesMax(t *testing.T) { + items := []searchResultItem{ + mkItem("a.go", 1, 100, 0.20, "Outer", "class"), + mkItem("a.go", 30, 50, 0.80, "inner", "method"), + } + out := mergeOverlappingHits(items) + if len(out) != 1 { + t.Fatalf("want 1, got %d", len(out)) + } + if out[0].Score != 0.80 { + t.Errorf("merged score = %v, want 0.80", out[0].Score) + } + if len(out[0].NestedHits) != 1 || out[0].NestedHits[0].SymbolName != "inner" { + t.Errorf("nested hit missing or wrong: %+v", out[0].NestedHits) + } +} + +// TestMerge_ResortByMergedScore: merged item's max score should bring it +// to the top of the result list. +func TestMerge_ResortByMergedScore(t *testing.T) { + items := []searchResultItem{ + mkItem("a.go", 1, 100, 0.20, "Outer", "class"), // will absorb 0.80 + mkItem("a.go", 30, 50, 0.80, "inner", "method"), + mkItem("b.go", 1, 50, 0.50, "other", "function"), + } + out := mergeOverlappingHits(items) + if len(out) != 2 { + t.Fatalf("want 2 results after merge, got %d", len(out)) + } + if out[0].FilePath != "a.go" { + t.Errorf("merged a.go (score 0.80) should be first, got %s (score %v)", out[0].FilePath, out[0].Score) + } +} + +// TestMerge_NoOverlapNoMerge: completely disjoint hits stay as-is and +// keep their original score order. +func TestMerge_NoOverlapNoMerge(t *testing.T) { + items := []searchResultItem{ + mkItem("a.go", 1, 5, 0.50, "fnA", "function"), + mkItem("b.go", 10, 15, 0.40, "fnB", "function"), + mkItem("c.go", 20, 25, 0.30, "fnC", "function"), + } + out := mergeOverlappingHits(items) + if len(out) != 3 { + t.Fatalf("disjoint items should stay separate, got %d", len(out)) + } + if out[0].Score != 0.50 || out[1].Score != 0.40 || out[2].Score != 0.30 { + t.Errorf("score order broken: %v / %v / %v", out[0].Score, out[1].Score, out[2].Score) + } +} + +// TestMerge_TripleNesting: H1 -> H2 -> H3, all match. After merge, ONE +// result with 2 nested hits (H2 and H3 inside H1). +func TestMerge_TripleNesting(t *testing.T) { + items := []searchResultItem{ + mkItem("d.md", 1, 100, 0.30, "", "section"), + mkItem("d.md", 10, 50, 0.40, "", "section"), + mkItem("d.md", 20, 30, 0.55, "", "section"), + } + out := mergeOverlappingHits(items) + if len(out) != 1 { + t.Fatalf("triple nesting → 1 result, got %d", len(out)) + } + if len(out[0].NestedHits) != 2 { + t.Errorf("want 2 nested hits, got %d", len(out[0].NestedHits)) + } +} + +// --- groupByFile ---------------------------------------------------------- + +// TestGroupByFile_SortsByBestScore: files are ordered by best chunk score +// descending. main.go's best chunk (0.80) outranks doc.md's best (0.60). +func TestGroupByFile_SortsByBestScore(t *testing.T) { + items := []searchResultItem{ + mkItem("doc.md", 1, 10, 0.60, "", "section"), + mkItem("main.go", 5, 20, 0.40, "Foo", "function"), + mkItem("main.go", 30, 50, 0.80, "Bar", "function"), + } + groups := groupByFile(items) + if len(groups) != 2 { + t.Fatalf("want 2 groups, got %d", len(groups)) + } + if groups[0].FilePath != "main.go" || groups[0].BestScore != 0.80 { + t.Errorf("first group should be main.go (0.80), got %+v", groups[0]) + } + if groups[1].FilePath != "doc.md" { + t.Errorf("second group should be doc.md, got %s", groups[1].FilePath) + } +} + +// TestGroupByFile_SortsMatchesByLineAsc: inside a file, matches read top- +// to-bottom — score order is for FILE ranking, not for matches inside. +func TestGroupByFile_SortsMatchesByLineAsc(t *testing.T) { + items := []searchResultItem{ + mkItem("a.go", 100, 120, 0.50, "later", "function"), + mkItem("a.go", 30, 50, 0.80, "earlier", "function"), + mkItem("a.go", 200, 220, 0.40, "latest", "function"), + } + groups := groupByFile(items) + if len(groups) != 1 { + t.Fatalf("want 1 group, got %d", len(groups)) + } + ms := groups[0].Matches + if len(ms) != 3 { + t.Fatalf("want 3 matches, got %d", len(ms)) + } + if ms[0].StartLine != 30 || ms[1].StartLine != 100 || ms[2].StartLine != 200 { + t.Errorf("matches not sorted by StartLine asc: %v %v %v", + ms[0].StartLine, ms[1].StartLine, ms[2].StartLine) + } + // Best score still tracks the max score across all matches. + if groups[0].BestScore != 0.80 { + t.Errorf("best score = %v, want 0.80", groups[0].BestScore) + } +} + +// TestGroupByFile_PreservesNestedHits: items that survived merge with +// nested_hits attached should carry them through into the file group. +func TestGroupByFile_PreservesNestedHits(t *testing.T) { + parent := mkItem("d.md", 1, 100, 0.50, "", "section") + parent.NestedHits = []nestedHit{ + {StartLine: 10, EndLine: 30, ChunkType: "section", Score: 0.60}, + } + groups := groupByFile([]searchResultItem{parent}) + if len(groups) != 1 || len(groups[0].Matches) != 1 { + t.Fatalf("unexpected shape: %+v", groups) + } + if len(groups[0].Matches[0].NestedHits) != 1 { + t.Errorf("nested hits dropped during groupByFile: %+v", groups[0].Matches[0]) + } +} + +// TestGroupByFile_Empty: nil/empty in → nil out. +func TestGroupByFile_Empty(t *testing.T) { + if groupByFile(nil) != nil { + t.Error("nil input should produce nil output") + } + if groupByFile([]searchResultItem{}) != nil { + t.Error("empty input should produce nil output") + } +} + +// TestMerge_AdjacentNoSymbolNotMerged: two anonymous chunks adjacent in +// the same file are NOT merged — we only merge adjacent chunks if at +// least one carries a symbol (otherwise we have no signal that they're +// related). +func TestMerge_AdjacentNoSymbolNotMerged(t *testing.T) { + items := []searchResultItem{ + mkItem("x.go", 1, 50, 0.40, "", "module"), + mkItem("x.go", 51, 100, 0.45, "", "module"), + } + out := mergeOverlappingHits(items) + if len(out) != 2 { + t.Errorf("anonymous adjacent chunks shouldn't merge, got %d", len(out)) + } +} diff --git a/server/internal/httpapi/server.go b/server/internal/httpapi/server.go new file mode 100644 index 0000000..cc6547a --- /dev/null +++ b/server/internal/httpapi/server.go @@ -0,0 +1,1101 @@ +package httpapi + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "os" + "path/filepath" + "sort" + "strconv" + "strings" + "time" + + "github.com/dvcdsys/code-index/server/internal/embeddings" + "github.com/dvcdsys/code-index/server/internal/httpapi/openapi" + "github.com/dvcdsys/code-index/server/internal/indexer" + "github.com/dvcdsys/code-index/server/internal/langdetect" + "github.com/dvcdsys/code-index/server/internal/projects" + "github.com/dvcdsys/code-index/server/internal/symbolindex" + "github.com/dvcdsys/code-index/server/internal/vectorstore" +) + +// Server is the chi-server implementation generated from doc/openapi.yaml. +// It owns the Deps bundle and translates between the generated types and +// the internal package types (projects.Project, indexer.Progress, etc.). +// +// Wire format guarantee: every JSON shape this struct emits is byte-identical +// to the pre-OpenAPI handler closures it replaced. The migration changes +// internal organisation only — request/response keys, status codes, and +// header behaviour are unchanged. +type Server struct { + Deps Deps + + // loginLimiter throttles POST /auth/login. Initialised by NewRouter + // so each test fixture (and each running server) gets its own + // in-memory state. + loginLimiter *loginLimiter +} + +// Compile-time assertion that Server implements the generated interface. +var _ openapi.ServerInterface = (*Server)(nil) + +// --------------------------------------------------------------------------- +// Probe endpoints +// --------------------------------------------------------------------------- + +// GetHealth — GET /health (public). +func (s *Server) GetHealth(w http.ResponseWriter, r *http.Request) { + if s.Deps.DB != nil { + pingCtx, cancel := context.WithTimeout(r.Context(), time.Second) + defer cancel() + if err := s.Deps.DB.PingContext(pingCtx); err != nil { + writeJSON(w, http.StatusServiceUnavailable, map[string]any{ + "status": "unhealthy", + "reason": "db unreachable", + }) + return + } + } + writeJSON(w, http.StatusOK, map[string]any{"status": "ok"}) +} + +// GetStatus — GET /api/v1/status. +func (s *Server) GetStatus(w http.ResponseWriter, r *http.Request) { + projectCount := 0 + activeJobs := 0 + if s.Deps.DB != nil { + _ = s.Deps.DB.QueryRowContext(r.Context(), + `SELECT COUNT(*) FROM projects`).Scan(&projectCount) + _ = s.Deps.DB.QueryRowContext(r.Context(), + `SELECT COUNT(*) FROM index_runs WHERE status = 'running'`).Scan(&activeJobs) + } + modelLoaded := false + if s.Deps.EmbeddingSvc != nil { + readyCtx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond) + modelLoaded = s.Deps.EmbeddingSvc.Ready(readyCtx) == nil + cancel() + } + // PR-E — embedding_model must reflect the LIVE config (after any + // dashboard runtime override + restart), not the boot-time value + // stamped into Deps. Fall back to Deps when the service is a fake or + // disabled, so test fixtures still get a stable string. + model := s.Deps.EmbeddingModel + if es, ok := s.Deps.EmbeddingSvc.(*embeddings.Service); ok && es != nil { + if cfg := es.Config(); cfg != nil && cfg.EmbeddingModel != "" { + model = cfg.EmbeddingModel + } + } + resp := map[string]any{ + "status": "ok", + "backend": s.Deps.Backend, + "server_version": s.Deps.ServerVersion, + "api_version": s.Deps.APIVersion, + "model_loaded": modelLoaded, + "embedding_model": model, + "projects": projectCount, + "active_indexing_jobs": activeJobs, + } + // Version-check fields — folded in only when the service is wired. + // `update_available` is always present (false when unknown) so the + // dashboard can branch without a null check; the optional URL/version + // fields stay nullable so the banner knows when there's nothing to + // link to yet. + if s.Deps.VersionCheck != nil { + snap := s.Deps.VersionCheck.Latest() + resp["update_available"] = snap.UpdateAvailable + resp["latest_version"] = nilIfEmpty(snap.LatestVersion) + resp["release_url"] = nilIfEmpty(snap.ReleaseURL) + vc := map[string]any{ + "enabled": snap.Enabled, + "error": nilIfEmpty(snap.LastError), + } + if snap.CheckedAt.IsZero() { + vc["checked_at"] = nil + } else { + vc["checked_at"] = snap.CheckedAt.Format(time.RFC3339) + } + resp["version_check"] = vc + } + writeJSON(w, http.StatusOK, resp) +} + +// nilIfEmpty returns nil for an empty string so writeJSON emits `null` +// rather than `""`. Lets the dashboard branch on `field !== null`. +func nilIfEmpty(s string) any { + if s == "" { + return nil + } + return s +} + +// --------------------------------------------------------------------------- +// Project CRUD +// --------------------------------------------------------------------------- + +// CreateProject — POST /api/v1/projects. +func (s *Server) CreateProject(w http.ResponseWriter, r *http.Request) { + var body openapi.CreateProjectRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.HostPath == "" { + writeError(w, http.StatusUnprocessableEntity, "host_path is required") + return + } + p, err := projects.Create(r.Context(), s.Deps.DB, projects.CreateRequest{HostPath: body.HostPath}) + if err != nil { + if errors.Is(err, projects.ErrConflict) || errors.Is(err, projects.ErrOverlap) { + writeError(w, http.StatusConflict, err.Error()) + return + } + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + writeJSON(w, http.StatusCreated, projectToOpenAPI(p)) +} + +// ListProjects — GET /api/v1/projects. +func (s *Server) ListProjects(w http.ResponseWriter, r *http.Request) { + list, err := projects.List(r.Context(), s.Deps.DB) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + out := make([]openapi.Project, 0, len(list)) + for i := range list { + out = append(out, projectToOpenAPI(&list[i])) + } + writeJSON(w, http.StatusOK, openapi.ProjectListResponse{ + Projects: out, + Total: len(out), + }) +} + +// GetProject — GET /api/v1/projects/{path}. +func (s *Server) GetProject(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + out := projectToOpenAPI(p) + s.enrichProjectStorage(&out, p) + writeJSON(w, http.StatusOK, out) +} + +// enrichProjectStorage fills the storage-related Project fields. Skipped +// when embeddings are disabled / unavailable — callers see those as nil and +// the dashboard hides the section. Per-call os.Stat is cheap enough for the +// single-project endpoint; we deliberately do NOT enrich the list endpoint +// (would multiply stat calls × N projects on every page load). +func (s *Server) enrichProjectStorage(out *openapi.Project, p *projects.Project) { + es, ok := s.Deps.EmbeddingSvc.(*embeddings.Service) + if !ok || es == nil { + return + } + cfg := es.Config() + if cfg == nil { + return + } + sqlitePath := cfg.DynamicSQLitePath() + if sqlitePath != "" { + out.SqlitePath = ptrString(sqlitePath) + if info, err := os.Stat(sqlitePath); err == nil { + sz := info.Size() + out.SqliteSizeBytes = &sz + } + } + if cfg.ChromaPersistDir != "" { + col := vectorstore.CollectionName(p.HostPath) + dir := filepath.Join(cfg.DynamicChromaPersistDir(), col) + out.ChromaPath = ptrString(dir) + if sz, ok := dirSizeBytes(dir); ok { + out.ChromaSizeBytes = &sz + } + } +} + +// dirSizeBytes walks dir and sums regular-file sizes. Returns (0,false) on +// any error (missing dir, permission, etc.) so callers can decide to omit +// the field rather than report a misleading 0. +func dirSizeBytes(dir string) (int64, bool) { + var total int64 + walkErr := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() { + return nil + } + info, err := d.Info() + if err != nil { + return nil + } + total += info.Size() + return nil + }) + if walkErr != nil { + return 0, false + } + return total, true +} + +// UpdateProject — PATCH /api/v1/projects/{path}. Admin-only: settings +// changes can shrink the indexing surface (exclude_patterns, max_file_size) +// and viewers should not be able to silently de-index a project. +func (s *Server) UpdateProject(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + p := s.lookupProject(w, r, path) + if p == nil { + return + } + var body openapi.UpdateProjectRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + var settingsPtr *projects.Settings + if body.Settings != nil { + s := projects.Settings{ + ExcludePatterns: body.Settings.ExcludePatterns, + MaxFileSize: body.Settings.MaxFileSize, + } + settingsPtr = &s + } + updated, err := projects.Patch(r.Context(), s.Deps.DB, p.HostPath, projects.UpdateRequest{Settings: settingsPtr}) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + writeJSON(w, http.StatusOK, projectToOpenAPI(updated)) +} + +// DeleteProject — DELETE /api/v1/projects/{path}. Admin-only: dropping a +// project also wipes its symbols/refs/embeddings and is destructive enough +// that it must not be reachable from a viewer-scoped session or API key. +func (s *Server) DeleteProject(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if err := projects.Delete(r.Context(), s.Deps.DB, p.HostPath); err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + w.WriteHeader(http.StatusNoContent) +} + +// --------------------------------------------------------------------------- +// Symbol / definition / reference / file search +// --------------------------------------------------------------------------- + +// SearchSymbols — POST /api/v1/projects/{path}/search/symbols. +func (s *Server) SearchSymbols(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + var body openapi.SymbolSearchRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.Query == "" { + writeError(w, http.StatusUnprocessableEntity, "query is required") + return + } + limit := clampLimit(body.Limit, 20) + kinds := derefStringSlice(body.Kinds) + + symbols, err := symbolindex.SearchByName(r.Context(), s.Deps.DB, p.HostPath, body.Query, kinds, limit) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + results := make([]openapi.SymbolResultItem, 0, len(symbols)) + for _, sym := range symbols { + results = append(results, openapi.SymbolResultItem{ + Name: sym.Name, + Kind: sym.Kind, + FilePath: sym.FilePath, + Line: sym.Line, + EndLine: sym.EndLine, + Language: sym.Language, + Signature: sym.Signature, + ParentName: sym.ParentName, + }) + } + writeJSON(w, http.StatusOK, openapi.SymbolSearchResponse{ + Results: results, + Total: len(results), + }) +} + +// SearchDefinitions — POST /api/v1/projects/{path}/search/definitions. +func (s *Server) SearchDefinitions(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + var body openapi.DefinitionRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.Symbol == "" { + writeError(w, http.StatusUnprocessableEntity, "symbol is required") + return + } + limit := clampLimit(body.Limit, 10) + kind := derefString(body.Kind) + filePath := derefString(body.FilePath) + + syms, err := symbolindex.SearchDefinitions(r.Context(), s.Deps.DB, p.HostPath, body.Symbol, kind, filePath, limit) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + results := make([]openapi.DefinitionItem, 0, len(syms)) + for _, sym := range syms { + results = append(results, openapi.DefinitionItem{ + Name: sym.Name, + Kind: sym.Kind, + FilePath: sym.FilePath, + Line: sym.Line, + EndLine: sym.EndLine, + Language: sym.Language, + Signature: sym.Signature, + ParentName: sym.ParentName, + }) + } + writeJSON(w, http.StatusOK, openapi.DefinitionResponse{ + Results: results, + Total: len(results), + }) +} + +// SearchReferences — POST /api/v1/projects/{path}/search/references. +func (s *Server) SearchReferences(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + var body openapi.ReferenceRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.Symbol == "" { + writeError(w, http.StatusUnprocessableEntity, "symbol is required") + return + } + limit := clampLimit(body.Limit, 50) + filePath := derefString(body.FilePath) + + refs, err := symbolindex.SearchReferences(r.Context(), s.Deps.DB, p.HostPath, body.Symbol, filePath, limit) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + results := make([]openapi.ReferenceItem, 0, len(refs)) + for _, ref := range refs { + results = append(results, openapi.ReferenceItem{ + FilePath: ref.FilePath, + StartLine: ref.Line, + EndLine: ref.Line, + Content: "", + ChunkType: openapi.ReferenceItemChunkType("reference"), + SymbolName: ref.Name, + Language: ref.Language, + }) + } + writeJSON(w, http.StatusOK, openapi.ReferenceResponse{ + Results: results, + Total: len(results), + }) +} + +// SearchFiles — POST /api/v1/projects/{path}/search/files. +func (s *Server) SearchFiles(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + var body openapi.FileSearchRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.Query == "" { + writeError(w, http.StatusUnprocessableEntity, "query is required") + return + } + limit := clampLimit(body.Limit, 20) + + rows, err := s.Deps.DB.QueryContext(r.Context(), + `SELECT file_path FROM file_hashes WHERE project_path = ? AND file_path LIKE ? ORDER BY file_path LIMIT ?`, + p.HostPath, "%"+body.Query+"%", limit, + ) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + results := make([]openapi.FileResultItem, 0, limit) + for rows.Next() { + var fp string + if err := rows.Scan(&fp); err != nil { + rows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + lang := langdetect.Detect(fp) + var langPtr *string + if lang != "" { + langPtr = &lang + } + results = append(results, openapi.FileResultItem{ + FilePath: fp, + Language: langPtr, + }) + } + if err := rows.Err(); err != nil { + rows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + rows.Close() + writeJSON(w, http.StatusOK, openapi.FileSearchResponse{ + Results: results, + Total: len(results), + }) +} + +// --------------------------------------------------------------------------- +// Project summary +// --------------------------------------------------------------------------- + +// GetProjectSummary — GET /api/v1/projects/{path}/summary. +func (s *Server) GetProjectSummary(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + + dirCount := map[string]int{} + { + rows, err := s.Deps.DB.QueryContext(r.Context(), + `SELECT file_path FROM file_hashes WHERE project_path = ?`, p.HostPath, + ) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + for rows.Next() { + var fp string + if err := rows.Scan(&fp); err != nil { + rows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + parts := splitPath(fp) + var key string + if len(parts) > 3 { + key = joinPath(parts[:4]) + } else if len(parts) > 1 { + key = joinPath(parts[:2]) + } + if key != "" { + dirCount[key]++ + } + } + if err := rows.Err(); err != nil { + rows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + rows.Close() + } + topDirs := topNDirs(dirCount, 10) + + var recentSyms []openapi.SymbolEntry + { + symRows, err := s.Deps.DB.QueryContext(r.Context(), + `SELECT name, kind, file_path, language FROM symbols WHERE project_path = ? LIMIT 20`, + p.HostPath, + ) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + for symRows.Next() { + var e openapi.SymbolEntry + if err := symRows.Scan(&e.Name, &e.Kind, &e.FilePath, &e.Language); err != nil { + symRows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + recentSyms = append(recentSyms, e) + } + if err := symRows.Err(); err != nil { + symRows.Close() + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + symRows.Close() + } + if recentSyms == nil { + recentSyms = []openapi.SymbolEntry{} + } + + var totalSymbols int + _ = s.Deps.DB.QueryRowContext(r.Context(), + `SELECT COUNT(*) FROM symbols WHERE project_path = ?`, p.HostPath, + ).Scan(&totalSymbols) + + langs := p.Languages + if langs == nil { + langs = []string{} + } + + writeJSON(w, http.StatusOK, openapi.ProjectSummary{ + PathHash: projects.HashPath(p.HostPath), + HostPath: p.HostPath, + Status: p.Status, + Languages: langs, + TotalFiles: p.Stats.TotalFiles, + TotalChunks: p.Stats.TotalChunks, + TotalSymbols: totalSymbols, + TopDirectories: topDirs, + RecentSymbols: recentSyms, + }) +} + +// --------------------------------------------------------------------------- +// Semantic search +// --------------------------------------------------------------------------- + +// SemanticSearch — POST /api/v1/projects/{path}/search. +func (s *Server) SemanticSearch(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.VectorStore == nil || s.Deps.EmbeddingSvc == nil { + writeError(w, http.StatusServiceUnavailable, "semantic search not configured") + return + } + var body openapi.SemanticSearchRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if strings.TrimSpace(body.Query) == "" { + writeError(w, http.StatusUnprocessableEntity, "query is required") + return + } + limit := clampLimit(body.Limit, 10) + languages := derefStringSlice(body.Languages) + paths := derefStringSlice(body.Paths) + excludes := derefStringSlice(body.Excludes) + + minScore := float32(0.4) + if body.MinScore != nil { + minScore = *body.MinScore + } + + start := time.Now() + + qEmb, err := s.Deps.EmbeddingSvc.EmbedQuery(r.Context(), body.Query) + if err != nil { + if retry, busy := embeddings.IsBusy(err); busy { + w.Header().Set("Retry-After", strconv.Itoa(retry)) + writeError(w, http.StatusServiceUnavailable, + "GPU is busy processing another embedding request, retry after "+strconv.Itoa(retry)+"s") + return + } + if errors.Is(err, embeddings.ErrDisabled) { + writeError(w, http.StatusServiceUnavailable, "embeddings disabled") + return + } + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + + langSet := map[string]struct{}{} + for _, l := range languages { + langSet[l] = struct{}{} + } + applyPostLangFilter := len(languages) > maxFanoutSearch + + var fileGroups []fileGroupResult + factor := 2 + for { + n := limit * factor + rawWrapped, err := fetchVectorResults( + r.Context(), s.Deps.VectorStore, p.HostPath, qEmb, n, languages, + ) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + filtered := filterToSearchItems(rawWrapped, minScore, paths, excludes, langSet, applyPostLangFilter) + merged := mergeOverlappingHits(filtered) + fileGroups = groupByFile(merged) + if len(fileGroups) >= limit { + break + } + if len(rawWrapped) < n { + break + } + if factor >= maxFactorSearch { + break + } + factor *= 2 + } + if len(fileGroups) > limit { + fileGroups = fileGroups[:limit] + } + + elapsedMS := float64(time.Since(start).Microseconds()) / 1000.0 + elapsedMS = float64(int(elapsedMS*10+0.5)) / 10 + + writeJSON(w, http.StatusOK, openapi.SemanticSearchResponse{ + Results: fileGroupsToOpenAPI(fileGroups), + Total: len(fileGroups), + QueryTimeMs: elapsedMS, + }) +} + +// fileGroupsToOpenAPI converts the internal []fileGroupResult into the +// generated []openapi.FileGroupResult. Wire-compat: openapi.FileGroupResult +// uses *string for Language (with omitempty) instead of plain string — +// nil pointer and empty string both produce an absent JSON key. +func fileGroupsToOpenAPI(in []fileGroupResult) []openapi.FileGroupResult { + out := make([]openapi.FileGroupResult, len(in)) + for i, g := range in { + var langPtr *string + if g.Language != "" { + lang := g.Language + langPtr = &lang + } + matches := make([]openapi.FileMatch, len(g.Matches)) + for j, m := range g.Matches { + var nested *[]openapi.NestedHit + if len(m.NestedHits) > 0 { + ns := make([]openapi.NestedHit, len(m.NestedHits)) + for k, n := range m.NestedHits { + var symPtr *string + if n.SymbolName != "" { + v := n.SymbolName + symPtr = &v + } + ns[k] = openapi.NestedHit{ + StartLine: n.StartLine, + EndLine: n.EndLine, + SymbolName: symPtr, + ChunkType: n.ChunkType, + Score: n.Score, + } + } + nested = &ns + } + var symPtr *string + if m.SymbolName != "" { + v := m.SymbolName + symPtr = &v + } + matches[j] = openapi.FileMatch{ + StartLine: m.StartLine, + EndLine: m.EndLine, + Content: m.Content, + Score: m.Score, + ChunkType: m.ChunkType, + SymbolName: symPtr, + NestedHits: nested, + } + } + out[i] = openapi.FileGroupResult{ + FilePath: g.FilePath, + Language: langPtr, + BestScore: g.BestScore, + Matches: matches, + } + } + return out +} + +// --------------------------------------------------------------------------- +// Indexing — three-phase protocol +// --------------------------------------------------------------------------- + +// IndexBegin — POST /api/v1/projects/{path}/index/begin. +func (s *Server) IndexBegin(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.Indexer == nil { + writeError(w, http.StatusServiceUnavailable, "indexer not configured") + return + } + var body openapi.IndexBeginRequest + // Body is optional — accept empty request. + if r.ContentLength > 0 { + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + } + full := body.Full != nil && *body.Full + + runID, stored, err := s.Deps.Indexer.BeginIndexing(r.Context(), p.HostPath, full) + if err != nil { + if errors.Is(err, indexer.ErrSessionConflict) { + writeError(w, http.StatusConflict, err.Error()) + return + } + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + if stored == nil { + stored = map[string]string{} + } + writeJSON(w, http.StatusOK, openapi.IndexBeginResponse{ + RunId: runID, + StoredHashes: stored, + }) +} + +// IndexFiles — POST /api/v1/projects/{path}/index/files. +// +// Honours `Accept: application/x-ndjson` to switch into the streaming +// variant; otherwise returns the legacy single-JSON summary. +func (s *Server) IndexFiles(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash, params openapi.IndexFilesParams) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.Indexer == nil { + writeError(w, http.StatusServiceUnavailable, "indexer not configured") + return + } + var body openapi.IndexFilesRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.RunId == "" { + writeError(w, http.StatusUnprocessableEntity, "run_id is required") + return + } + if len(body.Files) > maxFilesPerBatch { + writeError(w, http.StatusUnprocessableEntity, "too many files in batch (max 50)") + return + } + files := make([]indexer.FilePayload, len(body.Files)) + for i, f := range body.Files { + files[i] = indexer.FilePayload{ + Path: f.Path, + Content: f.Content, + ContentHash: f.ContentHash, + Language: derefString(f.Language), + Size: f.Size, + } + } + + // Accept-header negotiation. We re-read directly from the header rather + // than trusting params.Accept alone because chi-server passes the + // header verbatim — old clients that omit Accept get the JSON branch, + // new clients that send `application/x-ndjson` get the stream. + if acceptsNDJSON(r.Header.Get("Accept")) { + indexFilesStreamingHandler(s.Deps, p, body.RunId, files, w, r) + return + } + + accepted, chunks, total, err := s.Deps.Indexer.ProcessFiles(r.Context(), p.HostPath, body.RunId, files) + if err != nil { + if retry, busy := embeddings.IsBusy(err); busy { + w.Header().Set("Retry-After", strconv.Itoa(retry)) + writeError(w, http.StatusServiceUnavailable, + "GPU is busy processing another embedding request, retry after "+strconv.Itoa(retry)+"s") + return + } + if errors.Is(err, indexer.ErrNoSession) || errors.Is(err, indexer.ErrProjectMismatch) { + writeError(w, http.StatusNotFound, err.Error()) + return + } + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + writeJSON(w, http.StatusOK, openapi.IndexFilesResponse{ + FilesAccepted: accepted, + ChunksCreated: chunks, + FilesProcessedTotal: total, + }) +} + +// IndexFinish — POST /api/v1/projects/{path}/index/finish. +func (s *Server) IndexFinish(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.Indexer == nil { + writeError(w, http.StatusServiceUnavailable, "indexer not configured") + return + } + var body openapi.IndexFinishRequest + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid request body") + return + } + if body.RunId == "" { + writeError(w, http.StatusUnprocessableEntity, "run_id is required") + return + } + deletedPaths := derefStringSlice(body.DeletedPaths) + totalDiscovered := derefIntOrDefault(body.TotalFilesDiscovered, 0) + + status, files, chunks, err := s.Deps.Indexer.FinishIndexing( + r.Context(), p.HostPath, body.RunId, deletedPaths, totalDiscovered, + ) + if err != nil { + if errors.Is(err, indexer.ErrNoSession) || errors.Is(err, indexer.ErrProjectMismatch) { + writeError(w, http.StatusNotFound, err.Error()) + return + } + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + writeJSON(w, http.StatusOK, openapi.IndexFinishResponse{ + Status: openapi.IndexFinishResponseStatus(status), + FilesProcessed: files, + ChunksCreated: chunks, + }) +} + +// IndexCancel — POST /api/v1/projects/{path}/index/cancel. Open to any +// authenticated user. The CLI calls this in its defer-cleanup on early +// exit (Ctrl-C, network drop), so gating it on admin would leave run +// locks hanging for viewers until the 1-hour TTL — worse UX than the +// theoretical DoS we'd be preventing. If you need owner-scoped semantics +// later, key off projects.indexing_run.started_by_user_id. +func (s *Server) IndexCancel(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.Indexer == nil { + writeJSON(w, http.StatusOK, openapi.IndexCancelResponse{Cancelled: false}) + return + } + cancelled, err := s.Deps.Indexer.CancelIndexing(r.Context(), p.HostPath) + if err != nil { + writeError(w, http.StatusInternalServerError, err.Error()) + return + } + writeJSON(w, http.StatusOK, openapi.IndexCancelResponse{Cancelled: cancelled}) +} + +// IndexStatus — GET /api/v1/projects/{path}/index/status. +func (s *Server) IndexStatus(w http.ResponseWriter, r *http.Request, path openapi.ProjectHash) { + p := s.lookupProject(w, r, path) + if p == nil { + return + } + if s.Deps.Indexer == nil { + writeJSON(w, http.StatusOK, openapi.IndexProgressResponse{Status: "idle"}) + return + } + prog := s.Deps.Indexer.GetProgress(p.HostPath) + if prog != nil { + // Active session — emit the full progress payload. We use a + // raw map (not openapi.IndexProgressInfo) to preserve the + // historical wire shape: every field is present even when + // integer-zero (Python emitted these keys unconditionally). + writeJSON(w, http.StatusOK, openapi.IndexProgressResponse{ + Status: openapi.IndexProgressResponseStatus(prog.Status), + Progress: &openapi.IndexProgressInfo{ + Phase: progressPhasePtr(prog.Phase), + FilesDiscovered: ptrInt(prog.FilesDiscovered), + FilesProcessed: ptrInt(prog.FilesProcessed), + FilesTotal: ptrInt(prog.FilesTotal), + ChunksCreated: ptrInt(prog.ChunksCreated), + ElapsedSeconds: ptrFloat64(roundFloat1(prog.ElapsedSeconds)), + RunId: ptrString(prog.RunID), + }, + }) + return + } + // Fall back to last run row. + row := s.Deps.DB.QueryRowContext(r.Context(), + `SELECT status, files_processed, files_total, chunks_created + FROM index_runs WHERE project_path = ? ORDER BY started_at DESC LIMIT 1`, + p.HostPath, + ) + var status string + var filesProcessed, filesTotal, chunks int + if err := row.Scan(&status, &filesProcessed, &filesTotal, &chunks); err != nil { + writeJSON(w, http.StatusOK, openapi.IndexProgressResponse{Status: "idle"}) + return + } + writeJSON(w, http.StatusOK, openapi.IndexProgressResponse{ + Status: openapi.IndexProgressResponseStatus(status), + Progress: &openapi.IndexProgressInfo{ + FilesProcessed: ptrInt(filesProcessed), + FilesTotal: ptrInt(filesTotal), + ChunksCreated: ptrInt(chunks), + }, + }) +} + +// --------------------------------------------------------------------------- +// Internal helpers — type conversion + legacy lookup wrapper +// --------------------------------------------------------------------------- + +// lookupProject resolves the {path} URL parameter. Wraps resolveProjectFromHash +// so generated method signatures stay clean. +func (s *Server) lookupProject(w http.ResponseWriter, r *http.Request, _ openapi.ProjectHash) *projects.Project { + // Use the helper that already exists in search.go — it pulls the + // {path} chi URL param from r and writes a 404 on miss. + return resolveProjectFromHash(w, r, s.Deps) +} + +// projectToOpenAPI converts the internal projects.Project (string dates, +// flat Settings/Stats) into the generated openapi.Project (time.Time dates, +// embedded openapi.ProjectSettings/Stats). +// +// Wire-compat: projects.Project.CreatedAt/UpdatedAt/LastIndexedAt are +// RFC3339Nano strings produced by indexer.nowUTC (time.RFC3339Nano). Go's +// time.Time MarshalJSON also emits RFC3339Nano; round-tripping through +// time.Parse → time.Time produces byte-identical JSON output. +func projectToOpenAPI(p *projects.Project) openapi.Project { + langs := p.Languages + if langs == nil { + langs = []string{} + } + created, _ := time.Parse(time.RFC3339Nano, p.CreatedAt) + updated, _ := time.Parse(time.RFC3339Nano, p.UpdatedAt) + var lastIndexed *time.Time + if p.LastIndexedAt != nil { + t, err := time.Parse(time.RFC3339Nano, *p.LastIndexedAt) + if err == nil { + lastIndexed = &t + } + } + out := openapi.Project{ + PathHash: projects.HashPath(p.HostPath), + HostPath: p.HostPath, + ContainerPath: p.ContainerPath, + Languages: langs, + Settings: openapi.ProjectSettings{ + ExcludePatterns: p.Settings.ExcludePatterns, + MaxFileSize: p.Settings.MaxFileSize, + }, + Stats: openapi.ProjectStats{ + TotalFiles: p.Stats.TotalFiles, + IndexedFiles: p.Stats.IndexedFiles, + TotalChunks: p.Stats.TotalChunks, + TotalSymbols: p.Stats.TotalSymbols, + }, + Status: openapi.ProjectStatus(p.Status), + CreatedAt: created, + UpdatedAt: updated, + LastIndexedAt: lastIndexed, + } + if p.IndexedWithModel != nil { + v := *p.IndexedWithModel + out.IndexedWithModel = &v + } + return out +} + +// topNDirs sorts a path→count map descending and returns the top n entries +// as openapi.DirEntry. Replaces the closure-private topN that lived in +// search.go's projectSummaryHandler. +func topNDirs(m map[string]int, n int) []openapi.DirEntry { + type kv struct { + k string + v int + } + kvs := make([]kv, 0, len(m)) + for k, v := range m { + kvs = append(kvs, kv{k, v}) + } + sort.SliceStable(kvs, func(i, j int) bool { return kvs[i].v > kvs[j].v }) + if n > len(kvs) { + n = len(kvs) + } + out := make([]openapi.DirEntry, n) + for i := 0; i < n; i++ { + out[i] = openapi.DirEntry{Path: kvs[i].k, FileCount: kvs[i].v} + } + return out +} + +// progressPhasePtr converts a phase string into a typed pointer; empty +// strings collapse to nil so omitempty drops the key from the wire payload. +func progressPhasePtr(s string) *openapi.IndexProgressInfoPhase { + if s == "" { + return nil + } + v := openapi.IndexProgressInfoPhase(s) + return &v +} + +func ptrInt(v int) *int { return &v } +func ptrFloat64(v float64) *float64 { return &v } +func ptrString(v string) *string { return &v } + +// derefString returns the string pointed to by p, or "" if p is nil. +func derefString(p *string) string { + if p == nil { + return "" + } + return *p +} + +// derefStringSlice returns the slice pointed to by p, or nil if p is nil. +// Use this for optional array fields where downstream code accepts nil. +func derefStringSlice(p *[]string) []string { + if p == nil { + return nil + } + return *p +} + +// derefIntOrDefault returns the int pointed to by p when present and > 0; +// otherwise returns def. This matches the original handlers' behaviour +// `if body.Limit <= 0 { body.Limit = default }`. +func derefIntOrDefault(p *int, def int) int { + if p == nil || *p <= 0 { + return def + } + return *p +} + +// maxResultLimit caps user-supplied limit values to a sane upper bound. +// Anchored at 1000 — far above any legitimate dashboard / CLI page size, +// well below any value that would balloon a slice allocation or stall a +// LIMIT-clause query. CodeQL flags raw user-int → make() or SQL LIMIT +// flows; clampLimit is the chokepoint. +const maxResultLimit = 1000 + +// clampLimit is derefIntOrDefault that additionally caps the result at +// maxResultLimit. Use this for any value that goes into a slice +// allocation or a SQL LIMIT clause; use derefIntOrDefault when the int +// is just metadata. +func clampLimit(p *int, def int) int { + n := derefIntOrDefault(p, def) + if n > maxResultLimit { + return maxResultLimit + } + return n +} diff --git a/server/internal/indexer/indexer.go b/server/internal/indexer/indexer.go index 9839ef6..ee766ea 100644 --- a/server/internal/indexer/indexer.go +++ b/server/internal/indexer/indexer.go @@ -95,6 +95,19 @@ type Service struct { // instead of leaking for up to sessionTTL on server shutdown. stopCh chan struct{} stopOnce sync.Once + + // embedIncludePath, when true, makes ProcessFiles wrap each chunk with + // a "File: \nLanguage: \n..." preamble before embedding. + // Set via SetEmbedIncludePath; default false preserves Python-parity + // ": " formatting for projects that have not been + // reindexed under the new format. + embedIncludePath bool + + // embeddingModel is the active embedding model identifier persisted on + // projects.indexed_with_model at FinishIndexing. Set via + // SetEmbeddingModel from main; empty string keeps the column NULL so + // unit tests that skip the setter don't need to know about drift. + embeddingModel string } // New constructs a Service. All deps are required except logger (falls back to @@ -119,6 +132,22 @@ func (s *Service) Shutdown() { s.stopOnce.Do(func() { close(s.stopCh) }) } +// SetEmbedIncludePath toggles the path+language+symbol preamble that +// ProcessFiles prepends to chunk content before embedding. Toggling between +// runs requires a full reindex — vectors trained against the new preamble +// are not interchangeable with vectors trained on bare content. +func (s *Service) SetEmbedIncludePath(v bool) { + s.embedIncludePath = v +} + +// SetEmbeddingModel records the model identifier the indexer will write to +// projects.indexed_with_model at FinishIndexing. Called from main once the +// runtime config is resolved; empty string disables the write (the column +// stays NULL — desired for tests that don't care about drift tracking). +func (s *Service) SetEmbeddingModel(model string) { + s.embeddingModel = model +} + // --------------------------------------------------------------------------- // Phase 1 — begin // --------------------------------------------------------------------------- @@ -269,9 +298,36 @@ func (s *Service) ProcessFiles( ctx context.Context, projectPath, runID string, files []FilePayload, +) (int, int, int, error) { + return s.ProcessFilesStreaming(ctx, projectPath, runID, files, nil) +} + +// ProcessFilesStreaming is ProcessFiles with an optional progress channel. The +// streaming HTTP handler passes a channel that forwards each event as an +// NDJSON line; non-streaming callers use ProcessFiles which passes nil. +// +// The terminal event (batch_done on success, error fatal=true on failure) is +// sent with a guaranteed-blocking send so the consumer always sees it. +// Per-file progress events use a non-blocking send and may be dropped if the +// consumer is slower than the embed loop — that is acceptable because the +// final summary is what callers depend on. +// +// When progress is non-nil, the channel is left open on return; the caller +// is expected to close it after collecting the terminal event. +func (s *Service) ProcessFilesStreaming( + ctx context.Context, + projectPath, runID string, + files []FilePayload, + progress chan<- ProgressEvent, ) (int, int, int, error) { sess, err := s.requireSession(runID, projectPath) if err != nil { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: err.Error(), + Fatal: true, + RunID: runID, + }) return 0, 0, 0, err } @@ -303,12 +359,28 @@ func (s *Service) ProcessFiles( } }() - for _, fp := range files { + for fi, fp := range files { + // file_started — emit even for files we'll skip below, so the client + // counter advances monotonically and rendering stays aligned with N. + progressSend(progress, ProgressEvent{ + Event: EventFileStarted, + Path: fp.Path, + FileIndex: fi + 1, + BatchSize: len(files), + RunID: runID, + }) + if strings.TrimSpace(fp.Content) == "" { continue } if len(fp.Content) > maxContentBytes { s.logger.Warn("indexer: file too large, skipping", "path", fp.Path, "size_bytes", len(fp.Content)) + progressSend(progress, ProgressEvent{ + Event: EventFileError, + Path: fp.Path, + Message: fmt.Sprintf("file too large (%d bytes)", len(fp.Content)), + Fatal: false, + }) continue } @@ -320,11 +392,22 @@ func (s *Service) ProcessFiles( chunks, refs, err := chunker.ChunkFile(fp.Path, fp.Content, language, 0) if err != nil { s.logger.Warn("indexer: chunk file failed", "path", fp.Path, "err", err) + progressSend(progress, ProgressEvent{ + Event: EventFileError, + Path: fp.Path, + Message: "chunk: " + err.Error(), + Fatal: false, + }) continue } if len(chunks) == 0 { continue } + progressSend(progress, ProgressEvent{ + Event: EventFileChunked, + Path: fp.Path, + Chunks: len(chunks), + }) // Symbol extraction — mirrors Python: function|class|method|type with a name. fileSymbols := make([]symbolindex.Symbol, 0, len(chunks)) @@ -360,12 +443,22 @@ func (s *Service) ProcessFiles( }) } - // Embed. Python prefixes with "{chunk_type}: {content}". + // Embed. Format depends on embedIncludePath: legacy Python-parity + // "{chunk_type}: {content}" when false, or path+language+symbol + // preamble + content when true (see embeddings.FormatChunkForEmbedding). + // Relative path is computed once per file and reused for all its chunks. + relPath := fp.Path + if s.embedIncludePath { + if rp, rerr := filepath.Rel(projectPath, fp.Path); rerr == nil { + relPath = rp + } + } texts := make([]string, len(chunks)) for i, c := range chunks { - texts[i] = c.ChunkType + ": " + c.Content + texts[i] = embeddings.FormatChunkForEmbedding(c, relPath, s.embedIncludePath) } var embs [][]float32 + embedStart := time.Now() if tae, ok := s.emb.(TokenAwareEmbedder); ok { embs, err = tae.TokenizeAndEmbed(ctx, texts) } else { @@ -374,16 +467,38 @@ func (s *Service) ProcessFiles( if err != nil { // Propagate ErrBusy so handler can map to 503 + Retry-After. if _, busy := embeddings.IsBusy(err); busy { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, err } if errors.Is(err, embeddings.ErrDisabled) || errors.Is(err, embeddings.ErrSupervisor) || errors.Is(err, embeddings.ErrNotReady) { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, err } s.logger.Error("indexer: embed texts failed", "path", fp.Path, "err", err) + progressSend(progress, ProgressEvent{ + Event: EventFileError, + Path: fp.Path, + Message: "embed: " + err.Error(), + Fatal: false, + }) continue } + progressSend(progress, ProgressEvent{ + Event: EventFileEmbedded, + Path: fp.Path, + Chunks: len(chunks), + EmbedMS: time.Since(embedStart).Milliseconds(), + }) // Per-file SAVEPOINT so a partial failure rolls back only this file. // savepointName is derived from filesAccepted (monotonically increasing @@ -458,6 +573,11 @@ func (s *Service) ProcessFiles( } if _, err := tx.ExecContext(ctx, "RELEASE SAVEPOINT "+savepointName); err != nil { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: "release savepoint: " + err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, fmt.Errorf("release savepoint: %w", err) } @@ -469,6 +589,12 @@ func (s *Service) ProcessFiles( sess.languagesSeen[language] = struct{}{} s.mu.Unlock() filesAccepted++ + + progressSend(progress, ProgressEvent{ + Event: EventFileDone, + Path: fp.Path, + Chunks: len(chunks), + }) } // M2 — these upserts are part of the outer tx. Any failure returns the @@ -476,16 +602,31 @@ func (s *Service) ProcessFiles( // below only advance on a successful commit. if len(batchSymbols) > 0 { if err := symbolindex.UpsertSymbolsTx(ctx, tx, projectPath, batchSymbols); err != nil { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: "upsert symbols: " + err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, fmt.Errorf("upsert symbols: %w", err) } } if len(batchRefs) > 0 { if err := symbolindex.UpsertReferencesTx(ctx, tx, projectPath, batchRefs); err != nil { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: "upsert refs: " + err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, fmt.Errorf("upsert refs: %w", err) } } if err := tx.Commit(); err != nil { + emitTerminal(progress, ProgressEvent{ + Event: EventError, + Message: "commit batch: " + err.Error(), + Fatal: true, + }) return filesAccepted, batchChunks, sess.filesProcessed, fmt.Errorf("commit batch: %w", err) } txCommitted = true @@ -503,6 +644,13 @@ func (s *Service) ProcessFiles( "total_files", total, ) + emitTerminal(progress, ProgressEvent{ + Event: EventBatchDone, + FilesAccepted: filesAccepted, + ChunksCreated: batchChunks, + FilesProcessedTotal: total, + }) + return filesAccepted, batchChunks, total, nil } @@ -583,12 +731,17 @@ func (s *Service) FinishIndexing( ) langsJSON := marshalJSONStringArray(langs) + // PR-E — capture the active embedding model so the dashboard can flag + // projects whose vectors were produced under a different model than the + // one currently loaded in the sidecar. NULLIF keeps the column NULL when + // SetEmbeddingModel was never called (tests / pre-PR-E codepaths). if _, err := s.db.ExecContext(ctx, `UPDATE projects SET stats = ?, languages = ?, status = 'indexed', - last_indexed_at = ?, updated_at = ? + last_indexed_at = ?, updated_at = ?, + indexed_with_model = NULLIF(?, '') WHERE host_path = ?`, - statsJSON, langsJSON, now, now, projectPath, + statsJSON, langsJSON, now, now, s.embeddingModel, projectPath, ); err != nil { return "", 0, 0, fmt.Errorf("update project stats: %w", err) } @@ -825,5 +978,3 @@ func marshalJSONStringArray(langs []string) string { return b.String() } -// Unused but kept for symmetry with Python: filepath.Base is used by callers. -var _ = filepath.Base diff --git a/server/internal/indexer/indexer_test.go b/server/internal/indexer/indexer_test.go index d6da79a..02941cb 100644 --- a/server/internal/indexer/indexer_test.go +++ b/server/internal/indexer/indexer_test.go @@ -228,6 +228,130 @@ func TestProcessFiles_HappyPath(t *testing.T) { } } +// capturingEmbedder records every batch passed to EmbedTexts so tests can +// assert what the indexer actually sent to the embedder. Returned vectors +// are zero-valued (still unit length 8) — value content is never checked +// by callers of this helper. +type capturingEmbedder struct { + dim int + calls [][]string +} + +func (c *capturingEmbedder) EmbedTexts(ctx context.Context, texts []string) ([][]float32, error) { + captured := append([]string(nil), texts...) + c.calls = append(c.calls, captured) + out := make([][]float32, len(texts)) + for i := range out { + v := make([]float32, c.dim) + v[0] = 1 + out[i] = v + } + return out, nil +} + +// TestProcessFiles_EmbedTextFormat_LegacyByDefault verifies that without +// SetEmbedIncludePath, ProcessFiles preserves the historical ": +// " format that Python parity depends on. +func TestProcessFiles_EmbedTextFormat_LegacyByDefault(t *testing.T) { + d := openTestDB(t) + seedProject(t, d, "/proj") + + ctx := context.Background() + emb := &capturingEmbedder{dim: 8} + svc := New(d, newStore(t), emb, nil) + // Default: embedIncludePath is false. + + runID, _, err := svc.BeginIndexing(ctx, "/proj", false) + if err != nil { + t.Fatalf("BeginIndexing: %v", err) + } + goFile := "package main\n\nfunc Hello() {}\n" + files := []FilePayload{{ + Path: "/proj/cmd/hello/main.go", + Content: goFile, + ContentHash: sha256hex(goFile), + Language: "go", + Size: len(goFile), + }} + if _, _, _, err := svc.ProcessFiles(ctx, "/proj", runID, files); err != nil { + t.Fatalf("ProcessFiles: %v", err) + } + + if len(emb.calls) == 0 { + t.Fatal("embedder was never called") + } + first := emb.calls[0] + if len(first) == 0 { + t.Fatal("first batch was empty") + } + for _, txt := range first { + // Legacy format must NOT contain a "File:" preamble. + if containsString(txt, "File: cmd/hello") { + t.Errorf("legacy format leaked path preamble:\n%s", txt) + } + } +} + +// TestProcessFiles_EmbedTextFormat_PathPrefixWhenEnabled verifies that with +// SetEmbedIncludePath(true), every chunk text is wrapped with the path-aware +// preamble produced by embeddings.FormatChunkForEmbedding. +func TestProcessFiles_EmbedTextFormat_PathPrefixWhenEnabled(t *testing.T) { + d := openTestDB(t) + seedProject(t, d, "/proj") + + ctx := context.Background() + emb := &capturingEmbedder{dim: 8} + svc := New(d, newStore(t), emb, nil) + svc.SetEmbedIncludePath(true) + + runID, _, err := svc.BeginIndexing(ctx, "/proj", false) + if err != nil { + t.Fatalf("BeginIndexing: %v", err) + } + goFile := "package main\n\nfunc Hello() {}\n" + files := []FilePayload{{ + Path: "/proj/cmd/hello/main.go", + Content: goFile, + ContentHash: sha256hex(goFile), + Language: "go", + Size: len(goFile), + }} + if _, _, _, err := svc.ProcessFiles(ctx, "/proj", runID, files); err != nil { + t.Fatalf("ProcessFiles: %v", err) + } + + if len(emb.calls) == 0 { + t.Fatal("embedder was never called") + } + first := emb.calls[0] + if len(first) == 0 { + t.Fatal("first batch was empty") + } + hasPathPreamble := false + for _, txt := range first { + if containsString(txt, "File: cmd/hello/main.go") && + containsString(txt, "Language: go") { + hasPathPreamble = true + break + } + } + if !hasPathPreamble { + t.Errorf("expected at least one chunk text to carry 'File: cmd/hello/main.go' + 'Language: go'; sent texts:\n%v", first) + } +} + +func containsString(haystack, needle string) bool { + if len(needle) == 0 { + return true + } + for i := 0; i+len(needle) <= len(haystack); i++ { + if haystack[i:i+len(needle)] == needle { + return true + } + } + return false +} + func TestProcessFiles_EmbedderBusy(t *testing.T) { d := openTestDB(t) seedProject(t, d, "/proj") @@ -315,6 +439,70 @@ func TestFinishIndexing_UpdatesProject(t *testing.T) { } } +// TestFinishIndexing_CapturesEmbeddingModel ensures FinishIndexing writes the +// model identifier set via SetEmbeddingModel into projects.indexed_with_model. +// Empty model (default for tests that don't call the setter) keeps the column +// NULL so the dashboard treats those projects as "indexed before drift +// tracking existed" rather than as stale. +func TestFinishIndexing_CapturesEmbeddingModel(t *testing.T) { + d := openTestDB(t) + seedProject(t, d, "/proj") + + ctx := context.Background() + vs := newStore(t) + svc := New(d, vs, &fakeEmbedder{dim: 8}, nil) + svc.SetEmbeddingModel("test/model-v1") + + runID, _, err := svc.BeginIndexing(ctx, "/proj", false) + if err != nil { + t.Fatalf("BeginIndexing: %v", err) + } + goFile := "package main\nfunc X() {}\n" + if _, _, _, err := svc.ProcessFiles(ctx, "/proj", runID, []FilePayload{ + {Path: "/proj/a.go", Content: goFile, ContentHash: sha256hex(goFile), Language: "go"}, + }); err != nil { + t.Fatalf("ProcessFiles: %v", err) + } + if _, _, _, err := svc.FinishIndexing(ctx, "/proj", runID, nil, 1); err != nil { + t.Fatalf("FinishIndexing: %v", err) + } + + var model sql.NullString + if err := d.QueryRowContext(ctx, + `SELECT indexed_with_model FROM projects WHERE host_path = ?`, "/proj", + ).Scan(&model); err != nil { + t.Fatalf("select indexed_with_model: %v", err) + } + if !model.Valid || model.String != "test/model-v1" { + t.Errorf("indexed_with_model = %+v, want test/model-v1", model) + } + + // Round 2: another project, no setter call → column stays NULL. + seedProject(t, d, "/proj2") + svc2 := New(d, vs, &fakeEmbedder{dim: 8}, nil) // no SetEmbeddingModel + runID2, _, err := svc2.BeginIndexing(ctx, "/proj2", false) + if err != nil { + t.Fatalf("BeginIndexing /proj2: %v", err) + } + if _, _, _, err := svc2.ProcessFiles(ctx, "/proj2", runID2, []FilePayload{ + {Path: "/proj2/b.go", Content: goFile, ContentHash: sha256hex(goFile), Language: "go"}, + }); err != nil { + t.Fatalf("ProcessFiles /proj2: %v", err) + } + if _, _, _, err := svc2.FinishIndexing(ctx, "/proj2", runID2, nil, 1); err != nil { + t.Fatalf("FinishIndexing /proj2: %v", err) + } + var model2 sql.NullString + if err := d.QueryRowContext(ctx, + `SELECT indexed_with_model FROM projects WHERE host_path = ?`, "/proj2", + ).Scan(&model2); err != nil { + t.Fatalf("select indexed_with_model /proj2: %v", err) + } + if model2.Valid { + t.Errorf("indexed_with_model /proj2 = %q, want NULL", model2.String) + } +} + func TestFinishIndexing_DeletesPaths(t *testing.T) { d := openTestDB(t) seedProject(t, d, "/proj") diff --git a/server/internal/indexer/progress.go b/server/internal/indexer/progress.go new file mode 100644 index 0000000..851a0ba --- /dev/null +++ b/server/internal/indexer/progress.go @@ -0,0 +1,95 @@ +package indexer + +import "time" + +// ProgressEvent is emitted by ProcessFiles when a non-nil progress channel is +// supplied, so the streaming HTTP handler can forward each one as a JSON line. +// +// One struct with all possible fields + omitempty is intentional: it keeps the +// wire format easy to evolve and the consumer code a single switch on Event. +// +// Wire format example (newline-delimited JSON, one struct per line): +// +// {"event":"file_started","run_id":"...","path":"main.go","file_index":1,"batch_size":20} +// {"event":"file_chunked","path":"main.go","chunks":12} +// {"event":"file_embedded","path":"main.go","chunks":12,"embed_ms":540} +// {"event":"file_done","path":"main.go","chunks":12} +// {"event":"heartbeat","ts":"2026-04-27T17:25:00Z"} +// {"event":"file_error","path":"big.bin","message":"...","fatal":false} +// {"event":"batch_done","files_accepted":20,"chunks_created":347,"files_processed_total":300} +// {"event":"error","message":"...","fatal":true} +type ProgressEvent struct { + Event string `json:"event"` + + // Per-file fields. + Path string `json:"path,omitempty"` + FileIndex int `json:"file_index,omitempty"` + BatchSize int `json:"batch_size,omitempty"` + Chunks int `json:"chunks,omitempty"` + EmbedMS int64 `json:"embed_ms,omitempty"` + + // Heartbeat. + TS string `json:"ts,omitempty"` + + // Errors. + Message string `json:"message,omitempty"` + Fatal bool `json:"fatal,omitempty"` + + // Batch-done summary (mirrors indexFilesResponse). + FilesAccepted int `json:"files_accepted,omitempty"` + ChunksCreated int `json:"chunks_created,omitempty"` + FilesProcessedTotal int `json:"files_processed_total,omitempty"` + + // Run identifier — populated on the first event the handler emits. + RunID string `json:"run_id,omitempty"` +} + +// Event kinds. Using string constants both for documentation and for +// comparisons in tests / consumer switches. +const ( + EventFileStarted = "file_started" + EventFileChunked = "file_chunked" + EventFileEmbedded = "file_embedded" + EventFileDone = "file_done" + EventFileError = "file_error" + EventHeartbeat = "heartbeat" + EventBatchDone = "batch_done" + EventError = "error" +) + +// progressSend is a nil-safe non-blocking send. ProcessFiles uses it instead +// of `progress <- e` so that: +// +// 1. callers that do not care about progress pass nil and pay no cost +// 2. a slow consumer cannot stall the indexer (the channel has a small +// buffer in the streaming handler; if it fills we drop the event rather +// than blocking the embed pipeline) +// +// Drops are acceptable because the only events that *must* land are +// batch_done / error, and those are sent on the unbuffered close path +// using a guaranteed-blocking send (see emitTerminal). +func progressSend(ch chan<- ProgressEvent, e ProgressEvent) { + if ch == nil { + return + } + select { + case ch <- e: + default: + // channel full — drop. Keeps embed loop unblocked. + } +} + +// emitTerminal is for batch_done / fatal error: must reach the consumer. +// Always blocks until accepted (or ctx cancellation closes things upstream). +func emitTerminal(ch chan<- ProgressEvent, e ProgressEvent) { + if ch == nil { + return + } + ch <- e +} + +// NowTS returns an RFC3339 timestamp for heartbeat events. Exported so the +// streaming HTTP handler in package httpapi can stamp its own heartbeats. +func NowTS() string { + return time.Now().UTC().Format(time.RFC3339) +} diff --git a/server/internal/langdetect/langdetect.go b/server/internal/langdetect/langdetect.go index cc79fc8..4568fdf 100644 --- a/server/internal/langdetect/langdetect.go +++ b/server/internal/langdetect/langdetect.go @@ -25,6 +25,7 @@ var extensionMap = map[string]string{ ".cs": "c_sharp", ".swift": "swift", ".kt": "kotlin", + ".kts": "kotlin", ".scala": "scala", ".zig": "zig", ".jl": "julia", @@ -36,7 +37,7 @@ var extensionMap = map[string]string{ ".mm": "objc", // Web / scripting ".ts": "typescript", - ".tsx": "typescript", + ".tsx": "tsx", ".js": "javascript", ".jsx": "javascript", ".rb": "ruby", diff --git a/server/internal/langdetect/langdetect_test.go b/server/internal/langdetect/langdetect_test.go index 62f0dde..27e94f7 100644 --- a/server/internal/langdetect/langdetect_test.go +++ b/server/internal/langdetect/langdetect_test.go @@ -10,7 +10,7 @@ func TestDetect(t *testing.T) { {"main.go", "go"}, {"app.py", "python"}, {"index.ts", "typescript"}, - {"index.tsx", "typescript"}, + {"index.tsx", "tsx"}, {"app.js", "javascript"}, {"lib.rs", "rust"}, {"Hello.java", "java"}, @@ -35,6 +35,8 @@ func TestDetect(t *testing.T) { {"/some/path/to/main.go", "go"}, {"script.R", "r"}, // uppercase .R {"script.sh", "bash"}, + {"build.gradle.kts", "kotlin"}, + {"app.kts", "kotlin"}, } for _, c := range cases { got := Detect(c.path) diff --git a/server/internal/projects/projects.go b/server/internal/projects/projects.go index d1a5bcc..e8212c4 100644 --- a/server/internal/projects/projects.go +++ b/server/internal/projects/projects.go @@ -20,6 +20,12 @@ var ErrNotFound = errors.New("project not found") // ErrConflict is returned when a project with the same path already exists. var ErrConflict = errors.New("project already exists") +// ErrOverlap is returned when the new project path is nested inside an +// existing project (or vice versa). Overlapping projects double-index the +// same files, blow up storage, and make search results ambiguous — +// always indicates a registration mistake the operator should resolve. +var ErrOverlap = errors.New("project path overlaps an existing project") + // Settings mirrors Python ProjectSettings. type Settings struct { ExcludePatterns []string `json:"exclude_patterns"` @@ -56,6 +62,11 @@ type Project struct { CreatedAt string UpdatedAt string LastIndexedAt *string + // IndexedWithModel is the embedding model identifier captured at the + // last successful FinishIndexing. nil for projects that have never been + // indexed under PR-E (or never indexed at all). The dashboard renders + // nil as a neutral "Unknown" badge, NOT as drift. + IndexedWithModel *string } // CreateRequest mirrors Python ProjectCreate. @@ -81,7 +92,7 @@ func hashPath(path string) string { b := h.Sum(nil) const hexchars = "0123456789abcdef" out := make([]byte, 16) - for i := 0; i < 8; i++ { + for i := range 8 { out[i*2] = hexchars[b[i]>>4] out[i*2+1] = hexchars[b[i]&0xf] } @@ -92,7 +103,9 @@ func hashPath(path string) string { // CRUD // --------------------------------------------------------------------------- -// Create inserts a new project. Returns ErrConflict if the path already exists. +// Create inserts a new project. Returns ErrConflict if the path already +// exists, or ErrOverlap if the path is a parent or descendant of any existing +// project. // // We pass host_path through unchanged to match Python // (api/app/routers/projects.py). Normalising here (e.g. stripping trailing @@ -102,6 +115,12 @@ func Create(ctx context.Context, db *sql.DB, req CreateRequest) (*Project, error hostPath := req.HostPath now := time.Now().UTC().Format(time.RFC3339Nano) + if conflict, err := findOverlap(ctx, db, hostPath); err != nil { + return nil, fmt.Errorf("check overlap: %w", err) + } else if conflict != "" { + return nil, fmt.Errorf("%w: %s already registered", ErrOverlap, conflict) + } + defaultSettings := DefaultSettings() settingsJSON, err := json.Marshal(defaultSettings) if err != nil { @@ -127,10 +146,50 @@ func Create(ctx context.Context, db *sql.DB, req CreateRequest) (*Project, error return Get(ctx, db, hostPath) } +// findOverlap returns the host_path of the first existing project that is a +// parent or descendant of `candidate`, or "" if none. Same path is treated as +// "no overlap" — the unique-index on host_path raises ErrConflict for that +// case with a more specific message. +// +// Path comparison strips a single trailing slash from both sides and then +// requires either: +// - existing is a prefix of candidate followed by '/' (existing is parent), or +// - candidate is a prefix of existing followed by '/' (existing is descendant) +// +// Symlinks are intentionally NOT resolved: storing canonical paths would +// silently change identifiers across machines and break stored hashes. +func findOverlap(ctx context.Context, db *sql.DB, candidate string) (string, error) { + cand := strings.TrimSuffix(candidate, "/") + if cand == "" { + return "", nil + } + + rows, err := db.QueryContext(ctx, `SELECT host_path FROM projects`) + if err != nil { + return "", err + } + defer rows.Close() + + for rows.Next() { + var existing string + if err := rows.Scan(&existing); err != nil { + return "", err + } + ex := strings.TrimSuffix(existing, "/") + if ex == "" || ex == cand { + continue + } + if strings.HasPrefix(cand, ex+"/") || strings.HasPrefix(ex, cand+"/") { + return existing, nil + } + } + return "", rows.Err() +} + // Get retrieves a project by its host_path. Returns ErrNotFound if absent. func Get(ctx context.Context, db *sql.DB, hostPath string) (*Project, error) { row := db.QueryRowContext(ctx, - `SELECT host_path, container_path, languages, settings, stats, status, created_at, updated_at, last_indexed_at + `SELECT host_path, container_path, languages, settings, stats, status, created_at, updated_at, last_indexed_at, indexed_with_model FROM projects WHERE host_path = ?`, hostPath, ) return scanProject(hostPath, row) @@ -158,7 +217,7 @@ func GetByHash(ctx context.Context, db *sql.DB, pathHash string) (*Project, erro // List returns all projects ordered by created_at descending. func List(ctx context.Context, db *sql.DB) ([]Project, error) { rows, err := db.QueryContext(ctx, - `SELECT host_path, container_path, languages, settings, stats, status, created_at, updated_at, last_indexed_at + `SELECT host_path, container_path, languages, settings, stats, status, created_at, updated_at, last_indexed_at, indexed_with_model FROM projects ORDER BY created_at DESC`, ) if err != nil { @@ -218,16 +277,17 @@ func Delete(ctx context.Context, db *sql.DB, hostPath string) error { func scanProject(hostPath string, row *sql.Row) (*Project, error) { var ( - hp, containerPath string - langsJSON, settingsJSON string - statsJSON, status string - createdAt, updatedAt string - lastIndexedAt *string + hp, containerPath string + langsJSON, settingsJSON string + statsJSON, status string + createdAt, updatedAt string + lastIndexedAt *string + indexedWithModel *string ) err := row.Scan( &hp, &containerPath, &langsJSON, &settingsJSON, &statsJSON, - &status, &createdAt, &updatedAt, &lastIndexedAt, + &status, &createdAt, &updatedAt, &lastIndexedAt, &indexedWithModel, ) if errors.Is(err, sql.ErrNoRows) { return nil, fmt.Errorf("%w: %s", ErrNotFound, hostPath) @@ -235,7 +295,7 @@ func scanProject(hostPath string, row *sql.Row) (*Project, error) { if err != nil { return nil, fmt.Errorf("scan project row: %w", err) } - return buildProject(hp, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt, lastIndexedAt) + return buildProject(hp, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt, lastIndexedAt, indexedWithModel) } func scanProjectRow(rows *sql.Rows) (*Project, error) { @@ -243,20 +303,21 @@ func scanProjectRow(rows *sql.Rows) (*Project, error) { hostPath, containerPath string langsJSON, settingsJSON string statsJSON, status string - createdAt, updatedAt string + createdAt, updatedAt string lastIndexedAt *string + indexedWithModel *string ) if err := rows.Scan( &hostPath, &containerPath, &langsJSON, &settingsJSON, &statsJSON, - &status, &createdAt, &updatedAt, &lastIndexedAt, + &status, &createdAt, &updatedAt, &lastIndexedAt, &indexedWithModel, ); err != nil { return nil, fmt.Errorf("scan project: %w", err) } - return buildProject(hostPath, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt, lastIndexedAt) + return buildProject(hostPath, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt, lastIndexedAt, indexedWithModel) } -func buildProject(hostPath, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt string, lastIndexedAt *string) (*Project, error) { +func buildProject(hostPath, containerPath, langsJSON, settingsJSON, statsJSON, status, createdAt, updatedAt string, lastIndexedAt, indexedWithModel *string) (*Project, error) { var langs []string if err := json.Unmarshal([]byte(langsJSON), &langs); err != nil { langs = nil @@ -273,14 +334,15 @@ func buildProject(hostPath, containerPath, langsJSON, settingsJSON, statsJSON, s } return &Project{ - HostPath: hostPath, - ContainerPath: containerPath, - Languages: langs, - Settings: settings, - Stats: stats, - Status: status, - CreatedAt: createdAt, - UpdatedAt: updatedAt, - LastIndexedAt: lastIndexedAt, + HostPath: hostPath, + ContainerPath: containerPath, + Languages: langs, + Settings: settings, + Stats: stats, + Status: status, + CreatedAt: createdAt, + UpdatedAt: updatedAt, + LastIndexedAt: lastIndexedAt, + IndexedWithModel: indexedWithModel, }, nil } diff --git a/server/internal/projects/projects_test.go b/server/internal/projects/projects_test.go index aa78e85..9691136 100644 --- a/server/internal/projects/projects_test.go +++ b/server/internal/projects/projects_test.go @@ -85,6 +85,46 @@ func TestCreate_Conflict(t *testing.T) { } } +// TestCreate_RejectsOverlap covers both directions and a few cosmetic +// variants (trailing slash) of the parent/descendant containment check. +// Sibling and string-prefix-but-not-path-prefix cases must succeed — +// otherwise we'd block legitimate adjacent projects. +func TestCreate_RejectsOverlap(t *testing.T) { + cases := []struct { + name string + seed, attempt string + wantOverlapErr bool + }{ + {"new path is descendant", "/repo", "/repo/server", true}, + {"new path is ancestor", "/repo/server", "/repo", true}, + {"deep nesting still caught", "/repo", "/repo/a/b/c/d", true}, + {"trailing slash on seed", "/repo/", "/repo/server", true}, + {"trailing slash on candidate", "/repo", "/repo/server/", true}, + {"sibling is fine", "/repo/server", "/repo/cli", false}, + // "/repo-other" shares "/repo" as a string prefix but NOT as a path + // prefix — must not be rejected. + {"prefix-but-not-path-prefix is fine", "/repo", "/repo-other", false}, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + d := openTestDB(t) + ctx := context.Background() + if _, err := Create(ctx, d, CreateRequest{HostPath: tc.seed}); err != nil { + t.Fatalf("seed Create(%q) failed: %v", tc.seed, err) + } + _, err := Create(ctx, d, CreateRequest{HostPath: tc.attempt}) + if tc.wantOverlapErr { + if !errors.Is(err, ErrOverlap) { + t.Fatalf("Create(%q) error = %v, want ErrOverlap", tc.attempt, err) + } + } else if err != nil { + t.Fatalf("Create(%q) failed unexpectedly: %v", tc.attempt, err) + } + }) + } +} + func TestGet_NotFound(t *testing.T) { d := openTestDB(t) ctx := context.Background() diff --git a/server/internal/runtimecfg/runtimecfg.go b/server/internal/runtimecfg/runtimecfg.go new file mode 100644 index 0000000..c9d875f --- /dev/null +++ b/server/internal/runtimecfg/runtimecfg.go @@ -0,0 +1,357 @@ +// Package runtimecfg owns the dashboard-overridable subset of cix-server +// configuration. It sits one layer above package config (which is env-only, +// immutable, loaded once at boot). Resolution order for every field: +// +// db value (runtime_settings row, set via dashboard) → +// env value (CIX_* loaded into config.Config at boot) → +// hardcoded recommended default +// +// A Snapshot also carries a Source map so the dashboard can render a "DB" / +// "Env" / "Recommended" pill next to each field, telling the admin where the +// current value came from. Set replaces the row wholesale (UPSERT id=1) so +// "clear this override" is just sending NULL. +package runtimecfg + +import ( + "context" + "database/sql" + "errors" + "fmt" + "runtime" + "time" + + "github.com/dvcdsys/code-index/server/internal/config" +) + +// Source labels the origin of a resolved value; emitted in Snapshot.Source so +// the UI can render a "DB" / "Env" / "Recommended" pill next to each field. +const ( + SourceDB = "db" + SourceEnv = "env" + SourceRecommended = "recommended" +) + +// FieldEmbeddingModel and friends name the keys in Snapshot.Source. Exported +// so handler/UI code can iterate without copy-pasting string literals. +const ( + FieldEmbeddingModel = "embedding_model" + FieldLlamaCtxSize = "llama_ctx_size" + FieldLlamaNGpuLayers = "llama_n_gpu_layers" + FieldLlamaNThreads = "llama_n_threads" + FieldMaxEmbeddingConcurrency = "max_embedding_concurrency" + FieldLlamaBatchSize = "llama_batch_size" +) + +// Snapshot is a fully-resolved runtime config — every field is populated, no +// pointers / nullables — and the Source map records where each value came +// from. Returned by Get; consumed by main when wiring the embeddings service. +type Snapshot struct { + EmbeddingModel string + LlamaCtxSize int + LlamaNGpuLayers int + LlamaNThreads int + MaxEmbeddingConcurrency int + LlamaBatchSize int + + // Source maps Field* constants to one of SourceDB/SourceEnv/SourceRecommended. + Source map[string]string + + // UpdatedAt is the runtime_settings.updated_at value when at least one + // field came from DB; zero otherwise. + UpdatedAt time.Time + // UpdatedBy is the runtime_settings.updated_by value when at least one + // field came from DB; empty otherwise. + UpdatedBy string +} + +// Patch carries the new values an admin wants to write. nil pointers mean +// "don't change this field" — including "clear the DB override and fall back +// to env / recommended". To clear, send a non-nil pointer to the zero value +// for numeric fields, or a non-nil pointer to "" for the model. The handler +// does the nil/non-nil discrimination from the JSON request body. +type Patch struct { + EmbeddingModel *string + LlamaCtxSize *int + LlamaNGpuLayers *int + LlamaNThreads *int + MaxEmbeddingConcurrency *int + LlamaBatchSize *int +} + +// Service resolves runtime config from the DB, falling through to env-loaded +// config, then to hardcoded recommended values. Safe for concurrent use; the +// underlying *sql.DB pool is the only shared mutable state. +type Service struct { + db *sql.DB + env *config.Config +} + +// New constructs a Service. env is the bootstrap config.Config loaded at +// startup; runtimecfg never mutates it (the env layer is immutable by +// design). +func New(db *sql.DB, env *config.Config) *Service { + return &Service{db: db, env: env} +} + +// Recommended returns the hardcoded fallback Snapshot. These values are the +// project-wide "sensible defaults" — what we'd pick on a clean install with +// no env overrides and no DB row. Used by the UI to show "(Recommended)" +// alongside the current value. +func (s *Service) Recommended() Snapshot { + defaultGpu := 0 + if runtime.GOOS == "darwin" { + defaultGpu = -1 + } + return Snapshot{ + EmbeddingModel: "awhiteside/CodeRankEmbed-Q8_0-GGUF", + LlamaCtxSize: 2048, + LlamaNGpuLayers: defaultGpu, + LlamaNThreads: runtime.NumCPU() / 2, + MaxEmbeddingConcurrency: 5, + LlamaBatchSize: 2048, + Source: map[string]string{}, + } +} + +type dbRow struct { + embeddingModel sql.NullString + llamaCtxSize sql.NullInt64 + llamaNGpuLayers sql.NullInt64 + llamaNThreads sql.NullInt64 + maxEmbeddingConcurrency sql.NullInt64 + llamaBatchSize sql.NullInt64 + updatedAt sql.NullString + updatedBy sql.NullString +} + +func (s *Service) loadRow(ctx context.Context) (dbRow, bool, error) { + var r dbRow + err := s.db.QueryRowContext(ctx, ` + SELECT embedding_model, llama_ctx_size, llama_n_gpu_layers, + llama_n_threads, max_embedding_concurrency, llama_batch_size, + updated_at, updated_by + FROM runtime_settings WHERE id = 1 + `).Scan( + &r.embeddingModel, &r.llamaCtxSize, &r.llamaNGpuLayers, + &r.llamaNThreads, &r.maxEmbeddingConcurrency, &r.llamaBatchSize, + &r.updatedAt, &r.updatedBy, + ) + if errors.Is(err, sql.ErrNoRows) { + return dbRow{}, false, nil + } + if err != nil { + return dbRow{}, false, fmt.Errorf("select runtime_settings: %w", err) + } + return r, true, nil +} + +// Get resolves the current effective Snapshot. Always returns a populated +// Snapshot; a nil DB row simply means every field falls through to env / +// recommended. +func (s *Service) Get(ctx context.Context) (Snapshot, error) { + row, hasRow, err := s.loadRow(ctx) + if err != nil { + return Snapshot{}, err + } + rec := s.Recommended() + out := Snapshot{Source: map[string]string{}} + + // String — embedding model. + switch { + case hasRow && row.embeddingModel.Valid && row.embeddingModel.String != "": + out.EmbeddingModel = row.embeddingModel.String + out.Source[FieldEmbeddingModel] = SourceDB + case s.env != nil && s.env.EmbeddingModel != "": + out.EmbeddingModel = s.env.EmbeddingModel + out.Source[FieldEmbeddingModel] = SourceEnv + default: + out.EmbeddingModel = rec.EmbeddingModel + out.Source[FieldEmbeddingModel] = SourceRecommended + } + + // Numeric fields — pull env value with fallback so the helper handles all + // three layers uniformly. >0 from DB always wins; 0 == "unset". + out.LlamaCtxSize = resolveInt(row.llamaCtxSize, hasRow, envIntOrZero(s.env, "ctx"), rec.LlamaCtxSize, &out.Source, FieldLlamaCtxSize) + out.LlamaNGpuLayers = resolveIntSigned(row.llamaNGpuLayers, hasRow, envIntOrSentinel(s.env, "gpu"), rec.LlamaNGpuLayers, &out.Source, FieldLlamaNGpuLayers) + out.LlamaNThreads = resolveInt(row.llamaNThreads, hasRow, envIntOrZero(s.env, "threads"), rec.LlamaNThreads, &out.Source, FieldLlamaNThreads) + out.MaxEmbeddingConcurrency = resolveInt(row.maxEmbeddingConcurrency, hasRow, envIntOrZero(s.env, "conc"), rec.MaxEmbeddingConcurrency, &out.Source, FieldMaxEmbeddingConcurrency) + out.LlamaBatchSize = resolveInt(row.llamaBatchSize, hasRow, envIntOrZero(s.env, "batch"), rec.LlamaBatchSize, &out.Source, FieldLlamaBatchSize) + + if hasRow { + if row.updatedAt.Valid { + if t, err := time.Parse(time.RFC3339Nano, row.updatedAt.String); err == nil { + out.UpdatedAt = t + } + } + if row.updatedBy.Valid { + out.UpdatedBy = row.updatedBy.String + } + } + return out, nil +} + +// resolveInt picks DB > env > recommended for >0 fields. Used for ctx, +// threads, concurrency, batch — all where 0 is a sentinel meaning "unset". +func resolveInt(dbVal sql.NullInt64, hasRow bool, envVal int, recVal int, src *map[string]string, field string) int { + if hasRow && dbVal.Valid && dbVal.Int64 > 0 { + (*src)[field] = SourceDB + return int(dbVal.Int64) + } + if envVal > 0 { + (*src)[field] = SourceEnv + return envVal + } + (*src)[field] = SourceRecommended + return recVal +} + +// resolveIntSigned is the n_gpu_layers special case: -1 (Metal: all layers) +// and 0 (CPU-only) are both legitimate values, so we treat any *non-NULL* DB +// row as authoritative. Env is authoritative whenever it differs from the +// platform default; recommended is the final fallback. +func resolveIntSigned(dbVal sql.NullInt64, hasRow bool, envVal int, recVal int, src *map[string]string, field string) int { + if hasRow && dbVal.Valid { + (*src)[field] = SourceDB + return int(dbVal.Int64) + } + if envVal != recVal { + (*src)[field] = SourceEnv + return envVal + } + (*src)[field] = SourceRecommended + return recVal +} + +// envIntOrZero pulls a numeric value from the loaded env config or returns 0 +// (the "unset" sentinel resolveInt understands). Centralised here so all +// callers route through one place — easier to keep in sync if config.Config +// gains more fields. +func envIntOrZero(env *config.Config, which string) int { + if env == nil { + return 0 + } + switch which { + case "ctx": + return env.LlamaCtxSize + case "threads": + return env.LlamaNThreads + case "conc": + return env.MaxEmbeddingConcurrency + case "batch": + return env.LlamaBatchSize + } + return 0 +} + +// envIntOrSentinel mirrors envIntOrZero for fields where 0 is a legitimate +// value — currently only n_gpu_layers. Returns the env value verbatim. +func envIntOrSentinel(env *config.Config, which string) int { + if env == nil { + return 0 + } + if which == "gpu" { + return env.LlamaNGpuLayers + } + return 0 +} + +// Set applies a Patch to the runtime_settings row. nil pointer fields are +// preserved. Pointers to zero values (or empty strings) clear the override +// → next Get falls through to env / recommended for that field. +func (s *Service) Set(ctx context.Context, patch Patch, updatedBy string) error { + row, hasRow, err := s.loadRow(ctx) + if err != nil { + return err + } + + // Merge: start with current row (or empty), overlay patch. + merged := row + if patch.EmbeddingModel != nil { + if *patch.EmbeddingModel == "" { + merged.embeddingModel = sql.NullString{} + } else { + merged.embeddingModel = sql.NullString{String: *patch.EmbeddingModel, Valid: true} + } + } + mergeInt(&merged.llamaCtxSize, patch.LlamaCtxSize) + mergeInt(&merged.llamaNGpuLayers, patch.LlamaNGpuLayers) + mergeInt(&merged.llamaNThreads, patch.LlamaNThreads) + mergeInt(&merged.maxEmbeddingConcurrency, patch.MaxEmbeddingConcurrency) + mergeInt(&merged.llamaBatchSize, patch.LlamaBatchSize) + + now := time.Now().UTC().Format(time.RFC3339Nano) + if hasRow { + _, err = s.db.ExecContext(ctx, ` + UPDATE runtime_settings + SET embedding_model = ?, llama_ctx_size = ?, llama_n_gpu_layers = ?, + llama_n_threads = ?, max_embedding_concurrency = ?, llama_batch_size = ?, + updated_at = ?, updated_by = ? + WHERE id = 1 + `, + nullStr(merged.embeddingModel), nullInt(merged.llamaCtxSize), + nullInt(merged.llamaNGpuLayers), nullInt(merged.llamaNThreads), + nullInt(merged.maxEmbeddingConcurrency), nullInt(merged.llamaBatchSize), + now, updatedBy, + ) + } else { + _, err = s.db.ExecContext(ctx, ` + INSERT INTO runtime_settings ( + id, embedding_model, llama_ctx_size, llama_n_gpu_layers, + llama_n_threads, max_embedding_concurrency, llama_batch_size, + updated_at, updated_by + ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?) + `, + nullStr(merged.embeddingModel), nullInt(merged.llamaCtxSize), + nullInt(merged.llamaNGpuLayers), nullInt(merged.llamaNThreads), + nullInt(merged.maxEmbeddingConcurrency), nullInt(merged.llamaBatchSize), + now, updatedBy, + ) + } + if err != nil { + return fmt.Errorf("upsert runtime_settings: %w", err) + } + return nil +} + +// mergeInt overlays a patch field onto a NullInt64. nil patch keeps current; +// non-nil patch with zero clears (= NULL); non-nil non-zero sets. +func mergeInt(cur *sql.NullInt64, patch *int) { + if patch == nil { + return + } + if *patch == 0 { + *cur = sql.NullInt64{} + return + } + *cur = sql.NullInt64{Int64: int64(*patch), Valid: true} +} + +func nullStr(v sql.NullString) any { + if !v.Valid { + return nil + } + return v.String +} + +func nullInt(v sql.NullInt64) any { + if !v.Valid { + return nil + } + return v.Int64 +} + +// ApplyTo merges the resolved Snapshot's settings onto a *config.Config so the +// rest of the server (embeddings supervisor, indexer, etc.) reads the +// effective values from one struct. Mutates env in place — callers usually +// pass a freshly-loaded copy at boot. +func (snap Snapshot) ApplyTo(env *config.Config) { + if env == nil { + return + } + env.EmbeddingModel = snap.EmbeddingModel + env.LlamaCtxSize = snap.LlamaCtxSize + env.LlamaNGpuLayers = snap.LlamaNGpuLayers + env.LlamaNThreads = snap.LlamaNThreads + env.MaxEmbeddingConcurrency = snap.MaxEmbeddingConcurrency + env.LlamaBatchSize = snap.LlamaBatchSize +} diff --git a/server/internal/runtimecfg/runtimecfg_test.go b/server/internal/runtimecfg/runtimecfg_test.go new file mode 100644 index 0000000..4baacb5 --- /dev/null +++ b/server/internal/runtimecfg/runtimecfg_test.go @@ -0,0 +1,154 @@ +package runtimecfg + +import ( + "context" + "testing" + + "github.com/dvcdsys/code-index/server/internal/config" + "github.com/dvcdsys/code-index/server/internal/db" +) + +func openTestDB(t *testing.T) *Service { + t.Helper() + d, err := db.Open(":memory:") + if err != nil { + t.Fatalf("db.Open: %v", err) + } + t.Cleanup(func() { d.Close() }) + env := &config.Config{ + EmbeddingModel: "env/model-a", + LlamaCtxSize: 4096, + LlamaNGpuLayers: 8, + LlamaNThreads: 4, + MaxEmbeddingConcurrency: 2, + LlamaBatchSize: 1024, + } + return New(d, env) +} + +// TestGet_NoRow_FallsThroughToEnv covers the "fresh install with env vars +// set, no dashboard overrides yet" path. Every field should be sourced from +// env and the Source map should reflect that uniformly. +func TestGet_NoRow_FallsThroughToEnv(t *testing.T) { + svc := openTestDB(t) + got, err := svc.Get(context.Background()) + if err != nil { + t.Fatalf("Get: %v", err) + } + + if got.EmbeddingModel != "env/model-a" { + t.Errorf("EmbeddingModel = %q, want env/model-a", got.EmbeddingModel) + } + if got.LlamaCtxSize != 4096 || got.LlamaNGpuLayers != 8 || got.LlamaNThreads != 4 { + t.Errorf("numeric env fields not propagated: %+v", got) + } + for _, f := range []string{ + FieldEmbeddingModel, FieldLlamaCtxSize, FieldLlamaNGpuLayers, + FieldLlamaNThreads, FieldMaxEmbeddingConcurrency, FieldLlamaBatchSize, + } { + if got.Source[f] != SourceEnv { + t.Errorf("Source[%s] = %q, want env", f, got.Source[f]) + } + } +} + +// TestGet_FallsThroughToRecommended covers a clean DB + an empty env config. +// Every field should come from Recommended() and the Source map should say so. +func TestGet_FallsThroughToRecommended(t *testing.T) { + d, err := db.Open(":memory:") + if err != nil { + t.Fatalf("db.Open: %v", err) + } + defer d.Close() + svc := New(d, &config.Config{}) // env zero-valued + + got, err := svc.Get(context.Background()) + if err != nil { + t.Fatalf("Get: %v", err) + } + rec := svc.Recommended() + if got.EmbeddingModel != rec.EmbeddingModel { + t.Errorf("EmbeddingModel = %q, want %q", got.EmbeddingModel, rec.EmbeddingModel) + } + if got.LlamaCtxSize != rec.LlamaCtxSize { + t.Errorf("LlamaCtxSize = %d, want %d", got.LlamaCtxSize, rec.LlamaCtxSize) + } + if got.Source[FieldEmbeddingModel] != SourceRecommended { + t.Errorf("Source[model] = %q, want recommended", got.Source[FieldEmbeddingModel]) + } +} + +// TestSet_Get_RoundTrip overlays a partial patch and verifies that: +// - the patched field is now sourced from DB +// - unpatched fields still come from env +// - clearing (zero / "") returns the field to env source on next Get +func TestSet_Get_RoundTrip(t *testing.T) { + svc := openTestDB(t) + ctx := context.Background() + + model := "db/model-override" + ctxSize := 8192 + if err := svc.Set(ctx, Patch{ + EmbeddingModel: &model, + LlamaCtxSize: &ctxSize, + }, "tester"); err != nil { + t.Fatalf("Set: %v", err) + } + + got, err := svc.Get(ctx) + if err != nil { + t.Fatalf("Get: %v", err) + } + if got.EmbeddingModel != model || got.Source[FieldEmbeddingModel] != SourceDB { + t.Errorf("model not from DB after Set: val=%q src=%q", got.EmbeddingModel, got.Source[FieldEmbeddingModel]) + } + if got.LlamaCtxSize != ctxSize || got.Source[FieldLlamaCtxSize] != SourceDB { + t.Errorf("ctx not from DB after Set: val=%d src=%q", got.LlamaCtxSize, got.Source[FieldLlamaCtxSize]) + } + // Untouched field still env. + if got.LlamaNThreads != 4 || got.Source[FieldLlamaNThreads] != SourceEnv { + t.Errorf("untouched threads field shifted source: val=%d src=%q", got.LlamaNThreads, got.Source[FieldLlamaNThreads]) + } + if got.UpdatedBy != "tester" { + t.Errorf("UpdatedBy = %q, want tester", got.UpdatedBy) + } + if got.UpdatedAt.IsZero() { + t.Error("UpdatedAt should be populated after Set") + } + + // Clear the model override (empty string) — should return to env source. + empty := "" + if err := svc.Set(ctx, Patch{EmbeddingModel: &empty}, "tester"); err != nil { + t.Fatalf("Set clear: %v", err) + } + got2, err := svc.Get(ctx) + if err != nil { + t.Fatalf("Get after clear: %v", err) + } + if got2.EmbeddingModel != "env/model-a" || got2.Source[FieldEmbeddingModel] != SourceEnv { + t.Errorf("model didn't fall back to env after clear: val=%q src=%q", got2.EmbeddingModel, got2.Source[FieldEmbeddingModel]) + } + // Other DB-set field (ctx) preserved. + if got2.LlamaCtxSize != ctxSize || got2.Source[FieldLlamaCtxSize] != SourceDB { + t.Errorf("ctx override lost during model clear: val=%d src=%q", got2.LlamaCtxSize, got2.Source[FieldLlamaCtxSize]) + } +} + +// TestApplyTo verifies a Snapshot mutates *config.Config in-place so the +// rest of the server reads the effective values from one struct. +func TestApplyTo(t *testing.T) { + snap := Snapshot{ + EmbeddingModel: "x", + LlamaCtxSize: 1, + LlamaNGpuLayers: 2, + LlamaNThreads: 3, + MaxEmbeddingConcurrency: 4, + LlamaBatchSize: 5, + } + cfg := &config.Config{EmbeddingModel: "old", LlamaCtxSize: 99} + snap.ApplyTo(cfg) + if cfg.EmbeddingModel != "x" || cfg.LlamaCtxSize != 1 || cfg.LlamaNGpuLayers != 2 || + cfg.LlamaNThreads != 3 || cfg.MaxEmbeddingConcurrency != 4 || cfg.LlamaBatchSize != 5 { + t.Errorf("ApplyTo did not overwrite all fields: %+v", cfg) + } +} diff --git a/server/internal/sessions/sessions.go b/server/internal/sessions/sessions.go new file mode 100644 index 0000000..15d4507 --- /dev/null +++ b/server/internal/sessions/sessions.go @@ -0,0 +1,287 @@ +// Package sessions implements the dashboard's cookie-backed login sessions. +// +// A session is identified by a 256-bit random token. The token itself is +// only ever known to the user's browser (it lives in the cix_session +// HttpOnly cookie); the database stores sha256(token) so a leaked snapshot +// cannot be used to impersonate active sessions. Every other API in this +// package speaks the public hash id — generated at Create, returned by +// ListForUser, and accepted by Touch/Delete — so callers do not need to +// hold the raw token after issuing the cookie. +// +// Rolling expiry: every Touch pushes expires_at out by SessionTTL. This +// matches typical browser-tab usage (you stay logged in as long as you +// keep using it) without long-lived bearer tokens. +package sessions + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "database/sql" + "encoding/base64" + "encoding/hex" + "errors" + "fmt" + "time" + + "github.com/dvcdsys/code-index/server/internal/users" +) + +// SessionTTL is the rolling lifetime of a session: how long after the +// last request before the cookie expires. 14 days matches typical +// "stay signed in" behaviour for an internal admin tool. +const SessionTTL = 14 * 24 * time.Hour + +// CookieName is the name of the HTTP cookie carrying the raw session token. +const CookieName = "cix_session" + +var ( + ErrNotFound = errors.New("session not found") + ErrExpired = errors.New("session expired") + ErrDisabled = errors.New("user account is disabled") +) + +// Session is a single login session with its associated user attached. +// ID is the public hash id (sha256-hex of the raw token). The raw token +// is only ever returned by Create — every other call works with the hash. +type Session struct { + ID string + UserID string + CreatedAt time.Time + ExpiresAt time.Time + LastSeenAt time.Time + LastSeenIP string + LastSeenUA string +} + +// Created is the bundle returned by Create: the persisted Session (with +// its public hash id) plus the raw token the caller must put in the +// cookie. The raw token is never persisted — losing it means the user +// can never reuse this session, which is the whole point. +type Created struct { + Session Session + RawToken string +} + +// Service wraps the sessions table. +type Service struct { + DB *sql.DB +} + +// New returns a Service. +func New(db *sql.DB) *Service { return &Service{DB: db} } + +// Create issues a new session for userID. The returned RawToken is what +// must be set in the browser cookie; only sha256(RawToken) hits the DB. +func (s *Service) Create(ctx context.Context, userID, ip, ua string) (Created, error) { + raw, err := newRawToken() + if err != nil { + return Created{}, fmt.Errorf("generate session token: %w", err) + } + hash := HashToken(raw) + now := time.Now().UTC() + exp := now.Add(SessionTTL) + _, err = s.DB.ExecContext(ctx, + `INSERT INTO sessions (id, user_id, created_at, expires_at, last_seen_at, last_seen_ip, last_seen_ua) + VALUES (?, ?, ?, ?, ?, ?, ?)`, + hash, userID, + now.Format(time.RFC3339Nano), + exp.Format(time.RFC3339Nano), + now.Format(time.RFC3339Nano), + nullableString(ip), nullableString(ua), + ) + if err != nil { + return Created{}, fmt.Errorf("insert session: %w", err) + } + return Created{ + Session: Session{ + ID: hash, + UserID: userID, + CreatedAt: now, + ExpiresAt: exp, + LastSeenAt: now, + LastSeenIP: ip, + LastSeenUA: ua, + }, + RawToken: raw, + }, nil +} + +// Get looks up a session by the raw cookie token (the value the browser +// sends back on every request). Internally hashes the token and queries +// by hash. Returns ErrNotFound for unknown tokens, ErrExpired when the +// session has timed out (Get also deletes expired rows opportunistically), +// and ErrDisabled when the user has been disabled since the session was +// created. +func (s *Service) Get(ctx context.Context, rawToken string) (Session, users.User, error) { + if rawToken == "" { + return Session{}, users.User{}, ErrNotFound + } + hash := HashToken(rawToken) + row := s.DB.QueryRowContext(ctx, + `SELECT s.id, s.user_id, s.created_at, s.expires_at, s.last_seen_at, s.last_seen_ip, s.last_seen_ua, + u.email, u.role, u.must_change_password, u.created_at, u.updated_at, u.disabled_at + FROM sessions s + JOIN users u ON u.id = s.user_id + WHERE s.id = ?`, hash) + + var ( + sess Session + ip, ua sql.NullString + createdAt, expiresAt, lastSeenAt string + uEmail, uRole string + uMcp int + uCreatedAt, uUpdatedAt string + uDisabledAt sql.NullString + ) + err := row.Scan( + &sess.ID, &sess.UserID, &createdAt, &expiresAt, &lastSeenAt, &ip, &ua, + &uEmail, &uRole, &uMcp, &uCreatedAt, &uUpdatedAt, &uDisabledAt, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return Session{}, users.User{}, ErrNotFound + } + return Session{}, users.User{}, fmt.Errorf("scan session: %w", err) + } + sess.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + sess.ExpiresAt, _ = time.Parse(time.RFC3339Nano, expiresAt) + sess.LastSeenAt, _ = time.Parse(time.RFC3339Nano, lastSeenAt) + sess.LastSeenIP = ip.String + sess.LastSeenUA = ua.String + + if time.Now().UTC().After(sess.ExpiresAt) { + // Garbage-collect this row so it can't be re-tried. Best-effort: + // failure to delete is fine, the next GC pass will catch it. + _, _ = s.DB.ExecContext(ctx, `DELETE FROM sessions WHERE id = ?`, sess.ID) + return Session{}, users.User{}, ErrExpired + } + + u := users.User{ + ID: sess.UserID, + Email: uEmail, + Role: uRole, + MustChangePassword: uMcp == 1, + } + u.CreatedAt, _ = time.Parse(time.RFC3339Nano, uCreatedAt) + u.UpdatedAt, _ = time.Parse(time.RFC3339Nano, uUpdatedAt) + if uDisabledAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, uDisabledAt.String) + u.DisabledAt = &t + return Session{}, users.User{}, ErrDisabled + } + return sess, u, nil +} + +// Touch slides expires_at forward by SessionTTL and refreshes the last-seen +// metadata. Called by middleware on every authenticated request; the +// id argument is the public hash id (Session.ID), not the raw token. +func (s *Service) Touch(ctx context.Context, id, ip, ua string) error { + now := time.Now().UTC() + exp := now.Add(SessionTTL) + _, err := s.DB.ExecContext(ctx, + `UPDATE sessions + SET expires_at = ?, last_seen_at = ?, last_seen_ip = ?, last_seen_ua = ? + WHERE id = ?`, + exp.Format(time.RFC3339Nano), + now.Format(time.RFC3339Nano), + nullableString(ip), nullableString(ua), + id, + ) + if err != nil { + return fmt.Errorf("touch session: %w", err) + } + return nil +} + +// Delete removes a single session (logout-from-this-device). The id is +// the public hash id. +func (s *Service) Delete(ctx context.Context, id string) error { + _, err := s.DB.ExecContext(ctx, `DELETE FROM sessions WHERE id = ?`, id) + return err +} + +// DeleteAllForUser wipes every session of a user. +func (s *Service) DeleteAllForUser(ctx context.Context, userID string) error { + _, err := s.DB.ExecContext(ctx, `DELETE FROM sessions WHERE user_id = ?`, userID) + return err +} + +// DeleteAllForUserExcept is like DeleteAllForUser but keeps one session +// alive (typically the one carrying the password-change request itself). +// keepID is the public hash id. +func (s *Service) DeleteAllForUserExcept(ctx context.Context, userID, keepID string) error { + _, err := s.DB.ExecContext(ctx, + `DELETE FROM sessions WHERE user_id = ? AND id != ?`, userID, keepID) + return err +} + +// ListForUser returns active (non-expired) sessions for a user, newest +// first. Used by the Settings page to show "where am I logged in?". +// Session.ID is the public hash id; the raw tokens are never returned. +func (s *Service) ListForUser(ctx context.Context, userID string) ([]Session, error) { + now := time.Now().UTC().Format(time.RFC3339Nano) + rows, err := s.DB.QueryContext(ctx, + `SELECT id, user_id, created_at, expires_at, last_seen_at, last_seen_ip, last_seen_ua + FROM sessions + WHERE user_id = ? AND expires_at > ? + ORDER BY last_seen_at DESC`, userID, now) + if err != nil { + return nil, fmt.Errorf("list sessions: %w", err) + } + defer rows.Close() + var out []Session + for rows.Next() { + var ( + s Session + ip, ua sql.NullString + createdAt, expiresAt, lastSeenAt string + ) + if err := rows.Scan(&s.ID, &s.UserID, &createdAt, &expiresAt, &lastSeenAt, &ip, &ua); err != nil { + return nil, err + } + s.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + s.ExpiresAt, _ = time.Parse(time.RFC3339Nano, expiresAt) + s.LastSeenAt, _ = time.Parse(time.RFC3339Nano, lastSeenAt) + s.LastSeenIP = ip.String + s.LastSeenUA = ua.String + out = append(out, s) + } + return out, rows.Err() +} + +// GC deletes all expired sessions. Safe to run periodically. Returns the +// number of rows removed. +func (s *Service) GC(ctx context.Context) (int64, error) { + now := time.Now().UTC().Format(time.RFC3339Nano) + res, err := s.DB.ExecContext(ctx, `DELETE FROM sessions WHERE expires_at <= ?`, now) + if err != nil { + return 0, fmt.Errorf("gc sessions: %w", err) + } + n, _ := res.RowsAffected() + return n, nil +} + +// HashToken returns the public id (sha256-hex) for a raw session token. +// Exposed so tests can verify that the cookie value never appears in the +// DB column. +func HashToken(raw string) string { + h := sha256.Sum256([]byte(raw)) + return hex.EncodeToString(h[:]) +} + +// newRawToken returns a fresh 256-bit base64url-encoded random token. +func newRawToken() (string, error) { + var b [32]byte + if _, err := rand.Read(b[:]); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(b[:]), nil +} + +func nullableString(s string) any { + if s == "" { + return nil + } + return s +} diff --git a/server/internal/sessions/sessions_test.go b/server/internal/sessions/sessions_test.go new file mode 100644 index 0000000..ee79c37 --- /dev/null +++ b/server/internal/sessions/sessions_test.go @@ -0,0 +1,196 @@ +package sessions + +import ( + "context" + "errors" + "strings" + "testing" + "time" + + "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/users" +) + +type fixture struct { + S *Service + UserID string +} + +func newFixture(t *testing.T) fixture { + t.Helper() + d, err := db.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = d.Close() }) + usrSvc := users.New(d) + u, err := usrSvc.Create(context.Background(), "a@b.com", "password1234", users.RoleViewer, false) + if err != nil { + t.Fatalf("create user: %v", err) + } + return fixture{S: New(d), UserID: u.ID} +} + +func TestCreateAndGet(t *testing.T) { + f := newFixture(t) + c, err := f.S.Create(context.Background(), f.UserID, "10.0.0.1", "tester/1") + if err != nil { + t.Fatalf("Create: %v", err) + } + got, u, err := f.S.Get(context.Background(), c.RawToken) + if err != nil { + t.Fatalf("Get: %v", err) + } + if got.ID != c.Session.ID { + t.Errorf("Get returned different id: %v vs %v", got.ID, c.Session.ID) + } + if u.ID != f.UserID { + t.Errorf("Get returned different user: %v vs %v", u.ID, f.UserID) + } +} + +// TestCreate_StoresHashNotRawToken proves the headline security property: +// the value the browser sends in the cookie never appears in the sessions +// table. Only sha256(token) is persisted, so a leaked DB snapshot cannot +// be replayed to impersonate active sessions. +func TestCreate_StoresHashNotRawToken(t *testing.T) { + f := newFixture(t) + c, err := f.S.Create(context.Background(), f.UserID, "", "") + if err != nil { + t.Fatalf("Create: %v", err) + } + if c.RawToken == "" || c.Session.ID == "" { + t.Fatalf("Create returned empty token / id") + } + if c.RawToken == c.Session.ID { + t.Fatalf("RawToken and Session.ID must differ (token=%q id=%q)", c.RawToken, c.Session.ID) + } + + var dbID string + if err := f.S.DB.QueryRow(`SELECT id FROM sessions LIMIT 1`).Scan(&dbID); err != nil { + t.Fatalf("query: %v", err) + } + if dbID != c.Session.ID { + t.Errorf("DB id=%q, want hash %q", dbID, c.Session.ID) + } + if dbID == c.RawToken { + t.Errorf("DB stored raw token %q — must store the hash instead", c.RawToken) + } + if strings.Contains(dbID, c.RawToken) { + t.Errorf("DB id %q leaks the raw token %q", dbID, c.RawToken) + } + // Hash must be deterministic and match the public helper. + if HashToken(c.RawToken) != c.Session.ID { + t.Errorf("HashToken(raw) = %q, want Session.ID %q", HashToken(c.RawToken), c.Session.ID) + } +} + +// TestGet_RejectsRawHashLookup ensures an attacker who somehow knows the +// stored hash (e.g. from a leaked DB) cannot use it as the cookie value +// directly — Get hashes its argument before querying, so passing the +// hash hashes it again and finds nothing. +func TestGet_RejectsRawHashLookup(t *testing.T) { + f := newFixture(t) + c, _ := f.S.Create(context.Background(), f.UserID, "", "") + // Lookup with the raw token works. + if _, _, err := f.S.Get(context.Background(), c.RawToken); err != nil { + t.Fatalf("lookup with raw token: %v", err) + } + // Lookup with the stored hash must fail. + if _, _, err := f.S.Get(context.Background(), c.Session.ID); !errors.Is(err, ErrNotFound) { + t.Errorf("Get(hash) err = %v, want ErrNotFound", err) + } +} + +func TestTouch_SlidesExpires(t *testing.T) { + f := newFixture(t) + c, _ := f.S.Create(context.Background(), f.UserID, "", "") + originalExp := c.Session.ExpiresAt + + // Forward time by sleeping a hair so timestamps differ. + time.Sleep(10 * time.Millisecond) + if err := f.S.Touch(context.Background(), c.Session.ID, "127.0.0.1", "after"); err != nil { + t.Fatalf("Touch: %v", err) + } + got, _, _ := f.S.Get(context.Background(), c.RawToken) + if !got.ExpiresAt.After(originalExp) { + t.Errorf("ExpiresAt should slide forward; got %v vs %v", got.ExpiresAt, originalExp) + } + if got.LastSeenIP != "127.0.0.1" || got.LastSeenUA != "after" { + t.Errorf("Touch did not update IP/UA: %v / %v", got.LastSeenIP, got.LastSeenUA) + } +} + +func TestGet_Expired(t *testing.T) { + f := newFixture(t) + c, _ := f.S.Create(context.Background(), f.UserID, "", "") + // Force-expire by writing a past timestamp directly. + if _, err := f.S.DB.Exec(`UPDATE sessions SET expires_at = ? WHERE id = ?`, + time.Now().Add(-time.Hour).UTC().Format(time.RFC3339Nano), c.Session.ID); err != nil { + t.Fatalf("update expires_at: %v", err) + } + if _, _, err := f.S.Get(context.Background(), c.RawToken); !errors.Is(err, ErrExpired) { + t.Errorf("Get on expired session err = %v, want ErrExpired", err) + } +} + +func TestDelete(t *testing.T) { + f := newFixture(t) + c, _ := f.S.Create(context.Background(), f.UserID, "", "") + if err := f.S.Delete(context.Background(), c.Session.ID); err != nil { + t.Fatalf("Delete: %v", err) + } + if _, _, err := f.S.Get(context.Background(), c.RawToken); !errors.Is(err, ErrNotFound) { + t.Errorf("Get after Delete err = %v, want ErrNotFound", err) + } +} + +func TestDeleteAllForUserExcept(t *testing.T) { + f := newFixture(t) + keep, _ := f.S.Create(context.Background(), f.UserID, "", "") + gone1, _ := f.S.Create(context.Background(), f.UserID, "", "") + gone2, _ := f.S.Create(context.Background(), f.UserID, "", "") + + if err := f.S.DeleteAllForUserExcept(context.Background(), f.UserID, keep.Session.ID); err != nil { + t.Fatalf("DeleteAllForUserExcept: %v", err) + } + if _, _, err := f.S.Get(context.Background(), keep.RawToken); err != nil { + t.Errorf("kept session lost: %v", err) + } + for _, g := range []Created{gone1, gone2} { + if _, _, err := f.S.Get(context.Background(), g.RawToken); !errors.Is(err, ErrNotFound) { + t.Errorf("session %v should have been deleted, got err=%v", g.Session.ID, err) + } + } +} + +func TestGC(t *testing.T) { + f := newFixture(t) + live, _ := f.S.Create(context.Background(), f.UserID, "", "") + dead, _ := f.S.Create(context.Background(), f.UserID, "", "") + _, _ = f.S.DB.Exec(`UPDATE sessions SET expires_at = ? WHERE id = ?`, + time.Now().Add(-time.Hour).UTC().Format(time.RFC3339Nano), dead.Session.ID) + + n, err := f.S.GC(context.Background()) + if err != nil { + t.Fatalf("GC: %v", err) + } + if n != 1 { + t.Errorf("GC removed = %d, want 1", n) + } + if _, _, err := f.S.Get(context.Background(), live.RawToken); err != nil { + t.Errorf("live session lost after GC: %v", err) + } +} + +func TestGet_DisabledUser(t *testing.T) { + f := newFixture(t) + c, _ := f.S.Create(context.Background(), f.UserID, "", "") + // Disable the user directly (bypass the LastAdminBlock guard since + // the seeded user is a viewer, not an admin). + now := time.Now().UTC().Format(time.RFC3339Nano) + _, _ = f.S.DB.Exec(`UPDATE users SET disabled_at = ? WHERE id = ?`, now, f.UserID) + if _, _, err := f.S.Get(context.Background(), c.RawToken); !errors.Is(err, ErrDisabled) { + t.Errorf("Get on disabled-user session err = %v, want ErrDisabled", err) + } +} diff --git a/server/internal/users/users.go b/server/internal/users/users.go new file mode 100644 index 0000000..1cf55d6 --- /dev/null +++ b/server/internal/users/users.go @@ -0,0 +1,415 @@ +// Package users implements the dashboard's user-account model: email + +// bcrypt password + role. Replaces the old single-CIX_API_KEY auth, which +// could not distinguish actors. CLI access still flows through Bearer +// tokens, but those tokens now belong to a user via internal/apikeys. +package users + +import ( + "context" + "database/sql" + "errors" + "fmt" + "strings" + "time" + + "github.com/google/uuid" + "golang.org/x/crypto/bcrypt" +) + +// Roles. Kept open-coded (string constants) rather than a typed enum so +// SQL queries and HTTP handlers can compare without import gymnastics. +const ( + RoleAdmin = "admin" + RoleViewer = "viewer" +) + +// BcryptCost is the work factor for password hashing. 12 is the current +// industry default — tunable here without touching call sites if the +// hardware moves. +const BcryptCost = 12 + +var ( + ErrNotFound = errors.New("user not found") + ErrEmailTaken = errors.New("email already in use") + ErrInvalidLogin = errors.New("invalid email or password") + ErrUserDisabled = errors.New("user account is disabled") + ErrLastAdminBlock = errors.New("cannot remove the last active admin") + ErrInvalidRole = errors.New("invalid role") +) + +// User is the row shape returned by Service. password_hash never leaves +// the package — callers only see metadata + the role bit they need. +type User struct { + ID string + Email string + Role string + MustChangePassword bool + CreatedAt time.Time + UpdatedAt time.Time + DisabledAt *time.Time +} + +// Service wraps the users table. Stateless — safe to share across handlers. +type Service struct { + DB *sql.DB +} + +// New returns a Service bound to db. +func New(db *sql.DB) *Service { return &Service{DB: db} } + +// Count returns the total number of users (including disabled). Used by the +// bootstrap path in main.go to decide whether to seed an admin from env. +func (s *Service) Count(ctx context.Context) (int, error) { + var n int + if err := s.DB.QueryRowContext(ctx, `SELECT COUNT(1) FROM users`).Scan(&n); err != nil { + return 0, fmt.Errorf("count users: %w", err) + } + return n, nil +} + +// Create inserts a new user with the given plaintext password (hashed +// here). mustChangePassword=true is the right call for any account whose +// initial password came from somewhere other than the user themselves +// (env bootstrap, admin invite). +func (s *Service) Create(ctx context.Context, email, password, role string, mustChangePassword bool) (User, error) { + email = normalizeEmail(email) + if email == "" { + return User{}, fmt.Errorf("email required") + } + if !validRole(role) { + return User{}, ErrInvalidRole + } + if password == "" { + return User{}, fmt.Errorf("password required") + } + + hash, err := bcrypt.GenerateFromPassword([]byte(password), BcryptCost) + if err != nil { + return User{}, fmt.Errorf("hash password: %w", err) + } + + id := uuid.NewString() + now := time.Now().UTC().Format(time.RFC3339Nano) + mcp := 0 + if mustChangePassword { + mcp = 1 + } + + _, err = s.DB.ExecContext(ctx, + `INSERT INTO users (id, email, password_hash, role, must_change_password, created_at, updated_at) + VALUES (?, ?, ?, ?, ?, ?, ?)`, + id, email, string(hash), role, mcp, now, now, + ) + if err != nil { + if isUniqueViolation(err) { + return User{}, ErrEmailTaken + } + return User{}, fmt.Errorf("insert user: %w", err) + } + + return s.GetByID(ctx, id) +} + +// GetByID returns a user by id. ErrNotFound when absent. +func (s *Service) GetByID(ctx context.Context, id string) (User, error) { + return s.scanOne(ctx, `WHERE id = ?`, id) +} + +// GetByEmail returns a user by email (case-insensitive). ErrNotFound when absent. +func (s *Service) GetByEmail(ctx context.Context, email string) (User, error) { + return s.scanOne(ctx, `WHERE email = ? COLLATE NOCASE`, normalizeEmail(email)) +} + +// List returns every user, ordered oldest-first (admin UI usually wants +// stable ordering, and created_at is monotonic). +func (s *Service) List(ctx context.Context) ([]User, error) { + rows, err := s.DB.QueryContext(ctx, listSelect+` ORDER BY created_at ASC`) + if err != nil { + return nil, fmt.Errorf("list users: %w", err) + } + defer rows.Close() + var out []User + for rows.Next() { + u, err := scanUserRow(rows) + if err != nil { + return nil, err + } + out = append(out, u) + } + return out, rows.Err() +} + +// UserWithStats decorates User with admin-table aggregates: latest session +// timestamp + counts of non-expired sessions and non-revoked api keys. +type UserWithStats struct { + User + LastLoginAt *time.Time + ActiveSessionsCount int + APIKeysCount int +} + +// ListWithStats returns users joined with three aggregates used by the +// dashboard's admin /users table: last_login_at (= newest session +// created_at), active_sessions_count (= non-expired sessions), +// api_keys_count (= non-revoked api_keys). Performed as one query with +// correlated subqueries; per-user counts mean the n+1 stays inside SQLite. +func (s *Service) ListWithStats(ctx context.Context) ([]UserWithStats, error) { + now := time.Now().UTC().Format(time.RFC3339Nano) + const q = ` + SELECT id, email, role, must_change_password, created_at, updated_at, disabled_at, + (SELECT MAX(created_at) FROM sessions WHERE user_id = users.id), + (SELECT COUNT(1) FROM sessions WHERE user_id = users.id AND expires_at > ?), + (SELECT COUNT(1) FROM api_keys WHERE owner_user_id = users.id AND revoked_at IS NULL) + FROM users ORDER BY created_at ASC` + rows, err := s.DB.QueryContext(ctx, q, now) + if err != nil { + return nil, fmt.Errorf("list users with stats: %w", err) + } + defer rows.Close() + + var out []UserWithStats + for rows.Next() { + var ( + u User + mcp int + createdAt, updatedAt string + disabledAt sql.NullString + lastLogin sql.NullString + activeSessions, apiKeys int + ) + if err := rows.Scan( + &u.ID, &u.Email, &u.Role, &mcp, &createdAt, &updatedAt, &disabledAt, + &lastLogin, &activeSessions, &apiKeys, + ); err != nil { + return nil, err + } + u.MustChangePassword = mcp == 1 + u.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + u.UpdatedAt, _ = time.Parse(time.RFC3339Nano, updatedAt) + if disabledAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, disabledAt.String) + u.DisabledAt = &t + } + ws := UserWithStats{ + User: u, + ActiveSessionsCount: activeSessions, + APIKeysCount: apiKeys, + } + if lastLogin.Valid { + t, _ := time.Parse(time.RFC3339Nano, lastLogin.String) + ws.LastLoginAt = &t + } + out = append(out, ws) + } + return out, rows.Err() +} + +// Authenticate verifies email+password. Returns ErrInvalidLogin for any +// auth failure (bad password OR missing user) — never leak which one. +// Disabled accounts return ErrUserDisabled. +func (s *Service) Authenticate(ctx context.Context, email, password string) (User, error) { + email = normalizeEmail(email) + row := s.DB.QueryRowContext(ctx, + `SELECT id, password_hash, role, must_change_password, created_at, updated_at, disabled_at, email + FROM users WHERE email = ? COLLATE NOCASE`, email) + + var ( + u User + hash string + mcp int + disabledAt sql.NullString + createdAt string + updatedAt string + emailOut string + ) + if err := row.Scan(&u.ID, &hash, &u.Role, &mcp, &createdAt, &updatedAt, &disabledAt, &emailOut); err != nil { + if errors.Is(err, sql.ErrNoRows) { + // Match the timing of a hash-compare to mitigate user-enumeration + // via response time. CompareHashAndPassword on a known-bad hash + // burns the same cost as a real login. + _ = bcrypt.CompareHashAndPassword([]byte("$2a$12$invalidinvalidinvalidinvalidinvalidinvalidinvalidinvali"), []byte(password)) + return User{}, ErrInvalidLogin + } + return User{}, fmt.Errorf("scan user: %w", err) + } + if disabledAt.Valid { + return User{}, ErrUserDisabled + } + if err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)); err != nil { + return User{}, ErrInvalidLogin + } + u.Email = emailOut + u.MustChangePassword = mcp == 1 + u.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + u.UpdatedAt, _ = time.Parse(time.RFC3339Nano, updatedAt) + if disabledAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, disabledAt.String) + u.DisabledAt = &t + } + return u, nil +} + +// UpdatePassword sets a new password and clears must_change_password. The +// caller is responsible for invalidating any old sessions if desired — +// see internal/sessions DeleteAllForUser. +func (s *Service) UpdatePassword(ctx context.Context, id, newPassword string) error { + if newPassword == "" { + return fmt.Errorf("new password required") + } + hash, err := bcrypt.GenerateFromPassword([]byte(newPassword), BcryptCost) + if err != nil { + return fmt.Errorf("hash password: %w", err) + } + now := time.Now().UTC().Format(time.RFC3339Nano) + res, err := s.DB.ExecContext(ctx, + `UPDATE users SET password_hash = ?, must_change_password = 0, updated_at = ? WHERE id = ?`, + string(hash), now, id) + if err != nil { + return fmt.Errorf("update password: %w", err) + } + if n, _ := res.RowsAffected(); n == 0 { + return ErrNotFound + } + return nil +} + +// SetRole changes a user's role. Refuses to demote the last active admin +// to keep the system reachable. +func (s *Service) SetRole(ctx context.Context, id, role string) error { + if !validRole(role) { + return ErrInvalidRole + } + if role != RoleAdmin { + if err := s.guardLastAdmin(ctx, id); err != nil { + return err + } + } + now := time.Now().UTC().Format(time.RFC3339Nano) + res, err := s.DB.ExecContext(ctx, + `UPDATE users SET role = ?, updated_at = ? WHERE id = ?`, role, now, id) + if err != nil { + return fmt.Errorf("update role: %w", err) + } + if n, _ := res.RowsAffected(); n == 0 { + return ErrNotFound + } + return nil +} + +// SetDisabled flips the disabled flag. Disabled users cannot authenticate. +// Refuses to disable the last active admin (mirrors SetRole's guard). +func (s *Service) SetDisabled(ctx context.Context, id string, disabled bool) error { + if disabled { + if err := s.guardLastAdmin(ctx, id); err != nil { + return err + } + } + now := time.Now().UTC().Format(time.RFC3339Nano) + var res sql.Result + var err error + if disabled { + res, err = s.DB.ExecContext(ctx, + `UPDATE users SET disabled_at = ?, updated_at = ? WHERE id = ?`, now, now, id) + } else { + res, err = s.DB.ExecContext(ctx, + `UPDATE users SET disabled_at = NULL, updated_at = ? WHERE id = ?`, now, id) + } + if err != nil { + return fmt.Errorf("update disabled_at: %w", err) + } + if n, _ := res.RowsAffected(); n == 0 { + return ErrNotFound + } + return nil +} + +// Delete removes a user (cascades to sessions + api_keys via FK). +// Refuses to delete the last active admin. +func (s *Service) Delete(ctx context.Context, id string) error { + if err := s.guardLastAdmin(ctx, id); err != nil { + return err + } + res, err := s.DB.ExecContext(ctx, `DELETE FROM users WHERE id = ?`, id) + if err != nil { + return fmt.Errorf("delete user: %w", err) + } + if n, _ := res.RowsAffected(); n == 0 { + return ErrNotFound + } + return nil +} + +// guardLastAdmin returns ErrLastAdminBlock if id is the only enabled +// admin in the system. Used by demotion / disable / delete to keep at +// least one admin reachable. +func (s *Service) guardLastAdmin(ctx context.Context, id string) error { + u, err := s.GetByID(ctx, id) + if err != nil { + return err + } + if u.Role != RoleAdmin || u.DisabledAt != nil { + return nil + } + var n int + if err := s.DB.QueryRowContext(ctx, + `SELECT COUNT(1) FROM users WHERE role = 'admin' AND disabled_at IS NULL`).Scan(&n); err != nil { + return fmt.Errorf("count admins: %w", err) + } + if n <= 1 { + return ErrLastAdminBlock + } + return nil +} + +// --- helpers --- + +const listSelect = `SELECT id, email, role, must_change_password, created_at, updated_at, disabled_at FROM users` + +func (s *Service) scanOne(ctx context.Context, where string, args ...any) (User, error) { + row := s.DB.QueryRowContext(ctx, listSelect+" "+where, args...) + u, err := scanUserRow(row) + if errors.Is(err, sql.ErrNoRows) { + return User{}, ErrNotFound + } + return u, err +} + +type rowScanner interface { + Scan(dest ...any) error +} + +func scanUserRow(r rowScanner) (User, error) { + var ( + u User + mcp int + createdAt, updatedAt string + disabledAt sql.NullString + ) + if err := r.Scan(&u.ID, &u.Email, &u.Role, &mcp, &createdAt, &updatedAt, &disabledAt); err != nil { + return User{}, err + } + u.MustChangePassword = mcp == 1 + u.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + u.UpdatedAt, _ = time.Parse(time.RFC3339Nano, updatedAt) + if disabledAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, disabledAt.String) + u.DisabledAt = &t + } + return u, nil +} + +func normalizeEmail(s string) string { return strings.TrimSpace(strings.ToLower(s)) } + +func validRole(r string) bool { return r == RoleAdmin || r == RoleViewer } + +// isUniqueViolation matches modernc.org/sqlite's UNIQUE-constraint error +// without taking a hard import dependency on its error type. The driver +// formats these as "constraint failed: UNIQUE constraint failed: ...". +func isUniqueViolation(err error) bool { + if err == nil { + return false + } + msg := err.Error() + return strings.Contains(msg, "UNIQUE constraint failed") || + strings.Contains(msg, "constraint failed: UNIQUE") +} diff --git a/server/internal/users/users_test.go b/server/internal/users/users_test.go new file mode 100644 index 0000000..d7cc97c --- /dev/null +++ b/server/internal/users/users_test.go @@ -0,0 +1,251 @@ +package users + +import ( + "context" + "database/sql" + "errors" + "strings" + "testing" + "time" + + "github.com/dvcdsys/code-index/server/internal/db" +) + +func newTestService(t *testing.T) *Service { + t.Helper() + d, err := db.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = d.Close() }) + return New(d) +} + +func TestCreateAndAuthenticate(t *testing.T) { + s := newTestService(t) + u, err := s.Create(context.Background(), "Alice@Example.com", "supersecret", RoleAdmin, true) + if err != nil { + t.Fatalf("Create: %v", err) + } + if u.Email != "alice@example.com" { + t.Errorf("email not normalised: %q", u.Email) + } + if !u.MustChangePassword { + t.Errorf("MustChangePassword should be true after seeded creation") + } + + got, err := s.Authenticate(context.Background(), "ALICE@example.com", "supersecret") + if err != nil { + t.Fatalf("Authenticate: %v", err) + } + if got.ID != u.ID { + t.Errorf("Authenticate returned different user: %v vs %v", got.ID, u.ID) + } +} + +func TestAuthenticate_Wrong(t *testing.T) { + s := newTestService(t) + _, _ = s.Create(context.Background(), "a@b.com", "rightpassword", RoleViewer, false) + _, err := s.Authenticate(context.Background(), "a@b.com", "wrong") + if !errors.Is(err, ErrInvalidLogin) { + t.Errorf("err = %v, want ErrInvalidLogin", err) + } + _, err = s.Authenticate(context.Background(), "ghost@b.com", "anything") + if !errors.Is(err, ErrInvalidLogin) { + t.Errorf("missing user err = %v, want ErrInvalidLogin (no enumeration)", err) + } +} + +func TestEmailUniqueness(t *testing.T) { + s := newTestService(t) + _, err := s.Create(context.Background(), "a@b.com", "password1", RoleViewer, false) + if err != nil { + t.Fatalf("first Create: %v", err) + } + _, err = s.Create(context.Background(), "A@B.com", "password2", RoleViewer, false) + if !errors.Is(err, ErrEmailTaken) { + t.Errorf("err = %v, want ErrEmailTaken (case-insensitive uniqueness)", err) + } +} + +func TestUpdatePassword_ClearsMustChange(t *testing.T) { + s := newTestService(t) + u, _ := s.Create(context.Background(), "a@b.com", "initial-password", RoleViewer, true) + if err := s.UpdatePassword(context.Background(), u.ID, "newpassword123"); err != nil { + t.Fatalf("UpdatePassword: %v", err) + } + got, err := s.GetByID(context.Background(), u.ID) + if err != nil { + t.Fatalf("GetByID: %v", err) + } + if got.MustChangePassword { + t.Errorf("MustChangePassword should be cleared after UpdatePassword") + } + if _, err := s.Authenticate(context.Background(), "a@b.com", "newpassword123"); err != nil { + t.Errorf("Authenticate with new password: %v", err) + } + if _, err := s.Authenticate(context.Background(), "a@b.com", "initial-password"); !errors.Is(err, ErrInvalidLogin) { + t.Errorf("old password should no longer authenticate, got %v", err) + } +} + +func TestSetRole_LastAdminBlock(t *testing.T) { + s := newTestService(t) + a, _ := s.Create(context.Background(), "a@b.com", "password1", RoleAdmin, false) + if err := s.SetRole(context.Background(), a.ID, RoleViewer); !errors.Is(err, ErrLastAdminBlock) { + t.Errorf("demoting last admin err = %v, want ErrLastAdminBlock", err) + } + // Add a second admin — now demotion of the first must succeed. + _, _ = s.Create(context.Background(), "b@b.com", "password2", RoleAdmin, false) + if err := s.SetRole(context.Background(), a.ID, RoleViewer); err != nil { + t.Errorf("demoting with another admin around: %v", err) + } +} + +func TestSetDisabled_LastAdminBlock(t *testing.T) { + s := newTestService(t) + a, _ := s.Create(context.Background(), "a@b.com", "password1", RoleAdmin, false) + if err := s.SetDisabled(context.Background(), a.ID, true); !errors.Is(err, ErrLastAdminBlock) { + t.Errorf("disabling last admin err = %v, want ErrLastAdminBlock", err) + } +} + +func TestDelete_LastAdminBlock(t *testing.T) { + s := newTestService(t) + a, _ := s.Create(context.Background(), "a@b.com", "password1", RoleAdmin, false) + if err := s.Delete(context.Background(), a.ID); !errors.Is(err, ErrLastAdminBlock) { + t.Errorf("deleting last admin err = %v, want ErrLastAdminBlock", err) + } +} + +func TestInvalidRole(t *testing.T) { + s := newTestService(t) + _, err := s.Create(context.Background(), "a@b.com", "password1", "superadmin", false) + if !errors.Is(err, ErrInvalidRole) { + t.Errorf("Create with bad role err = %v, want ErrInvalidRole", err) + } +} + +func TestList(t *testing.T) { + s := newTestService(t) + for _, em := range []string{"a@b.com", "b@b.com", "c@b.com"} { + _, _ = s.Create(context.Background(), em, "password1234", RoleViewer, false) + } + list, err := s.List(context.Background()) + if err != nil { + t.Fatalf("List: %v", err) + } + if len(list) != 3 { + t.Errorf("list length = %d, want 3", len(list)) + } +} + +// Sanity: the dummy bcrypt-compare in Authenticate's no-row branch must +// not crash. Without this, a missing-user lookup would panic on a bad +// hash. The check is inside the function — we just need to exercise it. +func TestAuthenticate_NoUserDoesNotPanic(t *testing.T) { + s := newTestService(t) + _, err := s.Authenticate(context.Background(), "nobody@example.com", "anything") + if err == nil || !strings.Contains(err.Error(), "invalid email or password") { + t.Errorf("err = %v, want ErrInvalidLogin", err) + } +} + +// TestListWithStats verifies the joined aggregates: last_login_at (newest +// session), active_sessions_count (non-expired only), api_keys_count +// (non-revoked only). All three feed the dashboard's admin /users table. +func TestListWithStats(t *testing.T) { + ctx := context.Background() + s := newTestService(t) + now := time.Now().UTC() + + // Three users: alice (active session + 2 keys, 1 revoked), bob (expired + // session + 1 active key), carol (no sessions, no keys). + alice, err := s.Create(ctx, "alice@b.com", "password1234", RoleAdmin, false) + if err != nil { + t.Fatalf("create alice: %v", err) + } + bob, err := s.Create(ctx, "bob@b.com", "password1234", RoleViewer, false) + if err != nil { + t.Fatalf("create bob: %v", err) + } + carol, err := s.Create(ctx, "carol@b.com", "password1234", RoleViewer, false) + if err != nil { + t.Fatalf("create carol: %v", err) + } + + insertSession := func(userID string, created, expires time.Time) { + _, err := s.DB.ExecContext(ctx, + `INSERT INTO sessions (id, user_id, created_at, expires_at, last_seen_at) + VALUES (?, ?, ?, ?, ?)`, + "sess-"+userID+"-"+created.Format("150405.999999999"), + userID, + created.Format(time.RFC3339Nano), + expires.Format(time.RFC3339Nano), + created.Format(time.RFC3339Nano), + ) + if err != nil { + t.Fatalf("insert session for %s: %v", userID, err) + } + } + insertKey := func(userID, name string, revoked bool) { + var revokedAt sql.NullString + if revoked { + revokedAt = sql.NullString{Valid: true, String: now.Format(time.RFC3339Nano)} + } + _, err := s.DB.ExecContext(ctx, + `INSERT INTO api_keys (id, owner_user_id, name, prefix, hash, created_at, revoked_at) + VALUES (?, ?, ?, ?, ?, ?, ?)`, + "ak-"+userID+"-"+name, userID, name, + "cix_"+name[:4], "hash-"+userID+"-"+name, + now.Format(time.RFC3339Nano), revokedAt, + ) + if err != nil { + t.Fatalf("insert key for %s: %v", userID, err) + } + } + + // Alice: 2 sessions (newer = "now", older = 1 hour ago), both active. + insertSession(alice.ID, now.Add(-1*time.Hour), now.Add(13*24*time.Hour)) + aliceLatest := now.Add(-5 * time.Minute) + insertSession(alice.ID, aliceLatest, now.Add(14*24*time.Hour)) + insertKey(alice.ID, "live1", false) + insertKey(alice.ID, "live2", false) + insertKey(alice.ID, "deadx", true) + + // Bob: 1 expired session, 1 active key. last_login_at still set + // (expired session still counts as a past login event). + bobOnly := now.Add(-30 * 24 * time.Hour) + insertSession(bob.ID, bobOnly, now.Add(-16*24*time.Hour)) + insertKey(bob.ID, "bobok", false) + + // Carol: nothing. + _ = carol + + got, err := s.ListWithStats(ctx) + if err != nil { + t.Fatalf("ListWithStats: %v", err) + } + if len(got) != 3 { + t.Fatalf("len = %d, want 3", len(got)) + } + + by := map[string]UserWithStats{} + for _, u := range got { + by[u.Email] = u + } + + if a := by["alice@b.com"]; a.ActiveSessionsCount != 2 || a.APIKeysCount != 2 || + a.LastLoginAt == nil || !a.LastLoginAt.Equal(aliceLatest.Truncate(time.Nanosecond)) { + t.Errorf("alice stats wrong: sess=%d keys=%d last=%v (want sess=2 keys=2 last=%v)", + a.ActiveSessionsCount, a.APIKeysCount, a.LastLoginAt, aliceLatest) + } + if b := by["bob@b.com"]; b.ActiveSessionsCount != 0 || b.APIKeysCount != 1 || b.LastLoginAt == nil { + t.Errorf("bob stats wrong: sess=%d keys=%d last=%v (want sess=0 keys=1 last set)", + b.ActiveSessionsCount, b.APIKeysCount, b.LastLoginAt) + } + if c := by["carol@b.com"]; c.ActiveSessionsCount != 0 || c.APIKeysCount != 0 || c.LastLoginAt != nil { + t.Errorf("carol stats wrong: sess=%d keys=%d last=%v (want all zero/nil)", + c.ActiveSessionsCount, c.APIKeysCount, c.LastLoginAt) + } +} diff --git a/server/internal/vectorstore/store.go b/server/internal/vectorstore/store.go index 4b1435e..e00bcf9 100644 --- a/server/internal/vectorstore/store.go +++ b/server/internal/vectorstore/store.go @@ -63,17 +63,20 @@ func collectionName(projectPath string) string { return fmt.Sprintf("project_%x", h) } -// docID mirrors the Python VectorStoreService format: -// -// "{md5hex(filePath)[:12]}:{startLine}-{endLine}:{idx}" +// CollectionName is the exported alias for the per-project chromem-go +// collection identifier. The dashboard's project-detail card uses it to +// resolve the on-disk directory under cfg.DynamicChromaPersistDir(). +func CollectionName(projectPath string) string { return collectionName(projectPath) } + +// docID format: "{md5hex(filePath)[:12]}:{startLine}-{endLine}:{idx}" // // The positional `idx` is required because overlapping-window or repeated // chunkers can emit two chunks with identical (filePath, startLine, endLine); // without idx the second silently overwrites the first in chromem-go. // -// `h[:6]` gives 12 hex characters, matching Python's `md5[:12]`. Keep this -// function byte-compatible with `legacy/python-api/app-root/app/services/vector_store.py` -// so a future migration tool can diff ids between backends. +// `h[:6]` gives 12 hex characters. Format is frozen — existing prod indexes +// (including those imported from the prior Python backend) reference these +// ids on disk; changing the shape requires a full reindex. func docID(filePath string, startLine, endLine, idx int) string { h := md5.Sum([]byte(filePath)) return fmt.Sprintf("%x:%d-%d:%d", h[:6], startLine, endLine, idx) diff --git a/server/internal/versioncheck/check.go b/server/internal/versioncheck/check.go new file mode 100644 index 0000000..0626e75 --- /dev/null +++ b/server/internal/versioncheck/check.go @@ -0,0 +1,337 @@ +// Package versioncheck periodically polls GitHub for the latest cix-server +// release tag and exposes the result for the dashboard "update available" +// banner. One poll per server, regardless of how many clients are open — +// the per-instance cache avoids hammering the GitHub API and keeps an +// untrusted browser from being able to forge "latest version" claims. +// +// Tag stream is hardcoded to `server/v*` (cli/v* lives on a separate stream +// per CLAUDE.md). Pre-releases and drafts are skipped. ETag-based revalidation +// keeps unauthenticated rate-limit usage at ~4 req/day per server (default +// 6h interval, vs. the 60/h GitHub limit). +package versioncheck + +import ( + "context" + "encoding/json" + "fmt" + "io" + "log/slog" + "net/http" + "strconv" + "strings" + "sync" + "time" +) + +// Config configures the version-check service. Zero-value fields fall back +// to documented defaults inside New(). +type Config struct { + Enabled bool + Interval time.Duration + InitialDelay time.Duration + BaseURL string // default "https://api.github.com" — overridable for tests + Repo string // e.g. "dvcdsys/code-index" + TagPrefix string // default "server/v" + CurrentVersion string // e.g. "0.5.1" or "0.0.0-dev" + HTTPTimeout time.Duration + UserAgent string +} + +// Snapshot is a point-in-time view of the cached version-check state. +// All time / string fields are zero-valued when no successful check has +// happened yet — callers branch on LatestVersion != "" or CheckedAt.IsZero(). +type Snapshot struct { + Enabled bool + CurrentVersion string + LatestVersion string + UpdateAvailable bool + ReleaseURL string + CheckedAt time.Time + LastError string +} + +// Service polls GitHub on a ticker and serves the cached result via Latest(). +// Safe for concurrent use; Run blocks until the supplied context is canceled. +type Service struct { + cfg Config + logger *slog.Logger + client *http.Client + + mu sync.RWMutex + snapshot Snapshot + etag string + lastNotes string // unused for now; reserved for release-notes preview +} + +// New builds a Service. Defaults: BaseURL=api.github.com, TagPrefix=server/v, +// HTTPTimeout=10s, UserAgent="cix-server/". +func New(cfg Config, logger *slog.Logger) *Service { + if cfg.BaseURL == "" { + cfg.BaseURL = "https://api.github.com" + } + if cfg.TagPrefix == "" { + cfg.TagPrefix = "server/v" + } + if cfg.HTTPTimeout <= 0 { + cfg.HTTPTimeout = 10 * time.Second + } + if cfg.UserAgent == "" { + cfg.UserAgent = "cix-server/" + cfg.CurrentVersion + } + if logger == nil { + logger = slog.Default() + } + return &Service{ + cfg: cfg, + logger: logger, + client: &http.Client{Timeout: cfg.HTTPTimeout}, + snapshot: Snapshot{ + Enabled: cfg.Enabled, + CurrentVersion: cfg.CurrentVersion, + }, + } +} + +// Latest returns a copy of the current snapshot. Cheap; safe for hot paths. +func (s *Service) Latest() Snapshot { + s.mu.RLock() + defer s.mu.RUnlock() + return s.snapshot +} + +// Run loops on a ticker, refreshing the cache. Returns immediately when +// the feature is disabled. Exits cleanly on ctx.Done(). +func (s *Service) Run(ctx context.Context) { + if !s.cfg.Enabled { + s.logger.Info("version check disabled (CIX_VERSION_CHECK_ENABLED=false)") + return + } + if s.cfg.Repo == "" { + s.logger.Warn("version check enabled but CIX_VERSION_CHECK_REPO is empty — disabling") + return + } + + if s.cfg.InitialDelay > 0 { + select { + case <-ctx.Done(): + return + case <-time.After(s.cfg.InitialDelay): + } + } + + if err := s.CheckNow(ctx); err != nil { + s.logger.Warn("initial version check failed", "err", err) + } + + if s.cfg.Interval <= 0 { + return // one-shot mode (mainly for tests) + } + ticker := time.NewTicker(s.cfg.Interval) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + if err := s.CheckNow(ctx); err != nil { + s.logger.Warn("version check failed", "err", err) + } + } + } +} + +// CheckNow performs a single GitHub poll and updates the cache. +// Returns the error so callers (including Run) can log it; the cache +// already records the error in LastError on failure. +func (s *Service) CheckNow(ctx context.Context) error { + url := fmt.Sprintf("%s/repos/%s/releases?per_page=30", strings.TrimRight(s.cfg.BaseURL, "/"), s.cfg.Repo) + reqCtx, cancel := context.WithTimeout(ctx, s.cfg.HTTPTimeout) + defer cancel() + + req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, url, nil) + if err != nil { + s.recordError(fmt.Errorf("build request: %w", err)) + return err + } + req.Header.Set("Accept", "application/vnd.github+json") + req.Header.Set("User-Agent", s.cfg.UserAgent) + req.Header.Set("X-GitHub-Api-Version", "2022-11-28") + s.mu.RLock() + if s.etag != "" { + req.Header.Set("If-None-Match", s.etag) + } + s.mu.RUnlock() + + resp, err := s.client.Do(req) + if err != nil { + s.recordError(fmt.Errorf("github request: %w", err)) + return err + } + defer resp.Body.Close() + + switch resp.StatusCode { + case http.StatusNotModified: + // Cached snapshot still valid. Bump CheckedAt and clear any + // previous error so callers see "we tried, all good" rather + // than a stale failure. + s.mu.Lock() + s.snapshot.CheckedAt = time.Now().UTC() + s.snapshot.LastError = "" + s.mu.Unlock() + return nil + case http.StatusOK: + // fall through + default: + body, _ := io.ReadAll(io.LimitReader(resp.Body, 512)) + err := fmt.Errorf("github status %d: %s", resp.StatusCode, strings.TrimSpace(string(body))) + s.recordError(err) + return err + } + + var releases []githubRelease + if err := json.NewDecoder(resp.Body).Decode(&releases); err != nil { + s.recordError(fmt.Errorf("decode releases: %w", err)) + return err + } + + latestTag, htmlURL := pickLatest(releases, s.cfg.TagPrefix) + if latestTag == "" { + s.recordError(fmt.Errorf("no releases matching prefix %q", s.cfg.TagPrefix)) + return nil + } + + etag := resp.Header.Get("ETag") + updateAvail := isNewer(s.cfg.CurrentVersion, latestTag) + + s.mu.Lock() + s.etag = etag + s.snapshot = Snapshot{ + Enabled: true, + CurrentVersion: s.cfg.CurrentVersion, + LatestVersion: latestTag, + UpdateAvailable: updateAvail, + ReleaseURL: htmlURL, + CheckedAt: time.Now().UTC(), + LastError: "", + } + s.mu.Unlock() + return nil +} + +func (s *Service) recordError(err error) { + s.mu.Lock() + s.snapshot.CheckedAt = time.Now().UTC() + s.snapshot.LastError = err.Error() + s.mu.Unlock() +} + +// githubRelease is the subset of the GitHub Release schema we care about. +// Full schema: https://docs.github.com/en/rest/releases/releases +type githubRelease struct { + TagName string `json:"tag_name"` + HTMLURL string `json:"html_url"` + Draft bool `json:"draft"` + Prerelease bool `json:"prerelease"` +} + +// pickLatest filters releases by tag prefix, drops drafts/prereleases, and +// returns the highest-semver tag (with prefix stripped) plus its release URL. +// Empty result means no matching release. +func pickLatest(rels []githubRelease, prefix string) (tag, url string) { + var bestTag, bestURL string + for _, r := range rels { + if r.Draft || r.Prerelease { + continue + } + if !strings.HasPrefix(r.TagName, prefix) { + continue + } + v := strings.TrimPrefix(r.TagName, prefix) + // Defensive: drop anything that still looks like a prerelease + // (`-rc1`, `-beta`) even if GitHub didn't flag it. + if strings.ContainsAny(v, "-+") { + continue + } + if bestTag == "" || compareSemver(v, bestTag) > 0 { + bestTag, bestURL = v, r.HTMLURL + } + } + return bestTag, bestURL +} + +// isNewer reports whether `latest` is a strictly newer semver than `current`. +// Treats unparseable / dev / empty current as "anything is newer". +func isNewer(current, latest string) bool { + if latest == "" { + return false + } + cur := strings.TrimPrefix(current, "v") + if cur == "" || strings.Contains(cur, "-dev") || !looksNumeric(cur) { + // dev / unknown build → always offer the upgrade + return true + } + return compareSemver(latest, cur) > 0 +} + +// compareSemver compares two `MAJOR.MINOR.PATCH` strings numerically. +// Returns -1, 0, 1. Non-numeric components compare lexicographically as a +// safety fallback (shouldn't happen given pickLatest's filter). +func compareSemver(a, b string) int { + pa := strings.Split(a, ".") + pb := strings.Split(b, ".") + n := len(pa) + if len(pb) > n { + n = len(pb) + } + for i := 0; i < n; i++ { + ai, aOK := 0, true + bi, bOK := 0, true + if i < len(pa) { + ai, aOK = atoi(pa[i]) + } + if i < len(pb) { + bi, bOK = atoi(pb[i]) + } + if aOK && bOK { + if ai != bi { + if ai < bi { + return -1 + } + return 1 + } + continue + } + // Lexicographic fallback when at least one component is non-numeric. + var as, bs string + if i < len(pa) { + as = pa[i] + } + if i < len(pb) { + bs = pb[i] + } + if as != bs { + if as < bs { + return -1 + } + return 1 + } + } + return 0 +} + +func atoi(s string) (int, bool) { + n, err := strconv.Atoi(s) + if err != nil { + return 0, false + } + return n, true +} + +func looksNumeric(v string) bool { + for _, p := range strings.Split(v, ".") { + if _, ok := atoi(p); !ok { + return false + } + } + return true +} diff --git a/server/internal/versioncheck/check_test.go b/server/internal/versioncheck/check_test.go new file mode 100644 index 0000000..fdd57fc --- /dev/null +++ b/server/internal/versioncheck/check_test.go @@ -0,0 +1,266 @@ +package versioncheck + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" + "time" +) + +// fakeGitHub spins up an httptest.Server that mimics the +// /repos/{owner}/{repo}/releases endpoint. The handler closure can +// flip behavior between calls (e.g. to return 304 the second time). +func fakeGitHub(t *testing.T, handler http.HandlerFunc) *httptest.Server { + t.Helper() + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + return srv +} + +func mustEncode(t *testing.T, w http.ResponseWriter, body any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(body); err != nil { + t.Fatalf("encode: %v", err) + } +} + +func newTestService(t *testing.T, baseURL, current string) *Service { + t.Helper() + return New(Config{ + Enabled: true, + Interval: 0, // one-shot + InitialDelay: 0, + BaseURL: baseURL, + Repo: "owner/repo", + TagPrefix: "server/v", + CurrentVersion: current, + HTTPTimeout: 2 * time.Second, + UserAgent: "cix-server-test", + }, nil) +} + +func TestPicksLatestServerTagSkippingCli(t *testing.T) { + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + mustEncode(t, w, []githubRelease{ + {TagName: "cli/v0.5.0", HTMLURL: "u-cli", Prerelease: false}, + {TagName: "server/v0.4.0", HTMLURL: "u-server-040", Prerelease: false}, + {TagName: "server/v0.5.1", HTMLURL: "u-server-051", Prerelease: false}, + {TagName: "server/v0.5.0", HTMLURL: "u-server-050", Prerelease: false}, + }) + }) + + s := newTestService(t, srv.URL, "0.5.0") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("CheckNow: %v", err) + } + snap := s.Latest() + if snap.LatestVersion != "0.5.1" { + t.Errorf("LatestVersion = %q, want 0.5.1", snap.LatestVersion) + } + if !snap.UpdateAvailable { + t.Errorf("UpdateAvailable = false, want true (current=0.5.0, latest=0.5.1)") + } + if snap.ReleaseURL != "u-server-051" { + t.Errorf("ReleaseURL = %q, want u-server-051", snap.ReleaseURL) + } + if snap.LastError != "" { + t.Errorf("LastError = %q, want empty", snap.LastError) + } +} + +func TestSkipsPrereleaseAndDraft(t *testing.T) { + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + mustEncode(t, w, []githubRelease{ + {TagName: "server/v0.6.0", Prerelease: true, HTMLURL: "u-pre"}, + {TagName: "server/v0.5.9", Draft: true, HTMLURL: "u-draft"}, + {TagName: "server/v0.5.1", HTMLURL: "u-good"}, + }) + }) + + s := newTestService(t, srv.URL, "0.5.0") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("CheckNow: %v", err) + } + snap := s.Latest() + if snap.LatestVersion != "0.5.1" { + t.Errorf("LatestVersion = %q, want 0.5.1 (prereleases/drafts must be skipped)", snap.LatestVersion) + } +} + +func TestNoUpdateWhenCurrentIsLatest(t *testing.T) { + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + mustEncode(t, w, []githubRelease{ + {TagName: "server/v0.5.1", HTMLURL: "u-051"}, + }) + }) + + s := newTestService(t, srv.URL, "0.5.1") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("CheckNow: %v", err) + } + snap := s.Latest() + if snap.LatestVersion != "0.5.1" { + t.Errorf("LatestVersion = %q, want 0.5.1", snap.LatestVersion) + } + if snap.UpdateAvailable { + t.Errorf("UpdateAvailable = true, want false (running latest)") + } +} + +func TestETagRevalidation(t *testing.T) { + var calls atomic.Int32 + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + n := calls.Add(1) + // On first call, return data + ETag. On second call, expect + // If-None-Match and respond 304. + if n == 1 { + w.Header().Set("ETag", `"abc123"`) + mustEncode(t, w, []githubRelease{ + {TagName: "server/v0.6.0", HTMLURL: "u-060"}, + }) + return + } + if got := r.Header.Get("If-None-Match"); got != `"abc123"` { + t.Errorf("expected If-None-Match=abc123 on second call, got %q", got) + } + w.WriteHeader(http.StatusNotModified) + }) + + s := newTestService(t, srv.URL, "0.5.0") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("first CheckNow: %v", err) + } + first := s.Latest() + if first.LatestVersion != "0.6.0" { + t.Fatalf("first.LatestVersion = %q, want 0.6.0", first.LatestVersion) + } + firstChecked := first.CheckedAt + time.Sleep(2 * time.Millisecond) // ensure CheckedAt advances + + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("second CheckNow: %v", err) + } + second := s.Latest() + if second.LatestVersion != "0.6.0" { + t.Errorf("second.LatestVersion = %q, want 0.6.0 (304 must preserve cache)", second.LatestVersion) + } + if !second.CheckedAt.After(firstChecked) { + t.Errorf("CheckedAt did not advance on 304: first=%v second=%v", firstChecked, second.CheckedAt) + } + if calls.Load() != 2 { + t.Errorf("expected 2 GitHub calls, got %d", calls.Load()) + } +} + +func TestServerErrorPreservesCache(t *testing.T) { + var calls atomic.Int32 + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + n := calls.Add(1) + if n == 1 { + mustEncode(t, w, []githubRelease{ + {TagName: "server/v0.5.1", HTMLURL: "u-051"}, + }) + return + } + w.WriteHeader(http.StatusInternalServerError) + _, _ = w.Write([]byte(`{"message":"boom"}`)) + }) + + s := newTestService(t, srv.URL, "0.5.0") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("first CheckNow: %v", err) + } + if err := s.CheckNow(context.Background()); err == nil { + t.Fatalf("second CheckNow: expected error, got nil") + } + snap := s.Latest() + if snap.LatestVersion != "0.5.1" { + t.Errorf("LatestVersion = %q, want 0.5.1 (cache must survive 5xx)", snap.LatestVersion) + } + if snap.LastError == "" { + t.Errorf("LastError empty, want populated on 5xx") + } +} + +func TestDisabledServiceDoesNotCallGitHub(t *testing.T) { + var calls atomic.Int32 + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + calls.Add(1) + mustEncode(t, w, []githubRelease{}) + }) + + s := New(Config{ + Enabled: false, + Interval: 10 * time.Millisecond, + BaseURL: srv.URL, + Repo: "owner/repo", + CurrentVersion: "0.5.0", + HTTPTimeout: 2 * time.Second, + }, nil) + + ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) + defer cancel() + s.Run(ctx) // returns ~immediately + + if calls.Load() != 0 { + t.Errorf("disabled service made %d GitHub calls, want 0", calls.Load()) + } + if s.Latest().Enabled { + t.Errorf("Latest().Enabled = true, want false") + } +} + +func TestDevBuildAlwaysSeesUpdate(t *testing.T) { + srv := fakeGitHub(t, func(w http.ResponseWriter, r *http.Request) { + mustEncode(t, w, []githubRelease{ + {TagName: "server/v0.1.0", HTMLURL: "u-010"}, + }) + }) + + s := newTestService(t, srv.URL, "0.0.0-dev") + if err := s.CheckNow(context.Background()); err != nil { + t.Fatalf("CheckNow: %v", err) + } + if !s.Latest().UpdateAvailable { + t.Errorf("UpdateAvailable = false, want true on dev build") + } +} + +func TestCompareSemverEdgeCases(t *testing.T) { + cases := []struct { + a, b string + want int + }{ + {"0.5.0", "0.5.0", 0}, + {"0.5.1", "0.5.0", 1}, + {"0.5.0", "0.5.1", -1}, + {"0.10.0", "0.9.0", 1}, // numeric, not lexicographic + {"1.0.0", "0.99.99", 1}, + {"0.5", "0.5.0", 0}, // missing component treated as 0 + } + for _, c := range cases { + got := compareSemver(c.a, c.b) + if got != c.want { + t.Errorf("compareSemver(%q, %q) = %d, want %d", c.a, c.b, got, c.want) + } + } +} + +func TestNetworkErrorPopulatesLastError(t *testing.T) { + // Point at an unroutable address; the request must fail before timeout. + s := New(Config{ + Enabled: true, + BaseURL: "http://127.0.0.1:1", // closed port + Repo: "owner/repo", + CurrentVersion: "0.5.0", + HTTPTimeout: 250 * time.Millisecond, + }, nil) + _ = s.CheckNow(context.Background()) + if s.Latest().LastError == "" { + t.Errorf("LastError empty, want populated on network failure") + } +} diff --git a/skills/README.md b/skills/README.md index 6bb6a51..230130d 100644 --- a/skills/README.md +++ b/skills/README.md @@ -2,7 +2,9 @@ ## cix — Semantic Code Search -Teaches an AI agent how to use `cix` for code navigation instead of Grep/Glob. +Teaches an AI agent when to reach for `cix` (semantic, cross-file, +exploratory) versus Grep / Glob / Read (exact strings, known pointers, +non-code files). ### Install @@ -18,6 +20,8 @@ In a Claude Code session: /cix ``` -Loads search guidance into context. Claude will use `cix search` instead of Grep/Glob for the rest of the session. +Loads navigation guidance into context for the rest of the session. -To activate automatically in every session, add `cix` usage instructions to `~/.claude/CLAUDE.md` (see the [Agent Integration](../README.md#agent-integration) section in the main README). \ No newline at end of file +To activate automatically in every session, add `cix` usage instructions +to `~/.claude/CLAUDE.md` (see the [Agent Integration](../README.md#agent-integration) +section in the main README). \ No newline at end of file diff --git a/skills/cix/SKILL.md b/skills/cix/SKILL.md index f755307..d85c0b5 100644 --- a/skills/cix/SKILL.md +++ b/skills/cix/SKILL.md @@ -1,25 +1,36 @@ --- name: cix -description: Semantic code search and navigation using the cix index. Use BEFORE Grep/Glob/Read for faster, smarter code discovery. Covers search, definitions, references, symbols, files, and indexing. +description: Semantic code search and navigation using the cix index. Reach for cix when you don't already know where to look. Covers search, definitions, references, symbols, files, and indexing. user-invocable: true --- # Code Index (`cix`) — Semantic Code Search & Navigation -You have access to `cix`, a semantic code index that understands your codebase. It uses embeddings and AST parsing to provide intelligent search — **always prefer `cix` over Grep/Glob** when looking for code. +You have access to `cix`, a semantic code index that understands the +codebase via embeddings + AST parsing. The right reflex is **"cix when +you don't have a pointer; grep when you do."** -## Why use `cix` first? +## When to use which -1. **Saves tokens** — returns only relevant snippets, not entire files -2. **Understands meaning** — "authentication middleware" finds auth code even if those words aren't in the source -3. **Structured navigation** — go-to-definition and find-references like an IDE -4. **Fast** — pre-indexed, no filesystem scanning needed +**Reach for `cix` first when:** +- The starting point is open-ended ("how does indexing work?", "find the + authentication middleware", "where is the main entry point?") +- You need cross-file navigation (definitions / references / callers) +- You're searching by *meaning*, not by an exact string + (`"JWT validation"` should find `verifyToken` even without that phrase) +- You're exploring an unfamiliar package or codebase -## Search priority +**Skip `cix`, use Read / Grep / Glob directly when:** +- A failing test or stack trace already names the file and function — + just `Read` it +- You're chasing an exact literal: a specific error message, a config + key, a commit-message phrase, an import path +- You're inside dependencies (`node_modules`, `vendor`, `.venv`) — they + aren't indexed +- You're editing a non-code file (Dockerfile, yaml, lockfile) -1. `cix search` or `cix symbols` — FIRST choice -2. `cix definitions` / `cix references` — for navigation -3. Grep/Glob — only if `cix` returns no results or is unavailable +If `cix` returns nothing relevant after one well-formed query, fall +back to grep — don't loop on cix. --- @@ -32,29 +43,24 @@ cix search "database connection retry logic" cix search "error handling in payment flow" --limit 20 cix search "config parsing" --in ./internal/config/ cix search "API routes" --lang go -cix search "validation" --in ./api --lang python +cix search "main entry point" --exclude bench/fixtures --exclude legacy ``` **Flags:** - `--in ` — restrict to file or directory (can repeat) +- `--exclude ` — drop a directory or substring from results (can repeat) - `--lang ` — filter by language (can repeat) -- `--limit ` — max results (default: 10) -- `--min-score ` — minimum relevance 0.0-1.0 (default: 0.1) +- `--limit ` — max **files** returned (default: 10) — output is + grouped per file with all matches inside, so 10 files ≈ many snippets +- `--min-score ` — minimum relevance 0.0–1.0 (default: **0.4**) ### Go to Definition — find where a symbol is defined ```bash cix definitions HandleRequest cix def AuthMiddleware --kind function -cix goto UserService --kind class cix def Config --file ./internal/config.go ``` - -**Aliases:** `definitions`, `def`, `goto` - -**Flags:** -- `--kind ` — filter: function, class, method, type -- `--file ` — narrow to specific file -- `--limit ` — max results (default: 10) +Aliases: `definitions`, `def`, `goto`. Flags: `--kind`, `--file`, `--limit`. ### Find References — find where a symbol is used ```bash @@ -62,12 +68,7 @@ cix references HandleRequest cix refs AuthMiddleware --limit 50 cix usages UserService --file ./internal/api/ ``` - -**Aliases:** `references`, `refs`, `usages` - -**Flags:** -- `--file ` — narrow to specific file -- `--limit ` — max results (default: 30) +Aliases: `references`, `refs`, `usages`. Flags: `--file`, `--limit`. ### Symbol Search — find symbols by name ```bash @@ -75,10 +76,7 @@ cix symbols handleRequest cix symbols User --kind class cix symbols Auth --kind function --kind method ``` - -**Flags:** -- `--kind ` — filter: function, class, method, type (can repeat) -- `--limit ` — max results (default: 20) +Flags: `--kind` (function/class/method/type, repeatable), `--limit`. ### File Search — find files by path pattern ```bash @@ -88,60 +86,112 @@ cix files "middleware" --limit 20 ### Project Overview ```bash -cix summary # languages, directories, key symbols -cix status # indexing status, file counts +cix summary # languages, top dirs, key symbols +cix status # indexing status + file watcher status cix list # all indexed projects ``` ### Indexing ```bash cix init [path] # register + index + start watcher -cix reindex # incremental (only changed files) -cix reindex --full # full reindex from scratch -cix watch # start auto-reindex daemon +cix reindex # incremental +cix reindex --full # full reindex +cix cancel # cancel an in-flight indexing run +cix watch # start file-change auto-reindex daemon cix watch stop # stop daemon ``` +The watcher auto-reindexes on file change — manual `reindex` is rarely +needed. `cix status` shows whether the watcher is running and the +last-sync timestamp. + +--- + +## Search quality — what scores mean + +Default `--min-score 0.4` is calibrated for the production embedding +model (CodeRankEmbed-Q8 with path-aware preamble). Rough landscape: + +| Score | Meaning | +|----------|---------------------------------------------------------| +| 0.65+ | Exact / very strong match — almost certainly relevant | +| 0.50–0.65| Strong match — usually relevant | +| 0.40–0.50| Weaker match — sometimes useful, sometimes not | +| <0.40 | Noise — filtered out by default | + +**If a query returns nothing**, lower the floor explicitly: +`--min-score 0.2` for very specific or long-tail queries. Don't drop +below 0.2 — results below that are noise. + +--- + +## Writing better queries — leverage path-aware embedding + +Each chunk is embedded with its file path, language, and symbol name in +the preamble. This means **mentioning a file/dir/symbol you already +know about boosts ranking**: + +```bash +# Generic +cix search "validation" +# Better — pins the search to the auth area +cix search "validation in auth middleware" +# Even better when you know the symbol +cix search "ValidateToken" --kind function +``` + +Natural-language queries that name the *kind of thing* and *where it +lives* outperform single-word queries. + --- ## Usage Patterns -### Exploring unfamiliar code +### Exploring unfamiliar code (`cix`'s strongest case) ```bash -cix summary # understand project structure -cix search "main entry point" # find where it starts -cix search "database" --limit 20 # find all DB-related code +cix summary # project structure, top dirs +cix search "main entry point server" # find where it starts +cix search "database connection setup" # find DB wiring +cix search "request handler" --in ./api # narrow to API ``` -### Finding specific functionality +### Tracing a symbol end-to-end ```bash -cix search "JWT token validation" # semantic — finds by meaning -cix symbols "Validate" --kind function # exact name lookup -cix def ValidateToken # jump to definition -cix refs ValidateToken # find all callers +cix def HandleRequest # where is it defined? +cix refs HandleRequest # who calls it? +cix search "HandleRequest error handling" # how are errors handled? ``` -### Understanding a symbol +### Chasing a known target (often grep is enough) ```bash -cix def HandleRequest # where is it defined? -cix refs HandleRequest # who calls it? -cix search "HandleRequest error" # how are errors handled? +# Stack trace says "internal/auth/middleware.go:42 — invalid token" +# → just Read that file. No cix needed. + +# Config key "max_concurrent_requests" used somewhere? +# → grep is more precise. ``` ### Narrowing scope ```bash -cix search "middleware" --in ./api/ # only in api directory -cix search "config" --in ./cmd/ # only in cmd directory -cix refs Config --file ./internal/server.go # only in one file +cix search "middleware" --in ./api/ +cix search "config" --in ./cmd/ --exclude legacy +cix refs Config --file ./internal/server.go ``` --- ## Tips -- Search queries are natural language — write what you're looking for, not regex -- `cix def` is faster than `cix symbols` for exact name matches -- `cix refs` finds usages across the entire codebase in indexed chunks -- Use `--in` to avoid noise from irrelevant directories -- The index auto-updates via file watcher — no need to manually reindex -- If results seem stale, run `cix reindex` \ No newline at end of file +- Search queries are natural language, not regex. Write what you'd ask + a colleague. +- Output groups by file: each result line is a file with all relevant + matches inside, ordered top-to-bottom by line number. The + `[best 0.NN]` is the score of the top hit in that file. +- `cix def` is a faster path than `cix symbols` when you already know + the exact name. +- `--exclude` complements `--in` — use it to drop noisy dirs (`bench/`, + `legacy/`, vendored code) inline without touching `.cixignore`. +- The watcher keeps the index fresh. If results feel stale, check + `cix status` first — `Watcher: ✗ not running` is the usual cause. +- Don't loop. If a query returns nothing useful after one well-phrased + attempt + one `--min-score 0.2` retry, drop to grep.
    +)) +TableHead.displayName = "TableHead" + +const TableCell = React.forwardRef< + HTMLTableCellElement, + React.TdHTMLAttributes +>(({ className, ...props }, ref) => ( + +)) +TableCell.displayName = "TableCell" + +const TableCaption = React.forwardRef< + HTMLTableCaptionElement, + React.HTMLAttributes +>(({ className, ...props }, ref) => ( +
    +)) +TableCaption.displayName = "TableCaption" + +export { + Table, + TableHeader, + TableBody, + TableFooter, + TableHead, + TableRow, + TableCell, + TableCaption, +} diff --git a/server/dashboard/src/ui/tabs.tsx b/server/dashboard/src/ui/tabs.tsx new file mode 100644 index 0000000..e147b0e --- /dev/null +++ b/server/dashboard/src/ui/tabs.tsx @@ -0,0 +1,53 @@ +import * as React from "react" +import * as TabsPrimitive from "@radix-ui/react-tabs" + +import { cn } from "@/lib/cn" + +const Tabs = TabsPrimitive.Root + +const TabsList = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)) +TabsList.displayName = TabsPrimitive.List.displayName + +const TabsTrigger = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)) +TabsTrigger.displayName = TabsPrimitive.Trigger.displayName + +const TabsContent = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, ...props }, ref) => ( + +)) +TabsContent.displayName = TabsPrimitive.Content.displayName + +export { Tabs, TabsList, TabsTrigger, TabsContent } diff --git a/server/dashboard/src/ui/tooltip.tsx b/server/dashboard/src/ui/tooltip.tsx new file mode 100644 index 0000000..d64e00c --- /dev/null +++ b/server/dashboard/src/ui/tooltip.tsx @@ -0,0 +1,30 @@ +"use client" + +import * as React from "react" +import * as TooltipPrimitive from "@radix-ui/react-tooltip" + +import { cn } from "@/lib/cn" + +const TooltipProvider = TooltipPrimitive.Provider + +const Tooltip = TooltipPrimitive.Root + +const TooltipTrigger = TooltipPrimitive.Trigger + +const TooltipContent = React.forwardRef< + React.ElementRef, + React.ComponentPropsWithoutRef +>(({ className, sideOffset = 4, ...props }, ref) => ( + +)) +TooltipContent.displayName = TooltipPrimitive.Content.displayName + +export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } diff --git a/server/dashboard/src/vite-env.d.ts b/server/dashboard/src/vite-env.d.ts new file mode 100644 index 0000000..11f02fe --- /dev/null +++ b/server/dashboard/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/server/dashboard/tailwind.config.ts b/server/dashboard/tailwind.config.ts new file mode 100644 index 0000000..1bcfab6 --- /dev/null +++ b/server/dashboard/tailwind.config.ts @@ -0,0 +1,91 @@ +import type { Config } from 'tailwindcss'; +import animate from 'tailwindcss-animate'; + +// Notion-like palette — muted neutrals, a single accent. Light theme is the +// default; dark variants are wired but the toggle lands in PR-D. +export default { + darkMode: 'class', + content: ['./index.html', './src/**/*.{ts,tsx}'], + theme: { + container: { + center: true, + padding: '1.5rem', + screens: { '2xl': '1280px' }, + }, + extend: { + colors: { + border: 'hsl(var(--border))', + input: 'hsl(var(--input))', + ring: 'hsl(var(--ring))', + background: 'hsl(var(--background))', + foreground: 'hsl(var(--foreground))', + primary: { + DEFAULT: 'hsl(var(--primary))', + foreground: 'hsl(var(--primary-foreground))', + }, + secondary: { + DEFAULT: 'hsl(var(--secondary))', + foreground: 'hsl(var(--secondary-foreground))', + }, + muted: { + DEFAULT: 'hsl(var(--muted))', + foreground: 'hsl(var(--muted-foreground))', + }, + accent: { + DEFAULT: 'hsl(var(--accent))', + foreground: 'hsl(var(--accent-foreground))', + }, + destructive: { + DEFAULT: 'hsl(var(--destructive))', + foreground: 'hsl(var(--destructive-foreground))', + }, + card: { + DEFAULT: 'hsl(var(--card))', + foreground: 'hsl(var(--card-foreground))', + }, + popover: { + DEFAULT: 'hsl(var(--popover))', + foreground: 'hsl(var(--popover-foreground))', + }, + }, + borderRadius: { + lg: 'var(--radius)', + md: 'calc(var(--radius) - 2px)', + sm: 'calc(var(--radius) - 4px)', + }, + fontFamily: { + sans: [ + 'ui-sans-serif', + '-apple-system', + 'BlinkMacSystemFont', + 'Segoe UI', + 'Inter', + 'system-ui', + 'sans-serif', + ], + mono: [ + 'ui-monospace', + 'SFMono-Regular', + 'JetBrains Mono', + 'Menlo', + 'monospace', + ], + }, + keyframes: { + 'accordion-down': { + from: { height: '0' }, + to: { height: 'var(--radix-accordion-content-height)' }, + }, + 'accordion-up': { + from: { height: 'var(--radix-accordion-content-height)' }, + to: { height: '0' }, + }, + }, + animation: { + 'accordion-down': 'accordion-down 0.2s ease-out', + 'accordion-up': 'accordion-up 0.2s ease-out', + }, + }, + }, + plugins: [animate], +} satisfies Config; diff --git a/server/dashboard/tsconfig.json b/server/dashboard/tsconfig.json new file mode 100644 index 0000000..2847b19 --- /dev/null +++ b/server/dashboard/tsconfig.json @@ -0,0 +1,31 @@ +{ + "compilerOptions": { + "target": "ES2022", + "useDefineForClassFields": true, + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "module": "ESNext", + "skipLibCheck": true, + + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "isolatedModules": true, + "moduleDetection": "force", + "noEmit": true, + "jsx": "react-jsx", + + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedSideEffectImports": true, + "verbatimModuleSyntax": true, + "esModuleInterop": true, + + "baseUrl": ".", + "paths": { + "@/*": ["./src/*"] + } + }, + "include": ["src"], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/server/dashboard/tsconfig.node.json b/server/dashboard/tsconfig.node.json new file mode 100644 index 0000000..c75a336 --- /dev/null +++ b/server/dashboard/tsconfig.node.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "composite": true, + "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo", + "target": "ES2022", + "lib": ["ES2023"], + "module": "ESNext", + "skipLibCheck": true, + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true, + "strict": true + }, + "include": ["vite.config.ts"] +} diff --git a/server/dashboard/tsconfig.node.tsbuildinfo b/server/dashboard/tsconfig.node.tsbuildinfo new file mode 100644 index 0000000..62c7bf9 --- /dev/null +++ b/server/dashboard/tsconfig.node.tsbuildinfo @@ -0,0 +1 @@ +{"root":["./vite.config.ts"],"version":"5.9.3"} \ No newline at end of file diff --git a/server/dashboard/tsconfig.tsbuildinfo b/server/dashboard/tsconfig.tsbuildinfo new file mode 100644 index 0000000..9c15565 --- /dev/null +++ b/server/dashboard/tsconfig.tsbuildinfo @@ -0,0 +1 @@ +{"root":["./src/main.tsx","./src/vite-env.d.ts","./src/api/client.ts","./src/api/generated.ts","./src/api/types.ts","./src/app/app.tsx","./src/app/footer.tsx","./src/app/shell.tsx","./src/app/sidebar.tsx","./src/app/themeprovider.tsx","./src/app/updatebanner.tsx","./src/app/providers.tsx","./src/auth/authprovider.tsx","./src/auth/bootstrapneededpage.tsx","./src/auth/changepasswordpage.tsx","./src/auth/loginpage.tsx","./src/auth/useauth.ts","./src/lib/cn.ts","./src/lib/editorpreference.ts","./src/lib/formatdate.ts","./src/lib/theme.ts","./src/lib/useserverstatus.ts","./src/modules/registry.ts","./src/modules/types.ts","./src/modules/api-keys/apikeyspage.tsx","./src/modules/api-keys/hooks.ts","./src/modules/api-keys/index.ts","./src/modules/api-keys/components/apikeytable.tsx","./src/modules/api-keys/components/createapikeydialog.tsx","./src/modules/api-keys/components/revokeapikeydialog.tsx","./src/modules/home/homepage.tsx","./src/modules/home/index.ts","./src/modules/projects/projectdetailpage.tsx","./src/modules/projects/projectslistpage.tsx","./src/modules/projects/projectspage.tsx","./src/modules/projects/hooks.ts","./src/modules/projects/index.ts","./src/modules/projects/components/deleteprojectdialog.tsx","./src/modules/projects/components/projectcard.tsx","./src/modules/projects/components/projectinfocard.tsx","./src/modules/search/searchpage.tsx","./src/modules/search/hooks.ts","./src/modules/search/index.ts","./src/modules/search/components/filters.tsx","./src/modules/search/components/resultfilecard.tsx","./src/modules/search/components/resultsnippet.tsx","./src/modules/search/components/searchinput.tsx","./src/modules/server/serverpage.tsx","./src/modules/server/hooks.ts","./src/modules/server/index.ts","./src/modules/server/components/saveandrestartdialog.tsx","./src/modules/server/components/sidecarstatebadge.tsx","./src/modules/server/components/sourcepill.tsx","./src/modules/server/sections/advancedsection.tsx","./src/modules/server/sections/embeddingmodelsection.tsx","./src/modules/server/sections/runtimeparamssection.tsx","./src/modules/server/sections/sidecarsection.tsx","./src/modules/settings/settingspage.tsx","./src/modules/settings/hooks.ts","./src/modules/settings/index.ts","./src/modules/settings/components/changepasswordform.tsx","./src/modules/settings/components/sessionrow.tsx","./src/modules/settings/sections/editorsection.tsx","./src/modules/settings/sections/profilesection.tsx","./src/modules/settings/sections/sessionssection.tsx","./src/modules/settings/sections/themesection.tsx","./src/modules/users/userspage.tsx","./src/modules/users/hooks.ts","./src/modules/users/index.ts","./src/modules/users/components/deleteuserdialog.tsx","./src/modules/users/components/disableuserbutton.tsx","./src/modules/users/components/inviteuserdialog.tsx","./src/modules/users/components/userroleselect.tsx","./src/modules/users/components/userstable.tsx","./src/ui/alert.tsx","./src/ui/badge.tsx","./src/ui/button.tsx","./src/ui/card.tsx","./src/ui/dialog.tsx","./src/ui/input.tsx","./src/ui/label.tsx","./src/ui/radio-group.tsx","./src/ui/scroll-area.tsx","./src/ui/select.tsx","./src/ui/skeleton.tsx","./src/ui/slider.tsx","./src/ui/sonner.tsx","./src/ui/switch.tsx","./src/ui/table.tsx","./src/ui/tabs.tsx","./src/ui/tooltip.tsx"],"version":"5.9.3"} \ No newline at end of file diff --git a/server/dashboard/vite.config.d.ts b/server/dashboard/vite.config.d.ts new file mode 100644 index 0000000..340562a --- /dev/null +++ b/server/dashboard/vite.config.d.ts @@ -0,0 +1,2 @@ +declare const _default: import("vite").UserConfig; +export default _default; diff --git a/server/dashboard/vite.config.js b/server/dashboard/vite.config.js new file mode 100644 index 0000000..8c0170b --- /dev/null +++ b/server/dashboard/vite.config.js @@ -0,0 +1,44 @@ +import { defineConfig } from 'vite'; +import react from '@vitejs/plugin-react'; +import path from 'node:path'; +// Vite is told two non-default things: +// 1. base: '/dashboard/' — the Go server mounts the SPA under that prefix +// so all asset URLs need to be rewritten accordingly. +// 2. build.outDir: ../internal/httpapi/dashboard/dist — output lands inside +// the Go embed.FS root so `go build` picks it up automatically. +// +// In dev (`npm run dev`), /api requests are proxied to the running Go server +// on the default cix-server port (21847) so cookie auth works through the +// dev server origin. +export default defineConfig({ + plugins: [react()], + base: '/dashboard/', + resolve: { + alias: { + '@': path.resolve(__dirname, './src'), + }, + }, + server: { + port: 5173, + proxy: { + '/api': { + target: 'http://localhost:21847', + changeOrigin: false, + secure: false, + }, + }, + }, + build: { + outDir: '../internal/httpapi/dashboard/dist', + emptyOutDir: true, + sourcemap: false, + rollupOptions: { + output: { + // Stable hashed names; Go fileserver caches via Cache-Control. + entryFileNames: 'assets/[name]-[hash].js', + chunkFileNames: 'assets/[name]-[hash].js', + assetFileNames: 'assets/[name]-[hash][extname]', + }, + }, + }, +}); diff --git a/server/dashboard/vite.config.ts b/server/dashboard/vite.config.ts new file mode 100644 index 0000000..b1f84a3 --- /dev/null +++ b/server/dashboard/vite.config.ts @@ -0,0 +1,45 @@ +import { defineConfig } from 'vite'; +import react from '@vitejs/plugin-react'; +import path from 'node:path'; + +// Vite is told two non-default things: +// 1. base: '/dashboard/' — the Go server mounts the SPA under that prefix +// so all asset URLs need to be rewritten accordingly. +// 2. build.outDir: ../internal/httpapi/dashboard/dist — output lands inside +// the Go embed.FS root so `go build` picks it up automatically. +// +// In dev (`npm run dev`), /api requests are proxied to the running Go server +// on the default cix-server port (21847) so cookie auth works through the +// dev server origin. +export default defineConfig({ + plugins: [react()], + base: '/dashboard/', + resolve: { + alias: { + '@': path.resolve(__dirname, './src'), + }, + }, + server: { + port: 5173, + proxy: { + '/api': { + target: 'http://localhost:21847', + changeOrigin: false, + secure: false, + }, + }, + }, + build: { + outDir: '../internal/httpapi/dashboard/dist', + emptyOutDir: true, + sourcemap: false, + rollupOptions: { + output: { + // Stable hashed names; Go fileserver caches via Cache-Control. + entryFileNames: 'assets/[name]-[hash].js', + chunkFileNames: 'assets/[name]-[hash].js', + assetFileNames: 'assets/[name]-[hash][extname]', + }, + }, + }, +}); diff --git a/server/go.mod b/server/go.mod index e3fe407..eb59b44 100644 --- a/server/go.mod +++ b/server/go.mod @@ -1,22 +1,46 @@ module github.com/dvcdsys/code-index/server -go 1.25.9 +go 1.25.10 require ( + github.com/getkin/kin-openapi v0.135.0 github.com/go-chi/chi/v5 v5.2.4 github.com/google/uuid v1.6.0 + github.com/oapi-codegen/runtime v1.4.0 github.com/odvcencio/gotreesitter v0.0.0-20260423084729-38e2b42712f2 github.com/philippgille/chromem-go v0.7.0 + golang.org/x/crypto v0.50.0 modernc.org/sqlite v1.34.1 ) require ( + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect + github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-openapi/jsonpointer v0.22.4 // indirect + github.com/go-openapi/swag/jsonname v0.25.4 // indirect github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/mailru/easyjson v0.9.1 // indirect github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect + github.com/oapi-codegen/oapi-codegen/v2 v2.7.0 // indirect + github.com/oasdiff/yaml v0.0.9 // indirect + github.com/oasdiff/yaml3 v0.0.9 // indirect + github.com/perimeterx/marshmallow v1.1.5 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect - golang.org/x/sys v0.22.0 // indirect + github.com/speakeasy-api/jsonpath v0.6.3 // indirect + github.com/speakeasy-api/openapi v1.19.2 // indirect + github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect + github.com/woodsbury/decimal128 v1.4.0 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect + golang.org/x/mod v0.34.0 // indirect + golang.org/x/sync v0.20.0 // indirect + golang.org/x/sys v0.43.0 // indirect + golang.org/x/text v0.36.0 // indirect + golang.org/x/tools v0.43.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 // indirect modernc.org/libc v1.55.3 // indirect modernc.org/mathutil v1.6.0 // indirect @@ -24,3 +48,5 @@ require ( modernc.org/strutil v1.2.0 // indirect modernc.org/token v1.1.0 // indirect ) + +tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen diff --git a/server/go.sum b/server/go.sum index 4cd893c..1debe9e 100644 --- a/server/go.sum +++ b/server/go.sum @@ -1,32 +1,216 @@ +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dprotaso/go-yit v0.0.0-20191028211022-135eb7262960/go.mod h1:9HQzr9D/0PGwMEbC3d5AB7oi67+h4TsQqItC1GVYG58= +github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 h1:PRxIJD8XjimM5aTknUK9w6DHLDox2r2M3DI4i2pnd3w= +github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936/go.mod h1:ttYvX5qlB+mlV1okblJqcSMtR4c52UKxDiX9GRBS8+Q= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/getkin/kin-openapi v0.135.0 h1:751SjYfbiwqukYuVjwYEIKNfrSwS5YpA7DZnKSwQgtg= +github.com/getkin/kin-openapi v0.135.0/go.mod h1:6dd5FJl6RdX4usBtFBaQhk9q62Yb2J0Mk5IhUO/QqFI= github.com/go-chi/chi/v5 v5.2.4 h1:WtFKPHwlywe8Srng8j2BhOD9312j9cGUxG1SP4V2cR4= github.com/go-chi/chi/v5 v5.2.4/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0= +github.com/go-openapi/jsonpointer v0.22.4 h1:dZtK82WlNpVLDW2jlA1YCiVJFVqkED1MegOUy9kR5T4= +github.com/go-openapi/jsonpointer v0.22.4/go.mod h1:elX9+UgznpFhgBuaMQ7iu4lvvX1nvNsesQ3oxmYTw80= +github.com/go-openapi/swag/jsonname v0.25.4 h1:bZH0+MsS03MbnwBXYhuTttMOqk+5KcQ9869Vye1bNHI= +github.com/go-openapi/swag/jsonname v0.25.4/go.mod h1:GPVEk9CWVhNvWhZgrnvRA6utbAltopbKwDu8mXNUMag= +github.com/go-openapi/testify/v2 v2.0.2 h1:X999g3jeLcoY8qctY/c/Z8iBHTbwLz7R2WXd6Ub6wls= +github.com/go-openapi/testify/v2 v2.0.2/go.mod h1:HCPmvFFnheKK2BuwSA0TbbdxJ3I16pjwMkYkP4Ywn54= +github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= +github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM= +github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mailru/easyjson v0.9.1 h1:LbtsOm5WAswyWbvTEOqhypdPeZzHavpZx96/n553mR8= +github.com/mailru/easyjson v0.9.1/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw= +github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= +github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/oapi-codegen/oapi-codegen/v2 v2.7.0 h1:/8daqIYZfwnsHEAZdHUu9m0D5LA+5DoJCP7zLlT5Cs0= +github.com/oapi-codegen/oapi-codegen/v2 v2.7.0/go.mod h1:qzFy6iuobJw/hD1aRILee4G87/ShmhR0xYCwcUtZMCw= +github.com/oapi-codegen/runtime v1.4.0 h1:KLOSFOp7UzkbS7Cs1ms6NBEKYr0WmH2wZG0KKbd2er4= +github.com/oapi-codegen/runtime v1.4.0/go.mod h1:5sw5fxCDmnOzKNYmkVNF8d34kyUeejJEY8HNT2WaPec= +github.com/oasdiff/yaml v0.0.9 h1:zQOvd2UKoozsSsAknnWoDJlSK4lC0mpmjfDsfqNwX48= +github.com/oasdiff/yaml v0.0.9/go.mod h1:8lvhgJG4xiKPj3HN5lDow4jZHPlx1i7dIwzkdAo6oAM= +github.com/oasdiff/yaml3 v0.0.9 h1:rWPrKccrdUm8J0F3sGuU+fuh9+1K/RdJlWF7O/9yw2g= +github.com/oasdiff/yaml3 v0.0.9/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o= github.com/odvcencio/gotreesitter v0.0.0-20260423084729-38e2b42712f2 h1:UghQ3CfMxD2blnk/TVD88UOOR+hd4Mv5m5PfjShRmwI= github.com/odvcencio/gotreesitter v0.0.0-20260423084729-38e2b42712f2/go.mod h1:Sx+iYJBfw5xSWkSttLSuFvguJctlH+ma1BTxZ0MPCqo= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.10.2/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c= +github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= +github.com/onsi/gomega v1.19.0 h1:4ieX6qQjPP/BfC3mpsAtIGGlxTWPeA3Inl/7DtXw1tw= +github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= +github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s= +github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw= github.com/philippgille/chromem-go v0.7.0 h1:4jfvfyKymjKNfGxBUhHUcj1kp7B17NL/I1P+vGh1RvY= github.com/philippgille/chromem-go v0.7.0/go.mod h1:hTd+wGEm/fFPQl7ilfCwQXkgEUxceYh86iIdoKMolPo= -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/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -golang.org/x/mod v0.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic= -golang.org/x/mod v0.16.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= +github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= +github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0= +github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= +github.com/speakeasy-api/jsonpath v0.6.3 h1:c+QPwzAOdrWvzycuc9HFsIZcxKIaWcNpC+xhOW9rJxU= +github.com/speakeasy-api/jsonpath v0.6.3/go.mod h1:2cXloNuQ+RSXi5HTRaeBh7JEmjRXTiaKpFTdZiL7URI= +github.com/speakeasy-api/openapi v1.19.2 h1:md90tE71/M8jS3cuRlsuWP5Aed4xoG5PSRvXeZgCv/M= +github.com/speakeasy-api/openapi v1.19.2/go.mod h1:UfKa7FqE4jgexJZuj51MmdHAFGmDv0Zaw3+yOd81YKU= +github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= +github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +github.com/vmware-labs/yaml-jsonpath v0.3.2 h1:/5QKeCBGdsInyDCyVNLbXyilb61MXGi9NP674f9Hobk= +github.com/vmware-labs/yaml-jsonpath v0.3.2/go.mod h1:U6whw1z03QyqgWdgXxvVnQ90zN1BWz5V+51Ewf8k+rQ= +github.com/woodsbury/decimal128 v1.4.0 h1:xJATj7lLu4f2oObouMt2tgGiElE5gO6mSWUjQsBgUlc= +github.com/woodsbury/decimal128 v1.4.0/go.mod h1:BP46FUrVjVhdTbKT+XuQh2xfQaGki9LMIRJSFuh6THU= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI= +golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI= +golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= +golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= +golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= -golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/tools v0.19.0 h1:tfGCXNR1OsFG+sVdLAitlpjAvD/I6dHDKnYrpEZUHkw= -golang.org/x/tools v0.19.0/go.mod h1:qoJWxmGSIBmAeriMx19ogtrEPrGtDbPK634QFIcLAhc= +golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI= +golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg= +golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s= +golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20191026110619-0b21df46bc1d/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= modernc.org/cc/v4 v4.21.4 h1:3Be/Rdo1fpr8GrQ7IVw9OHtplU4gWbb+wNgeoBMmGLQ= modernc.org/cc/v4 v4.21.4/go.mod h1:HM7VJTZbUCR3rV8EYBi9wxnJ0ZBRiGE5OeGXNA0IsLQ= modernc.org/ccgo/v4 v4.19.2 h1:lwQZgvboKD0jBwdaeVCTouxhxAyN6iawF3STraAal8Y= diff --git a/server/internal/apikeys/apikeys.go b/server/internal/apikeys/apikeys.go new file mode 100644 index 0000000..c8a580c --- /dev/null +++ b/server/internal/apikeys/apikeys.go @@ -0,0 +1,361 @@ +// Package apikeys implements named, owner-scoped API keys for CLI/SDK +// access. Replaces the single-CIX_API_KEY model with one row per issued +// key, each tied to a user. Plaintext keys are returned exactly once at +// Generate time; only sha256(key) is persisted, so a stolen DB never +// leaks live credentials. +package apikeys + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "database/sql" + "encoding/base64" + "encoding/hex" + "errors" + "fmt" + "strings" + "time" + + "github.com/google/uuid" + + "github.com/dvcdsys/code-index/server/internal/users" +) + +// KeyPrefix is the recognisable prefix every issued key starts with — +// makes accidental leaks easy to grep for in logs and source control +// (a la GitHub's "ghp_..." pattern). +const KeyPrefix = "cix_" + +// PrefixDisplayLen is how many characters of the full key are stored +// verbatim in the prefix column for UI display ("cix_a1b2c3d4..."). Must +// be small enough that the displayed prefix is not itself sufficient to +// recover the key, but large enough that it's distinguishable in lists. +const PrefixDisplayLen = 12 // KeyPrefix("cix_") + 8 random hex chars + +var ( + ErrNotFound = errors.New("api key not found") + ErrInvalidKey = errors.New("invalid api key") + ErrAlreadyRevoked = errors.New("api key already revoked") + ErrUserDisabled = errors.New("api key owner is disabled") +) + +// ApiKey is the metadata view of a key. The plaintext value is only ever +// returned by Generate (in a separate string) — once issued, the server +// never sees the plaintext again. +type ApiKey struct { + ID string + OwnerUserID string + Name string + Prefix string + CreatedAt time.Time + LastUsedAt *time.Time + LastUsedIP string + LastUsedUA string + RevokedAt *time.Time +} + +// Service wraps the api_keys table. +type Service struct { + DB *sql.DB +} + +// New returns a Service. +func New(db *sql.DB) *Service { return &Service{DB: db} } + +// Generate issues a new key for ownerUserID. Returns (fullKey, ApiKey). +// Save the fullKey somewhere safe NOW — it will not be retrievable +// later. The ApiKey returned has prefix populated for UI display. +func (s *Service) Generate(ctx context.Context, ownerUserID, name string) (string, ApiKey, error) { + name = strings.TrimSpace(name) + if name == "" { + return "", ApiKey{}, fmt.Errorf("api key name required") + } + full, err := newKey() + if err != nil { + return "", ApiKey{}, fmt.Errorf("generate key: %w", err) + } + + id := uuid.NewString() + now := time.Now().UTC().Format(time.RFC3339Nano) + prefix := full[:PrefixDisplayLen] + hash := hashKey(full) + + _, err = s.DB.ExecContext(ctx, + `INSERT INTO api_keys (id, owner_user_id, name, prefix, hash, created_at) + VALUES (?, ?, ?, ?, ?, ?)`, + id, ownerUserID, name, prefix, hash, now, + ) + if err != nil { + return "", ApiKey{}, fmt.Errorf("insert api key: %w", err) + } + + ak, err := s.GetByID(ctx, id) + if err != nil { + return "", ApiKey{}, err + } + return full, ak, nil +} + +// ImportLegacy seeds the table with an externally-provided key value +// (used once at bootstrap to migrate the single CIX_API_KEY env var into +// a real api_keys row). Same hashing as Generate; the only difference is +// that fullKey is supplied by the caller rather than freshly generated. +func (s *Service) ImportLegacy(ctx context.Context, ownerUserID, name, fullKey string) (ApiKey, error) { + name = strings.TrimSpace(name) + if name == "" { + return ApiKey{}, fmt.Errorf("api key name required") + } + if fullKey == "" { + return ApiKey{}, fmt.Errorf("fullKey required") + } + id := uuid.NewString() + now := time.Now().UTC().Format(time.RFC3339Nano) + prefix := fullKey + if len(prefix) > PrefixDisplayLen { + prefix = prefix[:PrefixDisplayLen] + } + hash := hashKey(fullKey) + _, err := s.DB.ExecContext(ctx, + `INSERT INTO api_keys (id, owner_user_id, name, prefix, hash, created_at) + VALUES (?, ?, ?, ?, ?, ?)`, + id, ownerUserID, name, prefix, hash, now) + if err != nil { + return ApiKey{}, fmt.Errorf("insert legacy api key: %w", err) + } + return s.GetByID(ctx, id) +} + +// Authenticate looks up a key by its plaintext value, returning the +// owning user if the key is valid and active. Constant-time within the +// hash compare; we rely on sha256 not bcrypt because keys are 256 bits +// of entropy and brute-forcing the hash is irrelevant. +func (s *Service) Authenticate(ctx context.Context, fullKey string) (users.User, ApiKey, error) { + if !strings.HasPrefix(fullKey, KeyPrefix) { + return users.User{}, ApiKey{}, ErrInvalidKey + } + hash := hashKey(fullKey) + row := s.DB.QueryRowContext(ctx, + `SELECT k.id, k.owner_user_id, k.name, k.prefix, k.created_at, + k.last_used_at, k.last_used_ip, k.last_used_ua, k.revoked_at, + u.email, u.role, u.must_change_password, + u.created_at, u.updated_at, u.disabled_at + FROM api_keys k + JOIN users u ON u.id = k.owner_user_id + WHERE k.hash = ?`, hash) + + var ( + ak ApiKey + createdAt string + lastUsedAt, revokedAt sql.NullString + lastUsedIP, lastUsedUA sql.NullString + uEmail, uRole string + uMcp int + uCreatedAt, uUpdatedAt string + uDisabledAt sql.NullString + ) + err := row.Scan( + &ak.ID, &ak.OwnerUserID, &ak.Name, &ak.Prefix, &createdAt, + &lastUsedAt, &lastUsedIP, &lastUsedUA, &revokedAt, + &uEmail, &uRole, &uMcp, &uCreatedAt, &uUpdatedAt, &uDisabledAt, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return users.User{}, ApiKey{}, ErrInvalidKey + } + return users.User{}, ApiKey{}, fmt.Errorf("scan api key: %w", err) + } + ak.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + if lastUsedAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, lastUsedAt.String) + ak.LastUsedAt = &t + } + ak.LastUsedIP = lastUsedIP.String + ak.LastUsedUA = lastUsedUA.String + if revokedAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, revokedAt.String) + ak.RevokedAt = &t + return users.User{}, ApiKey{}, ErrInvalidKey + } + + u := users.User{ + ID: ak.OwnerUserID, + Email: uEmail, + Role: uRole, + MustChangePassword: uMcp == 1, + } + u.CreatedAt, _ = time.Parse(time.RFC3339Nano, uCreatedAt) + u.UpdatedAt, _ = time.Parse(time.RFC3339Nano, uUpdatedAt) + if uDisabledAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, uDisabledAt.String) + u.DisabledAt = &t + return users.User{}, ApiKey{}, ErrUserDisabled + } + return u, ak, nil +} + +// GetByID returns one key. ErrNotFound when absent. +func (s *Service) GetByID(ctx context.Context, id string) (ApiKey, error) { + row := s.DB.QueryRowContext(ctx, + `SELECT id, owner_user_id, name, prefix, created_at, + last_used_at, last_used_ip, last_used_ua, revoked_at + FROM api_keys WHERE id = ?`, id) + return scanKeyRow(row) +} + +// ListForOwner returns every key owned by a user, including revoked ones +// (UI fades them out — but the operator should see history). +func (s *Service) ListForOwner(ctx context.Context, ownerUserID string) ([]ApiKey, error) { + rows, err := s.DB.QueryContext(ctx, + `SELECT id, owner_user_id, name, prefix, created_at, + last_used_at, last_used_ip, last_used_ua, revoked_at + FROM api_keys WHERE owner_user_id = ? ORDER BY created_at DESC`, ownerUserID) + if err != nil { + return nil, fmt.Errorf("list api keys: %w", err) + } + defer rows.Close() + return scanKeyRows(rows) +} + +// ListAll is the admin view: every key in the system, newest first. +func (s *Service) ListAll(ctx context.Context) ([]ApiKey, error) { + rows, err := s.DB.QueryContext(ctx, + `SELECT id, owner_user_id, name, prefix, created_at, + last_used_at, last_used_ip, last_used_ua, revoked_at + FROM api_keys ORDER BY created_at DESC`) + if err != nil { + return nil, fmt.Errorf("list all api keys: %w", err) + } + defer rows.Close() + return scanKeyRows(rows) +} + +// CountActiveForOwner returns how many non-revoked keys a user has. +// Used by bootstrap to decide whether to seed an env-imported key. +func (s *Service) CountActiveForOwner(ctx context.Context, ownerUserID string) (int, error) { + var n int + err := s.DB.QueryRowContext(ctx, + `SELECT COUNT(1) FROM api_keys WHERE owner_user_id = ? AND revoked_at IS NULL`, + ownerUserID).Scan(&n) + if err != nil { + return 0, fmt.Errorf("count keys: %w", err) + } + return n, nil +} + +// Revoke marks a key as revoked. Subsequent Authenticate calls fail with +// ErrInvalidKey. Idempotent — re-revoking returns ErrAlreadyRevoked but +// does not modify the row. +func (s *Service) Revoke(ctx context.Context, id string) error { + ak, err := s.GetByID(ctx, id) + if err != nil { + return err + } + if ak.RevokedAt != nil { + return ErrAlreadyRevoked + } + now := time.Now().UTC().Format(time.RFC3339Nano) + _, err = s.DB.ExecContext(ctx, + `UPDATE api_keys SET revoked_at = ? WHERE id = ?`, now, id) + if err != nil { + return fmt.Errorf("revoke api key: %w", err) + } + return nil +} + +// Touch updates the last-used metadata for a key. Called by middleware +// on every successful Bearer auth. +func (s *Service) Touch(ctx context.Context, id, ip, ua string) error { + now := time.Now().UTC().Format(time.RFC3339Nano) + _, err := s.DB.ExecContext(ctx, + `UPDATE api_keys SET last_used_at = ?, last_used_ip = ?, last_used_ua = ? WHERE id = ?`, + now, nullableString(ip), nullableString(ua), id) + if err != nil { + return fmt.Errorf("touch api key: %w", err) + } + return nil +} + +// --- helpers --- + +// newKey returns a fresh `cix_<43 random base64url chars>` token. +// 32 random bytes → 43 base64url chars = 256 bits of entropy. The +// length matches GitHub-class personal-access-token verbosity and +// puts brute-force comfortably out of reach for any attacker, on +// any timescale, even against a non-stretched hash. Older keys +// issued at the previous 192-bit length keep working — the hash +// column is the lookup key, not the length. +func newKey() (string, error) { + var b [32]byte + if _, err := rand.Read(b[:]); err != nil { + return "", err + } + return KeyPrefix + base64.RawURLEncoding.EncodeToString(b[:]), nil +} + +// hashKey returns hex(sha256(fullKey)). SHA-256 is the right +// primitive here — NOT bcrypt/argon2/PBKDF2 — because the pre-image +// is 256 bits of CSPRNG output (server-issued; never user-chosen). +// At that entropy floor, brute-forcing the hash is computationally +// indistinguishable from brute-forcing the underlying random bytes, +// and adding a slow KDF would only tax every authenticated request +// (~25–250 ms each at typical bcrypt costs) without raising the +// security floor a single bit. This is the same pattern GitHub / +// Stripe / AWS use for their API tokens. CodeQL's +// `go/insufficient-password-hash` rule is heuristic and treats any +// SHA-256 over a string-typed value as a password hash — that +// heuristic does not apply to high-entropy machine-issued tokens. +func hashKey(fullKey string) string { + h := sha256.Sum256([]byte(fullKey)) + return hex.EncodeToString(h[:]) +} + +func scanKeyRow(r interface { + Scan(dest ...any) error +}) (ApiKey, error) { + var ( + ak ApiKey + createdAt string + lastUsedAt, revokedAt sql.NullString + lastUsedIP, lastUsedUA sql.NullString + ) + err := r.Scan(&ak.ID, &ak.OwnerUserID, &ak.Name, &ak.Prefix, &createdAt, + &lastUsedAt, &lastUsedIP, &lastUsedUA, &revokedAt) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return ApiKey{}, ErrNotFound + } + return ApiKey{}, err + } + ak.CreatedAt, _ = time.Parse(time.RFC3339Nano, createdAt) + if lastUsedAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, lastUsedAt.String) + ak.LastUsedAt = &t + } + ak.LastUsedIP = lastUsedIP.String + ak.LastUsedUA = lastUsedUA.String + if revokedAt.Valid { + t, _ := time.Parse(time.RFC3339Nano, revokedAt.String) + ak.RevokedAt = &t + } + return ak, nil +} + +func scanKeyRows(rows *sql.Rows) ([]ApiKey, error) { + var out []ApiKey + for rows.Next() { + ak, err := scanKeyRow(rows) + if err != nil { + return nil, err + } + out = append(out, ak) + } + return out, rows.Err() +} + +func nullableString(s string) any { + if s == "" { + return nil + } + return s +} diff --git a/server/internal/apikeys/apikeys_test.go b/server/internal/apikeys/apikeys_test.go new file mode 100644 index 0000000..db10e99 --- /dev/null +++ b/server/internal/apikeys/apikeys_test.go @@ -0,0 +1,173 @@ +package apikeys + +import ( + "context" + "errors" + "strings" + "testing" + "time" + + "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/users" +) + +type fixture struct { + S *Service + UserID string +} + +func newFixture(t *testing.T) fixture { + t.Helper() + d, err := db.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = d.Close() }) + usrSvc := users.New(d) + u, err := usrSvc.Create(context.Background(), "a@b.com", "password1234", users.RoleAdmin, false) + if err != nil { + t.Fatalf("create user: %v", err) + } + return fixture{S: New(d), UserID: u.ID} +} + +func TestGenerate_FormatAndAuthenticate(t *testing.T) { + f := newFixture(t) + full, ak, err := f.S.Generate(context.Background(), f.UserID, "my-cli") + if err != nil { + t.Fatalf("Generate: %v", err) + } + if !strings.HasPrefix(full, KeyPrefix) { + t.Errorf("full key %q missing %s prefix", full, KeyPrefix) + } + // Body of the key past the prefix is base64url(32 bytes) = 43 chars + // (256 bits of entropy — GitHub-class). + if len(full)-len(KeyPrefix) != 43 { + t.Errorf("body length = %d, want 43", len(full)-len(KeyPrefix)) + } + if ak.Prefix != full[:PrefixDisplayLen] { + t.Errorf("stored prefix %q does not match key head %q", ak.Prefix, full[:PrefixDisplayLen]) + } + // Re-authenticate with the plaintext value: must round-trip back to + // the same user + key. + u, gotAk, err := f.S.Authenticate(context.Background(), full) + if err != nil { + t.Fatalf("Authenticate: %v", err) + } + if u.ID != f.UserID { + t.Errorf("authenticated as wrong user: %v", u.ID) + } + if gotAk.ID != ak.ID { + t.Errorf("authenticated to wrong key: %v vs %v", gotAk.ID, ak.ID) + } +} + +func TestAuthenticate_BadKey(t *testing.T) { + f := newFixture(t) + cases := []string{ + "", + "not-a-cix-key", + KeyPrefix + "but-too-short", + KeyPrefix + strings.Repeat("x", 32), // right shape, wrong content + } + for _, c := range cases { + if _, _, err := f.S.Authenticate(context.Background(), c); !errors.Is(err, ErrInvalidKey) { + t.Errorf("Authenticate(%q) err = %v, want ErrInvalidKey", c, err) + } + } +} + +func TestRevoke_Blocks(t *testing.T) { + f := newFixture(t) + full, ak, _ := f.S.Generate(context.Background(), f.UserID, "soon-revoked") + if err := f.S.Revoke(context.Background(), ak.ID); err != nil { + t.Fatalf("Revoke: %v", err) + } + if _, _, err := f.S.Authenticate(context.Background(), full); !errors.Is(err, ErrInvalidKey) { + t.Errorf("Authenticate after Revoke err = %v, want ErrInvalidKey", err) + } + // Re-revoke is idempotent. + if err := f.S.Revoke(context.Background(), ak.ID); !errors.Is(err, ErrAlreadyRevoked) { + t.Errorf("re-Revoke err = %v, want ErrAlreadyRevoked", err) + } +} + +func TestTouch(t *testing.T) { + f := newFixture(t) + _, ak, _ := f.S.Generate(context.Background(), f.UserID, "touched") + if ak.LastUsedAt != nil { + t.Fatalf("freshly-issued key should not have LastUsedAt set, got %v", ak.LastUsedAt) + } + time.Sleep(5 * time.Millisecond) + if err := f.S.Touch(context.Background(), ak.ID, "10.0.0.1", "UA/1"); err != nil { + t.Fatalf("Touch: %v", err) + } + got, err := f.S.GetByID(context.Background(), ak.ID) + if err != nil { + t.Fatalf("GetByID: %v", err) + } + if got.LastUsedAt == nil || got.LastUsedIP != "10.0.0.1" || got.LastUsedUA != "UA/1" { + t.Errorf("Touch did not persist metadata: %+v", got) + } +} + +func TestImportLegacy(t *testing.T) { + f := newFixture(t) + const legacy = "my-old-cix-api-key-from-env" + ak, err := f.S.ImportLegacy(context.Background(), f.UserID, "env-bootstrap", legacy) + if err != nil { + t.Fatalf("ImportLegacy: %v", err) + } + // The legacy value doesn't have the cix_ prefix; Authenticate's + // prefix gate should reject it. + if _, _, err := f.S.Authenticate(context.Background(), legacy); !errors.Is(err, ErrInvalidKey) { + t.Errorf("legacy key without cix_ prefix should be rejected by Authenticate, got %v", err) + } + if ak.Name != "env-bootstrap" { + t.Errorf("Name = %q", ak.Name) + } +} + +func TestImportLegacy_RoundTripWhenPrefixed(t *testing.T) { + f := newFixture(t) + // A legacy key that already has the cix_ prefix DOES authenticate — + // covers the upgrade path where a user happened to set CIX_API_KEY=cix_... + const legacy = KeyPrefix + "exact-32-char-body-1234567890ab" + if _, err := f.S.ImportLegacy(context.Background(), f.UserID, "env-bootstrap", legacy); err != nil { + t.Fatalf("ImportLegacy: %v", err) + } + if _, _, err := f.S.Authenticate(context.Background(), legacy); err != nil { + t.Errorf("Authenticate of prefixed legacy key: %v", err) + } +} + +func TestListForOwner(t *testing.T) { + f := newFixture(t) + for i := 0; i < 3; i++ { + _, _, _ = f.S.Generate(context.Background(), f.UserID, "key-"+string(rune('a'+i))) + } + list, err := f.S.ListForOwner(context.Background(), f.UserID) + if err != nil { + t.Fatalf("ListForOwner: %v", err) + } + if len(list) != 3 { + t.Errorf("list length = %d, want 3", len(list)) + } +} + +func TestAuthenticate_DisabledUser(t *testing.T) { + f := newFixture(t) + full, _, _ := f.S.Generate(context.Background(), f.UserID, "soon-disabled") + + // Need a second admin so disabling the first one doesn't trip + // users.guardLastAdmin (apikeys tests don't use the users service + // for the disable, but the fixture user is the only admin, so we + // raw-update disabled_at to bypass that). + now := time.Now().UTC().Format(time.RFC3339Nano) + if _, err := f.S.DB.Exec(`UPDATE users SET disabled_at = ? WHERE id = ?`, now, f.UserID); err != nil { + t.Fatalf("disable user: %v", err) + } + if _, _, err := f.S.Authenticate(context.Background(), full); !errors.Is(err, ErrUserDisabled) { + t.Errorf("Authenticate of disabled-user key err = %v, want ErrUserDisabled", err) + } +} diff --git a/server/internal/chunker/bash_regex.go b/server/internal/chunker/bash_regex.go new file mode 100644 index 0000000..53c5006 --- /dev/null +++ b/server/internal/chunker/bash_regex.go @@ -0,0 +1,318 @@ +// Package chunker — regex-based bash function extractor. +// +// Used as a fallback when tree-sitter-bash hits a parse pathology (see +// parseBudget in chunker.go). Tree-sitter would have given us better symbol +// data, but on a 7KB install.sh-style script its parser can spend 30 seconds +// on catastrophic backtracking. The regex extractor below recognises the +// three common bash function forms and finds each function's closing brace +// with a small state machine that handles strings, comments, and heredocs. +// +// Output schema matches chunkWithTreesitter so the indexer's downstream code +// (DB upserts, vector embeddings) doesn't need to special-case bash. +// +// Limitations vs full tree-sitter parse: +// - No reference extraction (returns nil refs). +// - Functions with a `{` on a line *separate* from the opener (`name()` on +// one line, `{` on the next) are not matched. That form is legal in +// bash but rare in practice; falls back to sliding-window for those. +// - Comments containing `{`/`}` inside strings can confuse the brace +// counter on adversarial inputs; bounded by maxBashFuncLines so a +// malformed function never absorbs the whole file. + +package chunker + +import ( + "regexp" + "strings" +) + +// posixFuncRE matches the POSIX-shell style: `name() { ...`. +// Captures group 1 = function name. The trailing `{` must be on the same line. +var posixFuncRE = regexp.MustCompile( + `^[[:space:]]*([A-Za-z_][A-Za-z0-9_:.-]*)[[:space:]]*\(\)[[:space:]]*\{`) + +// bashFuncRE matches the bash-keyword style: `function name [()] { ...`. +// Captures group 1 = function name. +var bashFuncRE = regexp.MustCompile( + `^[[:space:]]*function[[:space:]]+([A-Za-z_][A-Za-z0-9_:.-]*)(?:[[:space:]]*\(\))?[[:space:]]*\{`) + +// maxBashFuncLines caps how far we'll scan for a function's closing `}`. +// Real-world bash functions rarely exceed ~200 lines. The cap protects +// against pathological inputs where the brace counter goes off-track — +// instead of consuming the whole file as one function, we stop and let the +// caller decide what to do (typically: keep a partial chunk, fall back +// to sliding-window for the remainder). +const maxBashFuncLines = 500 + +// bashRegexChunks extracts function-level chunks from bash source via regex. +// Returns nil when no functions were found, signalling the caller to fall +// through to sliding-window. Always returns nil refs (the regex doesn't +// track identifier usage). +func bashRegexChunks(filePath, content string) []Chunk { + lines := splitLines(content) + if len(lines) == 0 { + return nil + } + + var chunks []Chunk + covered := make([]bool, len(lines)) + + i := 0 + for i < len(lines) { + line := lines[i] + var name string + if m := posixFuncRE.FindStringSubmatch(line); m != nil { + name = m[1] + } else if m := bashFuncRE.FindStringSubmatch(line); m != nil { + name = m[1] + } + if name == "" { + i++ + continue + } + + endIdx, ok := scanBashFuncEnd(lines, i) + if !ok { + // Couldn't find balanced close within maxBashFuncLines. + // Skip this opener — don't emit a wildly oversized chunk. + i++ + continue + } + + startLine := i + 1 // 1-based + endLine := endIdx + 1 + body := joinLines(lines[i : endIdx+1]) + // Signature = the opener line trimmed. + sigStr := trimSpace(line) + nameCopy := name + + chunks = append(chunks, Chunk{ + Content: body, + ChunkType: "function", + FilePath: filePath, + StartLine: startLine, + EndLine: endLine, + Language: "bash", + SymbolName: &nameCopy, + SymbolSignature: &sigStr, + }) + for k := i; k <= endIdx && k < len(covered); k++ { + covered[k] = true + } + i = endIdx + 1 + } + + if len(chunks) == 0 { + return nil + } + + // Fill the gaps between functions with `module` chunks so the file's + // non-function content (top-level commands, comments, set -e, etc.) + // still gets indexed for full-text/semantic search. + chunks = appendBashGaps(chunks, lines, covered, filePath) + return chunks +} + +// appendBashGaps adds module-type chunks for line ranges not covered by any +// function. Mirrors the gap-filling logic chunkWithTreesitter applies for +// tree-sitter chunks. Returns chunks sorted by StartLine. +func appendBashGaps(chunks []Chunk, lines []string, covered []bool, filePath string) []Chunk { + gapStart := -1 + for i := 0; i <= len(lines); i++ { + uncovered := i < len(lines) && !covered[i] + if uncovered && gapStart < 0 { + gapStart = i + } + if !uncovered && gapStart >= 0 { + gapEnd := i - 1 + content := joinLines(lines[gapStart : gapEnd+1]) + if trimSpace(content) != "" { + chunks = append(chunks, Chunk{ + Content: content, + ChunkType: "module", + FilePath: filePath, + StartLine: gapStart + 1, + EndLine: gapEnd + 1, + Language: "bash", + }) + } + gapStart = -1 + } + } + // Sort by StartLine so consumers see a stable order. + insertSortByStartLine(chunks) + return chunks +} + +func insertSortByStartLine(chunks []Chunk) { + for i := 1; i < len(chunks); i++ { + j := i + for j > 0 && chunks[j].StartLine < chunks[j-1].StartLine { + chunks[j], chunks[j-1] = chunks[j-1], chunks[j] + j-- + } + } +} + +// scanBashFuncEnd walks forward from startLineIdx (the opener line, which +// already contains the first `{`) and returns the 0-based line index of the +// matching close `}` and ok=true. ok=false means we couldn't find a balance +// within maxBashFuncLines or hit EOF first. +// +// State machine handles: +// - Single-quoted strings ('...') — literal, no escapes +// - Double-quoted strings ("...") — `\"` is escaped quote, `\\` is escaped backslash +// - `# ... EOL` comments — but skipping `$#`, `${#var}`, `$(( # ...))` etc. heuristically +// - Heredocs (< len(lines) { + maxIdx = len(lines) + } + + for li := startLineIdx; li < maxIdx; li++ { + line := lines[li] + + if inHeredoc { + candidate := line + if heredocStripTabs { + candidate = strings.TrimLeft(line, "\t") + } + if candidate == heredocDelim { + inHeredoc = false + heredocDelim = "" + heredocStripTabs = false + } + continue + } + + i := 0 + for i < len(line) { + c := line[i] + + if inSingleStr { + if c == '\'' { + inSingleStr = false + } + i++ + continue + } + if inDoubleStr { + if c == '\\' && i+1 < len(line) { + // Skip the escaped char (handles `\"`, `\\`, etc.). + i += 2 + continue + } + if c == '"' { + inDoubleStr = false + } + i++ + continue + } + + // Comment — `#` starts a line comment unless it follows `$` (`$#`, + // argument count) or `{`/`(` (`${#var}`, `$((# expr ))`). We + // skip the comment if `#` is at start of line / after whitespace + // or after a token-ending char. + if c == '#' { + prev := byte(' ') + if i > 0 { + prev = line[i-1] + } + if prev == ' ' || prev == '\t' || prev == ';' || prev == '|' || + prev == '&' || prev == '(' || i == 0 { + break // rest of line is comment + } + } + + // Heredoc / here-string + if c == '<' && i+1 < len(line) && line[i+1] == '<' { + // `<<<` is here-string (single-line) — skip the marker + if i+2 < len(line) && line[i+2] == '<' { + i += 3 + continue + } + // `<<` or `<<-` + j := i + 2 + stripTabs := false + if j < len(line) && line[j] == '-' { + stripTabs = true + j++ + } + // Skip leading whitespace before delimiter + for j < len(line) && (line[j] == ' ' || line[j] == '\t') { + j++ + } + delim, after := readHeredocDelim(line, j) + if delim != "" { + inHeredoc = true + heredocDelim = delim + heredocStripTabs = stripTabs + // Resume after the delimiter on this line — there may + // be more code on the opener line (e.g. `cmd <= len(line) { + return "", start + } + q := line[start] + if q == '\'' || q == '"' { + end := strings.IndexByte(line[start+1:], q) + if end < 0 { + return "", start + } + return line[start+1 : start+1+end], start + 1 + end + 1 + } + j := start + for j < len(line) && (isBashIdentByte(line[j])) { + j++ + } + if j == start { + return "", start + } + return line[start:j], j +} + +func isBashIdentByte(b byte) bool { + return (b >= 'A' && b <= 'Z') || + (b >= 'a' && b <= 'z') || + (b >= '0' && b <= '9') || + b == '_' || b == '-' +} diff --git a/server/internal/chunker/bash_regex_test.go b/server/internal/chunker/bash_regex_test.go new file mode 100644 index 0000000..f4c3815 --- /dev/null +++ b/server/internal/chunker/bash_regex_test.go @@ -0,0 +1,341 @@ +package chunker + +import ( + "strings" + "testing" +) + +// helper: assert a chunk with the given symbol name and type exists. +func findChunkByName(t *testing.T, chunks []Chunk, name, kind string) Chunk { + t.Helper() + for _, c := range chunks { + if c.SymbolName != nil && *c.SymbolName == name && c.ChunkType == kind { + return c + } + } + t.Fatalf("no chunk with name=%q type=%q in: %s", name, kind, summariseChunks(chunks)) + return Chunk{} +} + +func summariseChunks(chunks []Chunk) string { + var b strings.Builder + for i, c := range chunks { + if i > 0 { + b.WriteString("; ") + } + name := "" + if c.SymbolName != nil { + name = *c.SymbolName + } + b.WriteString(c.ChunkType + ":" + name) + } + return b.String() +} + +// --- POSIX style: name() { ... } ------------------------------------------- + +func TestBashRegex_PosixSimple(t *testing.T) { + src := `#!/usr/bin/env bash +hello() { + echo "hi" +} +` + chunks := bashRegexChunks("/p/x.sh", src) + hello := findChunkByName(t, chunks, "hello", "function") + if hello.StartLine != 2 || hello.EndLine != 4 { + t.Errorf("hello lines = %d-%d, want 2-4", hello.StartLine, hello.EndLine) + } + if !strings.Contains(hello.Content, `echo "hi"`) { + t.Errorf("body missing echo: %q", hello.Content) + } +} + +func TestBashRegex_PosixOneLiner(t *testing.T) { + src := `greet() { echo "hi"; } +` + chunks := bashRegexChunks("/p/x.sh", src) + greet := findChunkByName(t, chunks, "greet", "function") + if greet.StartLine != 1 || greet.EndLine != 1 { + t.Errorf("greet lines = %d-%d, want 1-1", greet.StartLine, greet.EndLine) + } +} + +// --- bash function keyword form -------------------------------------------- + +func TestBashRegex_FunctionKeywordWithParens(t *testing.T) { + src := `function deploy() { + echo deploying +} +` + chunks := bashRegexChunks("/p/d.sh", src) + findChunkByName(t, chunks, "deploy", "function") +} + +func TestBashRegex_FunctionKeywordNoParens(t *testing.T) { + src := `function build { + make all +} +` + chunks := bashRegexChunks("/p/b.sh", src) + findChunkByName(t, chunks, "build", "function") +} + +// --- multiple functions ---------------------------------------------------- + +func TestBashRegex_MultipleFunctions(t *testing.T) { + src := `setup() { + mkdir -p /tmp/x +} + +teardown() { + rm -rf /tmp/x +} + +run_tests() { + setup + pytest + teardown +} +` + chunks := bashRegexChunks("/p/test.sh", src) + for _, name := range []string{"setup", "teardown", "run_tests"} { + findChunkByName(t, chunks, name, "function") + } + // Three functions + the gap before teardown / between functions / after. + functionCount := 0 + for _, c := range chunks { + if c.ChunkType == "function" { + functionCount++ + } + } + if functionCount != 3 { + t.Errorf("function count = %d, want 3", functionCount) + } +} + +// --- nested braces --------------------------------------------------------- + +func TestBashRegex_NestedBraces(t *testing.T) { + src := `outer() { + if [[ "$1" == "yes" ]]; then + local x={key:value} + echo "${x}" + fi +} +` + chunks := bashRegexChunks("/p/n.sh", src) + outer := findChunkByName(t, chunks, "outer", "function") + if outer.StartLine != 1 || outer.EndLine != 6 { + t.Errorf("outer lines = %d-%d, want 1-6", outer.StartLine, outer.EndLine) + } +} + +// --- strings containing braces --------------------------------------------- + +func TestBashRegex_StringsWithBraces(t *testing.T) { + src := `format() { + echo "literal { brace }" + echo 'single { quoted }' +} +trailer() { echo done; } +` + chunks := bashRegexChunks("/p/s.sh", src) + format := findChunkByName(t, chunks, "format", "function") + if format.EndLine != 4 { + t.Errorf("format end = %d, want 4 (string braces should not count)", format.EndLine) + } + findChunkByName(t, chunks, "trailer", "function") +} + +// --- heredoc handling ------------------------------------------------------ + +func TestBashRegex_HeredocBody(t *testing.T) { + src := `usage() { + cat <] +EOF +} + +main() { + usage +} +` + chunks := bashRegexChunks("/p/install.sh", src) + findChunkByName(t, chunks, "usage", "function") + findChunkByName(t, chunks, "main", "function") +} + +// --- fallback wiring: ChunkFile uses regex for bash on parse fallback ------ + +func TestChunkFile_BashFallbackUsesRegex(t *testing.T) { + // We pick a bash source that's chunked successfully by tree-sitter + // (so the parse-budget guard does NOT fire) and verify both paths + // produce a function-named chunk for `hello`. This is a sanity check + // that bashRegexChunks signature matches the public ChunkFile schema. + src := `hello() { + echo "hi" +} +` + chunks, _, err := ChunkFile("/p/x.sh", src, "bash", 0) + if err != nil { + t.Fatalf("ChunkFile: %v", err) + } + for _, c := range chunks { + if c.ChunkType == "function" && c.SymbolName != nil && *c.SymbolName == "hello" { + return + } + } + t.Errorf("expected `hello` function chunk, got: %s", summariseChunks(chunks)) +} diff --git a/server/internal/chunker/chunker.go b/server/internal/chunker/chunker.go index dc44f55..b5e34a2 100644 --- a/server/internal/chunker/chunker.go +++ b/server/internal/chunker/chunker.go @@ -2,9 +2,20 @@ // The public surface is ChunkFile, which returns ([]Chunk, []Reference, error). // Sliding-window fallback is used when a language is not supported by the // tree-sitter grammars bundle or when parsing fails. +// +// The set of active languages is built from a baked-in default registry +// (see defaultRegistry) and may be filtered at startup via Configure(). The +// CIX_LANGUAGES env var feeds Configure with a comma-separated whitelist; +// empty/nil keeps all defaults. package chunker import ( + "log/slog" + "strings" + "sync" + "sync/atomic" + "time" + sitter "github.com/odvcencio/gotreesitter" "github.com/odvcencio/gotreesitter/grammars" ) @@ -24,53 +35,404 @@ const ( // minRefNameLength mirrors MIN_REF_NAME_LENGTH in chunker.py. const minRefNameLength = 2 +// parseBudget caps wall-clock time spent in tree-sitter for a single file. +// Some grammars (notably bash) have catastrophic-backtracking pathologies on +// specific inputs — install.sh in this very repo took 31s to parse before +// this guard. The parser's own SetTimeoutMicros checkpoint is best-effort +// and overshoots by 3-4×, so we set the hint generously and rely on the +// post-parse wall-clock check to decide whether to keep the tree. +// +// On overshoot we fall back to sliding-window chunks. We accept the wasted +// CPU (parser keeps running until its next checkpoint) because killing a +// pure-Go parse from outside is not safe — the only practical levers are +// SetTimeoutMicros and the cancellation flag, both with the same overshoot +// characteristic. +const ( + parseBudget = 2 * time.Second + parseHint = uint64(parseBudget / time.Microsecond) +) + // --------------------------------------------------------------------------- -// Language maps — ported 1:1 from chunker.py +// Language registry — built from defaultRegistry() at init() and reduced by +// Configure() if the operator set CIX_LANGUAGES. The three exported maps +// stay package-private; the engine reads them directly. // --------------------------------------------------------------------------- -// languageNodes maps language → kind → []node_type. -// Kind values: function|class|method|type. -var languageNodes = map[string]map[string][]string{ - "python": { - "function": {"function_definition"}, - "class": {"class_definition"}, - }, - "typescript": { - "function": {"function_declaration", "arrow_function"}, - "class": {"class_declaration"}, - "method": {"method_definition"}, - "type": {"interface_declaration", "type_alias_declaration"}, - }, - "javascript": { - "function": {"function_declaration", "arrow_function"}, - "class": {"class_declaration"}, - "method": {"method_definition"}, - }, - "go": { - "function": {"function_declaration"}, - "method": {"method_declaration"}, - "type": {"type_spec"}, - }, - "rust": { - "function": {"function_item"}, - "class": {"struct_item", "enum_item"}, - "type": {"trait_item"}, - }, - "java": { - "function": {"method_declaration"}, - "class": {"class_declaration"}, - "type": {"interface_declaration"}, - }, +// languageEntry bundles the three pieces of state a language needs. +type languageEntry struct { + factory languageFunc + nodes map[string][]string // function|class|method|type → AST node types + identifiers map[string]struct{} // identifier leaf-node types for ref extraction +} + +// languageFunc is a factory for sitter.Language. +type languageFunc func() *sitter.Language + +var ( + registryMu sync.RWMutex + languageRegistry map[string]languageFunc + languageNodes map[string]map[string][]string + identifierNodes map[string]map[string]struct{} +) + +func init() { + // Populate full defaults so direct ChunkFile usage (and tests) works + // without a Configure() call. Server startup later may filter via + // Configure(cfg.Languages). + Configure(nil) +} + +// Configure (re)builds the active language registry from the baked-in +// defaultRegistry, optionally filtered to the IDs in `enabled`. Empty or nil +// `enabled` activates all defaults. Unknown IDs are logged and ignored. +// Idempotent and safe to call multiple times; concurrent ChunkFile callers +// see a consistent snapshot via registryMu. +func Configure(enabled []string) { + defaults := defaultRegistry() + + wantAll := len(enabled) == 0 + wanted := make(map[string]struct{}, len(enabled)) + if !wantAll { + for _, raw := range enabled { + id := strings.ToLower(strings.TrimSpace(raw)) + if id == "" { + continue + } + wanted[id] = struct{}{} + } + } + + reg := make(map[string]languageFunc, len(defaults)) + nodes := make(map[string]map[string][]string, len(defaults)) + idents := make(map[string]map[string]struct{}, len(defaults)) + + for lang, entry := range defaults { + if !wantAll { + if _, ok := wanted[lang]; !ok { + continue + } + } + reg[lang] = entry.factory + if entry.nodes != nil { + nodes[lang] = entry.nodes + } + if entry.identifiers != nil { + idents[lang] = entry.identifiers + } + } + + if !wantAll { + for id := range wanted { + if _, ok := defaults[id]; !ok { + slog.Warn("chunker: unknown language in CIX_LANGUAGES, ignored", "lang", id) + } + } + } + + registryMu.Lock() + languageRegistry = reg + languageNodes = nodes + identifierNodes = idents + registryMu.Unlock() +} + +// SupportedLanguages returns a snapshot of currently-active language IDs. +// Useful for /health, debug endpoints, and test assertions. +func SupportedLanguages() []string { + registryMu.RLock() + defer registryMu.RUnlock() + out := make([]string, 0, len(languageRegistry)) + for k := range languageRegistry { + out = append(out, k) + } + return out } -// identifierNodes maps language → set of identifier leaf-node types. -var identifierNodes = map[string]map[string]struct{}{ - "python": {"identifier": {}}, - "typescript": {"identifier": {}, "type_identifier": {}, "property_identifier": {}}, - "javascript": {"identifier": {}, "property_identifier": {}}, - "go": {"identifier": {}, "type_identifier": {}, "field_identifier": {}}, - "rust": {"identifier": {}, "type_identifier": {}, "field_identifier": {}}, - "java": {"identifier": {}, "type_identifier": {}}, +// defaultRegistry returns the baked-in language entries. Adding a language is +// a single new map entry — no other code changes are needed because the +// chunker engine is data-driven. +func defaultRegistry() map[string]languageEntry { + idID := func(extra ...string) map[string]struct{} { + m := map[string]struct{}{"identifier": {}} + for _, e := range extra { + m[e] = struct{}{} + } + return m + } + + return map[string]languageEntry{ + // --- Tier 1: original 6, kept as-is for parity with legacy Python --- + "python": { + factory: grammars.PythonLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"class_definition"}, + }, + identifiers: idID(), + }, + "typescript": { + factory: grammars.TypescriptLanguage, + nodes: map[string][]string{ + "function": {"function_declaration", "arrow_function"}, + "class": {"class_declaration"}, + "method": {"method_definition"}, + "type": {"interface_declaration", "type_alias_declaration"}, + }, + identifiers: idID("type_identifier", "property_identifier"), + }, + "javascript": { + factory: grammars.JavascriptLanguage, + nodes: map[string][]string{ + "function": {"function_declaration", "arrow_function"}, + "class": {"class_declaration"}, + "method": {"method_definition"}, + }, + identifiers: idID("property_identifier"), + }, + "go": { + factory: grammars.GoLanguage, + nodes: map[string][]string{ + "function": {"function_declaration"}, + "method": {"method_declaration"}, + "type": {"type_spec"}, + }, + identifiers: idID("type_identifier", "field_identifier"), + }, + "rust": { + factory: grammars.RustLanguage, + nodes: map[string][]string{ + "function": {"function_item"}, + "class": {"struct_item", "enum_item"}, + "type": {"trait_item"}, + }, + identifiers: idID("type_identifier", "field_identifier"), + }, + "java": { + factory: grammars.JavaLanguage, + nodes: map[string][]string{ + "function": {"method_declaration"}, + "class": {"class_declaration"}, + "type": {"interface_declaration"}, + }, + identifiers: idID("type_identifier"), + }, + + // --- Tier 2: bug-fix — grammars were registered, node maps were not --- + "tsx": { + factory: grammars.TsxLanguage, + nodes: map[string][]string{ + "function": {"function_declaration", "arrow_function"}, + "class": {"class_declaration"}, + "method": {"method_definition"}, + "type": {"interface_declaration", "type_alias_declaration"}, + }, + identifiers: idID("type_identifier", "property_identifier"), + }, + "c": { + factory: grammars.CLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"struct_specifier"}, + "type": {"enum_specifier", "union_specifier", "type_definition"}, + }, + identifiers: idID("type_identifier", "field_identifier"), + }, + "cpp": { + factory: grammars.CppLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"class_specifier", "struct_specifier"}, + "type": {"enum_specifier", "union_specifier", "type_definition", "namespace_definition"}, + }, + identifiers: idID("type_identifier", "field_identifier"), + }, + "ruby": { + factory: grammars.RubyLanguage, + nodes: map[string][]string{ + "function": {"method", "singleton_method"}, + "class": {"class", "module"}, + }, + identifiers: idID("constant"), + }, + + // --- Tier 3: mainstream additions, high confidence in node names --- + "c_sharp": { + factory: grammars.CSharpLanguage, + nodes: map[string][]string{ + "function": {"local_function_statement"}, + "class": {"class_declaration"}, + "method": {"method_declaration"}, + "type": {"interface_declaration", "struct_declaration", "enum_declaration", "record_declaration"}, + }, + identifiers: idID("type_identifier"), + }, + "php": { + factory: grammars.PhpLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"class_declaration"}, + "method": {"method_declaration"}, + "type": {"interface_declaration", "trait_declaration"}, + }, + identifiers: idID("name", "variable_name"), + }, + "swift": { + factory: grammars.SwiftLanguage, + nodes: map[string][]string{ + "function": {"function_declaration"}, + "class": {"class_declaration"}, + "type": {"protocol_declaration"}, + }, + identifiers: idID("simple_identifier", "type_identifier"), + }, + "kotlin": { + factory: grammars.KotlinLanguage, + nodes: map[string][]string{ + "function": {"function_declaration"}, + "class": {"class_declaration", "object_declaration"}, + }, + identifiers: idID("type_identifier", "simple_identifier"), + }, + "scala": { + factory: grammars.ScalaLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"class_definition", "object_definition"}, + "type": {"trait_definition"}, + }, + identifiers: idID("type_identifier"), + }, + "bash": { + factory: grammars.BashLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + }, + identifiers: idID("variable_name", "word"), + }, + "lua": { + factory: grammars.LuaLanguage, + nodes: map[string][]string{ + "function": {"function_declaration", "function_definition"}, + }, + identifiers: idID(), + }, + "dart": { + factory: grammars.DartLanguage, + nodes: map[string][]string{ + "function": {"function_signature"}, + "class": {"class_definition"}, + "method": {"method_signature"}, + "type": {"mixin_declaration", "extension_declaration"}, + }, + identifiers: idID("type_identifier"), + }, + "r": { + factory: grammars.RLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + }, + identifiers: idID(), + }, + "objc": { + factory: grammars.ObjcLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + "class": {"class_interface", "class_implementation"}, + "method": {"method_definition"}, + "type": {"protocol_declaration"}, + }, + identifiers: idID("type_identifier", "field_identifier"), + }, + + // --- Tier 4: markup / data / config with structural nodes --- + "html": { + factory: grammars.HtmlLanguage, + nodes: map[string][]string{ + "type": {"doctype"}, + }, + identifiers: nil, + }, + "css": { + factory: grammars.CssLanguage, + nodes: map[string][]string{ + "class": {"rule_set"}, + }, + identifiers: nil, + }, + "scss": { + factory: grammars.ScssLanguage, + nodes: map[string][]string{ + "function": {"mixin_statement"}, + "class": {"rule_set"}, + }, + identifiers: nil, + }, + "sql": { + factory: grammars.SqlLanguage, + nodes: map[string][]string{ + "function": {"create_function_statement"}, + "type": {"create_table_statement"}, + }, + identifiers: nil, + }, + "markdown": { + factory: grammars.MarkdownLanguage, + nodes: map[string][]string{ + // `section` already wraps the heading + body in + // tree-sitter-markdown — adding `atx_heading` would emit + // duplicate one-line chunks for every `### foo` line. + "type": {"section"}, + }, + identifiers: nil, + }, + + // --- Tier 5: medium-confidence additions --- + "zig": { + factory: grammars.ZigLanguage, + nodes: map[string][]string{ + "function": {"function_declaration"}, + "class": {"struct_declaration"}, + }, + identifiers: idID(), + }, + "julia": { + factory: grammars.JuliaLanguage, + nodes: map[string][]string{ + "function": {"function_definition"}, + }, + identifiers: idID(), + }, + "fortran": { + factory: grammars.FortranLanguage, + nodes: map[string][]string{ + "function": {"subroutine", "function"}, + "class": {"module"}, + }, + identifiers: idID(), + }, + "haskell": { + factory: grammars.HaskellLanguage, + nodes: map[string][]string{ + // `function` = untyped top-level def; `bind` = typed binding + // (signature + match together); `signature` is loose stand-alone + // type signatures. + "function": {"function", "bind", "signature"}, + "type": {"data_type", "newtype"}, + }, + identifiers: map[string]struct{}{ + "variable": {}, "constructor": {}, "name": {}, + }, + }, + "ocaml": { + factory: grammars.OcamlLanguage, + nodes: map[string][]string{ + "function": {"value_definition"}, + "class": {"module_definition"}, + "type": {"type_definition"}, + }, + identifiers: idID("type_identifier"), + }, + } } // skipNames mirrors SKIP_NAMES in chunker.py. @@ -121,26 +483,6 @@ type Reference struct { Language string } -// --------------------------------------------------------------------------- -// Language registry -// --------------------------------------------------------------------------- - -// languageFunc is a factory for sitter.Language. -type languageFunc func() *sitter.Language - -var languageRegistry = map[string]languageFunc{ - "python": grammars.PythonLanguage, - "go": grammars.GoLanguage, - "javascript": grammars.JavascriptLanguage, - "typescript": grammars.TypescriptLanguage, - "tsx": grammars.TsxLanguage, - "java": grammars.JavaLanguage, - "c": grammars.CLanguage, - "cpp": grammars.CppLanguage, - "rust": grammars.RustLanguage, - "ruby": grammars.RubyLanguage, -} - // --------------------------------------------------------------------------- // ChunkFile — main entry point // --------------------------------------------------------------------------- @@ -155,29 +497,51 @@ func ChunkFile(filePath, content, language string, maxSize int) ([]Chunk, []Refe chunks, refs, err := chunkWithTreesitter(filePath, content, language, maxSize) if err != nil { // Fallback: sliding window, no references. - return chunkSlidingWindow(filePath, content, language), nil, nil + return chunkFallback(filePath, content, language), nil, nil } return chunks, refs, nil } +// chunkFallback returns reasonable chunks for content that the tree-sitter +// path could not handle (parser timeout, no grammar, malformed input, …). +// +// For languages where a regex-based extractor exists (currently only bash), +// we try that first — it produces real `function` chunks instead of generic +// `block` ones, which is much more useful for semantic search. If the +// extractor returns nil (no symbols found), we fall through to the universal +// sliding-window strategy so the file content is still indexed. +func chunkFallback(filePath, content, language string) []Chunk { + if language == "bash" { + if c := bashRegexChunks(filePath, content); len(c) > 0 { + return c + } + } + return chunkSlidingWindow(filePath, content, language) +} + // --------------------------------------------------------------------------- // Tree-sitter path // --------------------------------------------------------------------------- func chunkWithTreesitter(filePath, content, language string, maxSize int) ([]Chunk, []Reference, error) { + // Snapshot under RLock so a concurrent Configure() call does not race the read. + registryMu.RLock() langFn, ok := languageRegistry[language] + nodeKinds := languageNodes[language] + idTypes := identifierNodes[language] + registryMu.RUnlock() + if !ok { - return chunkSlidingWindow(filePath, content, language), nil, nil + return chunkFallback(filePath, content, language), nil, nil } lang := langFn() if lang == nil { - return chunkSlidingWindow(filePath, content, language), nil, nil + return chunkFallback(filePath, content, language), nil, nil } - nodeKinds, ok := languageNodes[language] - if !ok { + if nodeKinds == nil { // Grammar exists but we don't have node definitions → sliding window. - return chunkSlidingWindow(filePath, content, language), nil, nil + return chunkFallback(filePath, content, language), nil, nil } // Build flat target → kind map. @@ -190,7 +554,41 @@ func chunkWithTreesitter(filePath, content, language string, maxSize int) ([]Chu src := []byte(content) parser := sitter.NewParser(lang) + + // Twin guards: SetTimeoutMicros is the parser's own checkpoint-based + // budget; the cancellation flag is set by an external timer when the + // wall-clock deadline expires. The parser checks both at the same + // granularity, so they overshoot together — we still rely on the + // post-parse wall-clock check below to decide whether the tree is + // trustworthy. + parser.SetTimeoutMicros(parseHint) + var cancelFlag uint32 + parser.SetCancellationFlag(&cancelFlag) + deadline := time.AfterFunc(parseBudget, func() { + atomic.StoreUint32(&cancelFlag, 1) + }) + + parseStart := time.Now() tree, err := parser.Parse(src) + parseElapsed := time.Since(parseStart) + deadline.Stop() + + // Hard wall-clock check — even if parser claims success, a tree that + // took >2× the budget is the result of a backtracking pathology and + // the structure is not trustworthy enough to chunk on. Falling back to + // sliding window keeps the indexer responsive. + if parseElapsed > 2*parseBudget { + slog.Warn("chunker: parse exceeded budget, falling back to sliding window", + "path", filePath, "language", language, "elapsed", parseElapsed, + "budget", parseBudget) + return chunkFallback(filePath, content, language), nil, nil + } + if atomic.LoadUint32(&cancelFlag) == 1 { + slog.Warn("chunker: parse cancelled by deadline, falling back to sliding window", + "path", filePath, "language", language, "elapsed", parseElapsed) + return chunkFallback(filePath, content, language), nil, nil + } + if err != nil { return nil, nil, err } @@ -205,8 +603,8 @@ func chunkWithTreesitter(filePath, content, language string, maxSize int) ([]Chu extractNodes(root, lang, src, targetTypes, lines, filePath, language, &chunks, &coveredRanges, nil) - // Extract references. - refs := extractReferences(root, lang, src, targetTypes, filePath, language) + // Extract references using the snapshotted identifier set. + refs := extractReferences(root, lang, src, targetTypes, idTypes, filePath, language) // Fill gaps between extracted symbol nodes with "module" chunks. sortRanges(coveredRanges) @@ -237,7 +635,7 @@ func chunkWithTreesitter(filePath, content, language string, maxSize int) ([]Chu } if len(finalChunks) == 0 { - return chunkSlidingWindow(filePath, content, language), nil, nil + return chunkFallback(filePath, content, language), nil, nil } return finalChunks, refs, nil } @@ -312,15 +710,17 @@ func extractNodes( } // extractReferences walks AST collecting identifier usages (not definitions). +// idNodeTypes is passed in (rather than read from the global map) so callers +// can snapshot once and stay consistent if Configure() is called concurrently. func extractReferences( root *sitter.Node, lang *sitter.Language, src []byte, targetTypes map[string]string, + idNodeTypes map[string]struct{}, filePath, language string, ) []Reference { - idNodeTypes, ok := identifierNodes[language] - if !ok { + if len(idNodeTypes) == 0 { return nil } @@ -388,12 +788,27 @@ func extractReferences( } // extractName returns the first identifier-like child's text, or nil. +// +// The set of "identifier-like" node types covers the main grammars in the +// default registry. Notable additions beyond the obvious `identifier`: +// - `field_identifier` — Go method names (`func (b *Bar) Foo()` → "Foo") +// - `word` — bash function names (`hello() { ... }` → "hello") +// - `simple_identifier` — Swift / Kotlin function names +// - `constant` — Ruby class/module names (which start with uppercase) +// +// Without these, the symbol_name field on the resulting chunk was nil and +// the CLI's `cix summary` rendered weird placeholders (`[method] bool`, +// `[function] `). func extractName(node *sitter.Node, lang *sitter.Language, src []byte) *string { nameTypes := map[string]struct{}{ "identifier": {}, "name": {}, "property_identifier": {}, "type_identifier": {}, + "field_identifier": {}, + "word": {}, + "simple_identifier": {}, + "constant": {}, } cnt := node.ChildCount() for i := 0; i < cnt; i++ { @@ -452,45 +867,60 @@ func chunkSlidingWindow(filePath, content, language string) []Chunk { // Chunk splitting // --------------------------------------------------------------------------- +// splitChunk cuts an oversized chunk into pieces of <= maxSize chars. +// +// Only the FIRST piece keeps the original SymbolName/SymbolSignature/ +// ChunkType — subsequent pieces become anonymous `block` chunks. Without +// this, splitting a long function would create N rows in the symbol index +// all claiming to be `func run()`, making `cix def run` return N +// duplicates pointing at different line ranges of the same symbol. +// +// The full text of the symbol is still indexed (both for FTS and embed +// search) — just attributed to the symbol only via its first chunk. func splitChunk(chunk Chunk, maxSize int) []Chunk { lines := splitLines(chunk.Content) var subChunks []Chunk var currentLines []string currentStart := chunk.StartLine + emit := func(content string, startLine, endLine int, isFirst bool) { + c := Chunk{ + Content: content, + FilePath: chunk.FilePath, + StartLine: startLine, + EndLine: endLine, + Language: chunk.Language, + ParentName: chunk.ParentName, + } + if isFirst { + c.ChunkType = chunk.ChunkType + c.SymbolName = chunk.SymbolName + c.SymbolSignature = chunk.SymbolSignature + } else { + c.ChunkType = "block" + } + subChunks = append(subChunks, c) + } + for _, line := range lines { currentLines = append(currentLines, line) currentContent := joinLines(currentLines) if len(currentContent) >= maxSize && len(currentLines) > 1 { splitContent := joinLines(currentLines[:len(currentLines)-1]) - subChunks = append(subChunks, Chunk{ - Content: splitContent, - ChunkType: chunk.ChunkType, - FilePath: chunk.FilePath, - StartLine: currentStart, - EndLine: currentStart + len(currentLines) - 2, - Language: chunk.Language, - SymbolName: chunk.SymbolName, - SymbolSignature: chunk.SymbolSignature, - ParentName: chunk.ParentName, - }) + emit(splitContent, + currentStart, + currentStart+len(currentLines)-2, + len(subChunks) == 0) currentStart = currentStart + len(currentLines) - 1 currentLines = []string{line} } } if len(currentLines) > 0 { - subChunks = append(subChunks, Chunk{ - Content: joinLines(currentLines), - ChunkType: chunk.ChunkType, - FilePath: chunk.FilePath, - StartLine: currentStart, - EndLine: chunk.EndLine, - Language: chunk.Language, - SymbolName: chunk.SymbolName, - SymbolSignature: chunk.SymbolSignature, - ParentName: chunk.ParentName, - }) + emit(joinLines(currentLines), + currentStart, + chunk.EndLine, + len(subChunks) == 0) } return subChunks } diff --git a/server/internal/chunker/chunker_test.go b/server/internal/chunker/chunker_test.go index b64eb74..15310c5 100644 --- a/server/internal/chunker/chunker_test.go +++ b/server/internal/chunker/chunker_test.go @@ -3,6 +3,9 @@ package chunker import ( "strings" "testing" + "time" + + sitter "github.com/odvcencio/gotreesitter" ) func TestChunkFile_Python(t *testing.T) { @@ -186,6 +189,47 @@ func TestChunkFile_OversizedChunkSplit(t *testing.T) { } } +func TestSplitChunk_OnlyFirstKeepsSymbol(t *testing.T) { + // A long Python function that splitChunk will cut into >1 piece. + var sb strings.Builder + sb.WriteString("def big_func():\n") + for i := 0; i < 2000; i++ { + sb.WriteString(" x = 1 # padding line\n") + } + src := sb.String() + chunks, _, err := ChunkFile("big.py", src, "python", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // Find all chunks that mention `big_func`. Only one chunk in the index + // should claim the symbol; the rest must be anonymous `block` pieces + // even though they textually belong to the same function. + withSymbol := 0 + for _, c := range chunks { + if c.SymbolName != nil && *c.SymbolName == "big_func" { + withSymbol++ + if c.ChunkType != "function" { + t.Errorf("chunk with symbol big_func has type %q, want function", c.ChunkType) + } + } + } + if withSymbol != 1 { + t.Errorf("expected exactly 1 chunk attributed to big_func after split, got %d", withSymbol) + } + + // And we DID split — meaning multiple chunks for this function exist. + totalForFunc := 0 + for _, c := range chunks { + if c.FilePath == "big.py" && c.ChunkType != "module" { + totalForFunc++ + } + } + if totalForFunc < 2 { + t.Skipf("test self-check: function fit into one chunk (totalForFunc=%d) — need bigger fixture", totalForFunc) + } +} + func TestFindGaps_NoOverlap(t *testing.T) { covered := [][2]int{{2, 5}, {10, 12}} gaps := findGaps(covered, 15) @@ -217,6 +261,60 @@ func TestSkipNames_ContainsExpected(t *testing.T) { } } +// TestChunkFile_ParseBudgetFallback exercises the parser-budget guard with +// a real-world pathology: the install.sh in this repo triggers ~31s of +// catastrophic backtracking in tree-sitter-bash. After the guard kicks in +// the chunker must return sliding-window chunks within ~parseBudget rather +// than blocking the entire indexer for half a minute. +// +// Skipped under -short because it deliberately runs until the deadline fires. +func TestChunkFile_ParseBudgetFallback(t *testing.T) { + if testing.Short() { + t.Skip("parse-budget test waits up to ~2s for the deadline to fire") + } + + // Construct bash content that deterministically tickles the bash + // grammar's slow path without depending on a specific repo file. + // Heredocs + nested $(...) inside a deeply nested case statement is a + // known trigger; we lean on the repo-known install.sh structure. + src := strings.Repeat(` +case "$x" in + pattern1) + cat < 2*parseBudget+500*time.Millisecond { + t.Errorf("ChunkFile elapsed %s, expected < ~2× parseBudget (%s)", + elapsed, parseBudget) + } + if len(chunks) == 0 { + t.Error("expected at least one chunk (block or function), got 0") + } + + // Refs are nil when sliding-window fallback fires. + _ = refs +} + func TestSplitLines_Roundtrip(t *testing.T) { original := "line one\nline two\nline three" lines := splitLines(original) @@ -246,3 +344,344 @@ type ID = string | number; t.Fatal("expected chunks from TypeScript source") } } + +// --- Tier 2 bug-fix tests: grammars were registered without languageNodes +// in earlier versions, so .tsx/.c/.cpp/.rb files silently fell to sliding +// window. These assert true semantic chunks now come back. --- + +func TestChunkFile_TSX(t *testing.T) { + src := `import React from "react"; + +interface Props { + name: string; +} + +export function Greeting(props: Props) { + return
    Hello, {props.name}
    ; +} + +type Id = string | number; +` + chunks, _, err := ChunkFile("sample.tsx", src, "tsx", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(chunks) == 0 { + t.Fatal("expected chunks from TSX source") + } + hasFunction := false + hasType := false + for _, c := range chunks { + if c.ChunkType == "function" { + hasFunction = true + } + if c.ChunkType == "type" { + hasType = true + } + } + if !hasFunction { + t.Errorf("expected function chunk for Greeting, got types: %v", chunkTypeCounts(chunks)) + } + if !hasType { + t.Errorf("expected type chunk for Id, got types: %v", chunkTypeCounts(chunks)) + } +} + +func TestChunkFile_C(t *testing.T) { + src := `#include + +struct Point { + double x; + double y; +}; + +typedef enum { RED, GREEN, BLUE } Color; + +int add(int a, int b) { + return a + b; +} + +int main(void) { + return add(1, 2); +} +` + chunks, _, err := ChunkFile("sample.c", src, "c", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(chunks) == 0 { + t.Fatal("expected chunks from C source") + } + counts := chunkTypeCounts(chunks) + if counts["function"] == 0 { + t.Errorf("expected function chunks, got: %v", counts) + } + if counts["class"] == 0 { + t.Errorf("expected struct (class) chunk for Point, got: %v", counts) + } +} + +func TestChunkFile_Cpp(t *testing.T) { + src := `#include + +class Animal { +public: + Animal(std::string name) : name_(name) {} + std::string name() const { return name_; } +private: + std::string name_; +}; + +namespace zoo { + int count() { return 42; } +} +` + chunks, _, err := ChunkFile("sample.cpp", src, "cpp", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(chunks) == 0 { + t.Fatal("expected chunks from C++ source") + } + counts := chunkTypeCounts(chunks) + if counts["class"] == 0 { + t.Errorf("expected class chunk for Animal, got: %v", counts) + } +} + +func TestChunkFile_Ruby(t *testing.T) { + src := `module Greetings + class Greeter + def initialize(name) + @name = name + end + + def greet + puts "Hello, #{@name}" + end + end +end +` + chunks, _, err := ChunkFile("sample.rb", src, "ruby", 0) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(chunks) == 0 { + t.Fatal("expected chunks from Ruby source") + } + counts := chunkTypeCounts(chunks) + if counts["class"] == 0 { + t.Errorf("expected class/module chunks, got: %v", counts) + } +} + +// --- Configure() filtering --- + +func TestConfigure_FilterToSubset(t *testing.T) { + defer Configure(nil) // restore defaults for other tests + + Configure([]string{"python", "go"}) + active := SupportedLanguages() + if len(active) != 2 { + t.Errorf("expected 2 active languages, got %d (%v)", len(active), active) + } + got := map[string]bool{} + for _, l := range active { + got[l] = true + } + if !got["python"] || !got["go"] { + t.Errorf("expected python+go, got %v", active) + } + if got["rust"] { + t.Error("rust should be filtered out") + } +} + +func TestConfigure_DefaultsAfterEmpty(t *testing.T) { + Configure([]string{"python"}) + Configure(nil) // should restore full defaults + active := SupportedLanguages() + if len(active) < 20 { + t.Errorf("expected ≥20 default languages, got %d", len(active)) + } +} + +func TestConfigure_UnknownIDIgnored(t *testing.T) { + defer Configure(nil) + + Configure([]string{"python", "imaginary-lang", "go"}) + active := SupportedLanguages() + got := map[string]bool{} + for _, l := range active { + got[l] = true + } + if !got["python"] || !got["go"] { + t.Errorf("expected python+go to survive, got %v", active) + } + if got["imaginary-lang"] { + t.Error("unknown language should not be added") + } +} + +func TestConfigure_CaseInsensitive(t *testing.T) { + defer Configure(nil) + + Configure([]string{" Python ", "GO"}) + active := SupportedLanguages() + if len(active) != 2 { + t.Errorf("expected 2 active languages, got %d (%v)", len(active), active) + } +} + +// chunkTypeCounts is a small helper for table-driven assertions on chunk types. +func chunkTypeCounts(chunks []Chunk) map[string]int { + out := map[string]int{} + for _, c := range chunks { + out[c.ChunkType]++ + } + return out +} + +// TestRegistry_AllFactoriesNonNil ensures every default-registered language +// resolves to a usable *sitter.Language. A nil factory return would mean +// gotreesitter renamed/removed a grammar between updates and we silently lost +// support — better to fail loud here than at runtime in production. +func TestRegistry_AllFactoriesNonNil(t *testing.T) { + defer Configure(nil) + Configure(nil) + + for _, lang := range SupportedLanguages() { + t.Run(lang, func(t *testing.T) { + registryMu.RLock() + fn := languageRegistry[lang] + registryMu.RUnlock() + if fn == nil { + t.Fatalf("nil factory for %q", lang) + } + if g := fn(); g == nil { + t.Fatalf("factory returned nil grammar for %q", lang) + } + }) + } +} + +// TestRegistry_NodeNamesMatchAST parses a tiny per-language fixture and +// asserts at least one configured node-type appears in its AST. This catches +// node-name typos in defaultRegistry without needing a fixture file per lang. +// Languages absent from the fixture map are skipped (registered but not +// covered — acceptable, but the per-language tests above cover the criticals). +func TestRegistry_NodeNamesMatchAST(t *testing.T) { + defer Configure(nil) + Configure(nil) + + fixtures := map[string]string{ + "python": "def f():\n pass\n", + "go": "package p\nfunc F() {}\n", + "javascript": "function f() {}\n", + "typescript": "function f(): void {}\n", + "tsx": "function F() { return
    ; }\n", + "java": "class C { void m() {} }\n", + "c": "int f(void) { return 0; }\n", + "cpp": "class C {}; int f(){return 0;}\n", + "rust": "fn f() {}\n", + "ruby": "class C\n def m; end\nend\n", + "c_sharp": "class C { void M() {} }\n", + "php": "\n", + "swift": "func f() {}\n", + "kotlin": "fun f() {}\n", + "scala": "object O { def f() = 1 }\n", + "bash": "f() { echo hi; }\n", + "lua": "function f() end\n", + "dart": "void f() {}\n", + "r": "f <- function() 1\n", + "objc": "@interface C\n@end\n", + "html": "\n", + "css": ".x { color: red; }\n", + "scss": ".x { color: red; }\n", + "sql": "CREATE TABLE t (id INT);\n", + "markdown": "# Heading\n\nbody\n", + "zig": "fn f() void {}\n", + "julia": "function f() end\n", + "fortran": "subroutine s\nend subroutine\n", + "haskell": "module M where\n\nf :: Int -> Int\nf x = x\n", + "ocaml": "let f x = x\n", + } + + for lang, src := range fixtures { + t.Run(lang, func(t *testing.T) { + registryMu.RLock() + fn, regOK := languageRegistry[lang] + nodes := languageNodes[lang] + registryMu.RUnlock() + + if !regOK { + t.Skipf("%q not in registry (deliberately filtered out)", lang) + } + if nodes == nil { + t.Skipf("%q has no node map (sliding-window only — by design)", lang) + } + + grammar := fn() + if grammar == nil { + t.Fatalf("nil grammar for %q", lang) + } + + parser := sitter.NewParser(grammar) + tree, err := parser.Parse([]byte(src)) + if err != nil { + t.Fatalf("parse error for %q: %v", lang, err) + } + root := tree.RootNode() + if root == nil { + t.Fatalf("nil root for %q", lang) + } + + want := map[string]struct{}{} + for _, types := range nodes { + for _, ty := range types { + want[ty] = struct{}{} + } + } + + seen := map[string]struct{}{} + collectNodeTypes(root, grammar, seen) + + matched := false + for ty := range want { + if _, ok := seen[ty]; ok { + matched = true + break + } + } + if !matched { + keys := make([]string, 0, len(want)) + for k := range want { + keys = append(keys, k) + } + t.Errorf("none of configured node types %v found in AST for %q. Sample AST node types seen: %v", + keys, lang, sampleKeys(seen, 12)) + } + }) + } +} + +func collectNodeTypes(n *sitter.Node, lang *sitter.Language, out map[string]struct{}) { + if n == nil { + return + } + out[n.Type(lang)] = struct{}{} + for i := 0; i < int(n.ChildCount()); i++ { + collectNodeTypes(n.Child(i), lang, out) + } +} + +func sampleKeys(m map[string]struct{}, n int) []string { + out := make([]string, 0, n) + for k := range m { + if len(out) >= n { + break + } + out = append(out, k) + } + return out +} diff --git a/server/internal/config/config.go b/server/internal/config/config.go index 3fa3c1e..372ddc7 100644 --- a/server/internal/config/config.go +++ b/server/internal/config/config.go @@ -10,13 +10,22 @@ import ( "runtime" "strconv" "strings" + "time" ) -// Config holds all runtime settings. Defaults match api/app/config.py except -// for Port, which is 8001 by default so the Go server does not collide with -// the Python server (21847) during parallel PoC rollout. +// Config holds all runtime settings. Port defaults to 21847 — the same +// value the Docker images bake into ENV CIX_PORT and the same the +// docker-compose templates map on the host side. The earlier 8001 +// default was a Python-FastAPI parallel-rollout carry-over; the Python +// backend was archived 2026-04 and the parity is no longer meaningful. type Config struct { APIKey string + // AuthDisabled, when true, makes the server skip the API-key check on + // every endpoint. Off by default — must be turned on EXPLICITLY via + // CIX_AUTH_DISABLED=true (and also requires CIX_API_KEY to be empty). + // Replaces the older "empty API key = no auth" implicit bypass; the new + // behaviour fails loud when CIX_API_KEY is missing without the flag. + AuthDisabled bool Port int EmbeddingModel string ChromaPersistDir string @@ -35,8 +44,55 @@ type Config struct { LlamaTransport string // CIX_LLAMA_TRANSPORT; "unix" or "tcp". LlamaCtxSize int // CIX_LLAMA_CTX; defaults to MaxChunkTokens + 128 when unset. LlamaNGpuLayers int // CIX_N_GPU_LAYERS; -1 on darwin (Metal all layers), 0 elsewhere. + LlamaNThreads int // CIX_LLAMA_THREADS; CPU thread count for llama-server (--threads). 0 = auto. + LlamaBatchSize int // CIX_LLAMA_BATCH; llama-server logical batch size (-b). 0 = match LlamaCtxSize. LlamaStartupSec int // CIX_LLAMA_STARTUP_TIMEOUT; readiness probe ceiling in seconds. EmbeddingsEnabled bool // CIX_EMBEDDINGS_ENABLED; test hook to bypass sidecar entirely. + + // BootstrapGGUFPath, when set, points at a .gguf file outside the cix + // cache that should be imported on first boot — atomically copied into + // `//` so subsequent restarts use + // the cache without re-downloading. Idempotent: if the target file + // already exists, the import is skipped. Source: CIX_BOOTSTRAP_GGUF_PATH. + // + // Typical use: a Docker bind-mounting an existing HF cache file as + // read-only (`/bootstrap/model.gguf:ro`) so the named cix-models volume + // gets seeded once, then the bind can be removed. + BootstrapGGUFPath string + + // EmbedIncludePath toggles a path+language+symbol preamble in front of + // each chunk before sending it to the embedder. Improves retrieval for + // queries whose terms appear in file paths (e.g. "server search handler"), + // at the cost of requiring a full reindex when toggled. Source: + // CIX_EMBED_INCLUDE_PATH (default true). + EmbedIncludePath bool + + // Languages narrows the chunker's active language set. Empty / unset + // activates all baked-in defaults (see chunker.defaultRegistry). Values + // not present in the registry are warned-and-ignored at startup. + // Source: CIX_LANGUAGES (comma-separated, case-insensitive). + Languages []string + + // Dashboard auth bootstrap. When the users table is empty AND both of + // these are set, main.go creates the first admin from these values. + // The user is flagged must_change_password=1 so the env-supplied + // password is never the long-term credential. Both ignored if the + // users table already has rows. Sources: CIX_BOOTSTRAP_ADMIN_EMAIL + + // CIX_BOOTSTRAP_ADMIN_PASSWORD. + BootstrapAdminEmail string + BootstrapAdminPassword string + + // Version-check feature — periodic GitHub poll that surfaces a + // "newer release available" banner in the dashboard. Off entirely when + // CIX_VERSION_CHECK_ENABLED=false (no outbound HTTP at all). Repo is + // configurable so forks can point at their own GitHub project; the tag + // filter is hardcoded to `server/v` since this is the server binary. + // Sources: CIX_VERSION_CHECK_ENABLED (default true), + // CIX_VERSION_CHECK_INTERVAL (default 6h, Go duration string), + // CIX_VERSION_CHECK_REPO (default "dvcdsys/code-index"). + VersionCheckEnabled bool + VersionCheckInterval time.Duration + VersionCheckRepo string } // ModelSafeName returns the embedding model name normalised for use inside @@ -62,15 +118,26 @@ func (c *Config) DynamicChromaPersistDir() string { // Load reads CIX_* environment variables and returns a populated Config. // Returns an error if a numeric variable is present but unparseable. +// +// Defaults for SQLitePath / ChromaPersistDir resolve to ~/.cix/data/... so a +// fresh `make run` works without any env-file editing. Containers (CUDA + CPU +// Dockerfiles, portainer-stack.yml) override these explicitly with /data/... +// where /data is the persistent volume — no behaviour change in production. func Load() (*Config, error) { c := &Config{ APIKey: getenv("CIX_API_KEY", ""), EmbeddingModel: getenv("CIX_EMBEDDING_MODEL", "awhiteside/CodeRankEmbed-Q8_0-GGUF"), - ChromaPersistDir: getenv("CIX_CHROMA_PERSIST_DIR", "/data/chroma"), - SQLitePath: getenv("CIX_SQLITE_PATH", "/data/sqlite/projects.db"), + ChromaPersistDir: getenv("CIX_CHROMA_PERSIST_DIR", defaultChromaPersistDir()), + SQLitePath: getenv("CIX_SQLITE_PATH", defaultSQLitePath()), + } + + authOff, err := getenvBool("CIX_AUTH_DISABLED", false) + if err != nil { + return nil, err } + c.AuthDisabled = authOff - port, err := getenvInt("CIX_PORT", 8001) + port, err := getenvInt("CIX_PORT", 21847) if err != nil { return nil, err } @@ -82,7 +149,7 @@ func Load() (*Config, error) { } c.MaxFileSize = maxFileSize - maxConc, err := getenvInt("CIX_MAX_EMBEDDING_CONCURRENCY", 1) + maxConc, err := getenvInt("CIX_MAX_EMBEDDING_CONCURRENCY", 5) if err != nil { return nil, err } @@ -134,6 +201,25 @@ func Load() (*Config, error) { } c.LlamaNGpuLayers = gpuLayers + // CIX_LLAMA_THREADS: when 0 (default), llama-server picks the count via + // std::thread::hardware_concurrency. The dashboard runtime config can + // override at runtime; an explicit env value still acts as the bootstrap + // default the runtime layer falls back to. + threads, err := getenvInt("CIX_LLAMA_THREADS", 0) + if err != nil { + return nil, err + } + c.LlamaNThreads = threads + + // CIX_LLAMA_BATCH: when 0 (default), the supervisor uses LlamaCtxSize so + // a single chunk fits in one batch (matches the prior --ubatch-size=ctx + // behaviour). Lower values trade throughput for memory. + batch, err := getenvInt("CIX_LLAMA_BATCH", 0) + if err != nil { + return nil, err + } + c.LlamaBatchSize = batch + startup, err := getenvInt("CIX_LLAMA_STARTUP_TIMEOUT", 60) if err != nil { return nil, err @@ -146,20 +232,63 @@ func Load() (*Config, error) { } c.EmbeddingsEnabled = enabled + c.BootstrapGGUFPath = getenv("CIX_BOOTSTRAP_GGUF_PATH", "") + + includePath, err := getenvBool("CIX_EMBED_INCLUDE_PATH", true) + if err != nil { + return nil, err + } + c.EmbedIncludePath = includePath + + if langs := getenv("CIX_LANGUAGES", ""); langs != "" { + for _, l := range strings.Split(langs, ",") { + if s := strings.TrimSpace(l); s != "" { + c.Languages = append(c.Languages, s) + } + } + } + + c.BootstrapAdminEmail = getenv("CIX_BOOTSTRAP_ADMIN_EMAIL", "") + c.BootstrapAdminPassword = getenv("CIX_BOOTSTRAP_ADMIN_PASSWORD", "") + + vcEnabled, err := getenvBool("CIX_VERSION_CHECK_ENABLED", true) + if err != nil { + return nil, err + } + c.VersionCheckEnabled = vcEnabled + + vcInterval, err := getenvDuration("CIX_VERSION_CHECK_INTERVAL", 6*time.Hour) + if err != nil { + return nil, err + } + c.VersionCheckInterval = vcInterval + + c.VersionCheckRepo = getenv("CIX_VERSION_CHECK_REPO", "dvcdsys/code-index") + return c, nil } -// Validate sanity-checks the Phase 3 fields and applies the dev-fallback rule -// for CIX_GGUF_PATH. It must be called after Load (main.go invokes it before -// constructing the embeddings service). Returns an error only for values that -// cannot be made safe with a default. +// Validate sanity-checks the Phase 3 fields. It must be called after Load +// (main.go invokes it before constructing the embeddings service). Returns +// an error only for values that cannot be made safe with a default. // -// Dev fallback: when EmbeddingsEnabled is true and GGUFPath is empty, we look -// for `bench/results/reference_gguf_path.txt` relative to the CWD. If present, -// we use its contents as the GGUF path so the parity gate works without the -// developer having to set an env var. This is a deliberate PoC ergonomic — -// it is silent when the file is missing and the HF downloader picks up. +// PR-E removed the implicit `bench/results/reference_gguf_path.txt` dev +// fallback that used to silently stamp `cfg.GGUFPath` here. The dashboard's +// runtime-config UI now requires the operator to pick exactly one of: +// (a) HF repo ID → cix downloads to its own cache, or (b) absolute path → +// used as-is. There is no longer a "magic file the user didn't paste" +// resolution branch — it confused the UI ("No cached models" while the +// sidecar happily ran an out-of-cache GGUF) and made provenance opaque. +// Parity-gate developers must set CIX_GGUF_PATH explicitly (the test-gate +// Makefile target now reads bench/results/reference_gguf_path.txt and +// passes it through as an env var instead of relying on this code path). func (c *Config) Validate() error { + // NOTE: the old "CIX_API_KEY required unless CIX_AUTH_DISABLED" check is + // gone. Auth gating moved into the bootstrap path in main.go: the server + // now refuses to start when the users table is empty AND no + // CIX_BOOTSTRAP_ADMIN_{EMAIL,PASSWORD} were supplied. CIX_API_KEY is now + // optional (it's imported as a legacy api_keys row at first boot if set). + // CIX_AUTH_DISABLED still works and bypasses auth wholesale. if c.LlamaTransport != "unix" && c.LlamaTransport != "tcp" { return fmt.Errorf("CIX_LLAMA_TRANSPORT=%q, must be 'unix' or 'tcp'", c.LlamaTransport) } @@ -169,14 +298,43 @@ func (c *Config) Validate() error { if c.LlamaStartupSec <= 0 { return fmt.Errorf("CIX_LLAMA_STARTUP_TIMEOUT=%d, must be positive", c.LlamaStartupSec) } - if c.EmbeddingsEnabled && c.GGUFPath == "" { - if path := readDevFallbackGGUF(); path != "" { - c.GGUFPath = path - } - } return nil } +// defaultDataDir returns the platform-specific root for runtime data +// (SQLite + chromem-go). Used to build defaults for CIX_SQLITE_PATH and +// CIX_CHROMA_PERSIST_DIR when neither env var is set. +// +// Order of resolution: +// 1. $CIX_DATA_DIR if set — explicit override +// 2. ~/.cix/data when $HOME is resolvable — typical dev case +// 3. /tmp/cix-data when $HOME is missing — fallback for headless / CI +// +// Container deployments (Dockerfile, Dockerfile.cuda, portainer-stack.yml) +// set CIX_SQLITE_PATH and CIX_CHROMA_PERSIST_DIR explicitly to /data/... so +// this function is never reached in production. +func defaultDataDir() string { + if v := os.Getenv("CIX_DATA_DIR"); v != "" { + return v + } + if home, err := os.UserHomeDir(); err == nil { + return filepath.Join(home, ".cix", "data") + } + return filepath.Join(os.TempDir(), "cix-data") +} + +// defaultSQLitePath resolves the local SQLite database path under the +// platform data dir. The `_` suffix from DynamicSQLitePath is appended at +// query time, not here. +func defaultSQLitePath() string { + return filepath.Join(defaultDataDir(), "sqlite", "projects.db") +} + +// defaultChromaPersistDir resolves the local chromem-go persist directory. +func defaultChromaPersistDir() string { + return filepath.Join(defaultDataDir(), "chroma") +} + // defaultGGUFCacheDir chooses a platform-appropriate location for downloaded // GGUF files. We prefer XDG_CACHE_HOME when set (matches Linux conventions), // then fall back to ~/Library/Caches on darwin and ~/.cache elsewhere. @@ -223,28 +381,6 @@ func defaultLlamaSocketPath() string { return filepath.Join(os.TempDir(), fmt.Sprintf("cix-llama-%d.sock", os.Getpid())) } -// readDevFallbackGGUF reads bench/results/reference_gguf_path.txt relative to -// the CWD if it exists. Empty return means "no fallback available"; callers -// then rely on HF download. -func readDevFallbackGGUF() string { - const refFile = "bench/results/reference_gguf_path.txt" - data, err := os.ReadFile(refFile) - if err != nil { - return "" - } - path := strings.TrimSpace(string(data)) - if path == "" { - return "" - } - // Only use the fallback when the file actually exists on disk. Otherwise - // we'd stamp a non-existent path and the supervisor would fail later with - // a less friendly error. - if _, err := os.Stat(path); err != nil { - return "" - } - return path -} - func getenv(key, def string) string { if v, ok := os.LookupEnv(key); ok { return v @@ -275,3 +411,15 @@ func getenvBool(key string, def bool) (bool, error) { } return b, nil } + +func getenvDuration(key string, def time.Duration) (time.Duration, error) { + v, ok := os.LookupEnv(key) + if !ok { + return def, nil + } + d, err := time.ParseDuration(v) + if err != nil { + return 0, fmt.Errorf("env %s: %w", key, err) + } + return d, nil +} diff --git a/server/internal/config/config_test.go b/server/internal/config/config_test.go index 7d5e602..c1e2310 100644 --- a/server/internal/config/config_test.go +++ b/server/internal/config/config_test.go @@ -1,6 +1,7 @@ package config import ( + "strings" "testing" ) @@ -14,8 +15,8 @@ func TestLoadDefaults(t *testing.T) { if err != nil { t.Fatalf("Load: %v", err) } - if c.Port != 8001 { - t.Errorf("Port default = %d, want 8001", c.Port) + if c.Port != 21847 { + t.Errorf("Port default = %d, want 21847", c.Port) } if c.EmbeddingModel != "awhiteside/CodeRankEmbed-Q8_0-GGUF" { t.Errorf("EmbeddingModel default = %q", c.EmbeddingModel) @@ -97,25 +98,88 @@ func TestLoadPhase3Defaults(t *testing.T) { func TestValidateBadTransport(t *testing.T) { unsetAll(t) + // Auth-off so the auth-gate check (which runs first) lets us reach the + // transport check we actually want to exercise. + t.Setenv("CIX_AUTH_DISABLED", "true") t.Setenv("CIX_LLAMA_TRANSPORT", "udp") c, err := Load() if err != nil { t.Fatalf("Load: %v", err) } - if err := c.Validate(); err == nil { - t.Fatal("Validate: expected error for bogus transport") + err = c.Validate() + if err == nil || !strings.Contains(err.Error(), "CIX_LLAMA_TRANSPORT") { + t.Fatalf("Validate: expected transport error, got %v", err) } } func TestValidateBadCtx(t *testing.T) { unsetAll(t) + t.Setenv("CIX_AUTH_DISABLED", "true") t.Setenv("CIX_LLAMA_CTX", "0") c, err := Load() if err != nil { t.Fatalf("Load: %v", err) } - if err := c.Validate(); err == nil { - t.Fatal("Validate: expected error for non-positive ctx") + err = c.Validate() + if err == nil || !strings.Contains(err.Error(), "CIX_LLAMA_CTX") { + t.Fatalf("Validate: expected ctx error, got %v", err) + } +} + +// TestValidate_NoLongerGuardsAuth — the explicit-or-die check on +// CIX_API_KEY moved out of config.Validate when the dashboard branch +// introduced per-user accounts. Auth gating is now main.go's job (it +// refuses to start with an empty users table and no +// CIX_BOOTSTRAP_ADMIN_* env). This test pins down the new permissive +// behaviour so a future revert wouldn't sneak past CI. +func TestValidate_NoLongerGuardsAuth(t *testing.T) { + cases := []struct { + name string + apiKey string + authOff string + }{ + {name: "no key, no flag", apiKey: "", authOff: ""}, + {name: "no key, flag=false", apiKey: "", authOff: "false"}, + {name: "no key, flag=true", apiKey: "", authOff: "true"}, + {name: "key set, no flag", apiKey: "secret"}, + {name: "key set, flag=true", apiKey: "secret", authOff: "true"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + unsetAll(t) + if tc.apiKey != "" { + t.Setenv("CIX_API_KEY", tc.apiKey) + } + if tc.authOff != "" { + t.Setenv("CIX_AUTH_DISABLED", tc.authOff) + } + c, err := Load() + if err != nil { + t.Fatalf("Load: %v", err) + } + if err := c.Validate(); err != nil { + t.Errorf("Validate must not block on auth fields, got %v", err) + } + }) + } +} + +// TestLoadBootstrapFields ensures the new CIX_BOOTSTRAP_ADMIN_* env vars +// land on the Config. The actual seed-or-skip decision lives in main.go +// where it has access to the users service. +func TestLoadBootstrapFields(t *testing.T) { + unsetAll(t) + t.Setenv("CIX_BOOTSTRAP_ADMIN_EMAIL", "admin@example.com") + t.Setenv("CIX_BOOTSTRAP_ADMIN_PASSWORD", "changeme") + c, err := Load() + if err != nil { + t.Fatalf("Load: %v", err) + } + if c.BootstrapAdminEmail != "admin@example.com" { + t.Errorf("BootstrapAdminEmail = %q", c.BootstrapAdminEmail) + } + if c.BootstrapAdminPassword != "changeme" { + t.Errorf("BootstrapAdminPassword not loaded") } } @@ -154,6 +218,13 @@ func unsetAll(t *testing.T) { "CIX_GGUF_PATH", "CIX_GGUF_CACHE_DIR", "CIX_LLAMA_BIN_DIR", "CIX_LLAMA_SOCKET", "CIX_LLAMA_TRANSPORT", "CIX_LLAMA_CTX", "CIX_N_GPU_LAYERS", "CIX_LLAMA_STARTUP_TIMEOUT", "CIX_EMBEDDINGS_ENABLED", + // Auth gating — without this, a developer's shell with + // CIX_AUTH_DISABLED=true would silently make Validate succeed + // on tests that expect a missing-key failure. + "CIX_AUTH_DISABLED", + // Bootstrap — wipe so the Load tests don't accidentally inherit + // a developer's local bootstrap-admin shell vars. + "CIX_BOOTSTRAP_ADMIN_EMAIL", "CIX_BOOTSTRAP_ADMIN_PASSWORD", } { t.Setenv(k, "sentinel") osUnsetenv(k) diff --git a/server/internal/db/db.go b/server/internal/db/db.go index d9766a5..942ec6e 100644 --- a/server/internal/db/db.go +++ b/server/internal/db/db.go @@ -67,6 +67,15 @@ func Open(path string) (*sql.DB, error) { return nil, fmt.Errorf("migrate path_hash: %w", err) } + // PR-E — add indexed_with_model to projects on pre-PR-E databases. Same + // PRAGMA-table_info pattern as migratePathHash; no backfill (NULL means + // "indexed before drift tracking landed" — UI renders this as Unknown, + // not as a stale-model warning). + if err := migrateIndexedWithModel(db); err != nil { + _ = db.Close() + return nil, fmt.Errorf("migrate indexed_with_model: %w", err) + } + return db, nil } @@ -134,6 +143,42 @@ func migratePathHash(db *sql.DB) error { return nil } +// migrateIndexedWithModel adds projects.indexed_with_model to pre-PR-E +// databases. Idempotent: PRAGMA table_info first; ALTER only if absent. Rows +// stay NULL — the dashboard treats NULL as "indexed before drift tracking +// existed" and renders a neutral Unknown badge rather than the destructive +// drift highlight. +func migrateIndexedWithModel(db *sql.DB) error { + rows, err := db.Query(`PRAGMA table_info(projects)`) + if err != nil { + return fmt.Errorf("table_info: %w", err) + } + have := false + for rows.Next() { + var ( + cid int + name, typ string + notnull, pk int + dflt sql.NullString + ) + if err := rows.Scan(&cid, &name, &typ, ¬null, &dflt, &pk); err != nil { + rows.Close() + return err + } + if name == "indexed_with_model" { + have = true + } + } + rows.Close() + if have { + return nil + } + if _, err := db.Exec(`ALTER TABLE projects ADD COLUMN indexed_with_model TEXT`); err != nil { + return fmt.Errorf("add indexed_with_model column: %w", err) + } + return nil +} + // HashHostPath returns the 16-char SHA1 prefix used as the URL segment for // projects. Exported so projects.Create and the migration share one // implementation (keep it byte-identical to projects.HashPath). diff --git a/server/internal/db/db_test.go b/server/internal/db/db_test.go index 9d99114..293ec35 100644 --- a/server/internal/db/db_test.go +++ b/server/internal/db/db_test.go @@ -134,6 +134,73 @@ func TestOpenMigratesPreM7DB(t *testing.T) { } } +// TestOpenMigratesPreEDB simulates a pre-PR-E database (projects table without +// indexed_with_model column, no runtime_settings table) and verifies Open +// migrates it cleanly + the new column is queryable on existing rows. +func TestOpenMigratesPreEDB(t *testing.T) { + tmp := filepath.Join(t.TempDir(), "pre-e.db") + + // Stage a pre-PR-E projects table that already has path_hash (post-m7) + // but lacks indexed_with_model. No runtime_settings table at all. + seed, err := sql.Open(DriverName, "file:"+tmp) + if err != nil { + t.Fatalf("seed Open: %v", err) + } + if _, err := seed.Exec(`CREATE TABLE projects ( + host_path TEXT PRIMARY KEY, + container_path TEXT NOT NULL, + languages TEXT DEFAULT '[]', + settings TEXT DEFAULT '{}', + stats TEXT DEFAULT '{}', + status TEXT DEFAULT 'created', + created_at TEXT NOT NULL, + updated_at TEXT NOT NULL, + last_indexed_at TEXT, + path_hash TEXT + )`); err != nil { + t.Fatalf("seed CREATE TABLE: %v", err) + } + if _, err := seed.Exec( + `INSERT INTO projects (host_path, container_path, created_at, updated_at, path_hash) + VALUES ('/legacy/proj', '/legacy/proj', '2024-01-01', '2024-01-01', 'abc')`, + ); err != nil { + t.Fatalf("seed INSERT: %v", err) + } + seed.Close() + + database, err := Open(tmp) + if err != nil { + t.Fatalf("Open migrates pre-PR-E DB: %v", err) + } + defer database.Close() + defer os.Remove(tmp) + + // indexed_with_model column exists and is queryable. Pre-existing rows + // must stay NULL — UI relies on this to render the neutral "Unknown" + // badge instead of the destructive drift highlight. + var model sql.NullString + if err := database.QueryRow( + `SELECT indexed_with_model FROM projects WHERE host_path = ?`, "/legacy/proj", + ).Scan(&model); err != nil { + t.Fatalf("select indexed_with_model: %v", err) + } + if model.Valid { + t.Errorf("legacy row indexed_with_model = %q, want NULL", model.String) + } + + // runtime_settings table exists with the single-row CHECK in place. + if _, err := database.Exec( + `INSERT INTO runtime_settings (id, embedding_model, updated_at) VALUES (1, 'foo', '2026-01-01')`, + ); err != nil { + t.Fatalf("runtime_settings insert: %v", err) + } + if _, err := database.Exec( + `INSERT INTO runtime_settings (id, embedding_model, updated_at) VALUES (2, 'bar', '2026-01-01')`, + ); err == nil { + t.Error("expected CHECK(id=1) violation on second row, got nil") + } +} + func TestSymbolsIndexExists(t *testing.T) { database, err := Open(":memory:") if err != nil { diff --git a/server/internal/db/schema.go b/server/internal/db/schema.go index 78f2f30..34b9910 100644 --- a/server/internal/db/schema.go +++ b/server/internal/db/schema.go @@ -18,7 +18,12 @@ CREATE TABLE IF NOT EXISTS projects ( -- O(n) GetByHash scan with an O(log n) index lookup. Computed in Go on -- insert; the column is nullable here so migrating databases can backfill -- lazily via Open's ALTER+UPDATE hook. - path_hash TEXT + path_hash TEXT, + -- indexed_with_model is the embedding model identifier active when the + -- project was last indexed. NULL on legacy rows (pre-PR-E) until next + -- reindex. Compared against the live runtime model to surface a "stale + -- model" badge on the dashboard project list. + indexed_with_model TEXT ); -- NOTE: CREATE INDEX on path_hash is intentionally NOT here. Pre-m7 databases @@ -82,6 +87,68 @@ CREATE TABLE IF NOT EXISTS index_runs ( error_message TEXT, FOREIGN KEY (project_path) REFERENCES projects(host_path) ON DELETE CASCADE ); + +-- Dashboard auth: users/sessions/api_keys. +-- Added in the dashboard branch when the single-CIX_API_KEY model was +-- replaced with per-user accounts and named API keys. Old deployments are +-- still expected to come up cleanly: the bootstrap flow in main.go creates +-- the first admin from CIX_BOOTSTRAP_ADMIN_{EMAIL,PASSWORD} on a fresh DB. +CREATE TABLE IF NOT EXISTS users ( + id TEXT PRIMARY KEY, + email TEXT NOT NULL COLLATE NOCASE, + password_hash TEXT NOT NULL, + role TEXT NOT NULL DEFAULT 'viewer', + must_change_password INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL, + updated_at TEXT NOT NULL, + disabled_at TEXT +); +CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email ON users(email COLLATE NOCASE); + +CREATE TABLE IF NOT EXISTS sessions ( + id TEXT PRIMARY KEY, + user_id TEXT NOT NULL, + created_at TEXT NOT NULL, + expires_at TEXT NOT NULL, + last_seen_at TEXT NOT NULL, + last_seen_ip TEXT, + last_seen_ua TEXT, + FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE +); +CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id); +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at); + +CREATE TABLE IF NOT EXISTS api_keys ( + id TEXT PRIMARY KEY, + owner_user_id TEXT NOT NULL, + name TEXT NOT NULL, + prefix TEXT NOT NULL, + hash TEXT NOT NULL UNIQUE, + created_at TEXT NOT NULL, + last_used_at TEXT, + last_used_ip TEXT, + last_used_ua TEXT, + revoked_at TEXT, + FOREIGN KEY (owner_user_id) REFERENCES users(id) ON DELETE CASCADE +); +CREATE INDEX IF NOT EXISTS idx_apikeys_owner ON api_keys(owner_user_id); +CREATE INDEX IF NOT EXISTS idx_apikeys_hash ON api_keys(hash); + +-- runtime_settings holds the single dashboard-overridable runtime config row +-- (PR-E). NULL columns mean "fall through to env / recommended". The +-- CHECK(id=1) constraint enforces a single-row table; UPSERT uses +-- INSERT OR REPLACE on id=1. +CREATE TABLE IF NOT EXISTS runtime_settings ( + id INTEGER PRIMARY KEY CHECK(id=1), + embedding_model TEXT, + llama_ctx_size INTEGER, + llama_n_gpu_layers INTEGER, + llama_n_threads INTEGER, + max_embedding_concurrency INTEGER, + llama_batch_size INTEGER, + updated_at TEXT NOT NULL, + updated_by TEXT +); ` // ExpectedTables lists the tables the schema creates. Used by db_test and by @@ -92,4 +159,8 @@ var ExpectedTables = []string{ "symbols", "refs", "index_runs", + "users", + "sessions", + "api_keys", + "runtime_settings", } diff --git a/server/internal/embeddings/bootstrap_test.go b/server/internal/embeddings/bootstrap_test.go new file mode 100644 index 0000000..455df72 --- /dev/null +++ b/server/internal/embeddings/bootstrap_test.go @@ -0,0 +1,115 @@ +package embeddings + +import ( + "io/fs" + "log/slog" + "os" + "path/filepath" + "testing" +) + +// TestImportBootstrapGGUF_HappyPath covers the typical Docker scenario: a +// fresh cix-models volume + a bind-mounted source GGUF outside the cache. +// First import copies the file into the cache layout; the second call is +// a no-op (idempotent) and returns the existing path. +func TestImportBootstrapGGUF_HappyPath(t *testing.T) { + tmp := t.TempDir() + cacheDir := filepath.Join(tmp, "cache") + srcPath := filepath.Join(tmp, "src", "model.gguf") + + if err := os.MkdirAll(filepath.Dir(srcPath), 0o755); err != nil { + t.Fatalf("mkdir src dir: %v", err) + } + payload := []byte("not really a gguf, but bytes are bytes") + if err := os.WriteFile(srcPath, payload, 0o644); err != nil { + t.Fatalf("write src: %v", err) + } + + repo := "owner/repo-Q8" + logger := slog.New(slog.NewTextHandler(os.Stderr, nil)) + + got, err := importBootstrapGGUF(cacheDir, repo, srcPath, logger) + if err != nil { + t.Fatalf("import: %v", err) + } + want := filepath.Join(cacheDir, "owner__repo-Q8", "model.gguf") + if got != want { + t.Fatalf("path = %q, want %q", got, want) + } + if data, err := os.ReadFile(got); err != nil { + t.Fatalf("read imported: %v", err) + } else if string(data) != string(payload) { + t.Errorf("imported file content mismatch") + } + + // Second import = no-op: target already exists, must return same path. + got2, err := importBootstrapGGUF(cacheDir, repo, srcPath, logger) + if err != nil { + t.Fatalf("second import: %v", err) + } + if got2 != want { + t.Errorf("second call path = %q, want %q", got2, want) + } + + // And no `.partial` file should be left around. + matches, _ := filepath.Glob(filepath.Join(cacheDir, "owner__repo-Q8", "*.partial")) + if len(matches) > 0 { + t.Errorf("leftover partials: %v", matches) + } +} + +// TestImportBootstrapGGUF_MissingSource — a missing source isn't an error; +// it returns ("", nil) so resolveGGUFPath can fall through to HF download. +// This matches the "operator set the env optimistically" use case. +func TestImportBootstrapGGUF_MissingSource(t *testing.T) { + cacheDir := t.TempDir() + got, err := importBootstrapGGUF(cacheDir, "owner/repo", filepath.Join(cacheDir, "missing.gguf"), slog.Default()) + if err != nil { + t.Fatalf("missing source should not error: %v", err) + } + if got != "" { + t.Errorf("got %q, want empty (so caller falls through to download)", got) + } +} + +// TestImportBootstrapGGUF_DirectoryRejected — passing a directory is a +// configuration mistake; we surface it loud so the operator notices. +func TestImportBootstrapGGUF_DirectoryRejected(t *testing.T) { + cacheDir := t.TempDir() + srcDir := filepath.Join(cacheDir, "not-a-file") + _ = os.MkdirAll(srcDir, 0o755) + _, err := importBootstrapGGUF(cacheDir, "owner/repo", srcDir, slog.Default()) + if err == nil { + t.Fatal("expected error for directory source, got nil") + } +} + +// TestImportBootstrapGGUF_PreservesContents ensures we don't truncate or +// corrupt the file mid-copy. Uses a 1 MiB payload to exercise the io.Copy +// loop multiple times. +func TestImportBootstrapGGUF_PreservesContents(t *testing.T) { + tmp := t.TempDir() + srcPath := filepath.Join(tmp, "big.gguf") + const size = 1 << 20 // 1 MiB + buf := make([]byte, size) + for i := range buf { + buf[i] = byte(i % 251) + } + if err := os.WriteFile(srcPath, buf, 0o644); err != nil { + t.Fatalf("write src: %v", err) + } + got, err := importBootstrapGGUF(filepath.Join(tmp, "cache"), "x/y", srcPath, slog.Default()) + if err != nil { + t.Fatalf("import: %v", err) + } + info, err := os.Stat(got) + if err != nil { + t.Fatalf("stat target: %v", err) + } + if info.Size() != size { + t.Errorf("size = %d, want %d", info.Size(), size) + } + if info.Mode()&fs.ModeType != 0 { + t.Errorf("target is not a regular file: mode=%v", info.Mode()) + } +} diff --git a/server/internal/embeddings/format.go b/server/internal/embeddings/format.go new file mode 100644 index 0000000..dcb8663 --- /dev/null +++ b/server/internal/embeddings/format.go @@ -0,0 +1,59 @@ +package embeddings + +import ( + "strings" + + "github.com/dvcdsys/code-index/server/internal/chunker" +) + +// FormatChunkForEmbedding builds the text passed to the embedder for a chunk. +// It optionally prepends a natural-language preamble carrying the relative +// path, language, and symbol kind+name. Code-trained embedders interpret this +// preamble as docstring-style context — empirically it improves retrieval for +// path-aware queries (e.g. "server search handler") because file paths +// contribute high-signal tokens that bare chunk content lacks. +// +// Off-recipe for CodeRankEmbed (whose passage side was trained on raw code), +// but the cost is a few dozen extra tokens per chunk and the gain on this +// repo's "main entry point server" type queries is large enough to be worth +// the trade. Switching this format on or off requires a full reindex — +// vectors are not interchangeable between formats. +// +// When relPath is empty (or includePath=false), the function falls back to +// the legacy ": " prefix that the Python indexer used, +// preserving parity for projects that have not yet reindexed. +func FormatChunkForEmbedding(c chunker.Chunk, relPath string, includePath bool) string { + if !includePath || relPath == "" { + return c.ChunkType + ": " + c.Content + } + + var sb strings.Builder + sb.Grow(len(relPath) + len(c.Content) + 64) + + sb.WriteString("File: ") + sb.WriteString(relPath) + sb.WriteByte('\n') + + if c.Language != "" { + sb.WriteString("Language: ") + sb.WriteString(c.Language) + sb.WriteByte('\n') + } + + // Symbol metadata is only included for nameable chunks. "module" / "block" + // chunks have no symbol and would just add noise. The chunker stores + // SymbolName as a *string; nil means "no symbol". + if c.SymbolName != nil && *c.SymbolName != "" { + switch c.ChunkType { + case "function", "class", "method", "type": + sb.WriteString(c.ChunkType) + sb.WriteString(": ") + sb.WriteString(*c.SymbolName) + sb.WriteByte('\n') + } + } + + sb.WriteByte('\n') + sb.WriteString(c.Content) + return sb.String() +} diff --git a/server/internal/embeddings/format_test.go b/server/internal/embeddings/format_test.go new file mode 100644 index 0000000..6d44925 --- /dev/null +++ b/server/internal/embeddings/format_test.go @@ -0,0 +1,102 @@ +package embeddings + +import ( + "strings" + "testing" + + "github.com/dvcdsys/code-index/server/internal/chunker" +) + +func ptr(s string) *string { return &s } + +func TestFormatChunkForEmbedding_Disabled(t *testing.T) { + c := chunker.Chunk{ + Content: "func main() {}", + ChunkType: "function", + Language: "go", + } + got := FormatChunkForEmbedding(c, "cmd/main.go", false) + want := "function: func main() {}" + if got != want { + t.Errorf("includePath=false: got %q, want %q", got, want) + } +} + +func TestFormatChunkForEmbedding_EmptyRelPath(t *testing.T) { + c := chunker.Chunk{ + Content: "x := 1", + ChunkType: "module", + Language: "go", + } + got := FormatChunkForEmbedding(c, "", true) + want := "module: x := 1" + if got != want { + t.Errorf("empty relPath: got %q, want %q", got, want) + } +} + +func TestFormatChunkForEmbedding_FunctionWithSymbol(t *testing.T) { + c := chunker.Chunk{ + Content: "func semanticSearchHandler() {}", + ChunkType: "function", + Language: "go", + SymbolName: ptr("semanticSearchHandler"), + } + got := FormatChunkForEmbedding(c, "server/internal/httpapi/search.go", true) + wantContains := []string{ + "File: server/internal/httpapi/search.go", + "Language: go", + "function: semanticSearchHandler", + "func semanticSearchHandler() {}", + } + for _, w := range wantContains { + if !strings.Contains(got, w) { + t.Errorf("output missing %q\nfull output:\n%s", w, got) + } + } +} + +func TestFormatChunkForEmbedding_ModuleChunkOmitsSymbol(t *testing.T) { + // Module chunks have no symbol and SymbolName is nil; ensure we don't + // emit a "module: " line. Even if a symbol leaks in, module/block kinds + // must not produce a symbol preamble line (would add path-correlated + // noise to gap-filler chunks). + c := chunker.Chunk{ + Content: "import \"fmt\"", + ChunkType: "module", + Language: "go", + SymbolName: ptr("Anything"), + } + got := FormatChunkForEmbedding(c, "main.go", true) + if strings.Contains(got, "module:") { + t.Errorf("module chunk should not produce 'module:' preamble, got:\n%s", got) + } + if !strings.Contains(got, "File: main.go") { + t.Errorf("expected File: line, got:\n%s", got) + } +} + +func TestFormatChunkForEmbedding_OmitsLangWhenEmpty(t *testing.T) { + c := chunker.Chunk{ + Content: "raw text", + ChunkType: "module", + } + got := FormatChunkForEmbedding(c, "README", true) + if strings.Contains(got, "Language:") { + t.Errorf("empty Language should not emit Language: line, got:\n%s", got) + } +} + +func TestFormatChunkForEmbedding_PreservesContentBytes(t *testing.T) { + // The raw chunk content must appear in the output unchanged — the + // preamble is additive, never lossy. + c := chunker.Chunk{ + Content: "line1\nline2\n indented\n", + ChunkType: "function", + Language: "go", + } + got := FormatChunkForEmbedding(c, "x.go", true) + if !strings.HasSuffix(got, c.Content) { + t.Errorf("output must end with raw content; got:\n%s", got) + } +} diff --git a/server/internal/embeddings/queue.go b/server/internal/embeddings/queue.go index 5e00be6..479233c 100644 --- a/server/internal/embeddings/queue.go +++ b/server/internal/embeddings/queue.go @@ -3,6 +3,7 @@ package embeddings import ( "context" "sync" + "sync/atomic" "time" ) @@ -28,9 +29,17 @@ type Queue struct { slots chan struct{} timeout time.Duration - mu sync.Mutex - avgBatchSec float64 - estFinishAtMs int64 // unix millis; 0 when no batch is in flight + mu sync.Mutex + avgBatchSec float64 + estFinishAtMs int64 // unix millis; 0 when no batch is in flight + + // blocked is set by BlockNew to make Acquire fail fast with ErrBusy. Used + // during a sidecar Restart so a queued caller doesn't get its request + // dispatched against a child process that's about to be killed. + blocked atomic.Bool + // inFlight is incremented by Acquire and decremented by Release. WaitDrain + // polls this to know when the queue has fully quiesced. + inFlight atomic.Int64 } // NewQueue constructs a queue with the given max concurrency and acquire @@ -50,7 +59,14 @@ func NewQueue(concurrency int, timeout time.Duration) *Queue { // Acquire blocks until a slot is free, the context is cancelled, or the // per-queue timeout fires. On timeout it returns *ErrBusy with a RetryAfter // hint derived from the EMA — callers surface this as HTTP 503. +// +// When the queue is in BlockNew state (Service.Restart drain), Acquire fails +// fast with ErrBusy so the dashboard's Save & Restart doesn't deadlock +// against a queue full of waiting callers. func (q *Queue) Acquire(ctx context.Context) error { + if q.blocked.Load() { + return &ErrBusy{RetryAfter: minRetryAfterSec} + } var ( cancel context.CancelFunc qctx = ctx @@ -64,6 +80,7 @@ func (q *Queue) Acquire(ctx context.Context) error { // so the busy response can tell clients roughly how long to wait. select { case q.slots <- struct{}{}: + q.inFlight.Add(1) q.markBatchStart() return nil case <-qctx.Done(): @@ -83,9 +100,45 @@ func (q *Queue) Acquire(ctx context.Context) error { // is caught in tests rather than silently leaking slots. func (q *Queue) Release(start time.Time) { <-q.slots + q.inFlight.Add(-1) q.updateEMA(time.Since(start)) } +// BlockNew puts the queue in drain mode: subsequent Acquire calls fail fast +// with ErrBusy. Idempotent. Used by Service.Restart so a sidecar swap can +// proceed without contending with new HTTP-driven embed requests. +func (q *Queue) BlockNew() { q.blocked.Store(true) } + +// Resume lifts the BlockNew gate so Acquire works again. Idempotent. +func (q *Queue) Resume() { q.blocked.Store(false) } + +// WaitDrain blocks until in-flight Acquire holders all release their slot, or +// ctx fires. Returns ctx.Err() on timeout — caller can decide whether to +// proceed with the restart anyway (forcing in-flight calls to fail mid-call) +// or abort. Polls every 50ms; cheap because in-flight is an atomic counter. +func (q *Queue) WaitDrain(ctx context.Context) error { + if q.inFlight.Load() == 0 { + return nil + } + t := time.NewTicker(50 * time.Millisecond) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return ctx.Err() + case <-t.C: + if q.inFlight.Load() == 0 { + return nil + } + } + } +} + +// InFlight reports the current number of acquired-but-not-released slots. +// Exposed for the sidecar status payload so the dashboard can render +// "draining (N in flight)" during a restart. +func (q *Queue) InFlight() int { return int(q.inFlight.Load()) } + // EstimatedWaitSec returns the EMA-based wait estimate. Exposed for tests and // for debug endpoints that want to surface queue health. func (q *Queue) EstimatedWaitSec() float64 { diff --git a/server/internal/embeddings/queue_test.go b/server/internal/embeddings/queue_test.go index 85f7b5c..f3111e6 100644 --- a/server/internal/embeddings/queue_test.go +++ b/server/internal/embeddings/queue_test.go @@ -150,3 +150,85 @@ func TestNewQueueClampsConcurrency(t *testing.T) { t.Errorf("slots cap = %d, want 1", cap(q.slots)) } } + +// TestQueueBlockNew_RejectsNewAcquires covers the PR-E sidecar restart drain +// path: BlockNew makes Acquire fail fast with ErrBusy so an admin's Save & +// Restart doesn't deadlock against a backlog of waiting search calls. +func TestQueueBlockNew_RejectsNewAcquires(t *testing.T) { + q := NewQueue(2, time.Second) + q.BlockNew() + err := q.Acquire(context.Background()) + var busy *ErrBusy + if !errors.As(err, &busy) { + t.Fatalf("Acquire after BlockNew = %v, want ErrBusy", err) + } + q.Resume() + if err := q.Acquire(context.Background()); err != nil { + t.Fatalf("Acquire after Resume = %v, want nil", err) + } + q.Release(time.Now()) +} + +// TestQueueWaitDrain_BlocksUntilInFlightZero verifies the drain primitive +// the PR-E Service.Restart relies on: WaitDrain returns once every Acquire +// has been released, regardless of how many slots the queue has. +func TestQueueWaitDrain_BlocksUntilInFlightZero(t *testing.T) { + q := NewQueue(3, time.Second) + startA, startB := time.Now(), time.Now() + if err := q.Acquire(context.Background()); err != nil { + t.Fatalf("Acquire A: %v", err) + } + if err := q.Acquire(context.Background()); err != nil { + t.Fatalf("Acquire B: %v", err) + } + if got := q.InFlight(); got != 2 { + t.Fatalf("InFlight = %d, want 2", got) + } + + // WaitDrain must block while slots are held — release them on a + // goroutine and ensure WaitDrain returns shortly after. + done := make(chan error, 1) + go func() { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + done <- q.WaitDrain(ctx) + }() + + time.Sleep(80 * time.Millisecond) + q.Release(startA) + time.Sleep(40 * time.Millisecond) + q.Release(startB) + + select { + case err := <-done: + if err != nil { + t.Errorf("WaitDrain after both releases: %v", err) + } + case <-time.After(500 * time.Millisecond): + t.Fatal("WaitDrain did not return after slots fully released") + } + if got := q.InFlight(); got != 0 { + t.Errorf("InFlight after drain = %d, want 0", got) + } +} + +// TestQueueWaitDrain_RespectsContext ensures the drain timeout we use during +// Restart actually fires — without it a stuck embed call could wedge the +// admin's intentional restart forever. +func TestQueueWaitDrain_RespectsContext(t *testing.T) { + q := NewQueue(1, time.Second) + hold := time.Now() + if err := q.Acquire(context.Background()); err != nil { + t.Fatalf("Acquire: %v", err) + } + defer q.Release(hold) + + ctx, cancel := context.WithTimeout(context.Background(), 80*time.Millisecond) + defer cancel() + if err := q.WaitDrain(ctx); !errors.Is(err, context.DeadlineExceeded) { + t.Errorf("WaitDrain err = %v, want DeadlineExceeded", err) + } +} + +// Avoid unused-var lint while keeping the suppress simple. +var _ = sync.Mutex{} diff --git a/server/internal/embeddings/service.go b/server/internal/embeddings/service.go index 22ec9f9..ee3a7d2 100644 --- a/server/internal/embeddings/service.go +++ b/server/internal/embeddings/service.go @@ -4,8 +4,10 @@ import ( "context" "errors" "fmt" + "io" "log/slog" "os" + "path/filepath" "strings" "time" @@ -60,7 +62,10 @@ func New(ctx context.Context, cfg *config.Config, logger *slog.Logger) (*Service Transport: cfg.LlamaTransport, CtxSize: cfg.LlamaCtxSize, NGpuLayers: cfg.LlamaNGpuLayers, + NThreads: cfg.LlamaNThreads, + BatchSize: cfg.LlamaBatchSize, StartupSec: cfg.LlamaStartupSec, + Model: cfg.EmbeddingModel, } sup, err := newSupervisor(ctx, supCfg, logger) @@ -77,6 +82,28 @@ func New(ctx context.Context, cfg *config.Config, logger *slog.Logger) (*Service }, nil } +// Config returns the *config.Config the service was constructed with. The +// pointer is shared; callers that mutate it in place must understand they +// are racing the supervisor — only the dashboard restart path is supposed +// to do this, and it does so behind queue.BlockNew + sup.Restart. +func (s *Service) Config() *config.Config { + if s == nil { + return nil + } + return s.cfg +} + +// CacheDirFromService returns the GGUF cache directory the dashboard's +// /admin/models handler should walk. Returns "" when the EmbeddingsQuerier +// isn't a *Service (test fakes) or when the service is disabled. +func CacheDirFromService(q any) string { + s, ok := q.(*Service) + if !ok || s == nil || s.cfg == nil { + return "" + } + return s.cfg.GGUFCacheDir +} + // Stop tears the supervisor down within the ctx deadline. Safe to call on a // disabled or partially-initialised Service. func (s *Service) Stop(ctx context.Context) error { @@ -86,6 +113,93 @@ func (s *Service) Stop(ctx context.Context) error { return s.sup.Stop(ctx) } +// Status returns a snapshot of the sidecar process state for the dashboard. +// Returns SupervisorStatus{State: "disabled"} when the service was started +// with embeddings turned off — the dashboard renders a banner in that case +// and disables the runtime-config save buttons. +func (s *Service) Status() SupervisorStatus { + if s == nil || s.disabled { + return SupervisorStatus{State: "disabled"} + } + if s.sup == nil { + return SupervisorStatus{State: "failed", LastError: "supervisor not initialised"} + } + st := s.sup.Status() + if s.queue != nil { + // Annotate with in-flight count so the UI can show "draining (N)" + // during a restart cycle. + st.InFlight = s.queue.InFlight() + } + return st +} + +// Restart drains the embedding queue, stops the current sidecar child, and +// spawns a new one with the new config. cfg is the freshly-resolved +// runtimecfg-on-top-of-env Config snapshot — Restart does not consult any +// stored boot config. +// +// On success, the new sidecar is ready to serve embeddings before this +// returns. On failure, the supervisor enters the "failed" state and the +// queue is reopened (so callers get the existing ErrSupervisor / ErrBusy +// rather than a permanent block). +func (s *Service) Restart(ctx context.Context, cfg *config.Config) error { + if s == nil || s.disabled { + return ErrDisabled + } + if s.sup == nil { + return ErrSupervisor + } + + // Drain: refuse new acquires, then wait for in-flight to settle. 30s + // matches the documented restart UX in the dashboard plan; longer values + // would let a stuck embedding call block the operator's intentional + // restart indefinitely. + s.queue.BlockNew() + defer s.queue.Resume() + drainCtx, drainCancel := context.WithTimeout(ctx, 30*time.Second) + if err := s.queue.WaitDrain(drainCtx); err != nil { + drainCancel() + s.logger.Warn("embeddings: drain timed out, proceeding with restart anyway", + "in_flight", s.queue.InFlight(), "err", err, + ) + } else { + drainCancel() + } + + // Resolve the (possibly new) GGUF path before tearing down the current + // child — if resolution fails, we stay on the running sidecar instead of + // crashing it for a config we can't honour. + ggufPath, err := resolveGGUFPath(ctx, cfg, s.logger) + if err != nil { + return fmt.Errorf("resolve gguf for restart: %w", err) + } + + // Update queue concurrency / prefix to match the new model. The buffered + // slot channel can't be resized in place; we swap the queue, but only + // AFTER drain so no caller is mid-Acquire/Release on the old channel. + if cfg.MaxEmbeddingConcurrency != cap(s.queue.slots) { + s.queue = NewQueue(cfg.MaxEmbeddingConcurrency, time.Duration(cfg.EmbeddingQueueTimeout)*time.Second) + // New queue starts unblocked; that's fine because we hold the + // *previous* queue's blocked state via deferred Resume. The previous + // queue is now garbage and won't see any callers. + } + s.prefix = ResolveQueryPrefix(cfg.EmbeddingModel) + + supCfg := supervisorConfig{ + BinDir: cfg.LlamaBinDir, + GGUFPath: ggufPath, + SocketPath: cfg.LlamaSocketPath, + Transport: cfg.LlamaTransport, + CtxSize: cfg.LlamaCtxSize, + NGpuLayers: cfg.LlamaNGpuLayers, + NThreads: cfg.LlamaNThreads, + BatchSize: cfg.LlamaBatchSize, + StartupSec: cfg.LlamaStartupSec, + Model: cfg.EmbeddingModel, + } + return s.sup.Restart(ctx, supCfg) +} + // Ready reports whether the embeddings pipeline is currently able to serve a // request. Returns nil when the model is loaded and the supervisor is healthy, // ErrDisabled when embeddings are turned off, or ErrSupervisor/ErrNotReady @@ -299,12 +413,20 @@ func (s *Service) embedRaw(ctx context.Context, texts []string) ([][]float32, er } // resolveGGUFPath walks the precedence chain: -// 1. CIX_GGUF_PATH (already applied to cfg.GGUFPath before Validate). -// 2. bench/results/reference_gguf_path.txt dev fallback (Validate handles it). -// 3. Cached file under cfg.GGUFCacheDir//*.gguf. -// 4. HuggingFace download (this is the path that actually writes to disk). +// 1. CIX_GGUF_PATH (absolute path env override, validated by Stat). +// 2. cfg.EmbeddingModel as absolute path — when the dashboard's "Local +// path" mode wrote it through to the runtime_settings row. +// 3. Cached file under cfg.GGUFCacheDir//*.gguf when +// cfg.EmbeddingModel is an HF repo ID. +// 4. CIX_BOOTSTRAP_GGUF_PATH one-shot import — copies the file into +// the cache layout, then behaves like step 3 forever after. +// 5. HuggingFace download into the same cix cache (this is the path +// that actually writes to disk). // -// Only step 4 can be expensive; all others are stat-only. +// PR-E removed the implicit `bench/results/reference_gguf_path.txt` dev +// fallback that used to short-circuit step 2 — operators must now make +// the choice explicitly via env or the dashboard. Only step 5 is +// expensive; all others are stat-only or one-time copies. func resolveGGUFPath(ctx context.Context, cfg *config.Config, logger *slog.Logger) (string, error) { if cfg.GGUFPath != "" { if _, err := os.Stat(cfg.GGUFPath); err != nil { @@ -312,11 +434,19 @@ func resolveGGUFPath(ctx context.Context, cfg *config.Config, logger *slog.Logge } return cfg.GGUFPath, nil } - // The embedding model is an HF repo id like "awhiteside/CodeRankEmbed-Q8_0-GGUF". - // Only repo ids contain a slash; a raw filesystem path would have been - // captured by the CIX_GGUF_PATH branch above. + // PR-E — the dashboard's "Local path" mode writes an absolute path into + // embedding_model. Treat it as such instead of trying to interpret it + // as an HF repo id (which would fail the slash check or, worse, send + // the path to api.huggingface.co). + if filepath.IsAbs(cfg.EmbeddingModel) { + if _, err := os.Stat(cfg.EmbeddingModel); err != nil { + return "", fmt.Errorf("embedding model path %s: %w", cfg.EmbeddingModel, err) + } + return cfg.EmbeddingModel, nil + } + // HF repo ids look like "/" — exactly one slash, no leading "/". if !strings.Contains(cfg.EmbeddingModel, "/") { - return "", fmt.Errorf("embedding model %q is neither a path nor an HF repo id", cfg.EmbeddingModel) + return "", fmt.Errorf("embedding model %q is neither an absolute path nor an HF repo id (owner/repo)", cfg.EmbeddingModel) } // Cache-hit short-circuit: if we already downloaded a .gguf from this repo @@ -327,9 +457,102 @@ func resolveGGUFPath(ctx context.Context, cfg *config.Config, logger *slog.Logge return cached, nil } + // CIX_BOOTSTRAP_GGUF_PATH — one-time import path. Used so a fresh + // container with a freshly-mounted cache volume doesn't have to + // re-download a 280 MB GGUF the operator already has on disk. Once + // the file lands in the cache layout, the next boot satisfies the + // findCachedGGUF branch above and the bootstrap path is never read + // again (idempotent — repeated boots with the same env are no-ops). + if cfg.BootstrapGGUFPath != "" { + imported, err := importBootstrapGGUF(cfg.GGUFCacheDir, cfg.EmbeddingModel, cfg.BootstrapGGUFPath, logger) + if err != nil { + logger.Warn("bootstrap gguf import failed; falling through to HF download", + "src", cfg.BootstrapGGUFPath, "err", err) + } else if imported != "" { + return imported, nil + } + } + return DownloadGGUF(ctx, cfg.EmbeddingModel, cfg.GGUFCacheDir, logger) } +// importBootstrapGGUF copies srcPath into // +// atomically (write to .partial, fsync, rename). Returns the final path +// on success, "" if the source is missing (caller falls through to HF +// download), or an error for IO problems we should surface to the operator. +// +// safe_repo derived from the HF repo id (`owner/repo` → `owner__repo`) +// to match DownloadGGUF's layout exactly — so subsequent boots' cache +// scan finds the imported file under the same name HF would have used. +func importBootstrapGGUF(cacheDir, repo, srcPath string, logger *slog.Logger) (string, error) { + if cacheDir == "" || repo == "" { + return "", nil + } + srcInfo, err := os.Stat(srcPath) + if err != nil { + // Missing file is not a hard error — the operator may have set + // the env optimistically with a path that lives on a host they + // haven't mounted yet. Let the caller fall through to download. + if os.IsNotExist(err) { + return "", nil + } + return "", fmt.Errorf("stat bootstrap gguf %s: %w", srcPath, err) + } + if srcInfo.IsDir() { + return "", fmt.Errorf("bootstrap gguf %s is a directory, expected file", srcPath) + } + + safeRepo := strings.ReplaceAll(repo, "/", "__") + targetDir := filepath.Join(cacheDir, safeRepo) + if err := os.MkdirAll(targetDir, 0o755); err != nil { + return "", fmt.Errorf("mkdir cache dir: %w", err) + } + finalPath := filepath.Join(targetDir, filepath.Base(srcPath)) + + // Idempotency: if a previous boot already imported the same file, + // trust it — re-importing would be wasted IO and could race with a + // concurrent boot of a sibling container against a shared volume. + if _, err := os.Stat(finalPath); err == nil { + return finalPath, nil + } + + logger.Info("importing bootstrap gguf into cache", + "src", srcPath, "dst", finalPath, "size", srcInfo.Size()) + + src, err := os.Open(srcPath) + if err != nil { + return "", fmt.Errorf("open bootstrap gguf: %w", err) + } + defer src.Close() + + partial := finalPath + ".partial" + dst, err := os.OpenFile(partial, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644) + if err != nil { + return "", fmt.Errorf("create cache target: %w", err) + } + + if _, err := io.Copy(dst, src); err != nil { + _ = dst.Close() + _ = os.Remove(partial) + return "", fmt.Errorf("copy bootstrap gguf: %w", err) + } + if err := dst.Sync(); err != nil { + _ = dst.Close() + _ = os.Remove(partial) + return "", fmt.Errorf("fsync bootstrap gguf: %w", err) + } + if err := dst.Close(); err != nil { + _ = os.Remove(partial) + return "", fmt.Errorf("close bootstrap gguf: %w", err) + } + if err := os.Rename(partial, finalPath); err != nil { + _ = os.Remove(partial) + return "", fmt.Errorf("atomic rename bootstrap gguf: %w", err) + } + logger.Info("bootstrap gguf imported", "path", finalPath) + return finalPath, nil +} + // findCachedGGUF looks for a previously-downloaded .gguf under the standard // cache layout produced by DownloadGGUF. Returns "" on any miss (including // IO errors) so the caller proceeds to the download path. diff --git a/server/internal/embeddings/supervisor.go b/server/internal/embeddings/supervisor.go index 2f11c95..70b27e0 100644 --- a/server/internal/embeddings/supervisor.go +++ b/server/internal/embeddings/supervisor.go @@ -34,14 +34,20 @@ const restartWindow = 5 * time.Minute // talk to llama-server. It is populated by Service.New from *config.Config // so the supervisor does not import the config package directly. type supervisorConfig struct { - BinDir string // where llama-server + dylibs live - GGUFPath string // absolute path to the model file - SocketPath string // unix socket path (only used when Transport == "unix") - Transport string // "unix" or "tcp" - CtxSize int - NGpuLayers int - StartupSec int - TCPPort int // 0 = auto-pick, only relevant for tcp transport + BinDir string // where llama-server + dylibs live + GGUFPath string // absolute path to the model file + SocketPath string // unix socket path (only used when Transport == "unix") + Transport string // "unix" or "tcp" + CtxSize int + NGpuLayers int + NThreads int // 0 = let llama-server auto-detect via hardware_concurrency + BatchSize int // 0 = match CtxSize (preserves prior --ubatch-size behaviour) + StartupSec int + TCPPort int // 0 = auto-pick, only relevant for tcp transport + // Model is the human-readable identifier (HF repo id or absolute path) + // that the dashboard surfaces in the sidecar status card. The supervisor + // does not act on this field — it's recorded for observability only. + Model string } // supervisor owns the llama-server child process. It is responsible for: @@ -70,6 +76,11 @@ type supervisor struct { readySignal chan struct{} waiterDone chan struct{} // closed after the exit-watcher goroutine returns + + // lastSpawnErr is the most recent spawn() / readiness error, surfaced by + // Status() so the dashboard can render "Sidecar failed to start: ..." + // without grepping logs. Cleared on the next successful spawn. + lastSpawnErr atomic.Value // string } // newSupervisor validates the config, clamps the transport if needed, and @@ -178,6 +189,18 @@ func (s *supervisor) spawn(ctx context.Context) error { "--ubatch-size", strconv.Itoa(s.cfg.CtxSize), "--n-gpu-layers", strconv.Itoa(s.cfg.NGpuLayers), } + // PR-E — only pass --threads when the operator explicitly set one. With + // 0 we let llama-server pick via std::thread::hardware_concurrency, which + // is the saner default for unknown deployment shapes. + if s.cfg.NThreads > 0 { + argv = append(argv, "--threads", strconv.Itoa(s.cfg.NThreads)) + } + // PR-E — logical batch size override. Default keeps the prior --ubatch = + // ctx-size invariant intact. Passing a value <= ctx-size is safe; > + // ctx-size is rejected by llama-server itself. + if s.cfg.BatchSize > 0 { + argv = append(argv, "-b", strconv.Itoa(s.cfg.BatchSize)) + } switch s.cfg.Transport { case "unix": // Clear any stale socket file from a previous crashed run. @@ -244,11 +267,13 @@ func (s *supervisor) spawn(ctx context.Context) error { defer cancel() if err := s.waitReady(readyCtx); err != nil { s.logger.Error("llama-server readiness probe failed, killing child", "err", err) + s.lastSpawnErr.Store(err.Error()) s.killGroup() <-s.waiterDone return fmt.Errorf("%w: %v", ErrNotReady, err) } close(s.readySignal) + s.lastSpawnErr.Store("") // clear any stale error from a prior failed start s.logger.Info("llama-server ready", "elapsed", time.Since(s.startedAt).String()) return nil } @@ -441,6 +466,110 @@ func (s *supervisor) killGroup() { } } +// Restart tears the current child down and respawns with newCfg. The caller +// (Service.Restart) is responsible for draining the embedding queue first so +// in-flight HTTP calls don't fail mid-request. +// +// Restart fully resets state that the auto-restart-on-crash machinery may +// have left in place: the stopping flag is cleared so the new exit-watcher +// goroutine treats subsequent crashes as crashes (not as deliberate stops), +// the dead flag is cleared so Embed callers stop short-circuiting with +// ErrSupervisor, and restartAt is wiped so the operator's intentional cycle +// doesn't count against the 3-strikes-in-5-minutes budget. +// +// On spawn failure, dead is set: the operator's new config is broken and the +// supervisor needs another deliberate Restart (with corrected config) to +// recover. The caller surfaces this as a destructive toast in the UI. +func (s *supervisor) Restart(ctx context.Context, newCfg supervisorConfig) error { + // Stop the current child. Use a deadline carved from ctx so a stuck + // SIGTERM can't hold up the whole restart. + stopCtx, stopCancel := context.WithTimeout(ctx, 30*time.Second) + if err := s.Stop(stopCtx); err != nil { + stopCancel() + s.logger.Warn("supervisor: stop during restart returned error (continuing)", "err", err) + } else { + stopCancel() + } + + // Reset state. Stop has already drained the prior waiter via waiterDone. + s.mu.Lock() + s.cfg = newCfg + s.restartAt = nil + s.mu.Unlock() + s.dead.Store(false) + s.stopping.Store(false) + + // Re-validate: a different model path / transport may now be invalid. + if err := validateSupervisorConfig(&newCfg, s.logger); err != nil { + s.dead.Store(true) + s.lastSpawnErr.Store(err.Error()) + return fmt.Errorf("validate restart config: %w", err) + } + s.mu.Lock() + s.cfg = newCfg + // Same transport? Keep the existing client. A transport switch is not + // supported via Restart — config validates that field as immutable above + // (Transport is stamped from env at boot and can't be overridden via the + // dashboard runtime-config surface). + s.mu.Unlock() + + if err := s.spawn(ctx); err != nil { + s.dead.Store(true) + // spawn already stored a more granular error via lastSpawnErr; only + // set the umbrella one if it didn't. + if v, _ := s.lastSpawnErr.Load().(string); v == "" { + s.lastSpawnErr.Store(err.Error()) + } + return err + } + return nil +} + +// SupervisorStatus is the dashboard-facing view of the sidecar process. +// Returned by Service.Status and rendered in the SidecarSection card. Fields +// are deliberately scalar so the JSON body is stable across versions. +type SupervisorStatus struct { + State string // "running" | "failed" | "starting" | "disabled" + PID int // 0 when not started or already reaped + Uptime time.Duration + Model string + Ready bool + LastError string // last spawn / readiness error; "" when healthy + InFlight int // queue.InFlight() at the moment Status was sampled +} + +// Status returns a snapshot of the supervisor's current state. Safe to call +// concurrently with Restart and Embed*. +func (s *supervisor) Status() SupervisorStatus { + st := SupervisorStatus{Model: s.cfg.Model} + if v, _ := s.lastSpawnErr.Load().(string); v != "" { + st.LastError = v + } + if s.dead.Load() { + st.State = "failed" + return st + } + s.mu.RLock() + cmd := s.cmd + startedAt := s.startedAt + readyCh := s.readySignal + s.mu.RUnlock() + if cmd != nil && cmd.Process != nil { + st.PID = cmd.Process.Pid + } + if !startedAt.IsZero() { + st.Uptime = time.Since(startedAt) + } + select { + case <-readyCh: + st.Ready = true + st.State = "running" + default: + st.State = "starting" + } + return st +} + // Ready blocks until the current child is ready or ctx expires. func (s *supervisor) Ready(ctx context.Context) error { if s.dead.Load() { diff --git a/server/internal/httpapi/admin_server.go b/server/internal/httpapi/admin_server.go new file mode 100644 index 0000000..b579bc3 --- /dev/null +++ b/server/internal/httpapi/admin_server.go @@ -0,0 +1,355 @@ +// admin_server.go holds the PR-E "Server" admin handlers: runtime config, +// sidecar restart/status, GGUF cache enumeration. Auth: every handler routes +// through mustBeAdmin → 403 for non-admin sessions / API keys. +// +// Wire format: hand-written payload structs (not the openapi.gen ones) so +// we can stamp time.Time as RFC3339Nano and emit map[string]string for the +// per-field source label without fighting the generator's nullable handling. +package httpapi + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "os" + "path/filepath" + "strings" + "sync/atomic" + "time" + + "github.com/dvcdsys/code-index/server/internal/embeddings" + "github.com/dvcdsys/code-index/server/internal/runtimecfg" + + "github.com/google/uuid" +) + +// runtimeConfigPayload is the JSON shape of GET/PUT /admin/runtime-config. +// Matches openapi.RuntimeConfig but is hand-written so updated_at uses the +// project-wide RFC3339Nano stamp and source values stay raw strings (the +// generated enum type would force a layer of conversion at no benefit). +type runtimeConfigPayload struct { + EmbeddingModel string `json:"embedding_model"` + LlamaCtxSize int `json:"llama_ctx_size"` + LlamaNGpuLayers int `json:"llama_n_gpu_layers"` + LlamaNThreads int `json:"llama_n_threads"` + MaxEmbeddingConcurrency int `json:"max_embedding_concurrency"` + LlamaBatchSize int `json:"llama_batch_size"` + Source map[string]string `json:"source"` + Recommended *recommendedSnapshotPayload `json:"recommended,omitempty"` + UpdatedAt *string `json:"updated_at,omitempty"` + UpdatedBy *string `json:"updated_by,omitempty"` +} + +type recommendedSnapshotPayload struct { + EmbeddingModel string `json:"embedding_model"` + LlamaCtxSize int `json:"llama_ctx_size"` + LlamaNGpuLayers int `json:"llama_n_gpu_layers"` + LlamaNThreads int `json:"llama_n_threads"` + MaxEmbeddingConcurrency int `json:"max_embedding_concurrency"` + LlamaBatchSize int `json:"llama_batch_size"` +} + +func snapshotToPayload(snap runtimecfg.Snapshot, rec runtimecfg.Snapshot) runtimeConfigPayload { + out := runtimeConfigPayload{ + EmbeddingModel: snap.EmbeddingModel, + LlamaCtxSize: snap.LlamaCtxSize, + LlamaNGpuLayers: snap.LlamaNGpuLayers, + LlamaNThreads: snap.LlamaNThreads, + MaxEmbeddingConcurrency: snap.MaxEmbeddingConcurrency, + LlamaBatchSize: snap.LlamaBatchSize, + Source: snap.Source, + Recommended: &recommendedSnapshotPayload{ + EmbeddingModel: rec.EmbeddingModel, + LlamaCtxSize: rec.LlamaCtxSize, + LlamaNGpuLayers: rec.LlamaNGpuLayers, + LlamaNThreads: rec.LlamaNThreads, + MaxEmbeddingConcurrency: rec.MaxEmbeddingConcurrency, + LlamaBatchSize: rec.LlamaBatchSize, + }, + } + if !snap.UpdatedAt.IsZero() { + stamp := snap.UpdatedAt.UTC().Format(time.RFC3339Nano) + out.UpdatedAt = &stamp + } + if snap.UpdatedBy != "" { + v := snap.UpdatedBy + out.UpdatedBy = &v + } + return out +} + +// GetRuntimeConfig — GET /api/v1/admin/runtime-config (admin only). +func (s *Server) GetRuntimeConfig(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + if s.Deps.RuntimeCfg == nil { + writeError(w, http.StatusServiceUnavailable, "runtime config not available") + return + } + snap, err := s.Deps.RuntimeCfg.Get(r.Context()) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not load runtime config") + return + } + writeJSON(w, http.StatusOK, snapshotToPayload(snap, s.Deps.RuntimeCfg.Recommended())) +} + +// PutRuntimeConfig — PUT /api/v1/admin/runtime-config (admin only). +// +// The request body is a partial patch. Pointers tell us "this field was +// supplied"; the value tells us what to do with it (zero = clear override, +// non-zero = set override). nil pointers leave the existing override alone. +func (s *Server) PutRuntimeConfig(w http.ResponseWriter, r *http.Request) { + ac, ok := s.mustBeAdmin(w, r) + if !ok { + return + } + if s.Deps.RuntimeCfg == nil { + writeError(w, http.StatusServiceUnavailable, "runtime config not available") + return + } + + var body struct { + EmbeddingModel *string `json:"embedding_model"` + LlamaCtxSize *int `json:"llama_ctx_size"` + LlamaNGpuLayers *int `json:"llama_n_gpu_layers"` + LlamaNThreads *int `json:"llama_n_threads"` + MaxEmbeddingConcurrency *int `json:"max_embedding_concurrency"` + LlamaBatchSize *int `json:"llama_batch_size"` + } + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + + // Light validation: refuse obviously broken numeric values. Negative + // n_gpu_layers other than -1 is also broken (only -1 is the "all layers" + // sentinel), but we let it through and trust llama-server to error at + // spawn time — the supervisor surfaces that via SidecarStatus.last_error. + if body.LlamaCtxSize != nil && *body.LlamaCtxSize < 0 { + writeError(w, http.StatusUnprocessableEntity, "llama_ctx_size must be >= 0") + return + } + if body.LlamaNThreads != nil && *body.LlamaNThreads < 0 { + writeError(w, http.StatusUnprocessableEntity, "llama_n_threads must be >= 0") + return + } + if body.MaxEmbeddingConcurrency != nil && *body.MaxEmbeddingConcurrency < 0 { + writeError(w, http.StatusUnprocessableEntity, "max_embedding_concurrency must be >= 0") + return + } + if body.LlamaBatchSize != nil && *body.LlamaBatchSize < 0 { + writeError(w, http.StatusUnprocessableEntity, "llama_batch_size must be >= 0") + return + } + + patch := runtimecfg.Patch{ + EmbeddingModel: body.EmbeddingModel, + LlamaCtxSize: body.LlamaCtxSize, + LlamaNGpuLayers: body.LlamaNGpuLayers, + LlamaNThreads: body.LlamaNThreads, + MaxEmbeddingConcurrency: body.MaxEmbeddingConcurrency, + LlamaBatchSize: body.LlamaBatchSize, + } + updatedBy := "" + if ac != nil { + updatedBy = ac.User.Email + } + if err := s.Deps.RuntimeCfg.Set(r.Context(), patch, updatedBy); err != nil { + writeError(w, http.StatusInternalServerError, "could not save runtime config") + return + } + snap, err := s.Deps.RuntimeCfg.Get(r.Context()) + if err != nil { + writeError(w, http.StatusInternalServerError, "saved but could not reload runtime config") + return + } + writeJSON(w, http.StatusOK, snapshotToPayload(snap, s.Deps.RuntimeCfg.Recommended())) +} + +// --------------------------------------------------------------------------- +// Sidecar restart + status +// --------------------------------------------------------------------------- + +// restartTracker holds in-flight restart state for the sidecar. PR-E V1: a +// single global flag is enough — only one restart can run at a time anyway +// because Service.Restart drains then mutates singleton supervisor state. +// Future versions may key by restart_id when we surface progress. +var restartInFlight atomic.Bool + +// RestartSidecar — POST /api/v1/admin/sidecar/restart (admin only). +// +// Returns 202 immediately and runs the actual stop/spawn cycle on a goroutine +// so the HTTP request doesn't block for tens of seconds while the sidecar +// drains, terminates, and respawns. The dashboard polls GET /sidecar/status +// to observe the running → restarting → running transition. +func (s *Server) RestartSidecar(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + if s.Deps.EmbeddingSvc == nil { + writeError(w, http.StatusServiceUnavailable, "embeddings service not available") + return + } + embedSvc, ok := s.Deps.EmbeddingSvc.(*embeddings.Service) + if !ok { + writeError(w, http.StatusServiceUnavailable, "embeddings service does not support restart") + return + } + if s.Deps.RuntimeCfg == nil { + writeError(w, http.StatusServiceUnavailable, "runtime config not available") + return + } + + if !restartInFlight.CompareAndSwap(false, true) { + writeError(w, http.StatusConflict, "another restart is already in progress") + return + } + + id := uuid.NewString() + go func() { + defer restartInFlight.Store(false) + // Resolve the latest config snapshot and apply onto a fresh shallow + // copy of the env config so the supervisor sees the runtime overrides. + bg, cancel := context.WithTimeout(context.Background(), 90*time.Second) + defer cancel() + snap, err := s.Deps.RuntimeCfg.Get(bg) + if err != nil { + s.Deps.Logger.Error("sidecar restart: load runtime config", "err", err, "restart_id", id) + return + } + // We don't have a clean handle on the original *config.Config in + // admin_server.go; the embeddings.Service holds a pointer to the + // process-wide one and Restart mutates it in place. snapshot.ApplyTo + // rewrites the relevant fields on whatever cfg the embedSvc carries. + snap.ApplyTo(embedSvc.Config()) + if err := embedSvc.Restart(bg, embedSvc.Config()); err != nil { + s.Deps.Logger.Error("sidecar restart failed", "err", err, "restart_id", id) + return + } + s.Deps.Logger.Info("sidecar restart complete", "restart_id", id) + }() + + writeJSON(w, http.StatusAccepted, map[string]any{"restart_id": id}) +} + +// GetSidecarStatus — GET /api/v1/admin/sidecar/status (admin only). +func (s *Server) GetSidecarStatus(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + if s.Deps.EmbeddingSvc == nil { + writeJSON(w, http.StatusOK, map[string]any{ + "state": "disabled", + "ready": false, + "in_flight": 0, + }) + return + } + embedSvc, ok := s.Deps.EmbeddingSvc.(*embeddings.Service) + if !ok { + writeJSON(w, http.StatusOK, map[string]any{ + "state": "running", + "ready": true, + "in_flight": 0, + }) + return + } + st := embedSvc.Status() + + body := map[string]any{ + "state": st.State, + "ready": st.Ready, + "in_flight": st.InFlight, + "restart_in_flight": restartInFlight.Load(), + } + if st.PID > 0 { + body["pid"] = st.PID + } + if st.Uptime > 0 { + body["uptime_seconds"] = int(st.Uptime.Seconds()) + } + if st.Model != "" { + body["model"] = st.Model + } + if st.LastError != "" { + body["last_error"] = st.LastError + } + // Active restart wins over the snapshot's transient state — Status() may + // see a momentary "running" while the goroutine is still tearing down. + if restartInFlight.Load() { + body["state"] = "restarting" + } + writeJSON(w, http.StatusOK, body) +} + +// --------------------------------------------------------------------------- +// Cached GGUF model enumeration +// --------------------------------------------------------------------------- + +// ListModels — GET /api/v1/admin/models (admin only). +// +// Walks CIX_GGUF_CACHE_DIR//*.gguf (the layout DownloadGGUF uses) +// and returns one entry per .gguf file. Repo IDs are reconstructed from the +// directory name (we encode HF "owner/model" as "owner__model" to stay +// filesystem-safe). +func (s *Server) ListModels(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + cacheDir := embeddings.CacheDirFromService(s.Deps.EmbeddingSvc) + if cacheDir == "" { + // Service might be disabled / fake in tests — fall through to an + // empty list with no cache_dir (UI shows free-text fallback). + writeJSON(w, http.StatusOK, map[string]any{ + "models": []any{}, + "cache_dir": "", + }) + return + } + type entry struct { + ID string `json:"id"` + Path string `json:"path"` + SizeBytes int64 `json:"size_bytes"` + } + out := []entry{} + + repos, err := os.ReadDir(cacheDir) + if err != nil && !errors.Is(err, os.ErrNotExist) { + s.Deps.Logger.Warn("list models: read cache dir", "dir", cacheDir, "err", err) + } + for _, repo := range repos { + if !repo.IsDir() { + continue + } + repoDir := filepath.Join(cacheDir, repo.Name()) + files, err := os.ReadDir(repoDir) + if err != nil { + continue + } + for _, f := range files { + if f.IsDir() || !strings.EqualFold(filepath.Ext(f.Name()), ".gguf") { + continue + } + info, err := f.Info() + if err != nil { + continue + } + id := strings.Replace(repo.Name(), "__", "/", 1) + out = append(out, entry{ + ID: id, + Path: filepath.Join(repoDir, f.Name()), + SizeBytes: info.Size(), + }) + } + } + + writeJSON(w, http.StatusOK, map[string]any{ + "models": out, + "cache_dir": cacheDir, + }) +} diff --git a/server/internal/httpapi/admin_server_test.go b/server/internal/httpapi/admin_server_test.go new file mode 100644 index 0000000..b99c093 --- /dev/null +++ b/server/internal/httpapi/admin_server_test.go @@ -0,0 +1,274 @@ +package httpapi + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/dvcdsys/code-index/server/internal/apikeys" + "github.com/dvcdsys/code-index/server/internal/config" + apidb "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/runtimecfg" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" +) + +// adminFixture extends authTestFixture with a wired runtimecfg.Service so +// the admin handlers under test see a real DB-backed config layer. +type adminFixture struct { + *authTestFixture +} + +func newAdminFixture(t *testing.T) *adminFixture { + t.Helper() + database, err := apidb.Open(":memory:") + if err != nil { + t.Fatalf("open db: %v", err) + } + t.Cleanup(func() { _ = database.Close() }) + + usrSvc := users.New(database) + sessSvc := sessions.New(database) + akSvc := apikeys.New(database) + + admin, err := usrSvc.Create(context.Background(), "admin@example.com", "secret-password", users.RoleAdmin, false) + if err != nil { + t.Fatalf("seed admin: %v", err) + } + viewer, err := usrSvc.Create(context.Background(), "viewer@example.com", "secret-password", users.RoleViewer, false) + if err != nil { + t.Fatalf("seed viewer: %v", err) + } + _ = viewer + + envCfg := &config.Config{ + EmbeddingModel: "env/model", + LlamaCtxSize: 4096, + LlamaNGpuLayers: 8, + LlamaNThreads: 4, + MaxEmbeddingConcurrency: 2, + LlamaBatchSize: 1024, + GGUFCacheDir: t.TempDir(), + } + + deps := Deps{ + DB: database, + ServerVersion: "0.0.0-test", + APIVersion: "v1", + EmbeddingModel: envCfg.EmbeddingModel, + Users: usrSvc, + Sessions: sessSvc, + APIKeys: akSvc, + RuntimeCfg: runtimecfg.New(database, envCfg), + } + return &adminFixture{ + authTestFixture: &authTestFixture{ + Router: NewRouter(deps), + Deps: deps, + UserID: admin.ID, + FullKey: "", + }, + } +} + +func adminCookie(t *testing.T, f *adminFixture) string { + t.Helper() + rr := loginRR(t, f.Router, "admin@example.com", "secret-password") + if rr.Code != http.StatusOK { + t.Fatalf("admin login failed: %d (%s)", rr.Code, rr.Body.String()) + } + c := sessionCookie(rr) + if c == "" { + t.Fatal("admin session cookie missing") + } + return c +} + +func viewerCookie(t *testing.T, f *adminFixture) string { + t.Helper() + rr := loginRR(t, f.Router, "viewer@example.com", "secret-password") + if rr.Code != http.StatusOK { + t.Fatalf("viewer login failed: %d (%s)", rr.Code, rr.Body.String()) + } + c := sessionCookie(rr) + if c == "" { + t.Fatal("viewer session cookie missing") + } + return c +} + +// TestGetRuntimeConfig_AdminSeesEnvSources covers the "fresh install / no DB +// override" path — every field should be marked as sourced from env, and the +// recommended snapshot should round-trip. Pre-PUT. +func TestGetRuntimeConfig_AdminSeesEnvSources(t *testing.T) { + f := newAdminFixture(t) + cookie := adminCookie(t, f) + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/admin/runtime-config", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (%s)", rr.Code, rr.Body.String()) + } + var body struct { + EmbeddingModel string `json:"embedding_model"` + LlamaCtxSize int `json:"llama_ctx_size"` + Source map[string]string `json:"source"` + Recommended map[string]any `json:"recommended"` + UpdatedAt *string `json:"updated_at"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if body.EmbeddingModel != "env/model" { + t.Errorf("embedding_model = %q, want env/model", body.EmbeddingModel) + } + if body.LlamaCtxSize != 4096 { + t.Errorf("llama_ctx_size = %d, want 4096", body.LlamaCtxSize) + } + for _, f := range []string{"embedding_model", "llama_ctx_size", "llama_n_gpu_layers", "llama_n_threads"} { + if body.Source[f] != "env" { + t.Errorf("source[%s] = %q, want env", f, body.Source[f]) + } + } + if body.Recommended == nil { + t.Error("recommended block missing — UI relies on it for the 'Recommended' pill") + } + if body.UpdatedAt != nil { + t.Errorf("updated_at = %v, want nil before any PUT", body.UpdatedAt) + } +} + +// TestGetRuntimeConfig_ViewerForbidden — the runtime config surface is +// admin-only; a viewer session must get 403, not the data. +func TestGetRuntimeConfig_ViewerForbidden(t *testing.T) { + f := newAdminFixture(t) + cookie := viewerCookie(t, f) + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/admin/runtime-config", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + + if rr.Code != http.StatusForbidden { + t.Fatalf("status = %d, want 403 (body=%s)", rr.Code, rr.Body.String()) + } +} + +// TestPutRuntimeConfig_RoundTrip exercises the dashboard's primary flow: +// admin saves a couple of overrides, GET reflects them with source="db", +// untouched fields keep source="env". Then a clear (empty + zero) returns +// the fields to env-sourced. +func TestPutRuntimeConfig_RoundTrip(t *testing.T) { + f := newAdminFixture(t) + cookie := adminCookie(t, f) + + patch := map[string]any{ + "embedding_model": "db/model-v2", + "llama_ctx_size": 8192, + } + body, _ := json.Marshal(patch) + req := withCookie(httptest.NewRequest(http.MethodPut, "/api/v1/admin/runtime-config", bytes.NewReader(body)), cookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + + if rr.Code != http.StatusOK { + t.Fatalf("PUT status = %d (%s)", rr.Code, rr.Body.String()) + } + var got struct { + EmbeddingModel string `json:"embedding_model"` + LlamaCtxSize int `json:"llama_ctx_size"` + LlamaNThreads int `json:"llama_n_threads"` + Source map[string]string `json:"source"` + UpdatedBy *string `json:"updated_by"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil { + t.Fatalf("unmarshal PUT response: %v", err) + } + if got.EmbeddingModel != "db/model-v2" || got.Source["embedding_model"] != "db" { + t.Errorf("model not from DB after PUT: %+v src=%q", got.EmbeddingModel, got.Source["embedding_model"]) + } + if got.LlamaCtxSize != 8192 || got.Source["llama_ctx_size"] != "db" { + t.Errorf("ctx not from DB after PUT: %d src=%q", got.LlamaCtxSize, got.Source["llama_ctx_size"]) + } + if got.LlamaNThreads != 4 || got.Source["llama_n_threads"] != "env" { + t.Errorf("untouched threads field shifted source: val=%d src=%q", got.LlamaNThreads, got.Source["llama_n_threads"]) + } + if got.UpdatedBy == nil || *got.UpdatedBy != "admin@example.com" { + t.Errorf("updated_by = %v, want admin@example.com", got.UpdatedBy) + } + + // Clear the model override; ctx override should remain. + clearBody, _ := json.Marshal(map[string]any{"embedding_model": ""}) + req = withCookie(httptest.NewRequest(http.MethodPut, "/api/v1/admin/runtime-config", bytes.NewReader(clearBody)), cookie) + req.Header.Set("Content-Type", "application/json") + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("PUT clear status = %d (%s)", rr.Code, rr.Body.String()) + } + if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil { + t.Fatalf("unmarshal clear: %v", err) + } + if got.EmbeddingModel != "env/model" || got.Source["embedding_model"] != "env" { + t.Errorf("model didn't fall back to env after clear: %q src=%q", got.EmbeddingModel, got.Source["embedding_model"]) + } + if got.LlamaCtxSize != 8192 || got.Source["llama_ctx_size"] != "db" { + t.Errorf("ctx override lost during model clear: %d src=%q", got.LlamaCtxSize, got.Source["llama_ctx_size"]) + } +} + +// TestSidecarStatus_DisabledWhenNoEmbedSvc — when the server boots with +// embeddings disabled, the dashboard still gets a meaningful status payload +// (state="disabled") so it can render the bootstrap-only banner. +func TestSidecarStatus_DisabledWhenNoEmbedSvc(t *testing.T) { + f := newAdminFixture(t) + cookie := adminCookie(t, f) + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/admin/sidecar/status", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (%s)", rr.Code, rr.Body.String()) + } + var body map[string]any + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if body["state"] != "disabled" { + t.Errorf("state = %v, want 'disabled' when EmbeddingSvc is nil", body["state"]) + } +} + +// TestListModels_EmptyCache — fresh cache directory returns an empty list + +// the cache_dir so the UI can render the "no cached models, use a path" +// fallback without guessing. +func TestListModels_EmptyCache(t *testing.T) { + f := newAdminFixture(t) + cookie := adminCookie(t, f) + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/admin/models", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (%s)", rr.Code, rr.Body.String()) + } + var body struct { + Models []any `json:"models"` + CacheDir string `json:"cache_dir"` + } + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if len(body.Models) != 0 { + t.Errorf("models = %d, want 0 in fresh fixture", len(body.Models)) + } + // EmbeddingSvc is nil in the fixture, so CacheDirFromService returns "" + // regardless of envCfg.GGUFCacheDir. That's fine — UI treats it as + // "no scan possible" and falls back to free-text input. + if body.CacheDir != "" { + t.Errorf("cache_dir = %q, want empty when EmbeddingSvc is nil", body.CacheDir) + } +} diff --git a/server/internal/httpapi/auth.go b/server/internal/httpapi/auth.go new file mode 100644 index 0000000..8ee8314 --- /dev/null +++ b/server/internal/httpapi/auth.go @@ -0,0 +1,604 @@ +package httpapi + +import ( + "encoding/json" + "errors" + "net/http" + "strings" + "time" + + "github.com/dvcdsys/code-index/server/internal/apikeys" + "github.com/dvcdsys/code-index/server/internal/httpapi/openapi" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" +) + +// userPayload mirrors the OpenAPI `User` schema. Built by hand instead of +// using the generated openapi.User to keep date formatting under our +// control (RFC3339Nano UTC) — keeps wire output stable across Go versions. +type userPayload struct { + ID string `json:"id"` + Email string `json:"email"` + Role string `json:"role"` + MustChangePassword bool `json:"must_change_password"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` + Disabled bool `json:"disabled"` + DisabledAt *string `json:"disabled_at"` +} + +func userToPayload(u users.User) userPayload { + p := userPayload{ + ID: u.ID, + Email: u.Email, + Role: u.Role, + MustChangePassword: u.MustChangePassword, + CreatedAt: u.CreatedAt.UTC().Format(time.RFC3339Nano), + UpdatedAt: u.UpdatedAt.UTC().Format(time.RFC3339Nano), + Disabled: u.DisabledAt != nil, + } + if u.DisabledAt != nil { + s := u.DisabledAt.UTC().Format(time.RFC3339Nano) + p.DisabledAt = &s + } + return p +} + +// userWithStatsPayload mirrors the OpenAPI `UserWithStats` schema. Returned +// only by the admin /users list endpoint — keeps the per-request /auth/me +// shape free of N+1 aggregate columns. +type userWithStatsPayload struct { + userPayload + LastLoginAt *string `json:"last_login_at"` + ActiveSessionsCount int `json:"active_sessions_count"` + APIKeysCount int `json:"api_keys_count"` +} + +func userWithStatsToPayload(u users.UserWithStats) userWithStatsPayload { + p := userWithStatsPayload{ + userPayload: userToPayload(u.User), + ActiveSessionsCount: u.ActiveSessionsCount, + APIKeysCount: u.APIKeysCount, + } + if u.LastLoginAt != nil { + s := u.LastLoginAt.UTC().Format(time.RFC3339Nano) + p.LastLoginAt = &s + } + return p +} + +type sessionPayload struct { + ID string `json:"id"` + CreatedAt string `json:"created_at"` + ExpiresAt string `json:"expires_at"` + LastSeenAt string `json:"last_seen_at"` + LastSeenIP *string `json:"last_seen_ip"` + LastSeenUA *string `json:"last_seen_ua"` + IsCurrent bool `json:"is_current"` +} + +func sessionToPayload(s sessions.Session, currentID string) sessionPayload { + p := sessionPayload{ + ID: s.ID, + CreatedAt: s.CreatedAt.UTC().Format(time.RFC3339Nano), + ExpiresAt: s.ExpiresAt.UTC().Format(time.RFC3339Nano), + LastSeenAt: s.LastSeenAt.UTC().Format(time.RFC3339Nano), + IsCurrent: s.ID == currentID, + } + if s.LastSeenIP != "" { + p.LastSeenIP = &s.LastSeenIP + } + if s.LastSeenUA != "" { + p.LastSeenUA = &s.LastSeenUA + } + return p +} + +type apiKeyPayload struct { + ID string `json:"id"` + OwnerUserID string `json:"owner_user_id"` + Name string `json:"name"` + Prefix string `json:"prefix"` + CreatedAt string `json:"created_at"` + LastUsedAt *string `json:"last_used_at"` + LastUsedIP *string `json:"last_used_ip"` + LastUsedUA *string `json:"last_used_ua"` + Revoked bool `json:"revoked"` + RevokedAt *string `json:"revoked_at"` +} + +func apiKeyToPayload(k apikeys.ApiKey) apiKeyPayload { + p := apiKeyPayload{ + ID: k.ID, + OwnerUserID: k.OwnerUserID, + Name: k.Name, + Prefix: k.Prefix, + CreatedAt: k.CreatedAt.UTC().Format(time.RFC3339Nano), + Revoked: k.RevokedAt != nil, + } + if k.LastUsedAt != nil { + s := k.LastUsedAt.UTC().Format(time.RFC3339Nano) + p.LastUsedAt = &s + } + if k.LastUsedIP != "" { + p.LastUsedIP = &k.LastUsedIP + } + if k.LastUsedUA != "" { + p.LastUsedUA = &k.LastUsedUA + } + if k.RevokedAt != nil { + s := k.RevokedAt.UTC().Format(time.RFC3339Nano) + p.RevokedAt = &s + } + return p +} + +// --------------------------------------------------------------------------- +// Auth endpoints +// --------------------------------------------------------------------------- + +// GetBootstrapStatus — GET /api/v1/auth/bootstrap-status (public). +func (s *Server) GetBootstrapStatus(w http.ResponseWriter, r *http.Request) { + if s.Deps.Users == nil { + writeJSON(w, http.StatusOK, map[string]any{"needs_bootstrap": false}) + return + } + n, err := s.Deps.Users.Count(r.Context()) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not check bootstrap status") + return + } + writeJSON(w, http.StatusOK, map[string]any{"needs_bootstrap": n == 0}) +} + +// Login — POST /api/v1/auth/login (public). +func (s *Server) Login(w http.ResponseWriter, r *http.Request) { + if s.Deps.Users == nil || s.Deps.Sessions == nil { + writeError(w, http.StatusServiceUnavailable, "auth not configured") + return + } + var body struct { + Email string `json:"email"` + Password string `json:"password"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + body.Email = strings.TrimSpace(body.Email) + if body.Email == "" || body.Password == "" { + writeError(w, http.StatusUnprocessableEntity, "email and password are required") + return + } + ip := clientIP(r) + if s.loginLimiter != nil { + if ok, retry := s.loginLimiter.allow(ip, body.Email); !ok { + writeRateLimited(w, retry) + return + } + } + u, err := s.Deps.Users.Authenticate(r.Context(), body.Email, body.Password) + if err != nil { + switch { + case errors.Is(err, users.ErrInvalidLogin): + writeError(w, http.StatusUnauthorized, "Invalid email or password") + case errors.Is(err, users.ErrUserDisabled): + writeError(w, http.StatusUnauthorized, "Account is disabled") + default: + writeError(w, http.StatusInternalServerError, "login failed") + } + return + } + created, err := s.Deps.Sessions.Create(r.Context(), u.ID, ip, r.UserAgent()) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not create session") + return + } + if s.loginLimiter != nil { + s.loginLimiter.reset(ip, body.Email) + } + // The cookie carries the raw token; only sha256(token) is in the DB. + setSessionCookie(w, r, created.RawToken, created.Session.ExpiresAt) + writeJSON(w, http.StatusOK, map[string]any{"user": userToPayload(u)}) +} + +// Logout — POST /api/v1/auth/logout. +func (s *Server) Logout(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + if ac.Method == "session" && ac.Session != nil && s.Deps.Sessions != nil { + _ = s.Deps.Sessions.Delete(r.Context(), ac.Session.ID) + clearSessionCookie(w, r) + } + w.WriteHeader(http.StatusNoContent) +} + +// GetMe — GET /api/v1/auth/me. +func (s *Server) GetMe(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + writeJSON(w, http.StatusOK, map[string]any{ + "user": userToPayload(ac.User), + "auth_method": ac.Method, + }) +} + +// ChangePassword — POST /api/v1/auth/change-password. +// +// Verifies the current password, updates to the new one, and revokes +// every other session of the user (the cookie carrying THIS request is +// preserved so the user stays logged in on the current device). +func (s *Server) ChangePassword(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + var body struct { + CurrentPassword string `json:"current_password"` + NewPassword string `json:"new_password"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + if body.NewPassword == "" || len(body.NewPassword) < 8 { + writeError(w, http.StatusUnprocessableEntity, "new password must be at least 8 characters") + return + } + // Re-authenticate with the current password to prove possession. + if _, err := s.Deps.Users.Authenticate(r.Context(), ac.User.Email, body.CurrentPassword); err != nil { + writeError(w, http.StatusUnauthorized, "current password is incorrect") + return + } + if err := s.Deps.Users.UpdatePassword(r.Context(), ac.User.ID, body.NewPassword); err != nil { + writeError(w, http.StatusInternalServerError, "could not update password") + return + } + // Revoke every OTHER session — the current one stays. Best-effort: + // failure here is non-fatal (the new password is already set). + if ac.Session != nil { + _ = s.Deps.Sessions.DeleteAllForUserExcept(r.Context(), ac.User.ID, ac.Session.ID) + } + w.WriteHeader(http.StatusNoContent) +} + +// ListMySessions — GET /api/v1/auth/sessions. +func (s *Server) ListMySessions(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + list, err := s.Deps.Sessions.ListForUser(r.Context(), ac.User.ID) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not list sessions") + return + } + currentID := "" + if ac.Session != nil { + currentID = ac.Session.ID + } + out := make([]sessionPayload, 0, len(list)) + for _, s := range list { + out = append(out, sessionToPayload(s, currentID)) + } + writeJSON(w, http.StatusOK, map[string]any{ + "sessions": out, + "total": len(out), + }) +} + +// DeleteMySession — DELETE /api/v1/auth/sessions/{id}. +func (s *Server) DeleteMySession(w http.ResponseWriter, r *http.Request, id string) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + // Confirm the session belongs to the caller — otherwise pretend it + // doesn't exist (404) so a user cannot enumerate other people's + // session ids. + list, err := s.Deps.Sessions.ListForUser(r.Context(), ac.User.ID) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not list sessions") + return + } + owns := false + for _, s := range list { + if s.ID == id { + owns = true + break + } + } + if !owns { + writeError(w, http.StatusNotFound, "session not found") + return + } + _ = s.Deps.Sessions.Delete(r.Context(), id) + if ac.Session != nil && ac.Session.ID == id { + clearSessionCookie(w, r) + } + w.WriteHeader(http.StatusNoContent) +} + +// --------------------------------------------------------------------------- +// Admin user endpoints +// --------------------------------------------------------------------------- + +// mustBeAdmin enforces the admin role on a handler. Returns the auth +// context on success; on failure writes the error response and returns +// (nil, false) so the caller can `if _, ok := s.s.mustBeAdmin(w, r); !ok { return }`. +// +// CIX_AUTH_DISABLED dev mode short-circuits both checks: when the operator +// turned auth off entirely, "admin-only" loses meaning and every endpoint +// behaves as if the caller is admin. Production deployments leave the +// flag off; the requireAuth middleware then guarantees a context exists. +func (s *Server) mustBeAdmin(w http.ResponseWriter, r *http.Request) (*authContext, bool) { + if s.Deps.AuthDisabled { + return nil, true + } + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return nil, false + } + if ac.User.Role != users.RoleAdmin { + writeError(w, http.StatusForbidden, "This action requires role: admin") + return nil, false + } + return ac, true +} + +// ListUsers — GET /api/v1/admin/users (admin only). +func (s *Server) ListUsers(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + list, err := s.Deps.Users.ListWithStats(r.Context()) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not list users") + return + } + out := make([]userWithStatsPayload, 0, len(list)) + for _, u := range list { + out = append(out, userWithStatsToPayload(u)) + } + writeJSON(w, http.StatusOK, map[string]any{ + "users": out, + "total": len(out), + }) +} + +// CreateUser — POST /api/v1/admin/users (admin only). +func (s *Server) CreateUser(w http.ResponseWriter, r *http.Request) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + var body struct { + Email string `json:"email"` + InitialPassword string `json:"initial_password"` + Role string `json:"role"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + body.Email = strings.TrimSpace(body.Email) + if body.Email == "" || len(body.InitialPassword) < 8 { + writeError(w, http.StatusUnprocessableEntity, "email and initial_password (>= 8 chars) are required") + return + } + u, err := s.Deps.Users.Create(r.Context(), body.Email, body.InitialPassword, body.Role, true) + if err != nil { + switch { + case errors.Is(err, users.ErrEmailTaken): + writeError(w, http.StatusConflict, "email already in use") + case errors.Is(err, users.ErrInvalidRole): + writeError(w, http.StatusUnprocessableEntity, "role must be 'admin' or 'viewer'") + default: + writeError(w, http.StatusInternalServerError, "could not create user") + } + return + } + writeJSON(w, http.StatusCreated, userToPayload(u)) +} + +// UpdateUser — PATCH /api/v1/admin/users/{id} (admin only). +func (s *Server) UpdateUser(w http.ResponseWriter, r *http.Request, id string) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + var body struct { + Role *string `json:"role"` + Disabled *bool `json:"disabled"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + if body.Role != nil { + if err := s.Deps.Users.SetRole(r.Context(), id, *body.Role); err != nil { + respondUserMutationError(w, err) + return + } + } + if body.Disabled != nil { + if err := s.Deps.Users.SetDisabled(r.Context(), id, *body.Disabled); err != nil { + respondUserMutationError(w, err) + return + } + } + u, err := s.Deps.Users.GetByID(r.Context(), id) + if err != nil { + respondUserMutationError(w, err) + return + } + writeJSON(w, http.StatusOK, userToPayload(u)) +} + +// DeleteUser — DELETE /api/v1/admin/users/{id} (admin only). +func (s *Server) DeleteUser(w http.ResponseWriter, r *http.Request, id string) { + if _, ok := s.mustBeAdmin(w, r); !ok { + return + } + if err := s.Deps.Users.Delete(r.Context(), id); err != nil { + respondUserMutationError(w, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func respondUserMutationError(w http.ResponseWriter, err error) { + switch { + case errors.Is(err, users.ErrNotFound): + writeError(w, http.StatusNotFound, "user not found") + case errors.Is(err, users.ErrInvalidRole): + writeError(w, http.StatusUnprocessableEntity, "role must be 'admin' or 'viewer'") + case errors.Is(err, users.ErrLastAdminBlock): + writeError(w, http.StatusForbidden, "cannot remove the last enabled admin") + default: + writeError(w, http.StatusInternalServerError, "user update failed") + } +} + +// --------------------------------------------------------------------------- +// API key endpoints +// --------------------------------------------------------------------------- + +// ListApiKeys — GET /api/v1/api-keys. +func (s *Server) ListApiKeys(w http.ResponseWriter, r *http.Request, params openapi.ListApiKeysParams) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + wantAll := params.Owner != nil && *params.Owner == "all" + if wantAll { + if ac.User.Role != users.RoleAdmin { + writeError(w, http.StatusForbidden, "owner=all is admin-only") + return + } + } + var ( + list []apikeys.ApiKey + err error + ) + if wantAll { + list, err = s.Deps.APIKeys.ListAll(r.Context()) + } else { + list, err = s.Deps.APIKeys.ListForOwner(r.Context(), ac.User.ID) + } + if err != nil { + writeError(w, http.StatusInternalServerError, "could not list api keys") + return + } + out := make([]apiKeyPayload, 0, len(list)) + for _, k := range list { + out = append(out, apiKeyToPayload(k)) + } + writeJSON(w, http.StatusOK, map[string]any{ + "api_keys": out, + "total": len(out), + }) +} + +// CreateApiKey — POST /api/v1/api-keys. +func (s *Server) CreateApiKey(w http.ResponseWriter, r *http.Request) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + var body struct { + Name string `json:"name"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusUnprocessableEntity, "invalid JSON body") + return + } + body.Name = strings.TrimSpace(body.Name) + if body.Name == "" { + writeError(w, http.StatusUnprocessableEntity, "name is required") + return + } + full, ak, err := s.Deps.APIKeys.Generate(r.Context(), ac.User.ID, body.Name) + if err != nil { + writeError(w, http.StatusInternalServerError, "could not create api key") + return + } + writeJSON(w, http.StatusCreated, map[string]any{ + "api_key": apiKeyToPayload(ak), + "full_key": full, + }) +} + +// RevokeApiKey — DELETE /api/v1/api-keys/{id}. +func (s *Server) RevokeApiKey(w http.ResponseWriter, r *http.Request, id string) { + ac, ok := authFromCtx(r.Context()) + if !ok { + writeError(w, http.StatusUnauthorized, "Authentication required") + return + } + ak, err := s.Deps.APIKeys.GetByID(r.Context(), id) + if err != nil { + if errors.Is(err, apikeys.ErrNotFound) { + writeError(w, http.StatusNotFound, "api key not found") + return + } + writeError(w, http.StatusInternalServerError, "could not look up api key") + return + } + if ak.OwnerUserID != ac.User.ID && ac.User.Role != users.RoleAdmin { + // Hide existence from non-owners — same response as "not found". + writeError(w, http.StatusNotFound, "api key not found") + return + } + if err := s.Deps.APIKeys.Revoke(r.Context(), id); err != nil { + if errors.Is(err, apikeys.ErrAlreadyRevoked) { + w.WriteHeader(http.StatusNoContent) + return + } + writeError(w, http.StatusInternalServerError, "could not revoke api key") + return + } + w.WriteHeader(http.StatusNoContent) +} + +// --------------------------------------------------------------------------- +// Cookie helpers +// --------------------------------------------------------------------------- + +// setSessionCookie writes the cix_session cookie. Secure flag is set +// when the request arrived via TLS — in dev (plain HTTP localhost) the +// flag is omitted so the browser actually stores it. +func setSessionCookie(w http.ResponseWriter, r *http.Request, id string, expiresAt time.Time) { + http.SetCookie(w, &http.Cookie{ + Name: sessions.CookieName, + Value: id, + Path: "/", + Expires: expiresAt, + HttpOnly: true, + SameSite: http.SameSiteStrictMode, + Secure: r.TLS != nil, + }) +} + +func clearSessionCookie(w http.ResponseWriter, r *http.Request) { + http.SetCookie(w, &http.Cookie{ + Name: sessions.CookieName, + Value: "", + Path: "/", + MaxAge: -1, + HttpOnly: true, + SameSite: http.SameSiteStrictMode, + Secure: r.TLS != nil, + }) +} + diff --git a/server/internal/httpapi/auth_test.go b/server/internal/httpapi/auth_test.go new file mode 100644 index 0000000..5162e95 --- /dev/null +++ b/server/internal/httpapi/auth_test.go @@ -0,0 +1,602 @@ +package httpapi + +import ( + "bytes" + "context" + "database/sql" + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/dvcdsys/code-index/server/internal/apikeys" + apidb "github.com/dvcdsys/code-index/server/internal/db" + "github.com/dvcdsys/code-index/server/internal/sessions" + "github.com/dvcdsys/code-index/server/internal/users" +) + +// dbOpenMemory + seedless* are tiny shims for tests that need wired +// services against an empty database (no admin seeded). +func dbOpenMemory(t *testing.T) (*sql.DB, error) { + d, err := apidb.Open(":memory:") + if err == nil { + t.Cleanup(func() { _ = d.Close() }) + } + return d, err +} +func seedlessUsers(d *sql.DB) *users.Service { return users.New(d) } +func seedlessSessions(d *sql.DB) *sessions.Service { return sessions.New(d) } +func seedlessAPIKeys(d *sql.DB) *apikeys.Service { return apikeys.New(d) } + +// loginRR runs POST /api/v1/auth/login against router and returns the +// response recorder. Centralised because every auth-flow test starts the +// same way. +func loginRR(t *testing.T, router http.Handler, email, password string) *httptest.ResponseRecorder { + t.Helper() + body, _ := json.Marshal(map[string]string{"email": email, "password": password}) + req := httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + router.ServeHTTP(rr, req) + return rr +} + +func sessionCookie(rr *httptest.ResponseRecorder) string { + for _, c := range rr.Result().Cookies() { + if c.Name == sessions.CookieName { + return c.Value + } + } + return "" +} + +// withCookie adds a session cookie to req for tests that simulate a +// logged-in browser. +func withCookie(req *http.Request, cookieValue string) *http.Request { + req.AddCookie(&http.Cookie{Name: sessions.CookieName, Value: cookieValue}) + return req +} + +func TestLogin_HappyPath(t *testing.T) { + f := newAuthFixture(t) + rr := loginRR(t, f.Router, "admin@example.com", "secret-password") + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (body=%s)", rr.Code, rr.Body.String()) + } + if sessionCookie(rr) == "" { + t.Errorf("Set-Cookie missing %s", sessions.CookieName) + } + var body struct { + User struct { + ID string + Email string + } + } + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if body.User.Email != "admin@example.com" { + t.Errorf("user.email = %q", body.User.Email) + } +} + +func TestLogin_WrongPassword(t *testing.T) { + f := newAuthFixture(t) + rr := loginRR(t, f.Router, "admin@example.com", "WRONG") + if rr.Code != http.StatusUnauthorized { + t.Fatalf("status = %d, want 401", rr.Code) + } +} + +// TestLogin_RateLimit_BlocksAfterRepeatedFailures fires N+1 wrong-password +// attempts at the live router and expects the (N+1)th to be 429 with a +// Retry-After header. The fixture's loginLimiter starts with the default +// policy (5/15min per email); the test follows that contract. +func TestLogin_RateLimit_BlocksAfterRepeatedFailures(t *testing.T) { + f := newAuthFixture(t) + for i := range 5 { + rr := loginRR(t, f.Router, "admin@example.com", "WRONG") + if rr.Code != http.StatusUnauthorized { + t.Fatalf("attempt %d: status = %d, want 401", i+1, rr.Code) + } + } + rr := loginRR(t, f.Router, "admin@example.com", "WRONG") + if rr.Code != http.StatusTooManyRequests { + t.Fatalf("6th attempt status = %d, want 429 (body=%s)", rr.Code, rr.Body.String()) + } + if ra := rr.Result().Header.Get("Retry-After"); ra == "" { + t.Errorf("Retry-After header missing on 429") + } + // Even a CORRECT password is now blocked — the limiter checks before + // authenticating, which is what we want for credential-stuffing + // resistance. + rr = loginRR(t, f.Router, "admin@example.com", "secret-password") + if rr.Code != http.StatusTooManyRequests { + t.Errorf("correct password while rate-limited status = %d, want 429", rr.Code) + } +} + +// TestLogin_RateLimit_ResetOnSuccess verifies that a user who fat-fingers +// their password a few times then logs in correctly does not stay locked +// out — the per-(IP, email) counter clears on a successful authentication. +func TestLogin_RateLimit_ResetOnSuccess(t *testing.T) { + f := newAuthFixture(t) + for i := range 4 { + rr := loginRR(t, f.Router, "admin@example.com", "WRONG") + if rr.Code != http.StatusUnauthorized { + t.Fatalf("warmup attempt %d: status = %d", i+1, rr.Code) + } + } + rr := loginRR(t, f.Router, "admin@example.com", "secret-password") + if rr.Code != http.StatusOK { + t.Fatalf("correct password status = %d, want 200", rr.Code) + } + // Counter is now reset; we should be able to fail again 4 more times + // before the next 429 (without the reset, we would hit 5 immediately). + for i := range 4 { + rr := loginRR(t, f.Router, "admin@example.com", "WRONG") + if rr.Code != http.StatusUnauthorized { + t.Fatalf("post-reset attempt %d: status = %d, want 401", i+1, rr.Code) + } + } +} + +func TestLogin_MissingFields(t *testing.T) { + f := newAuthFixture(t) + rr := loginRR(t, f.Router, "", "") + if rr.Code != http.StatusUnprocessableEntity { + t.Fatalf("status = %d, want 422", rr.Code) + } +} + +func TestMe_WithSession(t *testing.T) { + f := newAuthFixture(t) + login := loginRR(t, f.Router, "admin@example.com", "secret-password") + cookie := sessionCookie(login) + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d", rr.Code) + } + var body struct { + User map[string]any `json:"user"` + AuthMethod string `json:"auth_method"` + } + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if body.AuthMethod != "session" { + t.Errorf("auth_method = %q, want 'session'", body.AuthMethod) + } +} + +func TestMe_WithBearer(t *testing.T) { + f := newAuthFixture(t) + req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil) + req.Header.Set("Authorization", "Bearer "+f.FullKey) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (body=%s)", rr.Code, rr.Body.String()) + } + var body struct { + AuthMethod string `json:"auth_method"` + } + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if body.AuthMethod != "api_key" { + t.Errorf("auth_method = %q, want 'api_key'", body.AuthMethod) + } +} + +func TestLogout_DropsSession(t *testing.T) { + f := newAuthFixture(t) + login := loginRR(t, f.Router, "admin@example.com", "secret-password") + cookie := sessionCookie(login) + + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/auth/logout", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusNoContent { + t.Fatalf("status = %d", rr.Code) + } + // Subsequent /me with the same cookie must 401. + req = withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil), cookie) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusUnauthorized { + t.Errorf("/me after logout status = %d, want 401", rr.Code) + } +} + +func TestChangePassword_RotatesOtherSessions(t *testing.T) { + f := newAuthFixture(t) + // Two parallel logins (two different "browsers"). + cookieA := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + cookieB := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + body, _ := json.Marshal(map[string]string{ + "current_password": "secret-password", + "new_password": "an-even-better-password", + }) + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/auth/change-password", bytes.NewReader(body)), cookieA) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusNoContent { + t.Fatalf("change-password status = %d (body=%s)", rr.Code, rr.Body.String()) + } + + // Cookie A still works. + req = withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil), cookieA) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Errorf("cookie A status = %d, want 200 (current session preserved)", rr.Code) + } + + // Cookie B must now 401. + req = withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil), cookieB) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusUnauthorized { + t.Errorf("cookie B status = %d, want 401 (other sessions revoked)", rr.Code) + } + + // New password authenticates. + rr = loginRR(t, f.Router, "admin@example.com", "an-even-better-password") + if rr.Code != http.StatusOK { + t.Errorf("login with new password status = %d", rr.Code) + } +} + +func TestBootstrapStatus_True(t *testing.T) { + // Wire services against an empty users table (no Create call) — this + // is the same shape as a brand-new deployment. + database, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + router := NewRouter(Deps{ + DB: database, + Users: seedlessUsers(database), + Sessions: seedlessSessions(database), + APIKeys: seedlessAPIKeys(database), + ServerVersion: "0.0.0-test", + AuthDisabled: true, // skip the auth gate so we can hit the public endpoint without setup + }) + req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/bootstrap-status", nil) + rr := httptest.NewRecorder() + router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d", rr.Code) + } + if !strings.Contains(rr.Body.String(), `"needs_bootstrap":true`) { + t.Errorf("body = %s, want needs_bootstrap:true", rr.Body.String()) + } +} + +func TestBootstrapStatus_False(t *testing.T) { + f := newAuthFixture(t) // seeds an admin + req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/bootstrap-status", nil) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d", rr.Code) + } + if !strings.Contains(rr.Body.String(), `"needs_bootstrap":false`) { + t.Errorf("body = %s, want needs_bootstrap:false", rr.Body.String()) + } +} + +// --- Admin user CRUD via HTTP --- + +func TestCreateUser_AdminOnly(t *testing.T) { + f := newAuthFixture(t) + cookie := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + body, _ := json.Marshal(map[string]string{ + "email": "viewer@example.com", "initial_password": "viewerpass1", "role": "viewer", + }) + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/admin/users", bytes.NewReader(body)), cookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("admin POST status = %d (body=%s)", rr.Code, rr.Body.String()) + } + + // Now try the same request as the viewer — expect 403. + viewerCookie := sessionCookie(loginRR(t, f.Router, "viewer@example.com", "viewerpass1")) + body, _ = json.Marshal(map[string]string{ + "email": "another@example.com", "initial_password": "anotherpass1", "role": "viewer", + }) + req = withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/admin/users", bytes.NewReader(body)), viewerCookie) + req.Header.Set("Content-Type", "application/json") + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusForbidden { + t.Errorf("viewer POST status = %d, want 403", rr.Code) + } +} + +// --- API key CRUD via HTTP --- + +func TestApiKey_CreateListRevokeFlow(t *testing.T) { + f := newAuthFixture(t) + cookie := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + body, _ := json.Marshal(map[string]string{"name": "ci-bot"}) + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/api-keys", bytes.NewReader(body)), cookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("create key status = %d (body=%s)", rr.Code, rr.Body.String()) + } + var created struct { + FullKey string `json:"full_key"` + ApiKey struct{ ID string } `json:"api_key"` + } + _ = json.Unmarshal(rr.Body.Bytes(), &created) + if created.FullKey == "" { + t.Fatalf("create key did not return full_key") + } + + // Use the key — must auth. + req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil) + req.Header.Set("Authorization", "Bearer "+created.FullKey) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("Bearer with new key status = %d", rr.Code) + } + + // Revoke. + req = withCookie(httptest.NewRequest(http.MethodDelete, "/api/v1/api-keys/"+created.ApiKey.ID, nil), cookie) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusNoContent { + t.Fatalf("revoke status = %d", rr.Code) + } + + // Same key now 401. + req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil) + req.Header.Set("Authorization", "Bearer "+created.FullKey) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusUnauthorized { + t.Errorf("revoked key status = %d, want 401", rr.Code) + } +} + +func TestApiKey_ListForOwnerHidesOthers(t *testing.T) { + f := newAuthFixture(t) + // Seed a viewer + their own key directly via the underlying services. + v, err := f.Deps.Users.Create(context.Background(), "v@b.com", "viewerpass1", users.RoleViewer, false) + if err != nil { + t.Fatalf("seed viewer: %v", err) + } + if _, _, err := f.Deps.APIKeys.Generate(context.Background(), v.ID, "viewer-only-key"); err != nil { + t.Fatalf("seed viewer key: %v", err) + } + + // Login as viewer — list must contain only their key, not the + // admin's seed key. + cookie := sessionCookie(loginRR(t, f.Router, "v@b.com", "viewerpass1")) + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/api-keys", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d", rr.Code) + } + var body struct { + Total int `json:"total"` + } + _ = json.Unmarshal(rr.Body.Bytes(), &body) + if body.Total != 1 { + t.Errorf("viewer sees total = %d, want 1 (own key only)", body.Total) + } +} + +// TestProjectMutations_AdminOnly verifies that PATCH and DELETE on a +// project are gated behind the admin role. POST /index/cancel is +// intentionally NOT gated — see comment on IndexCancel for why — and is +// covered separately by TestIndexCancel_AnyAuthenticatedUser. +func TestProjectMutations_AdminOnly(t *testing.T) { + f := newAuthFixture(t) + adminCookie := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + // Admin creates a project to act on. CreateProject is intentionally + // not admin-only — viewers can register their own projects. + createBody, _ := json.Marshal(map[string]string{"host_path": "/tmp/test-proj"}) + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/projects", bytes.NewReader(createBody)), adminCookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("admin create project status = %d (body=%s)", rr.Code, rr.Body.String()) + } + var created struct{ PathHash string `json:"path_hash"` } + _ = json.Unmarshal(rr.Body.Bytes(), &created) + if created.PathHash == "" { + t.Fatalf("created project payload missing path_hash: %s", rr.Body.String()) + } + + // Seed a viewer + log in as them. + viewerBody, _ := json.Marshal(map[string]string{ + "email": "viewer@example.com", "initial_password": "viewerpass1", "role": "viewer", + }) + req = withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/admin/users", bytes.NewReader(viewerBody)), adminCookie) + req.Header.Set("Content-Type", "application/json") + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("seed viewer status = %d (body=%s)", rr.Code, rr.Body.String()) + } + viewerCookie := sessionCookie(loginRR(t, f.Router, "viewer@example.com", "viewerpass1")) + + // Each gated endpoint must 403 for the viewer, then succeed for the + // admin. PATCH first (mutates settings), DELETE last (destructive). + cases := []struct { + name string + method string + path string + body []byte + adminStatus int + }{ + { + name: "patch settings", + method: http.MethodPatch, + path: "/api/v1/projects/" + created.PathHash, + body: mustJSON(t, map[string]any{ + "settings": map[string]any{"exclude_patterns": []string{"vendor"}}, + }), + adminStatus: http.StatusOK, + }, + { + name: "delete project", + method: http.MethodDelete, + path: "/api/v1/projects/" + created.PathHash, + adminStatus: http.StatusNoContent, + }, + } + for _, c := range cases { + t.Run(c.name+"/viewer-forbidden", func(t *testing.T) { + req := withCookie(httptest.NewRequest(c.method, c.path, bytes.NewReader(c.body)), viewerCookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusForbidden { + t.Errorf("viewer %s %s status = %d, want 403", c.method, c.path, rr.Code) + } + }) + t.Run(c.name+"/admin-allowed", func(t *testing.T) { + req := withCookie(httptest.NewRequest(c.method, c.path, bytes.NewReader(c.body)), adminCookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != c.adminStatus { + t.Errorf("admin %s %s status = %d, want %d (body=%s)", c.method, c.path, rr.Code, c.adminStatus, rr.Body.String()) + } + }) + } +} + +func mustJSON(t *testing.T, v any) []byte { + t.Helper() + b, err := json.Marshal(v) + if err != nil { + t.Fatalf("marshal: %v", err) + } + return b +} + +// TestIndexCancel_AnyAuthenticatedUser pins the policy that /index/cancel +// is open to any authenticated user. The CLI calls cancel in defer-cleanup +// on early exit (Ctrl-C, network drop), and gating it behind admin would +// strand viewer-owned run locks until the 1-hour TTL. +func TestIndexCancel_AnyAuthenticatedUser(t *testing.T) { + f := newAuthFixture(t) + adminCookie := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + // Seed a viewer + a project they can cancel against. + viewerBody, _ := json.Marshal(map[string]string{ + "email": "viewer@example.com", "initial_password": "viewerpass1", "role": "viewer", + }) + req := withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/admin/users", bytes.NewReader(viewerBody)), adminCookie) + req.Header.Set("Content-Type", "application/json") + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("seed viewer status = %d (body=%s)", rr.Code, rr.Body.String()) + } + viewerCookie := sessionCookie(loginRR(t, f.Router, "viewer@example.com", "viewerpass1")) + + createBody, _ := json.Marshal(map[string]string{"host_path": "/tmp/cancel-test"}) + req = withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/projects", bytes.NewReader(createBody)), viewerCookie) + req.Header.Set("Content-Type", "application/json") + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusCreated { + t.Fatalf("viewer create project status = %d (body=%s)", rr.Code, rr.Body.String()) + } + var created struct{ PathHash string `json:"path_hash"` } + _ = json.Unmarshal(rr.Body.Bytes(), &created) + + // Viewer cancels — must NOT 403 (idempotent 200 even when no run is active). + req = withCookie(httptest.NewRequest(http.MethodPost, "/api/v1/projects/"+created.PathHash+"/index/cancel", nil), viewerCookie) + rr = httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Errorf("viewer cancel status = %d, want 200 (body=%s)", rr.Code, rr.Body.String()) + } +} + +// TestListUsers_IncludesStats — admin-list payload must carry the three +// aggregate columns the dashboard's Users table renders. Round-trip the +// JSON to ensure field names match the OpenAPI contract verbatim. +func TestListUsers_IncludesStats(t *testing.T) { + f := newAuthFixture(t) + cookie := sessionCookie(loginRR(t, f.Router, "admin@example.com", "secret-password")) + + // Seed a viewer + give them an api-key so the row is non-trivial. + v, err := f.Deps.Users.Create(context.Background(), "v@b.com", "viewerpass1", users.RoleViewer, false) + if err != nil { + t.Fatalf("seed viewer: %v", err) + } + if _, _, err := f.Deps.APIKeys.Generate(context.Background(), v.ID, "k"); err != nil { + t.Fatalf("seed key: %v", err) + } + + req := withCookie(httptest.NewRequest(http.MethodGet, "/api/v1/admin/users", nil), cookie) + rr := httptest.NewRecorder() + f.Router.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("status = %d (body=%s)", rr.Code, rr.Body.String()) + } + + var body struct { + Total int `json:"total"` + Users []struct { + Email string `json:"email"` + LastLoginAt *string `json:"last_login_at"` + ActiveSessionsCount int `json:"active_sessions_count"` + ApiKeysCount int `json:"api_keys_count"` + } `json:"users"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil { + t.Fatalf("unmarshal: %v (body=%s)", err, rr.Body.String()) + } + if body.Total != 2 { + t.Fatalf("total = %d, want 2", body.Total) + } + by := map[string]int{} + var viewerRow *struct { + Email string `json:"email"` + LastLoginAt *string `json:"last_login_at"` + ActiveSessionsCount int `json:"active_sessions_count"` + ApiKeysCount int `json:"api_keys_count"` + } + for i := range body.Users { + by[body.Users[i].Email] = i + if body.Users[i].Email == "v@b.com" { + viewerRow = &body.Users[i] + } + } + if viewerRow == nil { + t.Fatalf("viewer row missing in payload: %s", rr.Body.String()) + } + if viewerRow.ApiKeysCount != 1 { + t.Errorf("viewer api_keys_count = %d, want 1", viewerRow.ApiKeysCount) + } + if viewerRow.LastLoginAt != nil { + t.Errorf("viewer last_login_at = %v, want null (never logged in)", *viewerRow.LastLoginAt) + } + // Admin: just-logged-in via loginRR → 1 active session. + admin := body.Users[by["admin@example.com"]] + if admin.ActiveSessionsCount < 1 { + t.Errorf("admin active_sessions_count = %d, want >=1", admin.ActiveSessionsCount) + } + if admin.LastLoginAt == nil { + t.Errorf("admin last_login_at should be set after login") + } +} diff --git a/server/internal/httpapi/dashboard.go b/server/internal/httpapi/dashboard.go new file mode 100644 index 0000000..8a0185d --- /dev/null +++ b/server/internal/httpapi/dashboard.go @@ -0,0 +1,154 @@ +package httpapi + +import ( + "io/fs" + "net/http" + "strings" + + "github.com/dvcdsys/code-index/server/internal/httpapi/dashboard" +) + +// dashboardFS is the embedded SPA bundle, rooted at "dist/" so callers +// reference paths like "index.html" or "assets/index-abcd.js". +var dashboardFS = func() fs.FS { + sub, err := fs.Sub(dashboard.Assets, "dist") + if err != nil { + // embed.FS must contain "dist/" — codegen would have caught this + // at build time. A runtime panic here means the embed directive + // was edited without keeping the path in sync. + panic("dashboard: dist/ missing from embed: " + err.Error()) + } + return sub +}() + +// dashboardContentTypeMap mirrors docsContentTypeMap — pin the Content-Type +// for the handful of asset extensions Vite emits. Without this, Safari +// occasionally refuses to execute .js served as "application/javascript" +// (no charset). +var dashboardContentTypeMap = map[string]string{ + ".html": "text/html; charset=utf-8", + ".css": "text/css; charset=utf-8", + ".js": "application/javascript; charset=utf-8", + ".mjs": "application/javascript; charset=utf-8", + ".json": "application/json; charset=utf-8", + ".svg": "image/svg+xml", + ".png": "image/png", + ".ico": "image/x-icon", + ".woff": "font/woff", + ".woff2": "font/woff2", + ".map": "application/json; charset=utf-8", +} + +// dashboardIndexHandler serves the SPA shell on GET /dashboard and /dashboard/. +// The browser then loads /dashboard/assets/* and the runtime React Router +// takes over for client-side navigation. +func dashboardIndexHandler(w http.ResponseWriter, r *http.Request) { + serveDashboardIndex(w, r) +} + +// dashboardAssetsHandler serves anything under /dashboard/. Three cases: +// +// 1. /dashboard/assets/ — return the embedded asset +// 2. /dashboard/ e.g. /dashboard/favicon.svg — return +// the embedded file if it exists, 404 otherwise +// 3. /dashboard/ e.g. /dashboard/projects/abc — fall +// back to index.html so the SPA's HTML5 history routing keeps working +// across browser refreshes +func dashboardAssetsHandler(w http.ResponseWriter, r *http.Request) { + const prefix = "/dashboard/" + name := strings.TrimPrefix(r.URL.Path, prefix) + if name == "" { + serveDashboardIndex(w, r) + return + } + + // History fallback — anything that doesn't look like a file extension + // is treated as an in-app route. + if !strings.Contains(name, ".") { + serveDashboardIndex(w, r) + return + } + + data, err := fs.ReadFile(dashboardFS, name) + if err != nil { + http.NotFound(w, r) + return + } + if ct := dashboardContentTypeFor(name); ct != "" { + w.Header().Set("Content-Type", ct) + } + // Vite emits hashed filenames under assets/, so they're safe to cache + // hard. Everything else (PLACEHOLDER.html, future favicon) gets a short + // max-age so the operator picks up changes within a few minutes. + if strings.HasPrefix(name, "assets/") { + w.Header().Set("Cache-Control", "public, max-age=31536000, immutable") + } else { + w.Header().Set("Cache-Control", "public, max-age=300") + } + _, _ = w.Write(data) +} + +// dashboardPlaceholderHTML is shown when dist/index.html is missing — i.e. +// `go build` ran without `make dashboard-build` first. We could embed a +// separate file but inlining keeps the embed.FS minimal and removes the +// fragility of vite's emptyOutDir wiping any committed placeholder file. +const dashboardPlaceholderHTML = ` + + + + +cix dashboard — not built + + + +

    cix dashboard placeholder

    +

    The React dashboard hasn’t been built into this server binary yet.

    +

    From the repo root run:

    +
    cd server && make dashboard-build && make build
    +

    Then restart the server. If you’re seeing this in production, your CI build forgot to run the dashboard stage.

    + +` + +// serveDashboardIndex returns dist/index.html when present, otherwise the +// inline placeholder above. This lets `go build` succeed on a fresh clone +// without `make dashboard-build` first — the operator gets a clear "you +// need to build the dashboard" message instead of a blank page. +// +// The HTML is never cached: a fresh deploy must invalidate it immediately +// so the new asset hashes are picked up on the next request. +func serveDashboardIndex(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "text/html; charset=utf-8") + w.Header().Set("Cache-Control", "no-store") + if data, err := fs.ReadFile(dashboardFS, "index.html"); err == nil { + _, _ = w.Write(data) + return + } + _, _ = w.Write([]byte(dashboardPlaceholderHTML)) +} + +// dashboardContentTypeFor returns the explicit Content-Type for the given +// filename, or "" if Go's stdlib detection is good enough. +func dashboardContentTypeFor(name string) string { + for ext, ct := range dashboardContentTypeMap { + if strings.HasSuffix(name, ext) { + return ct + } + } + return "" +} diff --git a/legacy/python-api/app-root/app/__init__.py b/server/internal/httpapi/dashboard/dist/.gitkeep similarity index 100% rename from legacy/python-api/app-root/app/__init__.py rename to server/internal/httpapi/dashboard/dist/.gitkeep diff --git a/server/internal/httpapi/dashboard/embed.go b/server/internal/httpapi/dashboard/embed.go new file mode 100644 index 0000000..88b2d10 --- /dev/null +++ b/server/internal/httpapi/dashboard/embed.go @@ -0,0 +1,21 @@ +// Package dashboard holds the React SPA bundle that is served at /dashboard. +// +// The bundle is produced by `cd server && make dashboard-build` (which in +// turn runs `npm run build` inside server/dashboard/). Vite output lands in +// this directory's dist/ tree: +// +// dist/index.html +// dist/assets/index-.js +// dist/assets/index-.css +// +// On a fresh clone, dist/ contains only the committed `.gitkeep` marker — +// the real build artefacts are gitignored. The `all:` prefix in the embed +// directive includes dotfiles so the embed.FS is non-empty even before the +// frontend has been built. dashboard.go serves a hardcoded "please build" +// placeholder when index.html is missing. +package dashboard + +import "embed" + +//go:embed all:dist +var Assets embed.FS diff --git a/server/internal/httpapi/dashboard_test.go b/server/internal/httpapi/dashboard_test.go new file mode 100644 index 0000000..697c6ff --- /dev/null +++ b/server/internal/httpapi/dashboard_test.go @@ -0,0 +1,108 @@ +package httpapi + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// dashboardServer wires the router with auth disabled so the dashboard +// routes can be hit directly. Auth would only catch the API calls anyway — +// /dashboard/* is a public path by design. +func dashboardServer(t *testing.T) *httptest.Server { + t.Helper() + d := Deps{AuthDisabled: true} + srv := httptest.NewServer(NewRouter(d)) + t.Cleanup(srv.Close) + return srv +} + +func TestDashboard_IndexServesHTML(t *testing.T) { + srv := dashboardServer(t) + resp, err := http.Get(srv.URL + "/dashboard") + if err != nil { + t.Fatalf("GET /dashboard: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatalf("status = %d, want 200", resp.StatusCode) + } + if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/html") { + t.Fatalf("Content-Type = %q, want text/html…", ct) + } +} + +func TestDashboard_HistoryFallback(t *testing.T) { + // Deep links into the SPA must return the same HTML shell so the + // browser can boot React Router and route client-side. Anything + // without a file extension counts as an in-app route. + srv := dashboardServer(t) + for _, path := range []string{ + "/dashboard/projects", + "/dashboard/projects/abc123", + "/dashboard/some/deep/route", + } { + t.Run(path, func(t *testing.T) { + resp, err := http.Get(srv.URL + path) + if err != nil { + t.Fatalf("GET %s: %v", path, err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatalf("status = %d, want 200 (history fallback)", resp.StatusCode) + } + if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/html") { + t.Fatalf("Content-Type = %q, want text/html… (history fallback)", ct) + } + }) + } +} + +func TestDashboard_MissingAsset404(t *testing.T) { + // A path that LOOKS like a file (has an extension) and isn't in the + // embed should 404 rather than fall through to index.html — otherwise + // the SPA would silently absorb /dashboard/foo.js requests. + srv := dashboardServer(t) + resp, err := http.Get(srv.URL + "/dashboard/no-such-file.js") + if err != nil { + t.Fatalf("GET missing asset: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusNotFound { + t.Fatalf("status = %d, want 404", resp.StatusCode) + } +} + +func TestDashboard_PlaceholderConstantPresent(t *testing.T) { + // The inline placeholder (dashboardPlaceholderHTML in dashboard.go) is + // the fallback when dist/index.html is missing — typically because the + // operator forgot to run `make dashboard-build` before `go build`. We + // can't easily exercise the missing-index path in unit tests (the + // embed.FS is sealed at compile time), but we CAN sanity-check the + // constant itself so a refactor never silently empties it. + if !strings.Contains(dashboardPlaceholderHTML, "make dashboard-build") { + t.Fatal("placeholder HTML must mention `make dashboard-build` so the operator knows what to do") + } + if !strings.Contains(dashboardPlaceholderHTML, " not in public paths") + } + // Sanity — API paths stay gated. + if isPublicPath("/api/v1/projects") { + t.Fatal("/api/v1/projects must NOT be public") + } +} diff --git a/server/internal/httpapi/docs.go b/server/internal/httpapi/docs.go new file mode 100644 index 0000000..1aafc32 --- /dev/null +++ b/server/internal/httpapi/docs.go @@ -0,0 +1,102 @@ +package httpapi + +import ( + "io/fs" + "net/http" + + "github.com/dvcdsys/code-index/server/internal/httpapi/docs" + "github.com/dvcdsys/code-index/server/internal/httpapi/openapi" +) + +// docsContentTypeMap overrides the default Go mime detection for the +// swagger-ui bundle. Without this, .js sometimes resolves to +// "application/javascript" on older systems and Safari refuses to execute. +var docsContentTypeMap = map[string]string{ + ".html": "text/html; charset=utf-8", + ".css": "text/css; charset=utf-8", + ".js": "application/javascript; charset=utf-8", + ".png": "image/png", +} + +// docsFS is the embedded Swagger UI bundle, rooted at swagger-ui/ (i.e. +// "index.html" → swagger-ui/index.html). Computed once at package init. +var docsFS = func() fs.FS { + sub, err := fs.Sub(docs.Assets, "swagger-ui") + if err != nil { + // embed.FS must contain "swagger-ui/" — codegen will catch a typo + // at build time, so a runtime panic here means someone deleted + // the bundle without bumping the embed directive. + panic("docs: swagger-ui bundle missing from embed: " + err.Error()) + } + return sub +}() + +// docsIndexHandler serves the Swagger UI shell on GET /docs (and /docs/). +// The browser then fetches static assets via /docs/ (handled by +// docsAssetsHandler) and the spec via /openapi.json (handled by +// openapiSpecHandler). +func docsIndexHandler(w http.ResponseWriter, r *http.Request) { + serveDocsFile(w, r, "index.html") +} + +// docsAssetsHandler serves anything under /docs/. Strips the /docs/ +// prefix and looks the file up in the embedded bundle. +func docsAssetsHandler(w http.ResponseWriter, r *http.Request) { + const prefix = "/docs/" + name := r.URL.Path[len(prefix):] + if name == "" || name == "/" { + serveDocsFile(w, r, "index.html") + return + } + serveDocsFile(w, r, name) +} + +// serveDocsFile is the common path that reads from the embedded bundle and +// sets the right Content-Type for the file extension. +func serveDocsFile(w http.ResponseWriter, _ *http.Request, name string) { + data, err := fs.ReadFile(docsFS, name) + if err != nil { + http.NotFound(w, nil) + return + } + if ct := contentTypeFor(name); ct != "" { + w.Header().Set("Content-Type", ct) + } + // Static bundle is keyed by version in the URL implicitly (we don't + // version it), so a short cache is the safest default — long enough + // to avoid request storms, short enough to pick up a fresh deploy. + w.Header().Set("Cache-Control", "public, max-age=300") + _, _ = w.Write(data) +} + +// contentTypeFor returns the explicit content type for the given filename, +// or "" if Go's stdlib detection is good enough. +func contentTypeFor(name string) string { + for ext, ct := range docsContentTypeMap { + if hasSuffix(name, ext) { + return ct + } + } + return "" +} + +// hasSuffix is a tiny inline replacement for strings.HasSuffix to avoid +// pulling the strings import into this single-purpose file. +func hasSuffix(s, suffix string) bool { + return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix +} + +// openapiSpecHandler serves the OpenAPI spec at /openapi.json. The spec +// is decoded from the gzip+base64 blob embedded in openapi.gen.go (via +// the embedded-spec oapi-codegen flag) — there is no separate file on +// disk to drift out of sync. +func openapiSpecHandler(w http.ResponseWriter, _ *http.Request) { + data, err := openapi.GetSpecJSON() + if err != nil { + http.Error(w, "spec unavailable: "+err.Error(), http.StatusInternalServerError) + return + } + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("Cache-Control", "public, max-age=300") + _, _ = w.Write(data) +} diff --git a/server/internal/httpapi/docs/embed.go b/server/internal/httpapi/docs/embed.go new file mode 100644 index 0000000..921d036 --- /dev/null +++ b/server/internal/httpapi/docs/embed.go @@ -0,0 +1,15 @@ +// Package docs holds the Swagger UI bundle that is served at /docs. +// +// The OpenAPI spec itself is NOT embedded here — it ships compressed inside +// the generated openapi.gen.go (via the embedded-spec oapi-codegen flag) and +// is served via openapi.GetSpecJSON() at /openapi.json. Keeping these +// separate avoids the spec being duplicated in two places that can drift. +// +// The bundle was fetched from jsdelivr (swagger-ui-dist@5.18.2). To bump, +// re-run `make swagger-ui-fetch` in server/. +package docs + +import "embed" + +//go:embed swagger-ui +var Assets embed.FS diff --git a/server/internal/httpapi/docs/swagger-ui/favicon-16x16.png b/server/internal/httpapi/docs/swagger-ui/favicon-16x16.png new file mode 100644 index 0000000..8b194e6 Binary files /dev/null and b/server/internal/httpapi/docs/swagger-ui/favicon-16x16.png differ diff --git a/server/internal/httpapi/docs/swagger-ui/favicon-32x32.png b/server/internal/httpapi/docs/swagger-ui/favicon-32x32.png new file mode 100644 index 0000000..249737f Binary files /dev/null and b/server/internal/httpapi/docs/swagger-ui/favicon-32x32.png differ diff --git a/server/internal/httpapi/docs/swagger-ui/index.html b/server/internal/httpapi/docs/swagger-ui/index.html new file mode 100644 index 0000000..9b46c56 --- /dev/null +++ b/server/internal/httpapi/docs/swagger-ui/index.html @@ -0,0 +1,38 @@ + + + + + cix-server API · Swagger UI + + + + + + +
    + + + + + diff --git a/server/internal/httpapi/docs/swagger-ui/swagger-ui-bundle.js b/server/internal/httpapi/docs/swagger-ui/swagger-ui-bundle.js new file mode 100644 index 0000000..4526219 --- /dev/null +++ b/server/internal/httpapi/docs/swagger-ui/swagger-ui-bundle.js @@ -0,0 +1,2 @@ +/*! For license information please see swagger-ui-bundle.js.LICENSE.txt */ +!function webpackUniversalModuleDefinition(s,o){"object"==typeof exports&&"object"==typeof module?module.exports=o():"function"==typeof define&&define.amd?define([],o):"object"==typeof exports?exports.SwaggerUIBundle=o():s.SwaggerUIBundle=o()}(this,(()=>(()=>{var s,o,i={69119:(s,o)=>{"use strict";Object.defineProperty(o,"__esModule",{value:!0}),o.BLANK_URL=o.relativeFirstCharacters=o.whitespaceEscapeCharsRegex=o.urlSchemeRegex=o.ctrlCharactersRegex=o.htmlCtrlEntityRegex=o.htmlEntitiesRegex=o.invalidProtocolRegex=void 0,o.invalidProtocolRegex=/^([^\w]*)(javascript|data|vbscript)/im,o.htmlEntitiesRegex=/&#(\w+)(^\w|;)?/g,o.htmlCtrlEntityRegex=/&(newline|tab);/gi,o.ctrlCharactersRegex=/[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim,o.urlSchemeRegex=/^.+(:|:)/gim,o.whitespaceEscapeCharsRegex=/(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g,o.relativeFirstCharacters=[".","/"],o.BLANK_URL="about:blank"},16750:(s,o,i)=>{"use strict";o.J=void 0;var u=i(69119);function decodeURI(s){try{return decodeURIComponent(s)}catch(o){return s}}o.J=function sanitizeUrl(s){if(!s)return u.BLANK_URL;var o,i,_=decodeURI(s);do{o=(_=decodeURI(_=(i=_,i.replace(u.ctrlCharactersRegex,"").replace(u.htmlEntitiesRegex,(function(s,o){return String.fromCharCode(o)}))).replace(u.htmlCtrlEntityRegex,"").replace(u.ctrlCharactersRegex,"").replace(u.whitespaceEscapeCharsRegex,"").trim())).match(u.ctrlCharactersRegex)||_.match(u.htmlEntitiesRegex)||_.match(u.htmlCtrlEntityRegex)||_.match(u.whitespaceEscapeCharsRegex)}while(o&&o.length>0);var w=_;if(!w)return u.BLANK_URL;if(function isRelativeUrlWithoutProtocol(s){return u.relativeFirstCharacters.indexOf(s[0])>-1}(w))return w;var x=w.match(u.urlSchemeRegex);if(!x)return w;var C=x[0];return u.invalidProtocolRegex.test(C)?u.BLANK_URL:w}},67526:(s,o)=>{"use strict";o.byteLength=function byteLength(s){var o=getLens(s),i=o[0],u=o[1];return 3*(i+u)/4-u},o.toByteArray=function toByteArray(s){var o,i,w=getLens(s),x=w[0],C=w[1],j=new _(function _byteLength(s,o,i){return 3*(o+i)/4-i}(0,x,C)),L=0,B=C>0?x-4:x;for(i=0;i>16&255,j[L++]=o>>8&255,j[L++]=255&o;2===C&&(o=u[s.charCodeAt(i)]<<2|u[s.charCodeAt(i+1)]>>4,j[L++]=255&o);1===C&&(o=u[s.charCodeAt(i)]<<10|u[s.charCodeAt(i+1)]<<4|u[s.charCodeAt(i+2)]>>2,j[L++]=o>>8&255,j[L++]=255&o);return j},o.fromByteArray=function fromByteArray(s){for(var o,u=s.length,_=u%3,w=[],x=16383,C=0,j=u-_;Cj?j:C+x));1===_?(o=s[u-1],w.push(i[o>>2]+i[o<<4&63]+"==")):2===_&&(o=(s[u-2]<<8)+s[u-1],w.push(i[o>>10]+i[o>>4&63]+i[o<<2&63]+"="));return w.join("")};for(var i=[],u=[],_="undefined"!=typeof Uint8Array?Uint8Array:Array,w="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",x=0;x<64;++x)i[x]=w[x],u[w.charCodeAt(x)]=x;function getLens(s){var o=s.length;if(o%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var i=s.indexOf("=");return-1===i&&(i=o),[i,i===o?0:4-i%4]}function encodeChunk(s,o,u){for(var _,w,x=[],C=o;C>18&63]+i[w>>12&63]+i[w>>6&63]+i[63&w]);return x.join("")}u["-".charCodeAt(0)]=62,u["_".charCodeAt(0)]=63},48287:(s,o,i)=>{"use strict";const u=i(67526),_=i(251),w="function"==typeof Symbol&&"function"==typeof Symbol.for?Symbol.for("nodejs.util.inspect.custom"):null;o.Buffer=Buffer,o.SlowBuffer=function SlowBuffer(s){+s!=s&&(s=0);return Buffer.alloc(+s)},o.INSPECT_MAX_BYTES=50;const x=2147483647;function createBuffer(s){if(s>x)throw new RangeError('The value "'+s+'" is invalid for option "size"');const o=new Uint8Array(s);return Object.setPrototypeOf(o,Buffer.prototype),o}function Buffer(s,o,i){if("number"==typeof s){if("string"==typeof o)throw new TypeError('The "string" argument must be of type string. Received type number');return allocUnsafe(s)}return from(s,o,i)}function from(s,o,i){if("string"==typeof s)return function fromString(s,o){"string"==typeof o&&""!==o||(o="utf8");if(!Buffer.isEncoding(o))throw new TypeError("Unknown encoding: "+o);const i=0|byteLength(s,o);let u=createBuffer(i);const _=u.write(s,o);_!==i&&(u=u.slice(0,_));return u}(s,o);if(ArrayBuffer.isView(s))return function fromArrayView(s){if(isInstance(s,Uint8Array)){const o=new Uint8Array(s);return fromArrayBuffer(o.buffer,o.byteOffset,o.byteLength)}return fromArrayLike(s)}(s);if(null==s)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof s);if(isInstance(s,ArrayBuffer)||s&&isInstance(s.buffer,ArrayBuffer))return fromArrayBuffer(s,o,i);if("undefined"!=typeof SharedArrayBuffer&&(isInstance(s,SharedArrayBuffer)||s&&isInstance(s.buffer,SharedArrayBuffer)))return fromArrayBuffer(s,o,i);if("number"==typeof s)throw new TypeError('The "value" argument must not be of type number. Received type number');const u=s.valueOf&&s.valueOf();if(null!=u&&u!==s)return Buffer.from(u,o,i);const _=function fromObject(s){if(Buffer.isBuffer(s)){const o=0|checked(s.length),i=createBuffer(o);return 0===i.length||s.copy(i,0,0,o),i}if(void 0!==s.length)return"number"!=typeof s.length||numberIsNaN(s.length)?createBuffer(0):fromArrayLike(s);if("Buffer"===s.type&&Array.isArray(s.data))return fromArrayLike(s.data)}(s);if(_)return _;if("undefined"!=typeof Symbol&&null!=Symbol.toPrimitive&&"function"==typeof s[Symbol.toPrimitive])return Buffer.from(s[Symbol.toPrimitive]("string"),o,i);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof s)}function assertSize(s){if("number"!=typeof s)throw new TypeError('"size" argument must be of type number');if(s<0)throw new RangeError('The value "'+s+'" is invalid for option "size"')}function allocUnsafe(s){return assertSize(s),createBuffer(s<0?0:0|checked(s))}function fromArrayLike(s){const o=s.length<0?0:0|checked(s.length),i=createBuffer(o);for(let u=0;u=x)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+x.toString(16)+" bytes");return 0|s}function byteLength(s,o){if(Buffer.isBuffer(s))return s.length;if(ArrayBuffer.isView(s)||isInstance(s,ArrayBuffer))return s.byteLength;if("string"!=typeof s)throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof s);const i=s.length,u=arguments.length>2&&!0===arguments[2];if(!u&&0===i)return 0;let _=!1;for(;;)switch(o){case"ascii":case"latin1":case"binary":return i;case"utf8":case"utf-8":return utf8ToBytes(s).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*i;case"hex":return i>>>1;case"base64":return base64ToBytes(s).length;default:if(_)return u?-1:utf8ToBytes(s).length;o=(""+o).toLowerCase(),_=!0}}function slowToString(s,o,i){let u=!1;if((void 0===o||o<0)&&(o=0),o>this.length)return"";if((void 0===i||i>this.length)&&(i=this.length),i<=0)return"";if((i>>>=0)<=(o>>>=0))return"";for(s||(s="utf8");;)switch(s){case"hex":return hexSlice(this,o,i);case"utf8":case"utf-8":return utf8Slice(this,o,i);case"ascii":return asciiSlice(this,o,i);case"latin1":case"binary":return latin1Slice(this,o,i);case"base64":return base64Slice(this,o,i);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return utf16leSlice(this,o,i);default:if(u)throw new TypeError("Unknown encoding: "+s);s=(s+"").toLowerCase(),u=!0}}function swap(s,o,i){const u=s[o];s[o]=s[i],s[i]=u}function bidirectionalIndexOf(s,o,i,u,_){if(0===s.length)return-1;if("string"==typeof i?(u=i,i=0):i>2147483647?i=2147483647:i<-2147483648&&(i=-2147483648),numberIsNaN(i=+i)&&(i=_?0:s.length-1),i<0&&(i=s.length+i),i>=s.length){if(_)return-1;i=s.length-1}else if(i<0){if(!_)return-1;i=0}if("string"==typeof o&&(o=Buffer.from(o,u)),Buffer.isBuffer(o))return 0===o.length?-1:arrayIndexOf(s,o,i,u,_);if("number"==typeof o)return o&=255,"function"==typeof Uint8Array.prototype.indexOf?_?Uint8Array.prototype.indexOf.call(s,o,i):Uint8Array.prototype.lastIndexOf.call(s,o,i):arrayIndexOf(s,[o],i,u,_);throw new TypeError("val must be string, number or Buffer")}function arrayIndexOf(s,o,i,u,_){let w,x=1,C=s.length,j=o.length;if(void 0!==u&&("ucs2"===(u=String(u).toLowerCase())||"ucs-2"===u||"utf16le"===u||"utf-16le"===u)){if(s.length<2||o.length<2)return-1;x=2,C/=2,j/=2,i/=2}function read(s,o){return 1===x?s[o]:s.readUInt16BE(o*x)}if(_){let u=-1;for(w=i;wC&&(i=C-j),w=i;w>=0;w--){let i=!0;for(let u=0;u_&&(u=_):u=_;const w=o.length;let x;for(u>w/2&&(u=w/2),x=0;x>8,_=i%256,w.push(_),w.push(u);return w}(o,s.length-i),s,i,u)}function base64Slice(s,o,i){return 0===o&&i===s.length?u.fromByteArray(s):u.fromByteArray(s.slice(o,i))}function utf8Slice(s,o,i){i=Math.min(s.length,i);const u=[];let _=o;for(;_239?4:o>223?3:o>191?2:1;if(_+x<=i){let i,u,C,j;switch(x){case 1:o<128&&(w=o);break;case 2:i=s[_+1],128==(192&i)&&(j=(31&o)<<6|63&i,j>127&&(w=j));break;case 3:i=s[_+1],u=s[_+2],128==(192&i)&&128==(192&u)&&(j=(15&o)<<12|(63&i)<<6|63&u,j>2047&&(j<55296||j>57343)&&(w=j));break;case 4:i=s[_+1],u=s[_+2],C=s[_+3],128==(192&i)&&128==(192&u)&&128==(192&C)&&(j=(15&o)<<18|(63&i)<<12|(63&u)<<6|63&C,j>65535&&j<1114112&&(w=j))}}null===w?(w=65533,x=1):w>65535&&(w-=65536,u.push(w>>>10&1023|55296),w=56320|1023&w),u.push(w),_+=x}return function decodeCodePointsArray(s){const o=s.length;if(o<=C)return String.fromCharCode.apply(String,s);let i="",u=0;for(;uu.length?(Buffer.isBuffer(o)||(o=Buffer.from(o)),o.copy(u,_)):Uint8Array.prototype.set.call(u,o,_);else{if(!Buffer.isBuffer(o))throw new TypeError('"list" argument must be an Array of Buffers');o.copy(u,_)}_+=o.length}return u},Buffer.byteLength=byteLength,Buffer.prototype._isBuffer=!0,Buffer.prototype.swap16=function swap16(){const s=this.length;if(s%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let o=0;oi&&(s+=" ... "),""},w&&(Buffer.prototype[w]=Buffer.prototype.inspect),Buffer.prototype.compare=function compare(s,o,i,u,_){if(isInstance(s,Uint8Array)&&(s=Buffer.from(s,s.offset,s.byteLength)),!Buffer.isBuffer(s))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof s);if(void 0===o&&(o=0),void 0===i&&(i=s?s.length:0),void 0===u&&(u=0),void 0===_&&(_=this.length),o<0||i>s.length||u<0||_>this.length)throw new RangeError("out of range index");if(u>=_&&o>=i)return 0;if(u>=_)return-1;if(o>=i)return 1;if(this===s)return 0;let w=(_>>>=0)-(u>>>=0),x=(i>>>=0)-(o>>>=0);const C=Math.min(w,x),j=this.slice(u,_),L=s.slice(o,i);for(let s=0;s>>=0,isFinite(i)?(i>>>=0,void 0===u&&(u="utf8")):(u=i,i=void 0)}const _=this.length-o;if((void 0===i||i>_)&&(i=_),s.length>0&&(i<0||o<0)||o>this.length)throw new RangeError("Attempt to write outside buffer bounds");u||(u="utf8");let w=!1;for(;;)switch(u){case"hex":return hexWrite(this,s,o,i);case"utf8":case"utf-8":return utf8Write(this,s,o,i);case"ascii":case"latin1":case"binary":return asciiWrite(this,s,o,i);case"base64":return base64Write(this,s,o,i);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ucs2Write(this,s,o,i);default:if(w)throw new TypeError("Unknown encoding: "+u);u=(""+u).toLowerCase(),w=!0}},Buffer.prototype.toJSON=function toJSON(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};const C=4096;function asciiSlice(s,o,i){let u="";i=Math.min(s.length,i);for(let _=o;_u)&&(i=u);let _="";for(let u=o;ui)throw new RangeError("Trying to access beyond buffer length")}function checkInt(s,o,i,u,_,w){if(!Buffer.isBuffer(s))throw new TypeError('"buffer" argument must be a Buffer instance');if(o>_||os.length)throw new RangeError("Index out of range")}function wrtBigUInt64LE(s,o,i,u,_){checkIntBI(o,u,_,s,i,7);let w=Number(o&BigInt(4294967295));s[i++]=w,w>>=8,s[i++]=w,w>>=8,s[i++]=w,w>>=8,s[i++]=w;let x=Number(o>>BigInt(32)&BigInt(4294967295));return s[i++]=x,x>>=8,s[i++]=x,x>>=8,s[i++]=x,x>>=8,s[i++]=x,i}function wrtBigUInt64BE(s,o,i,u,_){checkIntBI(o,u,_,s,i,7);let w=Number(o&BigInt(4294967295));s[i+7]=w,w>>=8,s[i+6]=w,w>>=8,s[i+5]=w,w>>=8,s[i+4]=w;let x=Number(o>>BigInt(32)&BigInt(4294967295));return s[i+3]=x,x>>=8,s[i+2]=x,x>>=8,s[i+1]=x,x>>=8,s[i]=x,i+8}function checkIEEE754(s,o,i,u,_,w){if(i+u>s.length)throw new RangeError("Index out of range");if(i<0)throw new RangeError("Index out of range")}function writeFloat(s,o,i,u,w){return o=+o,i>>>=0,w||checkIEEE754(s,0,i,4),_.write(s,o,i,u,23,4),i+4}function writeDouble(s,o,i,u,w){return o=+o,i>>>=0,w||checkIEEE754(s,0,i,8),_.write(s,o,i,u,52,8),i+8}Buffer.prototype.slice=function slice(s,o){const i=this.length;(s=~~s)<0?(s+=i)<0&&(s=0):s>i&&(s=i),(o=void 0===o?i:~~o)<0?(o+=i)<0&&(o=0):o>i&&(o=i),o>>=0,o>>>=0,i||checkOffset(s,o,this.length);let u=this[s],_=1,w=0;for(;++w>>=0,o>>>=0,i||checkOffset(s,o,this.length);let u=this[s+--o],_=1;for(;o>0&&(_*=256);)u+=this[s+--o]*_;return u},Buffer.prototype.readUint8=Buffer.prototype.readUInt8=function readUInt8(s,o){return s>>>=0,o||checkOffset(s,1,this.length),this[s]},Buffer.prototype.readUint16LE=Buffer.prototype.readUInt16LE=function readUInt16LE(s,o){return s>>>=0,o||checkOffset(s,2,this.length),this[s]|this[s+1]<<8},Buffer.prototype.readUint16BE=Buffer.prototype.readUInt16BE=function readUInt16BE(s,o){return s>>>=0,o||checkOffset(s,2,this.length),this[s]<<8|this[s+1]},Buffer.prototype.readUint32LE=Buffer.prototype.readUInt32LE=function readUInt32LE(s,o){return s>>>=0,o||checkOffset(s,4,this.length),(this[s]|this[s+1]<<8|this[s+2]<<16)+16777216*this[s+3]},Buffer.prototype.readUint32BE=Buffer.prototype.readUInt32BE=function readUInt32BE(s,o){return s>>>=0,o||checkOffset(s,4,this.length),16777216*this[s]+(this[s+1]<<16|this[s+2]<<8|this[s+3])},Buffer.prototype.readBigUInt64LE=defineBigIntMethod((function readBigUInt64LE(s){validateNumber(s>>>=0,"offset");const o=this[s],i=this[s+7];void 0!==o&&void 0!==i||boundsError(s,this.length-8);const u=o+256*this[++s]+65536*this[++s]+this[++s]*2**24,_=this[++s]+256*this[++s]+65536*this[++s]+i*2**24;return BigInt(u)+(BigInt(_)<>>=0,"offset");const o=this[s],i=this[s+7];void 0!==o&&void 0!==i||boundsError(s,this.length-8);const u=o*2**24+65536*this[++s]+256*this[++s]+this[++s],_=this[++s]*2**24+65536*this[++s]+256*this[++s]+i;return(BigInt(u)<>>=0,o>>>=0,i||checkOffset(s,o,this.length);let u=this[s],_=1,w=0;for(;++w=_&&(u-=Math.pow(2,8*o)),u},Buffer.prototype.readIntBE=function readIntBE(s,o,i){s>>>=0,o>>>=0,i||checkOffset(s,o,this.length);let u=o,_=1,w=this[s+--u];for(;u>0&&(_*=256);)w+=this[s+--u]*_;return _*=128,w>=_&&(w-=Math.pow(2,8*o)),w},Buffer.prototype.readInt8=function readInt8(s,o){return s>>>=0,o||checkOffset(s,1,this.length),128&this[s]?-1*(255-this[s]+1):this[s]},Buffer.prototype.readInt16LE=function readInt16LE(s,o){s>>>=0,o||checkOffset(s,2,this.length);const i=this[s]|this[s+1]<<8;return 32768&i?4294901760|i:i},Buffer.prototype.readInt16BE=function readInt16BE(s,o){s>>>=0,o||checkOffset(s,2,this.length);const i=this[s+1]|this[s]<<8;return 32768&i?4294901760|i:i},Buffer.prototype.readInt32LE=function readInt32LE(s,o){return s>>>=0,o||checkOffset(s,4,this.length),this[s]|this[s+1]<<8|this[s+2]<<16|this[s+3]<<24},Buffer.prototype.readInt32BE=function readInt32BE(s,o){return s>>>=0,o||checkOffset(s,4,this.length),this[s]<<24|this[s+1]<<16|this[s+2]<<8|this[s+3]},Buffer.prototype.readBigInt64LE=defineBigIntMethod((function readBigInt64LE(s){validateNumber(s>>>=0,"offset");const o=this[s],i=this[s+7];void 0!==o&&void 0!==i||boundsError(s,this.length-8);const u=this[s+4]+256*this[s+5]+65536*this[s+6]+(i<<24);return(BigInt(u)<>>=0,"offset");const o=this[s],i=this[s+7];void 0!==o&&void 0!==i||boundsError(s,this.length-8);const u=(o<<24)+65536*this[++s]+256*this[++s]+this[++s];return(BigInt(u)<>>=0,o||checkOffset(s,4,this.length),_.read(this,s,!0,23,4)},Buffer.prototype.readFloatBE=function readFloatBE(s,o){return s>>>=0,o||checkOffset(s,4,this.length),_.read(this,s,!1,23,4)},Buffer.prototype.readDoubleLE=function readDoubleLE(s,o){return s>>>=0,o||checkOffset(s,8,this.length),_.read(this,s,!0,52,8)},Buffer.prototype.readDoubleBE=function readDoubleBE(s,o){return s>>>=0,o||checkOffset(s,8,this.length),_.read(this,s,!1,52,8)},Buffer.prototype.writeUintLE=Buffer.prototype.writeUIntLE=function writeUIntLE(s,o,i,u){if(s=+s,o>>>=0,i>>>=0,!u){checkInt(this,s,o,i,Math.pow(2,8*i)-1,0)}let _=1,w=0;for(this[o]=255&s;++w>>=0,i>>>=0,!u){checkInt(this,s,o,i,Math.pow(2,8*i)-1,0)}let _=i-1,w=1;for(this[o+_]=255&s;--_>=0&&(w*=256);)this[o+_]=s/w&255;return o+i},Buffer.prototype.writeUint8=Buffer.prototype.writeUInt8=function writeUInt8(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,1,255,0),this[o]=255&s,o+1},Buffer.prototype.writeUint16LE=Buffer.prototype.writeUInt16LE=function writeUInt16LE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,2,65535,0),this[o]=255&s,this[o+1]=s>>>8,o+2},Buffer.prototype.writeUint16BE=Buffer.prototype.writeUInt16BE=function writeUInt16BE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,2,65535,0),this[o]=s>>>8,this[o+1]=255&s,o+2},Buffer.prototype.writeUint32LE=Buffer.prototype.writeUInt32LE=function writeUInt32LE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,4,4294967295,0),this[o+3]=s>>>24,this[o+2]=s>>>16,this[o+1]=s>>>8,this[o]=255&s,o+4},Buffer.prototype.writeUint32BE=Buffer.prototype.writeUInt32BE=function writeUInt32BE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,4,4294967295,0),this[o]=s>>>24,this[o+1]=s>>>16,this[o+2]=s>>>8,this[o+3]=255&s,o+4},Buffer.prototype.writeBigUInt64LE=defineBigIntMethod((function writeBigUInt64LE(s,o=0){return wrtBigUInt64LE(this,s,o,BigInt(0),BigInt("0xffffffffffffffff"))})),Buffer.prototype.writeBigUInt64BE=defineBigIntMethod((function writeBigUInt64BE(s,o=0){return wrtBigUInt64BE(this,s,o,BigInt(0),BigInt("0xffffffffffffffff"))})),Buffer.prototype.writeIntLE=function writeIntLE(s,o,i,u){if(s=+s,o>>>=0,!u){const u=Math.pow(2,8*i-1);checkInt(this,s,o,i,u-1,-u)}let _=0,w=1,x=0;for(this[o]=255&s;++_>>=0,!u){const u=Math.pow(2,8*i-1);checkInt(this,s,o,i,u-1,-u)}let _=i-1,w=1,x=0;for(this[o+_]=255&s;--_>=0&&(w*=256);)s<0&&0===x&&0!==this[o+_+1]&&(x=1),this[o+_]=(s/w|0)-x&255;return o+i},Buffer.prototype.writeInt8=function writeInt8(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,1,127,-128),s<0&&(s=255+s+1),this[o]=255&s,o+1},Buffer.prototype.writeInt16LE=function writeInt16LE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,2,32767,-32768),this[o]=255&s,this[o+1]=s>>>8,o+2},Buffer.prototype.writeInt16BE=function writeInt16BE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,2,32767,-32768),this[o]=s>>>8,this[o+1]=255&s,o+2},Buffer.prototype.writeInt32LE=function writeInt32LE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,4,2147483647,-2147483648),this[o]=255&s,this[o+1]=s>>>8,this[o+2]=s>>>16,this[o+3]=s>>>24,o+4},Buffer.prototype.writeInt32BE=function writeInt32BE(s,o,i){return s=+s,o>>>=0,i||checkInt(this,s,o,4,2147483647,-2147483648),s<0&&(s=4294967295+s+1),this[o]=s>>>24,this[o+1]=s>>>16,this[o+2]=s>>>8,this[o+3]=255&s,o+4},Buffer.prototype.writeBigInt64LE=defineBigIntMethod((function writeBigInt64LE(s,o=0){return wrtBigUInt64LE(this,s,o,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),Buffer.prototype.writeBigInt64BE=defineBigIntMethod((function writeBigInt64BE(s,o=0){return wrtBigUInt64BE(this,s,o,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))})),Buffer.prototype.writeFloatLE=function writeFloatLE(s,o,i){return writeFloat(this,s,o,!0,i)},Buffer.prototype.writeFloatBE=function writeFloatBE(s,o,i){return writeFloat(this,s,o,!1,i)},Buffer.prototype.writeDoubleLE=function writeDoubleLE(s,o,i){return writeDouble(this,s,o,!0,i)},Buffer.prototype.writeDoubleBE=function writeDoubleBE(s,o,i){return writeDouble(this,s,o,!1,i)},Buffer.prototype.copy=function copy(s,o,i,u){if(!Buffer.isBuffer(s))throw new TypeError("argument should be a Buffer");if(i||(i=0),u||0===u||(u=this.length),o>=s.length&&(o=s.length),o||(o=0),u>0&&u=this.length)throw new RangeError("Index out of range");if(u<0)throw new RangeError("sourceEnd out of bounds");u>this.length&&(u=this.length),s.length-o>>=0,i=void 0===i?this.length:i>>>0,s||(s=0),"number"==typeof s)for(_=o;_=u+4;i-=3)o=`_${s.slice(i-3,i)}${o}`;return`${s.slice(0,i)}${o}`}function checkIntBI(s,o,i,u,_,w){if(s>i||s3?0===o||o===BigInt(0)?`>= 0${u} and < 2${u} ** ${8*(w+1)}${u}`:`>= -(2${u} ** ${8*(w+1)-1}${u}) and < 2 ** ${8*(w+1)-1}${u}`:`>= ${o}${u} and <= ${i}${u}`,new j.ERR_OUT_OF_RANGE("value",_,s)}!function checkBounds(s,o,i){validateNumber(o,"offset"),void 0!==s[o]&&void 0!==s[o+i]||boundsError(o,s.length-(i+1))}(u,_,w)}function validateNumber(s,o){if("number"!=typeof s)throw new j.ERR_INVALID_ARG_TYPE(o,"number",s)}function boundsError(s,o,i){if(Math.floor(s)!==s)throw validateNumber(s,i),new j.ERR_OUT_OF_RANGE(i||"offset","an integer",s);if(o<0)throw new j.ERR_BUFFER_OUT_OF_BOUNDS;throw new j.ERR_OUT_OF_RANGE(i||"offset",`>= ${i?1:0} and <= ${o}`,s)}E("ERR_BUFFER_OUT_OF_BOUNDS",(function(s){return s?`${s} is outside of buffer bounds`:"Attempt to access memory outside buffer bounds"}),RangeError),E("ERR_INVALID_ARG_TYPE",(function(s,o){return`The "${s}" argument must be of type number. Received type ${typeof o}`}),TypeError),E("ERR_OUT_OF_RANGE",(function(s,o,i){let u=`The value of "${s}" is out of range.`,_=i;return Number.isInteger(i)&&Math.abs(i)>2**32?_=addNumericalSeparator(String(i)):"bigint"==typeof i&&(_=String(i),(i>BigInt(2)**BigInt(32)||i<-(BigInt(2)**BigInt(32)))&&(_=addNumericalSeparator(_)),_+="n"),u+=` It must be ${o}. Received ${_}`,u}),RangeError);const L=/[^+/0-9A-Za-z-_]/g;function utf8ToBytes(s,o){let i;o=o||1/0;const u=s.length;let _=null;const w=[];for(let x=0;x55295&&i<57344){if(!_){if(i>56319){(o-=3)>-1&&w.push(239,191,189);continue}if(x+1===u){(o-=3)>-1&&w.push(239,191,189);continue}_=i;continue}if(i<56320){(o-=3)>-1&&w.push(239,191,189),_=i;continue}i=65536+(_-55296<<10|i-56320)}else _&&(o-=3)>-1&&w.push(239,191,189);if(_=null,i<128){if((o-=1)<0)break;w.push(i)}else if(i<2048){if((o-=2)<0)break;w.push(i>>6|192,63&i|128)}else if(i<65536){if((o-=3)<0)break;w.push(i>>12|224,i>>6&63|128,63&i|128)}else{if(!(i<1114112))throw new Error("Invalid code point");if((o-=4)<0)break;w.push(i>>18|240,i>>12&63|128,i>>6&63|128,63&i|128)}}return w}function base64ToBytes(s){return u.toByteArray(function base64clean(s){if((s=(s=s.split("=")[0]).trim().replace(L,"")).length<2)return"";for(;s.length%4!=0;)s+="=";return s}(s))}function blitBuffer(s,o,i,u){let _;for(_=0;_=o.length||_>=s.length);++_)o[_+i]=s[_];return _}function isInstance(s,o){return s instanceof o||null!=s&&null!=s.constructor&&null!=s.constructor.name&&s.constructor.name===o.name}function numberIsNaN(s){return s!=s}const B=function(){const s="0123456789abcdef",o=new Array(256);for(let i=0;i<16;++i){const u=16*i;for(let _=0;_<16;++_)o[u+_]=s[i]+s[_]}return o}();function defineBigIntMethod(s){return"undefined"==typeof BigInt?BufferBigIntNotDefined:s}function BufferBigIntNotDefined(){throw new Error("BigInt not supported")}},17965:(s,o,i)=>{"use strict";var u=i(16426),_={"text/plain":"Text","text/html":"Url",default:"Text"};s.exports=function copy(s,o){var i,w,x,C,j,L,B=!1;o||(o={}),i=o.debug||!1;try{if(x=u(),C=document.createRange(),j=document.getSelection(),(L=document.createElement("span")).textContent=s,L.ariaHidden="true",L.style.all="unset",L.style.position="fixed",L.style.top=0,L.style.clip="rect(0, 0, 0, 0)",L.style.whiteSpace="pre",L.style.webkitUserSelect="text",L.style.MozUserSelect="text",L.style.msUserSelect="text",L.style.userSelect="text",L.addEventListener("copy",(function(u){if(u.stopPropagation(),o.format)if(u.preventDefault(),void 0===u.clipboardData){i&&console.warn("unable to use e.clipboardData"),i&&console.warn("trying IE specific stuff"),window.clipboardData.clearData();var w=_[o.format]||_.default;window.clipboardData.setData(w,s)}else u.clipboardData.clearData(),u.clipboardData.setData(o.format,s);o.onCopy&&(u.preventDefault(),o.onCopy(u.clipboardData))})),document.body.appendChild(L),C.selectNodeContents(L),j.addRange(C),!document.execCommand("copy"))throw new Error("copy command was unsuccessful");B=!0}catch(u){i&&console.error("unable to copy using execCommand: ",u),i&&console.warn("trying IE specific stuff");try{window.clipboardData.setData(o.format||"text",s),o.onCopy&&o.onCopy(window.clipboardData),B=!0}catch(u){i&&console.error("unable to copy using clipboardData: ",u),i&&console.error("falling back to prompt"),w=function format(s){var o=(/mac os x/i.test(navigator.userAgent)?"⌘":"Ctrl")+"+C";return s.replace(/#{\s*key\s*}/g,o)}("message"in o?o.message:"Copy to clipboard: #{key}, Enter"),window.prompt(w,s)}}finally{j&&("function"==typeof j.removeRange?j.removeRange(C):j.removeAllRanges()),L&&document.body.removeChild(L),x()}return B}},2205:function(s,o,i){var u;u=void 0!==i.g?i.g:this,s.exports=function(s){if(s.CSS&&s.CSS.escape)return s.CSS.escape;var cssEscape=function(s){if(0==arguments.length)throw new TypeError("`CSS.escape` requires an argument.");for(var o,i=String(s),u=i.length,_=-1,w="",x=i.charCodeAt(0);++_=1&&o<=31||127==o||0==_&&o>=48&&o<=57||1==_&&o>=48&&o<=57&&45==x?"\\"+o.toString(16)+" ":0==_&&1==u&&45==o||!(o>=128||45==o||95==o||o>=48&&o<=57||o>=65&&o<=90||o>=97&&o<=122)?"\\"+i.charAt(_):i.charAt(_):w+="�";return w};return s.CSS||(s.CSS={}),s.CSS.escape=cssEscape,cssEscape}(u)},81919:(s,o,i)=>{"use strict";var u=i(48287).Buffer;function isSpecificValue(s){return s instanceof u||s instanceof Date||s instanceof RegExp}function cloneSpecificValue(s){if(s instanceof u){var o=u.alloc?u.alloc(s.length):new u(s.length);return s.copy(o),o}if(s instanceof Date)return new Date(s.getTime());if(s instanceof RegExp)return new RegExp(s);throw new Error("Unexpected situation")}function deepCloneArray(s){var o=[];return s.forEach((function(s,i){"object"==typeof s&&null!==s?Array.isArray(s)?o[i]=deepCloneArray(s):isSpecificValue(s)?o[i]=cloneSpecificValue(s):o[i]=_({},s):o[i]=s})),o}function safeGetProperty(s,o){return"__proto__"===o?void 0:s[o]}var _=s.exports=function(){if(arguments.length<1||"object"!=typeof arguments[0])return!1;if(arguments.length<2)return arguments[0];var s,o,i=arguments[0];return Array.prototype.slice.call(arguments,1).forEach((function(u){"object"!=typeof u||null===u||Array.isArray(u)||Object.keys(u).forEach((function(w){return o=safeGetProperty(i,w),(s=safeGetProperty(u,w))===i?void 0:"object"!=typeof s||null===s?void(i[w]=s):Array.isArray(s)?void(i[w]=deepCloneArray(s)):isSpecificValue(s)?void(i[w]=cloneSpecificValue(s)):"object"!=typeof o||null===o||Array.isArray(o)?void(i[w]=_({},s)):void(i[w]=_(o,s))}))})),i}},14744:s=>{"use strict";var o=function isMergeableObject(s){return function isNonNullObject(s){return!!s&&"object"==typeof s}(s)&&!function isSpecial(s){var o=Object.prototype.toString.call(s);return"[object RegExp]"===o||"[object Date]"===o||function isReactElement(s){return s.$$typeof===i}(s)}(s)};var i="function"==typeof Symbol&&Symbol.for?Symbol.for("react.element"):60103;function cloneUnlessOtherwiseSpecified(s,o){return!1!==o.clone&&o.isMergeableObject(s)?deepmerge(function emptyTarget(s){return Array.isArray(s)?[]:{}}(s),s,o):s}function defaultArrayMerge(s,o,i){return s.concat(o).map((function(s){return cloneUnlessOtherwiseSpecified(s,i)}))}function getKeys(s){return Object.keys(s).concat(function getEnumerableOwnPropertySymbols(s){return Object.getOwnPropertySymbols?Object.getOwnPropertySymbols(s).filter((function(o){return Object.propertyIsEnumerable.call(s,o)})):[]}(s))}function propertyIsOnObject(s,o){try{return o in s}catch(s){return!1}}function mergeObject(s,o,i){var u={};return i.isMergeableObject(s)&&getKeys(s).forEach((function(o){u[o]=cloneUnlessOtherwiseSpecified(s[o],i)})),getKeys(o).forEach((function(_){(function propertyIsUnsafe(s,o){return propertyIsOnObject(s,o)&&!(Object.hasOwnProperty.call(s,o)&&Object.propertyIsEnumerable.call(s,o))})(s,_)||(propertyIsOnObject(s,_)&&i.isMergeableObject(o[_])?u[_]=function getMergeFunction(s,o){if(!o.customMerge)return deepmerge;var i=o.customMerge(s);return"function"==typeof i?i:deepmerge}(_,i)(s[_],o[_],i):u[_]=cloneUnlessOtherwiseSpecified(o[_],i))})),u}function deepmerge(s,i,u){(u=u||{}).arrayMerge=u.arrayMerge||defaultArrayMerge,u.isMergeableObject=u.isMergeableObject||o,u.cloneUnlessOtherwiseSpecified=cloneUnlessOtherwiseSpecified;var _=Array.isArray(i);return _===Array.isArray(s)?_?u.arrayMerge(s,i,u):mergeObject(s,i,u):cloneUnlessOtherwiseSpecified(i,u)}deepmerge.all=function deepmergeAll(s,o){if(!Array.isArray(s))throw new Error("first argument should be an array");return s.reduce((function(s,i){return deepmerge(s,i,o)}),{})};var u=deepmerge;s.exports=u},42838:function(s){s.exports=function(){"use strict";const{entries:s,setPrototypeOf:o,isFrozen:i,getPrototypeOf:u,getOwnPropertyDescriptor:_}=Object;let{freeze:w,seal:x,create:C}=Object,{apply:j,construct:L}="undefined"!=typeof Reflect&&Reflect;w||(w=function freeze(s){return s}),x||(x=function seal(s){return s}),j||(j=function apply(s,o,i){return s.apply(o,i)}),L||(L=function construct(s,o){return new s(...o)});const B=unapply(Array.prototype.forEach),$=unapply(Array.prototype.pop),V=unapply(Array.prototype.push),U=unapply(String.prototype.toLowerCase),z=unapply(String.prototype.toString),Y=unapply(String.prototype.match),Z=unapply(String.prototype.replace),ee=unapply(String.prototype.indexOf),ie=unapply(String.prototype.trim),ae=unapply(Object.prototype.hasOwnProperty),le=unapply(RegExp.prototype.test),ce=unconstruct(TypeError);function unapply(s){return function(o){for(var i=arguments.length,u=new Array(i>1?i-1:0),_=1;_2&&void 0!==arguments[2]?arguments[2]:U;o&&o(s,null);let w=u.length;for(;w--;){let o=u[w];if("string"==typeof o){const s=_(o);s!==o&&(i(u)||(u[w]=s),o=s)}s[o]=!0}return s}function cleanArray(s){for(let o=0;o/gm),$e=x(/\${[\w\W]*}/gm),ze=x(/^data-[\-\w.\u00B7-\uFFFF]/),We=x(/^aria-[\-\w]+$/),He=x(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),Ye=x(/^(?:\w+script|data):/i),Xe=x(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),Qe=x(/^html$/i),et=x(/^[a-z][.\w]*(-[.\w]+)+$/i);var tt=Object.freeze({__proto__:null,MUSTACHE_EXPR:Re,ERB_EXPR:qe,TMPLIT_EXPR:$e,DATA_ATTR:ze,ARIA_ATTR:We,IS_ALLOWED_URI:He,IS_SCRIPT_OR_DATA:Ye,ATTR_WHITESPACE:Xe,DOCTYPE_NAME:Qe,CUSTOM_ELEMENT:et});const rt={element:1,attribute:2,text:3,cdataSection:4,entityReference:5,entityNode:6,progressingInstruction:7,comment:8,document:9,documentType:10,documentFragment:11,notation:12},nt=function getGlobal(){return"undefined"==typeof window?null:window},st=function _createTrustedTypesPolicy(s,o){if("object"!=typeof s||"function"!=typeof s.createPolicy)return null;let i=null;const u="data-tt-policy-suffix";o&&o.hasAttribute(u)&&(i=o.getAttribute(u));const _="dompurify"+(i?"#"+i:"");try{return s.createPolicy(_,{createHTML:s=>s,createScriptURL:s=>s})}catch(s){return console.warn("TrustedTypes policy "+_+" could not be created."),null}};function createDOMPurify(){let o=arguments.length>0&&void 0!==arguments[0]?arguments[0]:nt();const DOMPurify=s=>createDOMPurify(s);if(DOMPurify.version="3.1.6",DOMPurify.removed=[],!o||!o.document||o.document.nodeType!==rt.document)return DOMPurify.isSupported=!1,DOMPurify;let{document:i}=o;const u=i,_=u.currentScript,{DocumentFragment:x,HTMLTemplateElement:j,Node:L,Element:Re,NodeFilter:qe,NamedNodeMap:$e=o.NamedNodeMap||o.MozNamedAttrMap,HTMLFormElement:ze,DOMParser:We,trustedTypes:Ye}=o,Xe=Re.prototype,et=lookupGetter(Xe,"cloneNode"),ot=lookupGetter(Xe,"remove"),it=lookupGetter(Xe,"nextSibling"),at=lookupGetter(Xe,"childNodes"),lt=lookupGetter(Xe,"parentNode");if("function"==typeof j){const s=i.createElement("template");s.content&&s.content.ownerDocument&&(i=s.content.ownerDocument)}let ct,ut="";const{implementation:pt,createNodeIterator:ht,createDocumentFragment:dt,getElementsByTagName:mt}=i,{importNode:gt}=u;let yt={};DOMPurify.isSupported="function"==typeof s&&"function"==typeof lt&&pt&&void 0!==pt.createHTMLDocument;const{MUSTACHE_EXPR:vt,ERB_EXPR:bt,TMPLIT_EXPR:_t,DATA_ATTR:Et,ARIA_ATTR:wt,IS_SCRIPT_OR_DATA:St,ATTR_WHITESPACE:xt,CUSTOM_ELEMENT:kt}=tt;let{IS_ALLOWED_URI:Ct}=tt,Ot=null;const At=addToSet({},[...pe,...de,...fe,...be,...we]);let jt=null;const It=addToSet({},[...Se,...xe,...Pe,...Te]);let Pt=Object.seal(C(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),Mt=null,Tt=null,Nt=!0,Rt=!0,Dt=!1,Lt=!0,Bt=!1,Ft=!0,qt=!1,$t=!1,Vt=!1,Ut=!1,zt=!1,Wt=!1,Kt=!0,Ht=!1;const Jt="user-content-";let Gt=!0,Yt=!1,Xt={},Zt=null;const Qt=addToSet({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]);let er=null;const tr=addToSet({},["audio","video","img","source","image","track"]);let rr=null;const nr=addToSet({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),sr="http://www.w3.org/1998/Math/MathML",ir="http://www.w3.org/2000/svg",ar="http://www.w3.org/1999/xhtml";let lr=ar,cr=!1,ur=null;const pr=addToSet({},[sr,ir,ar],z);let dr=null;const fr=["application/xhtml+xml","text/html"],mr="text/html";let gr=null,yr=null;const vr=i.createElement("form"),br=function isRegexOrFunction(s){return s instanceof RegExp||s instanceof Function},_r=function _parseConfig(){let s=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(!yr||yr!==s){if(s&&"object"==typeof s||(s={}),s=clone(s),dr=-1===fr.indexOf(s.PARSER_MEDIA_TYPE)?mr:s.PARSER_MEDIA_TYPE,gr="application/xhtml+xml"===dr?z:U,Ot=ae(s,"ALLOWED_TAGS")?addToSet({},s.ALLOWED_TAGS,gr):At,jt=ae(s,"ALLOWED_ATTR")?addToSet({},s.ALLOWED_ATTR,gr):It,ur=ae(s,"ALLOWED_NAMESPACES")?addToSet({},s.ALLOWED_NAMESPACES,z):pr,rr=ae(s,"ADD_URI_SAFE_ATTR")?addToSet(clone(nr),s.ADD_URI_SAFE_ATTR,gr):nr,er=ae(s,"ADD_DATA_URI_TAGS")?addToSet(clone(tr),s.ADD_DATA_URI_TAGS,gr):tr,Zt=ae(s,"FORBID_CONTENTS")?addToSet({},s.FORBID_CONTENTS,gr):Qt,Mt=ae(s,"FORBID_TAGS")?addToSet({},s.FORBID_TAGS,gr):{},Tt=ae(s,"FORBID_ATTR")?addToSet({},s.FORBID_ATTR,gr):{},Xt=!!ae(s,"USE_PROFILES")&&s.USE_PROFILES,Nt=!1!==s.ALLOW_ARIA_ATTR,Rt=!1!==s.ALLOW_DATA_ATTR,Dt=s.ALLOW_UNKNOWN_PROTOCOLS||!1,Lt=!1!==s.ALLOW_SELF_CLOSE_IN_ATTR,Bt=s.SAFE_FOR_TEMPLATES||!1,Ft=!1!==s.SAFE_FOR_XML,qt=s.WHOLE_DOCUMENT||!1,Ut=s.RETURN_DOM||!1,zt=s.RETURN_DOM_FRAGMENT||!1,Wt=s.RETURN_TRUSTED_TYPE||!1,Vt=s.FORCE_BODY||!1,Kt=!1!==s.SANITIZE_DOM,Ht=s.SANITIZE_NAMED_PROPS||!1,Gt=!1!==s.KEEP_CONTENT,Yt=s.IN_PLACE||!1,Ct=s.ALLOWED_URI_REGEXP||He,lr=s.NAMESPACE||ar,Pt=s.CUSTOM_ELEMENT_HANDLING||{},s.CUSTOM_ELEMENT_HANDLING&&br(s.CUSTOM_ELEMENT_HANDLING.tagNameCheck)&&(Pt.tagNameCheck=s.CUSTOM_ELEMENT_HANDLING.tagNameCheck),s.CUSTOM_ELEMENT_HANDLING&&br(s.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)&&(Pt.attributeNameCheck=s.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),s.CUSTOM_ELEMENT_HANDLING&&"boolean"==typeof s.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements&&(Pt.allowCustomizedBuiltInElements=s.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),Bt&&(Rt=!1),zt&&(Ut=!0),Xt&&(Ot=addToSet({},we),jt=[],!0===Xt.html&&(addToSet(Ot,pe),addToSet(jt,Se)),!0===Xt.svg&&(addToSet(Ot,de),addToSet(jt,xe),addToSet(jt,Te)),!0===Xt.svgFilters&&(addToSet(Ot,fe),addToSet(jt,xe),addToSet(jt,Te)),!0===Xt.mathMl&&(addToSet(Ot,be),addToSet(jt,Pe),addToSet(jt,Te))),s.ADD_TAGS&&(Ot===At&&(Ot=clone(Ot)),addToSet(Ot,s.ADD_TAGS,gr)),s.ADD_ATTR&&(jt===It&&(jt=clone(jt)),addToSet(jt,s.ADD_ATTR,gr)),s.ADD_URI_SAFE_ATTR&&addToSet(rr,s.ADD_URI_SAFE_ATTR,gr),s.FORBID_CONTENTS&&(Zt===Qt&&(Zt=clone(Zt)),addToSet(Zt,s.FORBID_CONTENTS,gr)),Gt&&(Ot["#text"]=!0),qt&&addToSet(Ot,["html","head","body"]),Ot.table&&(addToSet(Ot,["tbody"]),delete Mt.tbody),s.TRUSTED_TYPES_POLICY){if("function"!=typeof s.TRUSTED_TYPES_POLICY.createHTML)throw ce('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if("function"!=typeof s.TRUSTED_TYPES_POLICY.createScriptURL)throw ce('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');ct=s.TRUSTED_TYPES_POLICY,ut=ct.createHTML("")}else void 0===ct&&(ct=st(Ye,_)),null!==ct&&"string"==typeof ut&&(ut=ct.createHTML(""));w&&w(s),yr=s}},Er=addToSet({},["mi","mo","mn","ms","mtext"]),wr=addToSet({},["foreignobject","annotation-xml"]),Sr=addToSet({},["title","style","font","a","script"]),xr=addToSet({},[...de,...fe,...ye]),kr=addToSet({},[...be,..._e]),Cr=function _checkValidNamespace(s){let o=lt(s);o&&o.tagName||(o={namespaceURI:lr,tagName:"template"});const i=U(s.tagName),u=U(o.tagName);return!!ur[s.namespaceURI]&&(s.namespaceURI===ir?o.namespaceURI===ar?"svg"===i:o.namespaceURI===sr?"svg"===i&&("annotation-xml"===u||Er[u]):Boolean(xr[i]):s.namespaceURI===sr?o.namespaceURI===ar?"math"===i:o.namespaceURI===ir?"math"===i&&wr[u]:Boolean(kr[i]):s.namespaceURI===ar?!(o.namespaceURI===ir&&!wr[u])&&!(o.namespaceURI===sr&&!Er[u])&&!kr[i]&&(Sr[i]||!xr[i]):!("application/xhtml+xml"!==dr||!ur[s.namespaceURI]))},Or=function _forceRemove(s){V(DOMPurify.removed,{element:s});try{lt(s).removeChild(s)}catch(o){ot(s)}},Ar=function _removeAttribute(s,o){try{V(DOMPurify.removed,{attribute:o.getAttributeNode(s),from:o})}catch(s){V(DOMPurify.removed,{attribute:null,from:o})}if(o.removeAttribute(s),"is"===s&&!jt[s])if(Ut||zt)try{Or(o)}catch(s){}else try{o.setAttribute(s,"")}catch(s){}},jr=function _initDocument(s){let o=null,u=null;if(Vt)s=""+s;else{const o=Y(s,/^[\r\n\t ]+/);u=o&&o[0]}"application/xhtml+xml"===dr&&lr===ar&&(s=''+s+"");const _=ct?ct.createHTML(s):s;if(lr===ar)try{o=(new We).parseFromString(_,dr)}catch(s){}if(!o||!o.documentElement){o=pt.createDocument(lr,"template",null);try{o.documentElement.innerHTML=cr?ut:_}catch(s){}}const w=o.body||o.documentElement;return s&&u&&w.insertBefore(i.createTextNode(u),w.childNodes[0]||null),lr===ar?mt.call(o,qt?"html":"body")[0]:qt?o.documentElement:w},Ir=function _createNodeIterator(s){return ht.call(s.ownerDocument||s,s,qe.SHOW_ELEMENT|qe.SHOW_COMMENT|qe.SHOW_TEXT|qe.SHOW_PROCESSING_INSTRUCTION|qe.SHOW_CDATA_SECTION,null)},Pr=function _isClobbered(s){return s instanceof ze&&("string"!=typeof s.nodeName||"string"!=typeof s.textContent||"function"!=typeof s.removeChild||!(s.attributes instanceof $e)||"function"!=typeof s.removeAttribute||"function"!=typeof s.setAttribute||"string"!=typeof s.namespaceURI||"function"!=typeof s.insertBefore||"function"!=typeof s.hasChildNodes)},Mr=function _isNode(s){return"function"==typeof L&&s instanceof L},Tr=function _executeHook(s,o,i){yt[s]&&B(yt[s],(s=>{s.call(DOMPurify,o,i,yr)}))},Nr=function _sanitizeElements(s){let o=null;if(Tr("beforeSanitizeElements",s,null),Pr(s))return Or(s),!0;const i=gr(s.nodeName);if(Tr("uponSanitizeElement",s,{tagName:i,allowedTags:Ot}),s.hasChildNodes()&&!Mr(s.firstElementChild)&&le(/<[/\w]/g,s.innerHTML)&&le(/<[/\w]/g,s.textContent))return Or(s),!0;if(s.nodeType===rt.progressingInstruction)return Or(s),!0;if(Ft&&s.nodeType===rt.comment&&le(/<[/\w]/g,s.data))return Or(s),!0;if(!Ot[i]||Mt[i]){if(!Mt[i]&&Dr(i)){if(Pt.tagNameCheck instanceof RegExp&&le(Pt.tagNameCheck,i))return!1;if(Pt.tagNameCheck instanceof Function&&Pt.tagNameCheck(i))return!1}if(Gt&&!Zt[i]){const o=lt(s)||s.parentNode,i=at(s)||s.childNodes;if(i&&o)for(let u=i.length-1;u>=0;--u){const _=et(i[u],!0);_.__removalCount=(s.__removalCount||0)+1,o.insertBefore(_,it(s))}}return Or(s),!0}return s instanceof Re&&!Cr(s)?(Or(s),!0):"noscript"!==i&&"noembed"!==i&&"noframes"!==i||!le(/<\/no(script|embed|frames)/i,s.innerHTML)?(Bt&&s.nodeType===rt.text&&(o=s.textContent,B([vt,bt,_t],(s=>{o=Z(o,s," ")})),s.textContent!==o&&(V(DOMPurify.removed,{element:s.cloneNode()}),s.textContent=o)),Tr("afterSanitizeElements",s,null),!1):(Or(s),!0)},Rr=function _isValidAttribute(s,o,u){if(Kt&&("id"===o||"name"===o)&&(u in i||u in vr))return!1;if(Rt&&!Tt[o]&&le(Et,o));else if(Nt&&le(wt,o));else if(!jt[o]||Tt[o]){if(!(Dr(s)&&(Pt.tagNameCheck instanceof RegExp&&le(Pt.tagNameCheck,s)||Pt.tagNameCheck instanceof Function&&Pt.tagNameCheck(s))&&(Pt.attributeNameCheck instanceof RegExp&&le(Pt.attributeNameCheck,o)||Pt.attributeNameCheck instanceof Function&&Pt.attributeNameCheck(o))||"is"===o&&Pt.allowCustomizedBuiltInElements&&(Pt.tagNameCheck instanceof RegExp&&le(Pt.tagNameCheck,u)||Pt.tagNameCheck instanceof Function&&Pt.tagNameCheck(u))))return!1}else if(rr[o]);else if(le(Ct,Z(u,xt,"")));else if("src"!==o&&"xlink:href"!==o&&"href"!==o||"script"===s||0!==ee(u,"data:")||!er[s])if(Dt&&!le(St,Z(u,xt,"")));else if(u)return!1;return!0},Dr=function _isBasicCustomElement(s){return"annotation-xml"!==s&&Y(s,kt)},Lr=function _sanitizeAttributes(s){Tr("beforeSanitizeAttributes",s,null);const{attributes:o}=s;if(!o)return;const i={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:jt};let u=o.length;for(;u--;){const _=o[u],{name:w,namespaceURI:x,value:C}=_,j=gr(w);let L="value"===w?C:ie(C);if(i.attrName=j,i.attrValue=L,i.keepAttr=!0,i.forceKeepAttr=void 0,Tr("uponSanitizeAttribute",s,i),L=i.attrValue,Ft&&le(/((--!?|])>)|<\/(style|title)/i,L)){Ar(w,s);continue}if(i.forceKeepAttr)continue;if(Ar(w,s),!i.keepAttr)continue;if(!Lt&&le(/\/>/i,L)){Ar(w,s);continue}Bt&&B([vt,bt,_t],(s=>{L=Z(L,s," ")}));const V=gr(s.nodeName);if(Rr(V,j,L)){if(!Ht||"id"!==j&&"name"!==j||(Ar(w,s),L=Jt+L),ct&&"object"==typeof Ye&&"function"==typeof Ye.getAttributeType)if(x);else switch(Ye.getAttributeType(V,j)){case"TrustedHTML":L=ct.createHTML(L);break;case"TrustedScriptURL":L=ct.createScriptURL(L)}try{x?s.setAttributeNS(x,w,L):s.setAttribute(w,L),Pr(s)?Or(s):$(DOMPurify.removed)}catch(s){}}}Tr("afterSanitizeAttributes",s,null)},Br=function _sanitizeShadowDOM(s){let o=null;const i=Ir(s);for(Tr("beforeSanitizeShadowDOM",s,null);o=i.nextNode();)Tr("uponSanitizeShadowNode",o,null),Nr(o)||(o.content instanceof x&&_sanitizeShadowDOM(o.content),Lr(o));Tr("afterSanitizeShadowDOM",s,null)};return DOMPurify.sanitize=function(s){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},i=null,_=null,w=null,C=null;if(cr=!s,cr&&(s="\x3c!--\x3e"),"string"!=typeof s&&!Mr(s)){if("function"!=typeof s.toString)throw ce("toString is not a function");if("string"!=typeof(s=s.toString()))throw ce("dirty is not a string, aborting")}if(!DOMPurify.isSupported)return s;if($t||_r(o),DOMPurify.removed=[],"string"==typeof s&&(Yt=!1),Yt){if(s.nodeName){const o=gr(s.nodeName);if(!Ot[o]||Mt[o])throw ce("root node is forbidden and cannot be sanitized in-place")}}else if(s instanceof L)i=jr("\x3c!----\x3e"),_=i.ownerDocument.importNode(s,!0),_.nodeType===rt.element&&"BODY"===_.nodeName||"HTML"===_.nodeName?i=_:i.appendChild(_);else{if(!Ut&&!Bt&&!qt&&-1===s.indexOf("<"))return ct&&Wt?ct.createHTML(s):s;if(i=jr(s),!i)return Ut?null:Wt?ut:""}i&&Vt&&Or(i.firstChild);const j=Ir(Yt?s:i);for(;w=j.nextNode();)Nr(w)||(w.content instanceof x&&Br(w.content),Lr(w));if(Yt)return s;if(Ut){if(zt)for(C=dt.call(i.ownerDocument);i.firstChild;)C.appendChild(i.firstChild);else C=i;return(jt.shadowroot||jt.shadowrootmode)&&(C=gt.call(u,C,!0)),C}let $=qt?i.outerHTML:i.innerHTML;return qt&&Ot["!doctype"]&&i.ownerDocument&&i.ownerDocument.doctype&&i.ownerDocument.doctype.name&&le(Qe,i.ownerDocument.doctype.name)&&($="\n"+$),Bt&&B([vt,bt,_t],(s=>{$=Z($,s," ")})),ct&&Wt?ct.createHTML($):$},DOMPurify.setConfig=function(){_r(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),$t=!0},DOMPurify.clearConfig=function(){yr=null,$t=!1},DOMPurify.isValidAttribute=function(s,o,i){yr||_r({});const u=gr(s),_=gr(o);return Rr(u,_,i)},DOMPurify.addHook=function(s,o){"function"==typeof o&&(yt[s]=yt[s]||[],V(yt[s],o))},DOMPurify.removeHook=function(s){if(yt[s])return $(yt[s])},DOMPurify.removeHooks=function(s){yt[s]&&(yt[s]=[])},DOMPurify.removeAllHooks=function(){yt={}},DOMPurify}return createDOMPurify()}()},78004:s=>{"use strict";class SubRange{constructor(s,o){this.low=s,this.high=o,this.length=1+o-s}overlaps(s){return!(this.highs.high)}touches(s){return!(this.high+1s.high)}add(s){return new SubRange(Math.min(this.low,s.low),Math.max(this.high,s.high))}subtract(s){return s.low<=this.low&&s.high>=this.high?[]:s.low>this.low&&s.highs+o.length),0)}add(s,o){var _add=s=>{for(var o=0;o{for(var o=0;o{for(var o=0;o{for(var i=o.low;i<=o.high;)s.push(i),i++;return s}),[])}subranges(){return this.ranges.map((s=>({low:s.low,high:s.high,length:1+s.high-s.low})))}}s.exports=DRange},37007:s=>{"use strict";var o,i="object"==typeof Reflect?Reflect:null,u=i&&"function"==typeof i.apply?i.apply:function ReflectApply(s,o,i){return Function.prototype.apply.call(s,o,i)};o=i&&"function"==typeof i.ownKeys?i.ownKeys:Object.getOwnPropertySymbols?function ReflectOwnKeys(s){return Object.getOwnPropertyNames(s).concat(Object.getOwnPropertySymbols(s))}:function ReflectOwnKeys(s){return Object.getOwnPropertyNames(s)};var _=Number.isNaN||function NumberIsNaN(s){return s!=s};function EventEmitter(){EventEmitter.init.call(this)}s.exports=EventEmitter,s.exports.once=function once(s,o){return new Promise((function(i,u){function errorListener(i){s.removeListener(o,resolver),u(i)}function resolver(){"function"==typeof s.removeListener&&s.removeListener("error",errorListener),i([].slice.call(arguments))}eventTargetAgnosticAddListener(s,o,resolver,{once:!0}),"error"!==o&&function addErrorHandlerIfEventEmitter(s,o,i){"function"==typeof s.on&&eventTargetAgnosticAddListener(s,"error",o,i)}(s,errorListener,{once:!0})}))},EventEmitter.EventEmitter=EventEmitter,EventEmitter.prototype._events=void 0,EventEmitter.prototype._eventsCount=0,EventEmitter.prototype._maxListeners=void 0;var w=10;function checkListener(s){if("function"!=typeof s)throw new TypeError('The "listener" argument must be of type Function. Received type '+typeof s)}function _getMaxListeners(s){return void 0===s._maxListeners?EventEmitter.defaultMaxListeners:s._maxListeners}function _addListener(s,o,i,u){var _,w,x;if(checkListener(i),void 0===(w=s._events)?(w=s._events=Object.create(null),s._eventsCount=0):(void 0!==w.newListener&&(s.emit("newListener",o,i.listener?i.listener:i),w=s._events),x=w[o]),void 0===x)x=w[o]=i,++s._eventsCount;else if("function"==typeof x?x=w[o]=u?[i,x]:[x,i]:u?x.unshift(i):x.push(i),(_=_getMaxListeners(s))>0&&x.length>_&&!x.warned){x.warned=!0;var C=new Error("Possible EventEmitter memory leak detected. "+x.length+" "+String(o)+" listeners added. Use emitter.setMaxListeners() to increase limit");C.name="MaxListenersExceededWarning",C.emitter=s,C.type=o,C.count=x.length,function ProcessEmitWarning(s){console&&console.warn&&console.warn(s)}(C)}return s}function onceWrapper(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,0===arguments.length?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function _onceWrap(s,o,i){var u={fired:!1,wrapFn:void 0,target:s,type:o,listener:i},_=onceWrapper.bind(u);return _.listener=i,u.wrapFn=_,_}function _listeners(s,o,i){var u=s._events;if(void 0===u)return[];var _=u[o];return void 0===_?[]:"function"==typeof _?i?[_.listener||_]:[_]:i?function unwrapListeners(s){for(var o=new Array(s.length),i=0;i0&&(x=o[0]),x instanceof Error)throw x;var C=new Error("Unhandled error."+(x?" ("+x.message+")":""));throw C.context=x,C}var j=w[s];if(void 0===j)return!1;if("function"==typeof j)u(j,this,o);else{var L=j.length,B=arrayClone(j,L);for(i=0;i=0;w--)if(i[w]===o||i[w].listener===o){x=i[w].listener,_=w;break}if(_<0)return this;0===_?i.shift():function spliceOne(s,o){for(;o+1=0;u--)this.removeListener(s,o[u]);return this},EventEmitter.prototype.listeners=function listeners(s){return _listeners(this,s,!0)},EventEmitter.prototype.rawListeners=function rawListeners(s){return _listeners(this,s,!1)},EventEmitter.listenerCount=function(s,o){return"function"==typeof s.listenerCount?s.listenerCount(o):listenerCount.call(s,o)},EventEmitter.prototype.listenerCount=listenerCount,EventEmitter.prototype.eventNames=function eventNames(){return this._eventsCount>0?o(this._events):[]}},85587:(s,o,i)=>{"use strict";var u=i(26311),_=create(Error);function create(s){return FormattedError.displayName=s.displayName||s.name,FormattedError;function FormattedError(o){return o&&(o=u.apply(null,arguments)),new s(o)}}s.exports=_,_.eval=create(EvalError),_.range=create(RangeError),_.reference=create(ReferenceError),_.syntax=create(SyntaxError),_.type=create(TypeError),_.uri=create(URIError),_.create=create},26311:s=>{!function(){var o;function format(s){for(var o,i,u,_,w=1,x=[].slice.call(arguments),C=0,j=s.length,L="",B=!1,$=!1,nextArg=function(){return x[w++]},slurpNumber=function(){for(var i="";/\d/.test(s[C]);)i+=s[C++],o=s[C];return i.length>0?parseInt(i):null};C{function deepFreeze(s){return s instanceof Map?s.clear=s.delete=s.set=function(){throw new Error("map is read-only")}:s instanceof Set&&(s.add=s.clear=s.delete=function(){throw new Error("set is read-only")}),Object.freeze(s),Object.getOwnPropertyNames(s).forEach((function(o){var i=s[o];"object"!=typeof i||Object.isFrozen(i)||deepFreeze(i)})),s}var o=deepFreeze,i=deepFreeze;o.default=i;class Response{constructor(s){void 0===s.data&&(s.data={}),this.data=s.data,this.isMatchIgnored=!1}ignoreMatch(){this.isMatchIgnored=!0}}function escapeHTML(s){return s.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function inherit(s,...o){const i=Object.create(null);for(const o in s)i[o]=s[o];return o.forEach((function(s){for(const o in s)i[o]=s[o]})),i}const emitsWrappingTags=s=>!!s.kind;class HTMLRenderer{constructor(s,o){this.buffer="",this.classPrefix=o.classPrefix,s.walk(this)}addText(s){this.buffer+=escapeHTML(s)}openNode(s){if(!emitsWrappingTags(s))return;let o=s.kind;s.sublanguage||(o=`${this.classPrefix}${o}`),this.span(o)}closeNode(s){emitsWrappingTags(s)&&(this.buffer+="")}value(){return this.buffer}span(s){this.buffer+=``}}class TokenTree{constructor(){this.rootNode={children:[]},this.stack=[this.rootNode]}get top(){return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(s){this.top.children.push(s)}openNode(s){const o={kind:s,children:[]};this.add(o),this.stack.push(o)}closeNode(){if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}walk(s){return this.constructor._walk(s,this.rootNode)}static _walk(s,o){return"string"==typeof o?s.addText(o):o.children&&(s.openNode(o),o.children.forEach((o=>this._walk(s,o))),s.closeNode(o)),s}static _collapse(s){"string"!=typeof s&&s.children&&(s.children.every((s=>"string"==typeof s))?s.children=[s.children.join("")]:s.children.forEach((s=>{TokenTree._collapse(s)})))}}class TokenTreeEmitter extends TokenTree{constructor(s){super(),this.options=s}addKeyword(s,o){""!==s&&(this.openNode(o),this.addText(s),this.closeNode())}addText(s){""!==s&&this.add(s)}addSublanguage(s,o){const i=s.root;i.kind=o,i.sublanguage=!0,this.add(i)}toHTML(){return new HTMLRenderer(this,this.options).value()}finalize(){return!0}}function source(s){return s?"string"==typeof s?s:s.source:null}const u=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;const _="[a-zA-Z]\\w*",w="[a-zA-Z_]\\w*",x="\\b\\d+(\\.\\d+)?",C="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",j="\\b(0b[01]+)",L={begin:"\\\\[\\s\\S]",relevance:0},B={className:"string",begin:"'",end:"'",illegal:"\\n",contains:[L]},$={className:"string",begin:'"',end:'"',illegal:"\\n",contains:[L]},V={begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/},COMMENT=function(s,o,i={}){const u=inherit({className:"comment",begin:s,end:o,contains:[]},i);return u.contains.push(V),u.contains.push({className:"doctag",begin:"(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):",relevance:0}),u},U=COMMENT("//","$"),z=COMMENT("/\\*","\\*/"),Y=COMMENT("#","$"),Z={className:"number",begin:x,relevance:0},ee={className:"number",begin:C,relevance:0},ie={className:"number",begin:j,relevance:0},ae={className:"number",begin:x+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},le={begin:/(?=\/[^/\n]*\/)/,contains:[{className:"regexp",begin:/\//,end:/\/[gimuy]*/,illegal:/\n/,contains:[L,{begin:/\[/,end:/\]/,relevance:0,contains:[L]}]}]},ce={className:"title",begin:_,relevance:0},pe={className:"title",begin:w,relevance:0},de={begin:"\\.\\s*"+w,relevance:0};var fe=Object.freeze({__proto__:null,MATCH_NOTHING_RE:/\b\B/,IDENT_RE:_,UNDERSCORE_IDENT_RE:w,NUMBER_RE:x,C_NUMBER_RE:C,BINARY_NUMBER_RE:j,RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",SHEBANG:(s={})=>{const o=/^#![ ]*\//;return s.binary&&(s.begin=function concat(...s){return s.map((s=>source(s))).join("")}(o,/.*\b/,s.binary,/\b.*/)),inherit({className:"meta",begin:o,end:/$/,relevance:0,"on:begin":(s,o)=>{0!==s.index&&o.ignoreMatch()}},s)},BACKSLASH_ESCAPE:L,APOS_STRING_MODE:B,QUOTE_STRING_MODE:$,PHRASAL_WORDS_MODE:V,COMMENT,C_LINE_COMMENT_MODE:U,C_BLOCK_COMMENT_MODE:z,HASH_COMMENT_MODE:Y,NUMBER_MODE:Z,C_NUMBER_MODE:ee,BINARY_NUMBER_MODE:ie,CSS_NUMBER_MODE:ae,REGEXP_MODE:le,TITLE_MODE:ce,UNDERSCORE_TITLE_MODE:pe,METHOD_GUARD:de,END_SAME_AS_BEGIN:function(s){return Object.assign(s,{"on:begin":(s,o)=>{o.data._beginMatch=s[1]},"on:end":(s,o)=>{o.data._beginMatch!==s[1]&&o.ignoreMatch()}})}});function skipIfhasPrecedingDot(s,o){"."===s.input[s.index-1]&&o.ignoreMatch()}function beginKeywords(s,o){o&&s.beginKeywords&&(s.begin="\\b("+s.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",s.__beforeBegin=skipIfhasPrecedingDot,s.keywords=s.keywords||s.beginKeywords,delete s.beginKeywords,void 0===s.relevance&&(s.relevance=0))}function compileIllegal(s,o){Array.isArray(s.illegal)&&(s.illegal=function either(...s){return"("+s.map((s=>source(s))).join("|")+")"}(...s.illegal))}function compileMatch(s,o){if(s.match){if(s.begin||s.end)throw new Error("begin & end are not supported with match");s.begin=s.match,delete s.match}}function compileRelevance(s,o){void 0===s.relevance&&(s.relevance=1)}const ye=["of","and","for","in","not","or","if","then","parent","list","value"];function compileKeywords(s,o,i="keyword"){const u={};return"string"==typeof s?compileList(i,s.split(" ")):Array.isArray(s)?compileList(i,s):Object.keys(s).forEach((function(i){Object.assign(u,compileKeywords(s[i],o,i))})),u;function compileList(s,i){o&&(i=i.map((s=>s.toLowerCase()))),i.forEach((function(o){const i=o.split("|");u[i[0]]=[s,scoreForKeyword(i[0],i[1])]}))}}function scoreForKeyword(s,o){return o?Number(o):function commonKeyword(s){return ye.includes(s.toLowerCase())}(s)?0:1}function compileLanguage(s,{plugins:o}){function langRe(o,i){return new RegExp(source(o),"m"+(s.case_insensitive?"i":"")+(i?"g":""))}class MultiRegex{constructor(){this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}addRule(s,o){o.position=this.position++,this.matchIndexes[this.matchAt]=o,this.regexes.push([o,s]),this.matchAt+=function countMatchGroups(s){return new RegExp(s.toString()+"|").exec("").length-1}(s)+1}compile(){0===this.regexes.length&&(this.exec=()=>null);const s=this.regexes.map((s=>s[1]));this.matcherRe=langRe(function join(s,o="|"){let i=0;return s.map((s=>{i+=1;const o=i;let _=source(s),w="";for(;_.length>0;){const s=u.exec(_);if(!s){w+=_;break}w+=_.substring(0,s.index),_=_.substring(s.index+s[0].length),"\\"===s[0][0]&&s[1]?w+="\\"+String(Number(s[1])+o):(w+=s[0],"("===s[0]&&i++)}return w})).map((s=>`(${s})`)).join(o)}(s),!0),this.lastIndex=0}exec(s){this.matcherRe.lastIndex=this.lastIndex;const o=this.matcherRe.exec(s);if(!o)return null;const i=o.findIndex(((s,o)=>o>0&&void 0!==s)),u=this.matchIndexes[i];return o.splice(0,i),Object.assign(o,u)}}class ResumableMultiRegex{constructor(){this.rules=[],this.multiRegexes=[],this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(s){if(this.multiRegexes[s])return this.multiRegexes[s];const o=new MultiRegex;return this.rules.slice(s).forEach((([s,i])=>o.addRule(s,i))),o.compile(),this.multiRegexes[s]=o,o}resumingScanAtSamePosition(){return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(s,o){this.rules.push([s,o]),"begin"===o.type&&this.count++}exec(s){const o=this.getMatcher(this.regexIndex);o.lastIndex=this.lastIndex;let i=o.exec(s);if(this.resumingScanAtSamePosition())if(i&&i.index===this.lastIndex);else{const o=this.getMatcher(0);o.lastIndex=this.lastIndex+1,i=o.exec(s)}return i&&(this.regexIndex+=i.position+1,this.regexIndex===this.count&&this.considerAll()),i}}if(s.compilerExtensions||(s.compilerExtensions=[]),s.contains&&s.contains.includes("self"))throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");return s.classNameAliases=inherit(s.classNameAliases||{}),function compileMode(o,i){const u=o;if(o.isCompiled)return u;[compileMatch].forEach((s=>s(o,i))),s.compilerExtensions.forEach((s=>s(o,i))),o.__beforeBegin=null,[beginKeywords,compileIllegal,compileRelevance].forEach((s=>s(o,i))),o.isCompiled=!0;let _=null;if("object"==typeof o.keywords&&(_=o.keywords.$pattern,delete o.keywords.$pattern),o.keywords&&(o.keywords=compileKeywords(o.keywords,s.case_insensitive)),o.lexemes&&_)throw new Error("ERR: Prefer `keywords.$pattern` to `mode.lexemes`, BOTH are not allowed. (see mode reference) ");return _=_||o.lexemes||/\w+/,u.keywordPatternRe=langRe(_,!0),i&&(o.begin||(o.begin=/\B|\b/),u.beginRe=langRe(o.begin),o.endSameAsBegin&&(o.end=o.begin),o.end||o.endsWithParent||(o.end=/\B|\b/),o.end&&(u.endRe=langRe(o.end)),u.terminatorEnd=source(o.end)||"",o.endsWithParent&&i.terminatorEnd&&(u.terminatorEnd+=(o.end?"|":"")+i.terminatorEnd)),o.illegal&&(u.illegalRe=langRe(o.illegal)),o.contains||(o.contains=[]),o.contains=[].concat(...o.contains.map((function(s){return function expandOrCloneMode(s){s.variants&&!s.cachedVariants&&(s.cachedVariants=s.variants.map((function(o){return inherit(s,{variants:null},o)})));if(s.cachedVariants)return s.cachedVariants;if(dependencyOnParent(s))return inherit(s,{starts:s.starts?inherit(s.starts):null});if(Object.isFrozen(s))return inherit(s);return s}("self"===s?o:s)}))),o.contains.forEach((function(s){compileMode(s,u)})),o.starts&&compileMode(o.starts,i),u.matcher=function buildModeRegex(s){const o=new ResumableMultiRegex;return s.contains.forEach((s=>o.addRule(s.begin,{rule:s,type:"begin"}))),s.terminatorEnd&&o.addRule(s.terminatorEnd,{type:"end"}),s.illegal&&o.addRule(s.illegal,{type:"illegal"}),o}(u),u}(s)}function dependencyOnParent(s){return!!s&&(s.endsWithParent||dependencyOnParent(s.starts))}function BuildVuePlugin(s){const o={props:["language","code","autodetect"],data:function(){return{detectedLanguage:"",unknownLanguage:!1}},computed:{className(){return this.unknownLanguage?"":"hljs "+this.detectedLanguage},highlighted(){if(!this.autoDetect&&!s.getLanguage(this.language))return console.warn(`The language "${this.language}" you specified could not be found.`),this.unknownLanguage=!0,escapeHTML(this.code);let o={};return this.autoDetect?(o=s.highlightAuto(this.code),this.detectedLanguage=o.language):(o=s.highlight(this.language,this.code,this.ignoreIllegals),this.detectedLanguage=this.language),o.value},autoDetect(){return!this.language||function hasValueOrEmptyAttribute(s){return Boolean(s||""===s)}(this.autodetect)},ignoreIllegals:()=>!0},render(s){return s("pre",{},[s("code",{class:this.className,domProps:{innerHTML:this.highlighted}})])}};return{Component:o,VuePlugin:{install(s){s.component("highlightjs",o)}}}}const be={"after:highlightElement":({el:s,result:o,text:i})=>{const u=nodeStream(s);if(!u.length)return;const _=document.createElement("div");_.innerHTML=o.value,o.value=function mergeStreams(s,o,i){let u=0,_="";const w=[];function selectStream(){return s.length&&o.length?s[0].offset!==o[0].offset?s[0].offset"}function close(s){_+=""}function render(s){("start"===s.event?open:close)(s.node)}for(;s.length||o.length;){let o=selectStream();if(_+=escapeHTML(i.substring(u,o[0].offset)),u=o[0].offset,o===s){w.reverse().forEach(close);do{render(o.splice(0,1)[0]),o=selectStream()}while(o===s&&o.length&&o[0].offset===u);w.reverse().forEach(open)}else"start"===o[0].event?w.push(o[0].node):w.pop(),render(o.splice(0,1)[0])}return _+escapeHTML(i.substr(u))}(u,nodeStream(_),i)}};function tag(s){return s.nodeName.toLowerCase()}function nodeStream(s){const o=[];return function _nodeStream(s,i){for(let u=s.firstChild;u;u=u.nextSibling)3===u.nodeType?i+=u.nodeValue.length:1===u.nodeType&&(o.push({event:"start",offset:i,node:u}),i=_nodeStream(u,i),tag(u).match(/br|hr|img|input/)||o.push({event:"stop",offset:i,node:u}));return i}(s,0),o}const _e={},error=s=>{console.error(s)},warn=(s,...o)=>{console.log(`WARN: ${s}`,...o)},deprecated=(s,o)=>{_e[`${s}/${o}`]||(console.log(`Deprecated as of ${s}. ${o}`),_e[`${s}/${o}`]=!0)},we=escapeHTML,Se=inherit,xe=Symbol("nomatch");var Pe=function(s){const i=Object.create(null),u=Object.create(null),_=[];let w=!0;const x=/(^(<[^>]+>|\t|)+|\n)/gm,C="Could not find the language '{}', did you forget to load/include a language module?",j={disableAutodetect:!0,name:"Plain text",contains:[]};let L={noHighlightRe:/^(no-?highlight)$/i,languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:null,__emitter:TokenTreeEmitter};function shouldNotHighlight(s){return L.noHighlightRe.test(s)}function highlight(s,o,i,u){let _="",w="";"object"==typeof o?(_=s,i=o.ignoreIllegals,w=o.language,u=void 0):(deprecated("10.7.0","highlight(lang, code, ...args) has been deprecated."),deprecated("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),w=s,_=o);const x={code:_,language:w};fire("before:highlight",x);const C=x.result?x.result:_highlight(x.language,x.code,i,u);return C.code=x.code,fire("after:highlight",C),C}function _highlight(s,o,u,x){function keywordData(s,o){const i=B.case_insensitive?o[0].toLowerCase():o[0];return Object.prototype.hasOwnProperty.call(s.keywords,i)&&s.keywords[i]}function processBuffer(){null!=U.subLanguage?function processSubLanguage(){if(""===Z)return;let s=null;if("string"==typeof U.subLanguage){if(!i[U.subLanguage])return void Y.addText(Z);s=_highlight(U.subLanguage,Z,!0,z[U.subLanguage]),z[U.subLanguage]=s.top}else s=highlightAuto(Z,U.subLanguage.length?U.subLanguage:null);U.relevance>0&&(ee+=s.relevance),Y.addSublanguage(s.emitter,s.language)}():function processKeywords(){if(!U.keywords)return void Y.addText(Z);let s=0;U.keywordPatternRe.lastIndex=0;let o=U.keywordPatternRe.exec(Z),i="";for(;o;){i+=Z.substring(s,o.index);const u=keywordData(U,o);if(u){const[s,_]=u;if(Y.addText(i),i="",ee+=_,s.startsWith("_"))i+=o[0];else{const i=B.classNameAliases[s]||s;Y.addKeyword(o[0],i)}}else i+=o[0];s=U.keywordPatternRe.lastIndex,o=U.keywordPatternRe.exec(Z)}i+=Z.substr(s),Y.addText(i)}(),Z=""}function startNewMode(s){return s.className&&Y.openNode(B.classNameAliases[s.className]||s.className),U=Object.create(s,{parent:{value:U}}),U}function endOfMode(s,o,i){let u=function startsWith(s,o){const i=s&&s.exec(o);return i&&0===i.index}(s.endRe,i);if(u){if(s["on:end"]){const i=new Response(s);s["on:end"](o,i),i.isMatchIgnored&&(u=!1)}if(u){for(;s.endsParent&&s.parent;)s=s.parent;return s}}if(s.endsWithParent)return endOfMode(s.parent,o,i)}function doIgnore(s){return 0===U.matcher.regexIndex?(Z+=s[0],1):(le=!0,0)}function doBeginMatch(s){const o=s[0],i=s.rule,u=new Response(i),_=[i.__beforeBegin,i["on:begin"]];for(const i of _)if(i&&(i(s,u),u.isMatchIgnored))return doIgnore(o);return i&&i.endSameAsBegin&&(i.endRe=function escape(s){return new RegExp(s.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}(o)),i.skip?Z+=o:(i.excludeBegin&&(Z+=o),processBuffer(),i.returnBegin||i.excludeBegin||(Z=o)),startNewMode(i),i.returnBegin?0:o.length}function doEndMatch(s){const i=s[0],u=o.substr(s.index),_=endOfMode(U,s,u);if(!_)return xe;const w=U;w.skip?Z+=i:(w.returnEnd||w.excludeEnd||(Z+=i),processBuffer(),w.excludeEnd&&(Z=i));do{U.className&&Y.closeNode(),U.skip||U.subLanguage||(ee+=U.relevance),U=U.parent}while(U!==_.parent);return _.starts&&(_.endSameAsBegin&&(_.starts.endRe=_.endRe),startNewMode(_.starts)),w.returnEnd?0:i.length}let j={};function processLexeme(i,_){const x=_&&_[0];if(Z+=i,null==x)return processBuffer(),0;if("begin"===j.type&&"end"===_.type&&j.index===_.index&&""===x){if(Z+=o.slice(_.index,_.index+1),!w){const o=new Error("0 width match regex");throw o.languageName=s,o.badRule=j.rule,o}return 1}if(j=_,"begin"===_.type)return doBeginMatch(_);if("illegal"===_.type&&!u){const s=new Error('Illegal lexeme "'+x+'" for mode "'+(U.className||"")+'"');throw s.mode=U,s}if("end"===_.type){const s=doEndMatch(_);if(s!==xe)return s}if("illegal"===_.type&&""===x)return 1;if(ae>1e5&&ae>3*_.index){throw new Error("potential infinite loop, way more iterations than matches")}return Z+=x,x.length}const B=getLanguage(s);if(!B)throw error(C.replace("{}",s)),new Error('Unknown language: "'+s+'"');const $=compileLanguage(B,{plugins:_});let V="",U=x||$;const z={},Y=new L.__emitter(L);!function processContinuations(){const s=[];for(let o=U;o!==B;o=o.parent)o.className&&s.unshift(o.className);s.forEach((s=>Y.openNode(s)))}();let Z="",ee=0,ie=0,ae=0,le=!1;try{for(U.matcher.considerAll();;){ae++,le?le=!1:U.matcher.considerAll(),U.matcher.lastIndex=ie;const s=U.matcher.exec(o);if(!s)break;const i=processLexeme(o.substring(ie,s.index),s);ie=s.index+i}return processLexeme(o.substr(ie)),Y.closeAllNodes(),Y.finalize(),V=Y.toHTML(),{relevance:Math.floor(ee),value:V,language:s,illegal:!1,emitter:Y,top:U}}catch(i){if(i.message&&i.message.includes("Illegal"))return{illegal:!0,illegalBy:{msg:i.message,context:o.slice(ie-100,ie+100),mode:i.mode},sofar:V,relevance:0,value:we(o),emitter:Y};if(w)return{illegal:!1,relevance:0,value:we(o),emitter:Y,language:s,top:U,errorRaised:i};throw i}}function highlightAuto(s,o){o=o||L.languages||Object.keys(i);const u=function justTextHighlightResult(s){const o={relevance:0,emitter:new L.__emitter(L),value:we(s),illegal:!1,top:j};return o.emitter.addText(s),o}(s),_=o.filter(getLanguage).filter(autoDetection).map((o=>_highlight(o,s,!1)));_.unshift(u);const w=_.sort(((s,o)=>{if(s.relevance!==o.relevance)return o.relevance-s.relevance;if(s.language&&o.language){if(getLanguage(s.language).supersetOf===o.language)return 1;if(getLanguage(o.language).supersetOf===s.language)return-1}return 0})),[x,C]=w,B=x;return B.second_best=C,B}const B={"before:highlightElement":({el:s})=>{L.useBR&&(s.innerHTML=s.innerHTML.replace(/\n/g,"").replace(//g,"\n"))},"after:highlightElement":({result:s})=>{L.useBR&&(s.value=s.value.replace(/\n/g,"
    "))}},$=/^(<[^>]+>|\t)+/gm,V={"after:highlightElement":({result:s})=>{L.tabReplace&&(s.value=s.value.replace($,(s=>s.replace(/\t/g,L.tabReplace))))}};function highlightElement(s){let o=null;const i=function blockLanguage(s){let o=s.className+" ";o+=s.parentNode?s.parentNode.className:"";const i=L.languageDetectRe.exec(o);if(i){const o=getLanguage(i[1]);return o||(warn(C.replace("{}",i[1])),warn("Falling back to no-highlight mode for this block.",s)),o?i[1]:"no-highlight"}return o.split(/\s+/).find((s=>shouldNotHighlight(s)||getLanguage(s)))}(s);if(shouldNotHighlight(i))return;fire("before:highlightElement",{el:s,language:i}),o=s;const _=o.textContent,w=i?highlight(_,{language:i,ignoreIllegals:!0}):highlightAuto(_);fire("after:highlightElement",{el:s,result:w,text:_}),s.innerHTML=w.value,function updateClassName(s,o,i){const _=o?u[o]:i;s.classList.add("hljs"),_&&s.classList.add(_)}(s,i,w.language),s.result={language:w.language,re:w.relevance,relavance:w.relevance},w.second_best&&(s.second_best={language:w.second_best.language,re:w.second_best.relevance,relavance:w.second_best.relevance})}const initHighlighting=()=>{if(initHighlighting.called)return;initHighlighting.called=!0,deprecated("10.6.0","initHighlighting() is deprecated. Use highlightAll() instead.");document.querySelectorAll("pre code").forEach(highlightElement)};let U=!1;function highlightAll(){if("loading"===document.readyState)return void(U=!0);document.querySelectorAll("pre code").forEach(highlightElement)}function getLanguage(s){return s=(s||"").toLowerCase(),i[s]||i[u[s]]}function registerAliases(s,{languageName:o}){"string"==typeof s&&(s=[s]),s.forEach((s=>{u[s.toLowerCase()]=o}))}function autoDetection(s){const o=getLanguage(s);return o&&!o.disableAutodetect}function fire(s,o){const i=s;_.forEach((function(s){s[i]&&s[i](o)}))}"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(function boot(){U&&highlightAll()}),!1),Object.assign(s,{highlight,highlightAuto,highlightAll,fixMarkup:function deprecateFixMarkup(s){return deprecated("10.2.0","fixMarkup will be removed entirely in v11.0"),deprecated("10.2.0","Please see https://github.com/highlightjs/highlight.js/issues/2534"),function fixMarkup(s){return L.tabReplace||L.useBR?s.replace(x,(s=>"\n"===s?L.useBR?"
    ":s:L.tabReplace?s.replace(/\t/g,L.tabReplace):s)):s}(s)},highlightElement,highlightBlock:function deprecateHighlightBlock(s){return deprecated("10.7.0","highlightBlock will be removed entirely in v12.0"),deprecated("10.7.0","Please use highlightElement now."),highlightElement(s)},configure:function configure(s){s.useBR&&(deprecated("10.3.0","'useBR' will be removed entirely in v11.0"),deprecated("10.3.0","Please see https://github.com/highlightjs/highlight.js/issues/2559")),L=Se(L,s)},initHighlighting,initHighlightingOnLoad:function initHighlightingOnLoad(){deprecated("10.6.0","initHighlightingOnLoad() is deprecated. Use highlightAll() instead."),U=!0},registerLanguage:function registerLanguage(o,u){let _=null;try{_=u(s)}catch(s){if(error("Language definition for '{}' could not be registered.".replace("{}",o)),!w)throw s;error(s),_=j}_.name||(_.name=o),i[o]=_,_.rawDefinition=u.bind(null,s),_.aliases&®isterAliases(_.aliases,{languageName:o})},unregisterLanguage:function unregisterLanguage(s){delete i[s];for(const o of Object.keys(u))u[o]===s&&delete u[o]},listLanguages:function listLanguages(){return Object.keys(i)},getLanguage,registerAliases,requireLanguage:function requireLanguage(s){deprecated("10.4.0","requireLanguage will be removed entirely in v11."),deprecated("10.4.0","Please see https://github.com/highlightjs/highlight.js/pull/2844");const o=getLanguage(s);if(o)return o;throw new Error("The '{}' language is required, but not loaded.".replace("{}",s))},autoDetection,inherit:Se,addPlugin:function addPlugin(s){!function upgradePluginAPI(s){s["before:highlightBlock"]&&!s["before:highlightElement"]&&(s["before:highlightElement"]=o=>{s["before:highlightBlock"](Object.assign({block:o.el},o))}),s["after:highlightBlock"]&&!s["after:highlightElement"]&&(s["after:highlightElement"]=o=>{s["after:highlightBlock"](Object.assign({block:o.el},o))})}(s),_.push(s)},vuePlugin:BuildVuePlugin(s).VuePlugin}),s.debugMode=function(){w=!1},s.safeMode=function(){w=!0},s.versionString="10.7.3";for(const s in fe)"object"==typeof fe[s]&&o(fe[s]);return Object.assign(s,fe),s.addPlugin(B),s.addPlugin(be),s.addPlugin(V),s}({});s.exports=Pe},35344:s=>{function concat(...s){return s.map((s=>function source(s){return s?"string"==typeof s?s:s.source:null}(s))).join("")}s.exports=function bash(s){const o={},i={begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[o]}]};Object.assign(o,{className:"variable",variants:[{begin:concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},i]});const u={className:"subst",begin:/\$\(/,end:/\)/,contains:[s.BACKSLASH_ESCAPE]},_={begin:/<<-?\s*(?=\w+)/,starts:{contains:[s.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,className:"string"})]}},w={className:"string",begin:/"/,end:/"/,contains:[s.BACKSLASH_ESCAPE,o,u]};u.contains.push(w);const x={begin:/\$\(\(/,end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},s.NUMBER_MODE,o]},C=s.SHEBANG({binary:`(${["fish","bash","zsh","sh","csh","ksh","tcsh","dash","scsh"].join("|")})`,relevance:10}),j={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,contains:[s.inherit(s.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0};return{name:"Bash",aliases:["sh","zsh"],keywords:{$pattern:/\b[a-z._-]+\b/,keyword:"if then else elif fi for while in do done case esac function",literal:"true false",built_in:"break cd continue eval exec exit export getopts hash pwd readonly return shift test times trap umask unset alias bind builtin caller command declare echo enable help let local logout mapfile printf read readarray source type typeset ulimit unalias set shopt autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate fc fg float functions getcap getln history integer jobs kill limit log noglob popd print pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp"},contains:[C,s.SHEBANG(),j,x,s.HASH_COMMENT_MODE,_,w,{className:"",begin:/\\"/},{className:"string",begin:/'/,end:/'/},o]}}},73402:s=>{function concat(...s){return s.map((s=>function source(s){return s?"string"==typeof s?s:s.source:null}(s))).join("")}s.exports=function http(s){const o="HTTP/(2|1\\.[01])",i={className:"attribute",begin:concat("^",/[A-Za-z][A-Za-z0-9-]*/,"(?=\\:\\s)"),starts:{contains:[{className:"punctuation",begin:/: /,relevance:0,starts:{end:"$",relevance:0}}]}},u=[i,{begin:"\\n\\n",starts:{subLanguage:[],endsWithParent:!0}}];return{name:"HTTP",aliases:["https"],illegal:/\S/,contains:[{begin:"^(?="+o+" \\d{3})",end:/$/,contains:[{className:"meta",begin:o},{className:"number",begin:"\\b\\d{3}\\b"}],starts:{end:/\b\B/,illegal:/\S/,contains:u}},{begin:"(?=^[A-Z]+ (.*?) "+o+"$)",end:/$/,contains:[{className:"string",begin:" ",end:" ",excludeBegin:!0,excludeEnd:!0},{className:"meta",begin:o},{className:"keyword",begin:"[A-Z]+"}],starts:{end:/\b\B/,illegal:/\S/,contains:u}},s.inherit(i,{relevance:0})]}}},95089:s=>{const o="[A-Za-z$_][0-9A-Za-z$_]*",i=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends"],u=["true","false","null","undefined","NaN","Infinity"],_=[].concat(["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],["arguments","this","super","console","window","document","localStorage","module","global"],["Intl","DataView","Number","Math","Date","String","RegExp","Object","Function","Boolean","Error","Symbol","Set","Map","WeakSet","WeakMap","Proxy","Reflect","JSON","Promise","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Float32Array","Array","Uint8Array","Uint8ClampedArray","ArrayBuffer","BigInt64Array","BigUint64Array","BigInt"],["EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"]);function lookahead(s){return concat("(?=",s,")")}function concat(...s){return s.map((s=>function source(s){return s?"string"==typeof s?s:s.source:null}(s))).join("")}s.exports=function javascript(s){const w=o,x="<>",C="",j={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(s,o)=>{const i=s[0].length+s.index,u=s.input[i];"<"!==u?">"===u&&(((s,{after:o})=>{const i="",returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:s.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:L,contains:ce}]}]},{begin:/,/,relevance:0},{className:"",begin:/\s/,end:/\s*/,skip:!0},{variants:[{begin:x,end:C},{begin:j.begin,"on:begin":j.isTrulyOpeningTag,end:j.end}],subLanguage:"xml",contains:[{begin:j.begin,end:j.end,skip:!0,contains:["self"]}]}],relevance:0},{className:"function",beginKeywords:"function",end:/[{;]/,excludeEnd:!0,keywords:L,contains:["self",s.inherit(s.TITLE_MODE,{begin:w}),pe],illegal:/%/},{beginKeywords:"while if switch catch for"},{className:"function",begin:s.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,contains:[pe,s.inherit(s.TITLE_MODE,{begin:w})]},{variants:[{begin:"\\."+w},{begin:"\\$"+w}],relevance:0},{className:"class",beginKeywords:"class",end:/[{;=]/,excludeEnd:!0,illegal:/[:"[\]]/,contains:[{beginKeywords:"extends"},s.UNDERSCORE_TITLE_MODE]},{begin:/\b(?=constructor)/,end:/[{;]/,excludeEnd:!0,contains:[s.inherit(s.TITLE_MODE,{begin:w}),"self",pe]},{begin:"(get|set)\\s+(?="+w+"\\()",end:/\{/,keywords:"get set",contains:[s.inherit(s.TITLE_MODE,{begin:w}),{begin:/\(\)/},pe]},{begin:/\$[(.]/}]}}},65772:s=>{s.exports=function json(s){const o={literal:"true false null"},i=[s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE],u=[s.QUOTE_STRING_MODE,s.C_NUMBER_MODE],_={end:",",endsWithParent:!0,excludeEnd:!0,contains:u,keywords:o},w={begin:/\{/,end:/\}/,contains:[{className:"attr",begin:/"/,end:/"/,contains:[s.BACKSLASH_ESCAPE],illegal:"\\n"},s.inherit(_,{begin:/:/})].concat(i),illegal:"\\S"},x={begin:"\\[",end:"\\]",contains:[s.inherit(_)],illegal:"\\S"};return u.push(w,x),i.forEach((function(s){u.push(s)})),{name:"JSON",contains:u,keywords:o,illegal:"\\S"}}},26571:s=>{s.exports=function powershell(s){const o={$pattern:/-?[A-z\.\-]+\b/,keyword:"if else foreach return do while until elseif begin for trap data dynamicparam end break throw param continue finally in switch exit filter try process catch hidden static parameter",built_in:"ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write"},i={begin:"`[\\s\\S]",relevance:0},u={className:"variable",variants:[{begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]},_={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],contains:[i,u,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},w={className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]},x=s.inherit(s.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,end:/#>/}],contains:[{className:"doctag",variants:[{begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/},{begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/}]}]}),C={className:"built_in",variants:[{begin:"(".concat("Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|Unprotect|Use|ForEach|Sort|Tee|Where",")+(-)[\\w\\d]+")}]},j={className:"class",beginKeywords:"class enum",end:/\s*[{]/,excludeEnd:!0,relevance:0,contains:[s.TITLE_MODE]},L={className:"function",begin:/function\s+/,end:/\s*\{|$/,excludeEnd:!0,returnBegin:!0,relevance:0,contains:[{begin:"function",relevance:0,className:"keyword"},{className:"title",begin:/\w[\w\d]*((-)[\w\d]+)*/,relevance:0},{begin:/\(/,end:/\)/,className:"params",relevance:0,contains:[u]}]},B={begin:/using\s/,end:/$/,returnBegin:!0,contains:[_,w,{className:"keyword",begin:/(using|assembly|command|module|namespace|type)/}]},$={variants:[{className:"operator",begin:"(".concat("-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|-split|-wildcard|-xor",")\\b")},{className:"literal",begin:/(-)[\w\d]+/,relevance:0}]},V={className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,relevance:0,contains:[{className:"keyword",begin:"(".concat(o.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,relevance:0},s.inherit(s.TITLE_MODE,{endsParent:!0})]},U=[V,x,i,s.NUMBER_MODE,_,w,C,u,{className:"literal",begin:/\$(null|true|false)\b/},{className:"selector-tag",begin:/@\B/,relevance:0}],z={begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",U,{begin:"("+["string","char","byte","int","long","bool","decimal","single","double","DateTime","xml","array","hashtable","void"].join("|")+")",className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,relevance:0})};return V.contains.unshift(z),{name:"PowerShell",aliases:["ps","ps1"],case_insensitive:!0,keywords:o,contains:U.concat(j,L,B,$,z)}}},17285:s=>{function source(s){return s?"string"==typeof s?s:s.source:null}function lookahead(s){return concat("(?=",s,")")}function concat(...s){return s.map((s=>source(s))).join("")}function either(...s){return"("+s.map((s=>source(s))).join("|")+")"}s.exports=function xml(s){const o=concat(/[A-Z_]/,function optional(s){return concat("(",s,")?")}(/[A-Z0-9_.-]*:/),/[A-Z0-9_.-]*/),i={className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},u={begin:/\s/,contains:[{className:"meta-keyword",begin:/#?[a-z_][a-z1-9_-]+/,illegal:/\n/}]},_=s.inherit(u,{begin:/\(/,end:/\)/}),w=s.inherit(s.APOS_STRING_MODE,{className:"meta-string"}),x=s.inherit(s.QUOTE_STRING_MODE,{className:"meta-string"}),C={endsWithParent:!0,illegal:/`]+/}]}]}]};return{name:"HTML, XML",aliases:["html","xhtml","rss","atom","xjb","xsd","xsl","plist","wsf","svg"],case_insensitive:!0,contains:[{className:"meta",begin://,relevance:10,contains:[u,x,w,_,{begin:/\[/,end:/\]/,contains:[{className:"meta",begin://,contains:[u,_,x,w]}]}]},s.COMMENT(//,{relevance:10}),{begin://,relevance:10},i,{className:"meta",begin:/<\?xml/,end:/\?>/,relevance:10},{className:"tag",begin:/)/,end:/>/,keywords:{name:"style"},contains:[C],starts:{end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",begin:/)/,end:/>/,keywords:{name:"script"},contains:[C],starts:{end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{className:"tag",begin:/<>|<\/>/},{className:"tag",begin:concat(//,/>/,/\s/)))),end:/\/?>/,contains:[{className:"name",begin:o,relevance:0,starts:C}]},{className:"tag",begin:concat(/<\//,lookahead(concat(o,/>/))),contains:[{className:"name",begin:o,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}}},17533:s=>{s.exports=function yaml(s){var o="true false yes no null",i="[\\w#;/?:@&=+$,.~*'()[\\]]+",u={className:"string",relevance:0,variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/\S+/}],contains:[s.BACKSLASH_ESCAPE,{className:"template-variable",variants:[{begin:/\{\{/,end:/\}\}/},{begin:/%\{/,end:/\}/}]}]},_=s.inherit(u,{variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),w={className:"number",begin:"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"},x={end:",",endsWithParent:!0,excludeEnd:!0,keywords:o,relevance:0},C={begin:/\{/,end:/\}/,contains:[x],illegal:"\\n",relevance:0},j={begin:"\\[",end:"\\]",contains:[x],illegal:"\\n",relevance:0},L=[{className:"attr",variants:[{begin:"\\w[\\w :\\/.-]*:(?=[ \t]|$)"},{begin:'"\\w[\\w :\\/.-]*":(?=[ \t]|$)'},{begin:"'\\w[\\w :\\/.-]*':(?=[ \t]|$)"}]},{className:"meta",begin:"^---\\s*$",relevance:10},{className:"string",begin:"[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"},{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:"!\\w+!"+i},{className:"type",begin:"!<"+i+">"},{className:"type",begin:"!"+i},{className:"type",begin:"!!"+i},{className:"meta",begin:"&"+s.UNDERSCORE_IDENT_RE+"$"},{className:"meta",begin:"\\*"+s.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",relevance:0},s.HASH_COMMENT_MODE,{beginKeywords:o,keywords:{literal:o}},w,{className:"number",begin:s.C_NUMBER_RE+"\\b",relevance:0},C,j,u],B=[...L];return B.pop(),B.push(_),x.contains=B,{name:"YAML",case_insensitive:!0,aliases:["yml"],contains:L}}},251:(s,o)=>{o.read=function(s,o,i,u,_){var w,x,C=8*_-u-1,j=(1<>1,B=-7,$=i?_-1:0,V=i?-1:1,U=s[o+$];for($+=V,w=U&(1<<-B)-1,U>>=-B,B+=C;B>0;w=256*w+s[o+$],$+=V,B-=8);for(x=w&(1<<-B)-1,w>>=-B,B+=u;B>0;x=256*x+s[o+$],$+=V,B-=8);if(0===w)w=1-L;else{if(w===j)return x?NaN:1/0*(U?-1:1);x+=Math.pow(2,u),w-=L}return(U?-1:1)*x*Math.pow(2,w-u)},o.write=function(s,o,i,u,_,w){var x,C,j,L=8*w-_-1,B=(1<>1,V=23===_?Math.pow(2,-24)-Math.pow(2,-77):0,U=u?0:w-1,z=u?1:-1,Y=o<0||0===o&&1/o<0?1:0;for(o=Math.abs(o),isNaN(o)||o===1/0?(C=isNaN(o)?1:0,x=B):(x=Math.floor(Math.log(o)/Math.LN2),o*(j=Math.pow(2,-x))<1&&(x--,j*=2),(o+=x+$>=1?V/j:V*Math.pow(2,1-$))*j>=2&&(x++,j/=2),x+$>=B?(C=0,x=B):x+$>=1?(C=(o*j-1)*Math.pow(2,_),x+=$):(C=o*Math.pow(2,$-1)*Math.pow(2,_),x=0));_>=8;s[i+U]=255&C,U+=z,C/=256,_-=8);for(x=x<<_|C,L+=_;L>0;s[i+U]=255&x,U+=z,x/=256,L-=8);s[i+U-z]|=128*Y}},9404:function(s){s.exports=function(){"use strict";var s=Array.prototype.slice;function createClass(s,o){o&&(s.prototype=Object.create(o.prototype)),s.prototype.constructor=s}function Iterable(s){return isIterable(s)?s:Seq(s)}function KeyedIterable(s){return isKeyed(s)?s:KeyedSeq(s)}function IndexedIterable(s){return isIndexed(s)?s:IndexedSeq(s)}function SetIterable(s){return isIterable(s)&&!isAssociative(s)?s:SetSeq(s)}function isIterable(s){return!(!s||!s[o])}function isKeyed(s){return!(!s||!s[i])}function isIndexed(s){return!(!s||!s[u])}function isAssociative(s){return isKeyed(s)||isIndexed(s)}function isOrdered(s){return!(!s||!s[_])}createClass(KeyedIterable,Iterable),createClass(IndexedIterable,Iterable),createClass(SetIterable,Iterable),Iterable.isIterable=isIterable,Iterable.isKeyed=isKeyed,Iterable.isIndexed=isIndexed,Iterable.isAssociative=isAssociative,Iterable.isOrdered=isOrdered,Iterable.Keyed=KeyedIterable,Iterable.Indexed=IndexedIterable,Iterable.Set=SetIterable;var o="@@__IMMUTABLE_ITERABLE__@@",i="@@__IMMUTABLE_KEYED__@@",u="@@__IMMUTABLE_INDEXED__@@",_="@@__IMMUTABLE_ORDERED__@@",w="delete",x=5,C=1<>>0;if(""+i!==o||4294967295===i)return NaN;o=i}return o<0?ensureSize(s)+o:o}function returnTrue(){return!0}function wholeSlice(s,o,i){return(0===s||void 0!==i&&s<=-i)&&(void 0===o||void 0!==i&&o>=i)}function resolveBegin(s,o){return resolveIndex(s,o,0)}function resolveEnd(s,o){return resolveIndex(s,o,o)}function resolveIndex(s,o,i){return void 0===s?i:s<0?Math.max(0,o+s):void 0===o?s:Math.min(o,s)}var V=0,U=1,z=2,Y="function"==typeof Symbol&&Symbol.iterator,Z="@@iterator",ee=Y||Z;function Iterator(s){this.next=s}function iteratorValue(s,o,i,u){var _=0===s?o:1===s?i:[o,i];return u?u.value=_:u={value:_,done:!1},u}function iteratorDone(){return{value:void 0,done:!0}}function hasIterator(s){return!!getIteratorFn(s)}function isIterator(s){return s&&"function"==typeof s.next}function getIterator(s){var o=getIteratorFn(s);return o&&o.call(s)}function getIteratorFn(s){var o=s&&(Y&&s[Y]||s[Z]);if("function"==typeof o)return o}function isArrayLike(s){return s&&"number"==typeof s.length}function Seq(s){return null==s?emptySequence():isIterable(s)?s.toSeq():seqFromValue(s)}function KeyedSeq(s){return null==s?emptySequence().toKeyedSeq():isIterable(s)?isKeyed(s)?s.toSeq():s.fromEntrySeq():keyedSeqFromValue(s)}function IndexedSeq(s){return null==s?emptySequence():isIterable(s)?isKeyed(s)?s.entrySeq():s.toIndexedSeq():indexedSeqFromValue(s)}function SetSeq(s){return(null==s?emptySequence():isIterable(s)?isKeyed(s)?s.entrySeq():s:indexedSeqFromValue(s)).toSetSeq()}Iterator.prototype.toString=function(){return"[Iterator]"},Iterator.KEYS=V,Iterator.VALUES=U,Iterator.ENTRIES=z,Iterator.prototype.inspect=Iterator.prototype.toSource=function(){return this.toString()},Iterator.prototype[ee]=function(){return this},createClass(Seq,Iterable),Seq.of=function(){return Seq(arguments)},Seq.prototype.toSeq=function(){return this},Seq.prototype.toString=function(){return this.__toString("Seq {","}")},Seq.prototype.cacheResult=function(){return!this._cache&&this.__iterateUncached&&(this._cache=this.entrySeq().toArray(),this.size=this._cache.length),this},Seq.prototype.__iterate=function(s,o){return seqIterate(this,s,o,!0)},Seq.prototype.__iterator=function(s,o){return seqIterator(this,s,o,!0)},createClass(KeyedSeq,Seq),KeyedSeq.prototype.toKeyedSeq=function(){return this},createClass(IndexedSeq,Seq),IndexedSeq.of=function(){return IndexedSeq(arguments)},IndexedSeq.prototype.toIndexedSeq=function(){return this},IndexedSeq.prototype.toString=function(){return this.__toString("Seq [","]")},IndexedSeq.prototype.__iterate=function(s,o){return seqIterate(this,s,o,!1)},IndexedSeq.prototype.__iterator=function(s,o){return seqIterator(this,s,o,!1)},createClass(SetSeq,Seq),SetSeq.of=function(){return SetSeq(arguments)},SetSeq.prototype.toSetSeq=function(){return this},Seq.isSeq=isSeq,Seq.Keyed=KeyedSeq,Seq.Set=SetSeq,Seq.Indexed=IndexedSeq;var ie,ae,le,ce="@@__IMMUTABLE_SEQ__@@";function ArraySeq(s){this._array=s,this.size=s.length}function ObjectSeq(s){var o=Object.keys(s);this._object=s,this._keys=o,this.size=o.length}function IterableSeq(s){this._iterable=s,this.size=s.length||s.size}function IteratorSeq(s){this._iterator=s,this._iteratorCache=[]}function isSeq(s){return!(!s||!s[ce])}function emptySequence(){return ie||(ie=new ArraySeq([]))}function keyedSeqFromValue(s){var o=Array.isArray(s)?new ArraySeq(s).fromEntrySeq():isIterator(s)?new IteratorSeq(s).fromEntrySeq():hasIterator(s)?new IterableSeq(s).fromEntrySeq():"object"==typeof s?new ObjectSeq(s):void 0;if(!o)throw new TypeError("Expected Array or iterable object of [k, v] entries, or keyed object: "+s);return o}function indexedSeqFromValue(s){var o=maybeIndexedSeqFromValue(s);if(!o)throw new TypeError("Expected Array or iterable object of values: "+s);return o}function seqFromValue(s){var o=maybeIndexedSeqFromValue(s)||"object"==typeof s&&new ObjectSeq(s);if(!o)throw new TypeError("Expected Array or iterable object of values, or keyed object: "+s);return o}function maybeIndexedSeqFromValue(s){return isArrayLike(s)?new ArraySeq(s):isIterator(s)?new IteratorSeq(s):hasIterator(s)?new IterableSeq(s):void 0}function seqIterate(s,o,i,u){var _=s._cache;if(_){for(var w=_.length-1,x=0;x<=w;x++){var C=_[i?w-x:x];if(!1===o(C[1],u?C[0]:x,s))return x+1}return x}return s.__iterateUncached(o,i)}function seqIterator(s,o,i,u){var _=s._cache;if(_){var w=_.length-1,x=0;return new Iterator((function(){var s=_[i?w-x:x];return x++>w?iteratorDone():iteratorValue(o,u?s[0]:x-1,s[1])}))}return s.__iteratorUncached(o,i)}function fromJS(s,o){return o?fromJSWith(o,s,"",{"":s}):fromJSDefault(s)}function fromJSWith(s,o,i,u){return Array.isArray(o)?s.call(u,i,IndexedSeq(o).map((function(i,u){return fromJSWith(s,i,u,o)}))):isPlainObj(o)?s.call(u,i,KeyedSeq(o).map((function(i,u){return fromJSWith(s,i,u,o)}))):o}function fromJSDefault(s){return Array.isArray(s)?IndexedSeq(s).map(fromJSDefault).toList():isPlainObj(s)?KeyedSeq(s).map(fromJSDefault).toMap():s}function isPlainObj(s){return s&&(s.constructor===Object||void 0===s.constructor)}function is(s,o){if(s===o||s!=s&&o!=o)return!0;if(!s||!o)return!1;if("function"==typeof s.valueOf&&"function"==typeof o.valueOf){if((s=s.valueOf())===(o=o.valueOf())||s!=s&&o!=o)return!0;if(!s||!o)return!1}return!("function"!=typeof s.equals||"function"!=typeof o.equals||!s.equals(o))}function deepEqual(s,o){if(s===o)return!0;if(!isIterable(o)||void 0!==s.size&&void 0!==o.size&&s.size!==o.size||void 0!==s.__hash&&void 0!==o.__hash&&s.__hash!==o.__hash||isKeyed(s)!==isKeyed(o)||isIndexed(s)!==isIndexed(o)||isOrdered(s)!==isOrdered(o))return!1;if(0===s.size&&0===o.size)return!0;var i=!isAssociative(s);if(isOrdered(s)){var u=s.entries();return o.every((function(s,o){var _=u.next().value;return _&&is(_[1],s)&&(i||is(_[0],o))}))&&u.next().done}var _=!1;if(void 0===s.size)if(void 0===o.size)"function"==typeof s.cacheResult&&s.cacheResult();else{_=!0;var w=s;s=o,o=w}var x=!0,C=o.__iterate((function(o,u){if(i?!s.has(o):_?!is(o,s.get(u,L)):!is(s.get(u,L),o))return x=!1,!1}));return x&&s.size===C}function Repeat(s,o){if(!(this instanceof Repeat))return new Repeat(s,o);if(this._value=s,this.size=void 0===o?1/0:Math.max(0,o),0===this.size){if(ae)return ae;ae=this}}function invariant(s,o){if(!s)throw new Error(o)}function Range(s,o,i){if(!(this instanceof Range))return new Range(s,o,i);if(invariant(0!==i,"Cannot step a Range by 0"),s=s||0,void 0===o&&(o=1/0),i=void 0===i?1:Math.abs(i),ou?iteratorDone():iteratorValue(s,_,i[o?u-_++:_++])}))},createClass(ObjectSeq,KeyedSeq),ObjectSeq.prototype.get=function(s,o){return void 0===o||this.has(s)?this._object[s]:o},ObjectSeq.prototype.has=function(s){return this._object.hasOwnProperty(s)},ObjectSeq.prototype.__iterate=function(s,o){for(var i=this._object,u=this._keys,_=u.length-1,w=0;w<=_;w++){var x=u[o?_-w:w];if(!1===s(i[x],x,this))return w+1}return w},ObjectSeq.prototype.__iterator=function(s,o){var i=this._object,u=this._keys,_=u.length-1,w=0;return new Iterator((function(){var x=u[o?_-w:w];return w++>_?iteratorDone():iteratorValue(s,x,i[x])}))},ObjectSeq.prototype[_]=!0,createClass(IterableSeq,IndexedSeq),IterableSeq.prototype.__iterateUncached=function(s,o){if(o)return this.cacheResult().__iterate(s,o);var i=getIterator(this._iterable),u=0;if(isIterator(i))for(var _;!(_=i.next()).done&&!1!==s(_.value,u++,this););return u},IterableSeq.prototype.__iteratorUncached=function(s,o){if(o)return this.cacheResult().__iterator(s,o);var i=getIterator(this._iterable);if(!isIterator(i))return new Iterator(iteratorDone);var u=0;return new Iterator((function(){var o=i.next();return o.done?o:iteratorValue(s,u++,o.value)}))},createClass(IteratorSeq,IndexedSeq),IteratorSeq.prototype.__iterateUncached=function(s,o){if(o)return this.cacheResult().__iterate(s,o);for(var i,u=this._iterator,_=this._iteratorCache,w=0;w<_.length;)if(!1===s(_[w],w++,this))return w;for(;!(i=u.next()).done;){var x=i.value;if(_[w]=x,!1===s(x,w++,this))break}return w},IteratorSeq.prototype.__iteratorUncached=function(s,o){if(o)return this.cacheResult().__iterator(s,o);var i=this._iterator,u=this._iteratorCache,_=0;return new Iterator((function(){if(_>=u.length){var o=i.next();if(o.done)return o;u[_]=o.value}return iteratorValue(s,_,u[_++])}))},createClass(Repeat,IndexedSeq),Repeat.prototype.toString=function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},Repeat.prototype.get=function(s,o){return this.has(s)?this._value:o},Repeat.prototype.includes=function(s){return is(this._value,s)},Repeat.prototype.slice=function(s,o){var i=this.size;return wholeSlice(s,o,i)?this:new Repeat(this._value,resolveEnd(o,i)-resolveBegin(s,i))},Repeat.prototype.reverse=function(){return this},Repeat.prototype.indexOf=function(s){return is(this._value,s)?0:-1},Repeat.prototype.lastIndexOf=function(s){return is(this._value,s)?this.size:-1},Repeat.prototype.__iterate=function(s,o){for(var i=0;i=0&&o=0&&ii?iteratorDone():iteratorValue(s,w++,x)}))},Range.prototype.equals=function(s){return s instanceof Range?this._start===s._start&&this._end===s._end&&this._step===s._step:deepEqual(this,s)},createClass(Collection,Iterable),createClass(KeyedCollection,Collection),createClass(IndexedCollection,Collection),createClass(SetCollection,Collection),Collection.Keyed=KeyedCollection,Collection.Indexed=IndexedCollection,Collection.Set=SetCollection;var pe="function"==typeof Math.imul&&-2===Math.imul(4294967295,2)?Math.imul:function imul(s,o){var i=65535&(s|=0),u=65535&(o|=0);return i*u+((s>>>16)*u+i*(o>>>16)<<16>>>0)|0};function smi(s){return s>>>1&1073741824|3221225471&s}function hash(s){if(!1===s||null==s)return 0;if("function"==typeof s.valueOf&&(!1===(s=s.valueOf())||null==s))return 0;if(!0===s)return 1;var o=typeof s;if("number"===o){if(s!=s||s===1/0)return 0;var i=0|s;for(i!==s&&(i^=4294967295*s);s>4294967295;)i^=s/=4294967295;return smi(i)}if("string"===o)return s.length>Se?cachedHashString(s):hashString(s);if("function"==typeof s.hashCode)return s.hashCode();if("object"===o)return hashJSObj(s);if("function"==typeof s.toString)return hashString(s.toString());throw new Error("Value type "+o+" cannot be hashed.")}function cachedHashString(s){var o=Te[s];return void 0===o&&(o=hashString(s),Pe===xe&&(Pe=0,Te={}),Pe++,Te[s]=o),o}function hashString(s){for(var o=0,i=0;i0)switch(s.nodeType){case 1:return s.uniqueID;case 9:return s.documentElement&&s.documentElement.uniqueID}}var ye,be="function"==typeof WeakMap;be&&(ye=new WeakMap);var _e=0,we="__immutablehash__";"function"==typeof Symbol&&(we=Symbol(we));var Se=16,xe=255,Pe=0,Te={};function assertNotInfinite(s){invariant(s!==1/0,"Cannot perform this action with an infinite size.")}function Map(s){return null==s?emptyMap():isMap(s)&&!isOrdered(s)?s:emptyMap().withMutations((function(o){var i=KeyedIterable(s);assertNotInfinite(i.size),i.forEach((function(s,i){return o.set(i,s)}))}))}function isMap(s){return!(!s||!s[qe])}createClass(Map,KeyedCollection),Map.of=function(){var o=s.call(arguments,0);return emptyMap().withMutations((function(s){for(var i=0;i=o.length)throw new Error("Missing value for key: "+o[i]);s.set(o[i],o[i+1])}}))},Map.prototype.toString=function(){return this.__toString("Map {","}")},Map.prototype.get=function(s,o){return this._root?this._root.get(0,void 0,s,o):o},Map.prototype.set=function(s,o){return updateMap(this,s,o)},Map.prototype.setIn=function(s,o){return this.updateIn(s,L,(function(){return o}))},Map.prototype.remove=function(s){return updateMap(this,s,L)},Map.prototype.deleteIn=function(s){return this.updateIn(s,(function(){return L}))},Map.prototype.update=function(s,o,i){return 1===arguments.length?s(this):this.updateIn([s],o,i)},Map.prototype.updateIn=function(s,o,i){i||(i=o,o=void 0);var u=updateInDeepMap(this,forceIterator(s),o,i);return u===L?void 0:u},Map.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):emptyMap()},Map.prototype.merge=function(){return mergeIntoMapWith(this,void 0,arguments)},Map.prototype.mergeWith=function(o){return mergeIntoMapWith(this,o,s.call(arguments,1))},Map.prototype.mergeIn=function(o){var i=s.call(arguments,1);return this.updateIn(o,emptyMap(),(function(s){return"function"==typeof s.merge?s.merge.apply(s,i):i[i.length-1]}))},Map.prototype.mergeDeep=function(){return mergeIntoMapWith(this,deepMerger,arguments)},Map.prototype.mergeDeepWith=function(o){var i=s.call(arguments,1);return mergeIntoMapWith(this,deepMergerWith(o),i)},Map.prototype.mergeDeepIn=function(o){var i=s.call(arguments,1);return this.updateIn(o,emptyMap(),(function(s){return"function"==typeof s.mergeDeep?s.mergeDeep.apply(s,i):i[i.length-1]}))},Map.prototype.sort=function(s){return OrderedMap(sortFactory(this,s))},Map.prototype.sortBy=function(s,o){return OrderedMap(sortFactory(this,o,s))},Map.prototype.withMutations=function(s){var o=this.asMutable();return s(o),o.wasAltered()?o.__ensureOwner(this.__ownerID):this},Map.prototype.asMutable=function(){return this.__ownerID?this:this.__ensureOwner(new OwnerID)},Map.prototype.asImmutable=function(){return this.__ensureOwner()},Map.prototype.wasAltered=function(){return this.__altered},Map.prototype.__iterator=function(s,o){return new MapIterator(this,s,o)},Map.prototype.__iterate=function(s,o){var i=this,u=0;return this._root&&this._root.iterate((function(o){return u++,s(o[1],o[0],i)}),o),u},Map.prototype.__ensureOwner=function(s){return s===this.__ownerID?this:s?makeMap(this.size,this._root,s,this.__hash):(this.__ownerID=s,this.__altered=!1,this)},Map.isMap=isMap;var Re,qe="@@__IMMUTABLE_MAP__@@",$e=Map.prototype;function ArrayMapNode(s,o){this.ownerID=s,this.entries=o}function BitmapIndexedNode(s,o,i){this.ownerID=s,this.bitmap=o,this.nodes=i}function HashArrayMapNode(s,o,i){this.ownerID=s,this.count=o,this.nodes=i}function HashCollisionNode(s,o,i){this.ownerID=s,this.keyHash=o,this.entries=i}function ValueNode(s,o,i){this.ownerID=s,this.keyHash=o,this.entry=i}function MapIterator(s,o,i){this._type=o,this._reverse=i,this._stack=s._root&&mapIteratorFrame(s._root)}function mapIteratorValue(s,o){return iteratorValue(s,o[0],o[1])}function mapIteratorFrame(s,o){return{node:s,index:0,__prev:o}}function makeMap(s,o,i,u){var _=Object.create($e);return _.size=s,_._root=o,_.__ownerID=i,_.__hash=u,_.__altered=!1,_}function emptyMap(){return Re||(Re=makeMap(0))}function updateMap(s,o,i){var u,_;if(s._root){var w=MakeRef(B),x=MakeRef($);if(u=updateNode(s._root,s.__ownerID,0,void 0,o,i,w,x),!x.value)return s;_=s.size+(w.value?i===L?-1:1:0)}else{if(i===L)return s;_=1,u=new ArrayMapNode(s.__ownerID,[[o,i]])}return s.__ownerID?(s.size=_,s._root=u,s.__hash=void 0,s.__altered=!0,s):u?makeMap(_,u):emptyMap()}function updateNode(s,o,i,u,_,w,x,C){return s?s.update(o,i,u,_,w,x,C):w===L?s:(SetRef(C),SetRef(x),new ValueNode(o,u,[_,w]))}function isLeafNode(s){return s.constructor===ValueNode||s.constructor===HashCollisionNode}function mergeIntoNode(s,o,i,u,_){if(s.keyHash===u)return new HashCollisionNode(o,u,[s.entry,_]);var w,C=(0===i?s.keyHash:s.keyHash>>>i)&j,L=(0===i?u:u>>>i)&j;return new BitmapIndexedNode(o,1<>>=1)x[j]=1&i?o[w++]:void 0;return x[u]=_,new HashArrayMapNode(s,w+1,x)}function mergeIntoMapWith(s,o,i){for(var u=[],_=0;_>1&1431655765))+(s>>2&858993459))+(s>>4)&252645135,s+=s>>8,127&(s+=s>>16)}function setIn(s,o,i,u){var _=u?s:arrCopy(s);return _[o]=i,_}function spliceIn(s,o,i,u){var _=s.length+1;if(u&&o+1===_)return s[o]=i,s;for(var w=new Array(_),x=0,C=0;C<_;C++)C===o?(w[C]=i,x=-1):w[C]=s[C+x];return w}function spliceOut(s,o,i){var u=s.length-1;if(i&&o===u)return s.pop(),s;for(var _=new Array(u),w=0,x=0;x=ze)return createNodes(s,j,u,_);var U=s&&s===this.ownerID,z=U?j:arrCopy(j);return V?C?B===$-1?z.pop():z[B]=z.pop():z[B]=[u,_]:z.push([u,_]),U?(this.entries=z,this):new ArrayMapNode(s,z)}},BitmapIndexedNode.prototype.get=function(s,o,i,u){void 0===o&&(o=hash(i));var _=1<<((0===s?o:o>>>s)&j),w=this.bitmap;return w&_?this.nodes[popCount(w&_-1)].get(s+x,o,i,u):u},BitmapIndexedNode.prototype.update=function(s,o,i,u,_,w,C){void 0===i&&(i=hash(u));var B=(0===o?i:i>>>o)&j,$=1<=We)return expandNodes(s,Y,V,B,ee);if(U&&!ee&&2===Y.length&&isLeafNode(Y[1^z]))return Y[1^z];if(U&&ee&&1===Y.length&&isLeafNode(ee))return ee;var ie=s&&s===this.ownerID,ae=U?ee?V:V^$:V|$,le=U?ee?setIn(Y,z,ee,ie):spliceOut(Y,z,ie):spliceIn(Y,z,ee,ie);return ie?(this.bitmap=ae,this.nodes=le,this):new BitmapIndexedNode(s,ae,le)},HashArrayMapNode.prototype.get=function(s,o,i,u){void 0===o&&(o=hash(i));var _=(0===s?o:o>>>s)&j,w=this.nodes[_];return w?w.get(s+x,o,i,u):u},HashArrayMapNode.prototype.update=function(s,o,i,u,_,w,C){void 0===i&&(i=hash(u));var B=(0===o?i:i>>>o)&j,$=_===L,V=this.nodes,U=V[B];if($&&!U)return this;var z=updateNode(U,s,o+x,i,u,_,w,C);if(z===U)return this;var Y=this.count;if(U){if(!z&&--Y0&&u=0&&s>>o&j;if(u>=this.array.length)return new VNode([],s);var _,w=0===u;if(o>0){var C=this.array[u];if((_=C&&C.removeBefore(s,o-x,i))===C&&w)return this}if(w&&!_)return this;var L=editableVNode(this,s);if(!w)for(var B=0;B>>o&j;if(_>=this.array.length)return this;if(o>0){var w=this.array[_];if((u=w&&w.removeAfter(s,o-x,i))===w&&_===this.array.length-1)return this}var C=editableVNode(this,s);return C.array.splice(_+1),u&&(C.array[_]=u),C};var Qe,et,tt={};function iterateList(s,o){var i=s._origin,u=s._capacity,_=getTailOffset(u),w=s._tail;return iterateNodeOrLeaf(s._root,s._level,0);function iterateNodeOrLeaf(s,o,i){return 0===o?iterateLeaf(s,i):iterateNode(s,o,i)}function iterateLeaf(s,x){var j=x===_?w&&w.array:s&&s.array,L=x>i?0:i-x,B=u-x;return B>C&&(B=C),function(){if(L===B)return tt;var s=o?--B:L++;return j&&j[s]}}function iterateNode(s,_,w){var j,L=s&&s.array,B=w>i?0:i-w>>_,$=1+(u-w>>_);return $>C&&($=C),function(){for(;;){if(j){var s=j();if(s!==tt)return s;j=null}if(B===$)return tt;var i=o?--$:B++;j=iterateNodeOrLeaf(L&&L[i],_-x,w+(i<<_))}}}}function makeList(s,o,i,u,_,w,x){var C=Object.create(Xe);return C.size=o-s,C._origin=s,C._capacity=o,C._level=i,C._root=u,C._tail=_,C.__ownerID=w,C.__hash=x,C.__altered=!1,C}function emptyList(){return Qe||(Qe=makeList(0,0,x))}function updateList(s,o,i){if((o=wrapIndex(s,o))!=o)return s;if(o>=s.size||o<0)return s.withMutations((function(s){o<0?setListBounds(s,o).set(0,i):setListBounds(s,0,o+1).set(o,i)}));o+=s._origin;var u=s._tail,_=s._root,w=MakeRef($);return o>=getTailOffset(s._capacity)?u=updateVNode(u,s.__ownerID,0,o,i,w):_=updateVNode(_,s.__ownerID,s._level,o,i,w),w.value?s.__ownerID?(s._root=_,s._tail=u,s.__hash=void 0,s.__altered=!0,s):makeList(s._origin,s._capacity,s._level,_,u):s}function updateVNode(s,o,i,u,_,w){var C,L=u>>>i&j,B=s&&L0){var $=s&&s.array[L],V=updateVNode($,o,i-x,u,_,w);return V===$?s:((C=editableVNode(s,o)).array[L]=V,C)}return B&&s.array[L]===_?s:(SetRef(w),C=editableVNode(s,o),void 0===_&&L===C.array.length-1?C.array.pop():C.array[L]=_,C)}function editableVNode(s,o){return o&&s&&o===s.ownerID?s:new VNode(s?s.array.slice():[],o)}function listNodeFor(s,o){if(o>=getTailOffset(s._capacity))return s._tail;if(o<1<0;)i=i.array[o>>>u&j],u-=x;return i}}function setListBounds(s,o,i){void 0!==o&&(o|=0),void 0!==i&&(i|=0);var u=s.__ownerID||new OwnerID,_=s._origin,w=s._capacity,C=_+o,L=void 0===i?w:i<0?w+i:_+i;if(C===_&&L===w)return s;if(C>=L)return s.clear();for(var B=s._level,$=s._root,V=0;C+V<0;)$=new VNode($&&$.array.length?[void 0,$]:[],u),V+=1<<(B+=x);V&&(C+=V,_+=V,L+=V,w+=V);for(var U=getTailOffset(w),z=getTailOffset(L);z>=1<U?new VNode([],u):Y;if(Y&&z>U&&Cx;ie-=x){var ae=U>>>ie&j;ee=ee.array[ae]=editableVNode(ee.array[ae],u)}ee.array[U>>>x&j]=Y}if(L=z)C-=z,L-=z,B=x,$=null,Z=Z&&Z.removeBefore(u,0,C);else if(C>_||z>>B&j;if(le!==z>>>B&j)break;le&&(V+=(1<_&&($=$.removeBefore(u,B,C-V)),$&&z_&&(_=C.size),isIterable(x)||(C=C.map((function(s){return fromJS(s)}))),u.push(C)}return _>s.size&&(s=s.setSize(_)),mergeIntoCollectionWith(s,o,u)}function getTailOffset(s){return s>>x<=C&&x.size>=2*w.size?(u=(_=x.filter((function(s,o){return void 0!==s&&j!==o}))).toKeyedSeq().map((function(s){return s[0]})).flip().toMap(),s.__ownerID&&(u.__ownerID=_.__ownerID=s.__ownerID)):(u=w.remove(o),_=j===x.size-1?x.pop():x.set(j,void 0))}else if(B){if(i===x.get(j)[1])return s;u=w,_=x.set(j,[o,i])}else u=w.set(o,x.size),_=x.set(x.size,[o,i]);return s.__ownerID?(s.size=u.size,s._map=u,s._list=_,s.__hash=void 0,s):makeOrderedMap(u,_)}function ToKeyedSequence(s,o){this._iter=s,this._useKeys=o,this.size=s.size}function ToIndexedSequence(s){this._iter=s,this.size=s.size}function ToSetSequence(s){this._iter=s,this.size=s.size}function FromEntriesSequence(s){this._iter=s,this.size=s.size}function flipFactory(s){var o=makeSequence(s);return o._iter=s,o.size=s.size,o.flip=function(){return s},o.reverse=function(){var o=s.reverse.apply(this);return o.flip=function(){return s.reverse()},o},o.has=function(o){return s.includes(o)},o.includes=function(o){return s.has(o)},o.cacheResult=cacheResultThrough,o.__iterateUncached=function(o,i){var u=this;return s.__iterate((function(s,i){return!1!==o(i,s,u)}),i)},o.__iteratorUncached=function(o,i){if(o===z){var u=s.__iterator(o,i);return new Iterator((function(){var s=u.next();if(!s.done){var o=s.value[0];s.value[0]=s.value[1],s.value[1]=o}return s}))}return s.__iterator(o===U?V:U,i)},o}function mapFactory(s,o,i){var u=makeSequence(s);return u.size=s.size,u.has=function(o){return s.has(o)},u.get=function(u,_){var w=s.get(u,L);return w===L?_:o.call(i,w,u,s)},u.__iterateUncached=function(u,_){var w=this;return s.__iterate((function(s,_,x){return!1!==u(o.call(i,s,_,x),_,w)}),_)},u.__iteratorUncached=function(u,_){var w=s.__iterator(z,_);return new Iterator((function(){var _=w.next();if(_.done)return _;var x=_.value,C=x[0];return iteratorValue(u,C,o.call(i,x[1],C,s),_)}))},u}function reverseFactory(s,o){var i=makeSequence(s);return i._iter=s,i.size=s.size,i.reverse=function(){return s},s.flip&&(i.flip=function(){var o=flipFactory(s);return o.reverse=function(){return s.flip()},o}),i.get=function(i,u){return s.get(o?i:-1-i,u)},i.has=function(i){return s.has(o?i:-1-i)},i.includes=function(o){return s.includes(o)},i.cacheResult=cacheResultThrough,i.__iterate=function(o,i){var u=this;return s.__iterate((function(s,i){return o(s,i,u)}),!i)},i.__iterator=function(o,i){return s.__iterator(o,!i)},i}function filterFactory(s,o,i,u){var _=makeSequence(s);return u&&(_.has=function(u){var _=s.get(u,L);return _!==L&&!!o.call(i,_,u,s)},_.get=function(u,_){var w=s.get(u,L);return w!==L&&o.call(i,w,u,s)?w:_}),_.__iterateUncached=function(_,w){var x=this,C=0;return s.__iterate((function(s,w,j){if(o.call(i,s,w,j))return C++,_(s,u?w:C-1,x)}),w),C},_.__iteratorUncached=function(_,w){var x=s.__iterator(z,w),C=0;return new Iterator((function(){for(;;){var w=x.next();if(w.done)return w;var j=w.value,L=j[0],B=j[1];if(o.call(i,B,L,s))return iteratorValue(_,u?L:C++,B,w)}}))},_}function countByFactory(s,o,i){var u=Map().asMutable();return s.__iterate((function(_,w){u.update(o.call(i,_,w,s),0,(function(s){return s+1}))})),u.asImmutable()}function groupByFactory(s,o,i){var u=isKeyed(s),_=(isOrdered(s)?OrderedMap():Map()).asMutable();s.__iterate((function(w,x){_.update(o.call(i,w,x,s),(function(s){return(s=s||[]).push(u?[x,w]:w),s}))}));var w=iterableClass(s);return _.map((function(o){return reify(s,w(o))}))}function sliceFactory(s,o,i,u){var _=s.size;if(void 0!==o&&(o|=0),void 0!==i&&(i===1/0?i=_:i|=0),wholeSlice(o,i,_))return s;var w=resolveBegin(o,_),x=resolveEnd(i,_);if(w!=w||x!=x)return sliceFactory(s.toSeq().cacheResult(),o,i,u);var C,j=x-w;j==j&&(C=j<0?0:j);var L=makeSequence(s);return L.size=0===C?C:s.size&&C||void 0,!u&&isSeq(s)&&C>=0&&(L.get=function(o,i){return(o=wrapIndex(this,o))>=0&&oC)return iteratorDone();var s=_.next();return u||o===U?s:iteratorValue(o,j-1,o===V?void 0:s.value[1],s)}))},L}function takeWhileFactory(s,o,i){var u=makeSequence(s);return u.__iterateUncached=function(u,_){var w=this;if(_)return this.cacheResult().__iterate(u,_);var x=0;return s.__iterate((function(s,_,C){return o.call(i,s,_,C)&&++x&&u(s,_,w)})),x},u.__iteratorUncached=function(u,_){var w=this;if(_)return this.cacheResult().__iterator(u,_);var x=s.__iterator(z,_),C=!0;return new Iterator((function(){if(!C)return iteratorDone();var s=x.next();if(s.done)return s;var _=s.value,j=_[0],L=_[1];return o.call(i,L,j,w)?u===z?s:iteratorValue(u,j,L,s):(C=!1,iteratorDone())}))},u}function skipWhileFactory(s,o,i,u){var _=makeSequence(s);return _.__iterateUncached=function(_,w){var x=this;if(w)return this.cacheResult().__iterate(_,w);var C=!0,j=0;return s.__iterate((function(s,w,L){if(!C||!(C=o.call(i,s,w,L)))return j++,_(s,u?w:j-1,x)})),j},_.__iteratorUncached=function(_,w){var x=this;if(w)return this.cacheResult().__iterator(_,w);var C=s.__iterator(z,w),j=!0,L=0;return new Iterator((function(){var s,w,B;do{if((s=C.next()).done)return u||_===U?s:iteratorValue(_,L++,_===V?void 0:s.value[1],s);var $=s.value;w=$[0],B=$[1],j&&(j=o.call(i,B,w,x))}while(j);return _===z?s:iteratorValue(_,w,B,s)}))},_}function concatFactory(s,o){var i=isKeyed(s),u=[s].concat(o).map((function(s){return isIterable(s)?i&&(s=KeyedIterable(s)):s=i?keyedSeqFromValue(s):indexedSeqFromValue(Array.isArray(s)?s:[s]),s})).filter((function(s){return 0!==s.size}));if(0===u.length)return s;if(1===u.length){var _=u[0];if(_===s||i&&isKeyed(_)||isIndexed(s)&&isIndexed(_))return _}var w=new ArraySeq(u);return i?w=w.toKeyedSeq():isIndexed(s)||(w=w.toSetSeq()),(w=w.flatten(!0)).size=u.reduce((function(s,o){if(void 0!==s){var i=o.size;if(void 0!==i)return s+i}}),0),w}function flattenFactory(s,o,i){var u=makeSequence(s);return u.__iterateUncached=function(u,_){var w=0,x=!1;function flatDeep(s,C){var j=this;s.__iterate((function(s,_){return(!o||C0}function zipWithFactory(s,o,i){var u=makeSequence(s);return u.size=new ArraySeq(i).map((function(s){return s.size})).min(),u.__iterate=function(s,o){for(var i,u=this.__iterator(U,o),_=0;!(i=u.next()).done&&!1!==s(i.value,_++,this););return _},u.__iteratorUncached=function(s,u){var _=i.map((function(s){return s=Iterable(s),getIterator(u?s.reverse():s)})),w=0,x=!1;return new Iterator((function(){var i;return x||(i=_.map((function(s){return s.next()})),x=i.some((function(s){return s.done}))),x?iteratorDone():iteratorValue(s,w++,o.apply(null,i.map((function(s){return s.value}))))}))},u}function reify(s,o){return isSeq(s)?o:s.constructor(o)}function validateEntry(s){if(s!==Object(s))throw new TypeError("Expected [K, V] tuple: "+s)}function resolveSize(s){return assertNotInfinite(s.size),ensureSize(s)}function iterableClass(s){return isKeyed(s)?KeyedIterable:isIndexed(s)?IndexedIterable:SetIterable}function makeSequence(s){return Object.create((isKeyed(s)?KeyedSeq:isIndexed(s)?IndexedSeq:SetSeq).prototype)}function cacheResultThrough(){return this._iter.cacheResult?(this._iter.cacheResult(),this.size=this._iter.size,this):Seq.prototype.cacheResult.call(this)}function defaultComparator(s,o){return s>o?1:s=0;i--)o={value:arguments[i],next:o};return this.__ownerID?(this.size=s,this._head=o,this.__hash=void 0,this.__altered=!0,this):makeStack(s,o)},Stack.prototype.pushAll=function(s){if(0===(s=IndexedIterable(s)).size)return this;assertNotInfinite(s.size);var o=this.size,i=this._head;return s.reverse().forEach((function(s){o++,i={value:s,next:i}})),this.__ownerID?(this.size=o,this._head=i,this.__hash=void 0,this.__altered=!0,this):makeStack(o,i)},Stack.prototype.pop=function(){return this.slice(1)},Stack.prototype.unshift=function(){return this.push.apply(this,arguments)},Stack.prototype.unshiftAll=function(s){return this.pushAll(s)},Stack.prototype.shift=function(){return this.pop.apply(this,arguments)},Stack.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):emptyStack()},Stack.prototype.slice=function(s,o){if(wholeSlice(s,o,this.size))return this;var i=resolveBegin(s,this.size);if(resolveEnd(o,this.size)!==this.size)return IndexedCollection.prototype.slice.call(this,s,o);for(var u=this.size-i,_=this._head;i--;)_=_.next;return this.__ownerID?(this.size=u,this._head=_,this.__hash=void 0,this.__altered=!0,this):makeStack(u,_)},Stack.prototype.__ensureOwner=function(s){return s===this.__ownerID?this:s?makeStack(this.size,this._head,s,this.__hash):(this.__ownerID=s,this.__altered=!1,this)},Stack.prototype.__iterate=function(s,o){if(o)return this.reverse().__iterate(s);for(var i=0,u=this._head;u&&!1!==s(u.value,i++,this);)u=u.next;return i},Stack.prototype.__iterator=function(s,o){if(o)return this.reverse().__iterator(s);var i=0,u=this._head;return new Iterator((function(){if(u){var o=u.value;return u=u.next,iteratorValue(s,i++,o)}return iteratorDone()}))},Stack.isStack=isStack;var lt,ct="@@__IMMUTABLE_STACK__@@",ut=Stack.prototype;function makeStack(s,o,i,u){var _=Object.create(ut);return _.size=s,_._head=o,_.__ownerID=i,_.__hash=u,_.__altered=!1,_}function emptyStack(){return lt||(lt=makeStack(0))}function mixin(s,o){var keyCopier=function(i){s.prototype[i]=o[i]};return Object.keys(o).forEach(keyCopier),Object.getOwnPropertySymbols&&Object.getOwnPropertySymbols(o).forEach(keyCopier),s}ut[ct]=!0,ut.withMutations=$e.withMutations,ut.asMutable=$e.asMutable,ut.asImmutable=$e.asImmutable,ut.wasAltered=$e.wasAltered,Iterable.Iterator=Iterator,mixin(Iterable,{toArray:function(){assertNotInfinite(this.size);var s=new Array(this.size||0);return this.valueSeq().__iterate((function(o,i){s[i]=o})),s},toIndexedSeq:function(){return new ToIndexedSequence(this)},toJS:function(){return this.toSeq().map((function(s){return s&&"function"==typeof s.toJS?s.toJS():s})).__toJS()},toJSON:function(){return this.toSeq().map((function(s){return s&&"function"==typeof s.toJSON?s.toJSON():s})).__toJS()},toKeyedSeq:function(){return new ToKeyedSequence(this,!0)},toMap:function(){return Map(this.toKeyedSeq())},toObject:function(){assertNotInfinite(this.size);var s={};return this.__iterate((function(o,i){s[i]=o})),s},toOrderedMap:function(){return OrderedMap(this.toKeyedSeq())},toOrderedSet:function(){return OrderedSet(isKeyed(this)?this.valueSeq():this)},toSet:function(){return Set(isKeyed(this)?this.valueSeq():this)},toSetSeq:function(){return new ToSetSequence(this)},toSeq:function(){return isIndexed(this)?this.toIndexedSeq():isKeyed(this)?this.toKeyedSeq():this.toSetSeq()},toStack:function(){return Stack(isKeyed(this)?this.valueSeq():this)},toList:function(){return List(isKeyed(this)?this.valueSeq():this)},toString:function(){return"[Iterable]"},__toString:function(s,o){return 0===this.size?s+o:s+" "+this.toSeq().map(this.__toStringMapper).join(", ")+" "+o},concat:function(){return reify(this,concatFactory(this,s.call(arguments,0)))},includes:function(s){return this.some((function(o){return is(o,s)}))},entries:function(){return this.__iterator(z)},every:function(s,o){assertNotInfinite(this.size);var i=!0;return this.__iterate((function(u,_,w){if(!s.call(o,u,_,w))return i=!1,!1})),i},filter:function(s,o){return reify(this,filterFactory(this,s,o,!0))},find:function(s,o,i){var u=this.findEntry(s,o);return u?u[1]:i},forEach:function(s,o){return assertNotInfinite(this.size),this.__iterate(o?s.bind(o):s)},join:function(s){assertNotInfinite(this.size),s=void 0!==s?""+s:",";var o="",i=!0;return this.__iterate((function(u){i?i=!1:o+=s,o+=null!=u?u.toString():""})),o},keys:function(){return this.__iterator(V)},map:function(s,o){return reify(this,mapFactory(this,s,o))},reduce:function(s,o,i){var u,_;return assertNotInfinite(this.size),arguments.length<2?_=!0:u=o,this.__iterate((function(o,w,x){_?(_=!1,u=o):u=s.call(i,u,o,w,x)})),u},reduceRight:function(s,o,i){var u=this.toKeyedSeq().reverse();return u.reduce.apply(u,arguments)},reverse:function(){return reify(this,reverseFactory(this,!0))},slice:function(s,o){return reify(this,sliceFactory(this,s,o,!0))},some:function(s,o){return!this.every(not(s),o)},sort:function(s){return reify(this,sortFactory(this,s))},values:function(){return this.__iterator(U)},butLast:function(){return this.slice(0,-1)},isEmpty:function(){return void 0!==this.size?0===this.size:!this.some((function(){return!0}))},count:function(s,o){return ensureSize(s?this.toSeq().filter(s,o):this)},countBy:function(s,o){return countByFactory(this,s,o)},equals:function(s){return deepEqual(this,s)},entrySeq:function(){var s=this;if(s._cache)return new ArraySeq(s._cache);var o=s.toSeq().map(entryMapper).toIndexedSeq();return o.fromEntrySeq=function(){return s.toSeq()},o},filterNot:function(s,o){return this.filter(not(s),o)},findEntry:function(s,o,i){var u=i;return this.__iterate((function(i,_,w){if(s.call(o,i,_,w))return u=[_,i],!1})),u},findKey:function(s,o){var i=this.findEntry(s,o);return i&&i[0]},findLast:function(s,o,i){return this.toKeyedSeq().reverse().find(s,o,i)},findLastEntry:function(s,o,i){return this.toKeyedSeq().reverse().findEntry(s,o,i)},findLastKey:function(s,o){return this.toKeyedSeq().reverse().findKey(s,o)},first:function(){return this.find(returnTrue)},flatMap:function(s,o){return reify(this,flatMapFactory(this,s,o))},flatten:function(s){return reify(this,flattenFactory(this,s,!0))},fromEntrySeq:function(){return new FromEntriesSequence(this)},get:function(s,o){return this.find((function(o,i){return is(i,s)}),void 0,o)},getIn:function(s,o){for(var i,u=this,_=forceIterator(s);!(i=_.next()).done;){var w=i.value;if((u=u&&u.get?u.get(w,L):L)===L)return o}return u},groupBy:function(s,o){return groupByFactory(this,s,o)},has:function(s){return this.get(s,L)!==L},hasIn:function(s){return this.getIn(s,L)!==L},isSubset:function(s){return s="function"==typeof s.includes?s:Iterable(s),this.every((function(o){return s.includes(o)}))},isSuperset:function(s){return(s="function"==typeof s.isSubset?s:Iterable(s)).isSubset(this)},keyOf:function(s){return this.findKey((function(o){return is(o,s)}))},keySeq:function(){return this.toSeq().map(keyMapper).toIndexedSeq()},last:function(){return this.toSeq().reverse().first()},lastKeyOf:function(s){return this.toKeyedSeq().reverse().keyOf(s)},max:function(s){return maxFactory(this,s)},maxBy:function(s,o){return maxFactory(this,o,s)},min:function(s){return maxFactory(this,s?neg(s):defaultNegComparator)},minBy:function(s,o){return maxFactory(this,o?neg(o):defaultNegComparator,s)},rest:function(){return this.slice(1)},skip:function(s){return this.slice(Math.max(0,s))},skipLast:function(s){return reify(this,this.toSeq().reverse().skip(s).reverse())},skipWhile:function(s,o){return reify(this,skipWhileFactory(this,s,o,!0))},skipUntil:function(s,o){return this.skipWhile(not(s),o)},sortBy:function(s,o){return reify(this,sortFactory(this,o,s))},take:function(s){return this.slice(0,Math.max(0,s))},takeLast:function(s){return reify(this,this.toSeq().reverse().take(s).reverse())},takeWhile:function(s,o){return reify(this,takeWhileFactory(this,s,o))},takeUntil:function(s,o){return this.takeWhile(not(s),o)},valueSeq:function(){return this.toIndexedSeq()},hashCode:function(){return this.__hash||(this.__hash=hashIterable(this))}});var pt=Iterable.prototype;pt[o]=!0,pt[ee]=pt.values,pt.__toJS=pt.toArray,pt.__toStringMapper=quoteString,pt.inspect=pt.toSource=function(){return this.toString()},pt.chain=pt.flatMap,pt.contains=pt.includes,mixin(KeyedIterable,{flip:function(){return reify(this,flipFactory(this))},mapEntries:function(s,o){var i=this,u=0;return reify(this,this.toSeq().map((function(_,w){return s.call(o,[w,_],u++,i)})).fromEntrySeq())},mapKeys:function(s,o){var i=this;return reify(this,this.toSeq().flip().map((function(u,_){return s.call(o,u,_,i)})).flip())}});var ht=KeyedIterable.prototype;function keyMapper(s,o){return o}function entryMapper(s,o){return[o,s]}function not(s){return function(){return!s.apply(this,arguments)}}function neg(s){return function(){return-s.apply(this,arguments)}}function quoteString(s){return"string"==typeof s?JSON.stringify(s):String(s)}function defaultZipper(){return arrCopy(arguments)}function defaultNegComparator(s,o){return so?-1:0}function hashIterable(s){if(s.size===1/0)return 0;var o=isOrdered(s),i=isKeyed(s),u=o?1:0;return murmurHashOfSize(s.__iterate(i?o?function(s,o){u=31*u+hashMerge(hash(s),hash(o))|0}:function(s,o){u=u+hashMerge(hash(s),hash(o))|0}:o?function(s){u=31*u+hash(s)|0}:function(s){u=u+hash(s)|0}),u)}function murmurHashOfSize(s,o){return o=pe(o,3432918353),o=pe(o<<15|o>>>-15,461845907),o=pe(o<<13|o>>>-13,5),o=pe((o=o+3864292196^s)^o>>>16,2246822507),o=smi((o=pe(o^o>>>13,3266489909))^o>>>16)}function hashMerge(s,o){return s^o+2654435769+(s<<6)+(s>>2)}return ht[i]=!0,ht[ee]=pt.entries,ht.__toJS=pt.toObject,ht.__toStringMapper=function(s,o){return JSON.stringify(o)+": "+quoteString(s)},mixin(IndexedIterable,{toKeyedSeq:function(){return new ToKeyedSequence(this,!1)},filter:function(s,o){return reify(this,filterFactory(this,s,o,!1))},findIndex:function(s,o){var i=this.findEntry(s,o);return i?i[0]:-1},indexOf:function(s){var o=this.keyOf(s);return void 0===o?-1:o},lastIndexOf:function(s){var o=this.lastKeyOf(s);return void 0===o?-1:o},reverse:function(){return reify(this,reverseFactory(this,!1))},slice:function(s,o){return reify(this,sliceFactory(this,s,o,!1))},splice:function(s,o){var i=arguments.length;if(o=Math.max(0|o,0),0===i||2===i&&!o)return this;s=resolveBegin(s,s<0?this.count():this.size);var u=this.slice(0,s);return reify(this,1===i?u:u.concat(arrCopy(arguments,2),this.slice(s+o)))},findLastIndex:function(s,o){var i=this.findLastEntry(s,o);return i?i[0]:-1},first:function(){return this.get(0)},flatten:function(s){return reify(this,flattenFactory(this,s,!1))},get:function(s,o){return(s=wrapIndex(this,s))<0||this.size===1/0||void 0!==this.size&&s>this.size?o:this.find((function(o,i){return i===s}),void 0,o)},has:function(s){return(s=wrapIndex(this,s))>=0&&(void 0!==this.size?this.size===1/0||s{"function"==typeof Object.create?s.exports=function inherits(s,o){o&&(s.super_=o,s.prototype=Object.create(o.prototype,{constructor:{value:s,enumerable:!1,writable:!0,configurable:!0}}))}:s.exports=function inherits(s,o){if(o){s.super_=o;var TempCtor=function(){};TempCtor.prototype=o.prototype,s.prototype=new TempCtor,s.prototype.constructor=s}}},5419:s=>{s.exports=function(s,o,i,u){var _=new Blob(void 0!==u?[u,s]:[s],{type:i||"application/octet-stream"});if(void 0!==window.navigator.msSaveBlob)window.navigator.msSaveBlob(_,o);else{var w=window.URL&&window.URL.createObjectURL?window.URL.createObjectURL(_):window.webkitURL.createObjectURL(_),x=document.createElement("a");x.style.display="none",x.href=w,x.setAttribute("download",o),void 0===x.download&&x.setAttribute("target","_blank"),document.body.appendChild(x),x.click(),setTimeout((function(){document.body.removeChild(x),window.URL.revokeObjectURL(w)}),200)}}},20181:(s,o,i)=>{var u=/^\s+|\s+$/g,_=/^[-+]0x[0-9a-f]+$/i,w=/^0b[01]+$/i,x=/^0o[0-7]+$/i,C=parseInt,j="object"==typeof i.g&&i.g&&i.g.Object===Object&&i.g,L="object"==typeof self&&self&&self.Object===Object&&self,B=j||L||Function("return this")(),$=Object.prototype.toString,V=Math.max,U=Math.min,now=function(){return B.Date.now()};function isObject(s){var o=typeof s;return!!s&&("object"==o||"function"==o)}function toNumber(s){if("number"==typeof s)return s;if(function isSymbol(s){return"symbol"==typeof s||function isObjectLike(s){return!!s&&"object"==typeof s}(s)&&"[object Symbol]"==$.call(s)}(s))return NaN;if(isObject(s)){var o="function"==typeof s.valueOf?s.valueOf():s;s=isObject(o)?o+"":o}if("string"!=typeof s)return 0===s?s:+s;s=s.replace(u,"");var i=w.test(s);return i||x.test(s)?C(s.slice(2),i?2:8):_.test(s)?NaN:+s}s.exports=function debounce(s,o,i){var u,_,w,x,C,j,L=0,B=!1,$=!1,z=!0;if("function"!=typeof s)throw new TypeError("Expected a function");function invokeFunc(o){var i=u,w=_;return u=_=void 0,L=o,x=s.apply(w,i)}function shouldInvoke(s){var i=s-j;return void 0===j||i>=o||i<0||$&&s-L>=w}function timerExpired(){var s=now();if(shouldInvoke(s))return trailingEdge(s);C=setTimeout(timerExpired,function remainingWait(s){var i=o-(s-j);return $?U(i,w-(s-L)):i}(s))}function trailingEdge(s){return C=void 0,z&&u?invokeFunc(s):(u=_=void 0,x)}function debounced(){var s=now(),i=shouldInvoke(s);if(u=arguments,_=this,j=s,i){if(void 0===C)return function leadingEdge(s){return L=s,C=setTimeout(timerExpired,o),B?invokeFunc(s):x}(j);if($)return C=setTimeout(timerExpired,o),invokeFunc(j)}return void 0===C&&(C=setTimeout(timerExpired,o)),x}return o=toNumber(o)||0,isObject(i)&&(B=!!i.leading,w=($="maxWait"in i)?V(toNumber(i.maxWait)||0,o):w,z="trailing"in i?!!i.trailing:z),debounced.cancel=function cancel(){void 0!==C&&clearTimeout(C),L=0,u=j=_=C=void 0},debounced.flush=function flush(){return void 0===C?x:trailingEdge(now())},debounced}},55580:(s,o,i)=>{var u=i(56110)(i(9325),"DataView");s.exports=u},21549:(s,o,i)=>{var u=i(22032),_=i(63862),w=i(66721),x=i(12749),C=i(35749);function Hash(s){var o=-1,i=null==s?0:s.length;for(this.clear();++o{var u=i(39344),_=i(94033);function LazyWrapper(s){this.__wrapped__=s,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=4294967295,this.__views__=[]}LazyWrapper.prototype=u(_.prototype),LazyWrapper.prototype.constructor=LazyWrapper,s.exports=LazyWrapper},80079:(s,o,i)=>{var u=i(63702),_=i(70080),w=i(24739),x=i(48655),C=i(31175);function ListCache(s){var o=-1,i=null==s?0:s.length;for(this.clear();++o{var u=i(39344),_=i(94033);function LodashWrapper(s,o){this.__wrapped__=s,this.__actions__=[],this.__chain__=!!o,this.__index__=0,this.__values__=void 0}LodashWrapper.prototype=u(_.prototype),LodashWrapper.prototype.constructor=LodashWrapper,s.exports=LodashWrapper},68223:(s,o,i)=>{var u=i(56110)(i(9325),"Map");s.exports=u},53661:(s,o,i)=>{var u=i(63040),_=i(17670),w=i(90289),x=i(4509),C=i(72949);function MapCache(s){var o=-1,i=null==s?0:s.length;for(this.clear();++o{var u=i(56110)(i(9325),"Promise");s.exports=u},76545:(s,o,i)=>{var u=i(56110)(i(9325),"Set");s.exports=u},38859:(s,o,i)=>{var u=i(53661),_=i(31380),w=i(51459);function SetCache(s){var o=-1,i=null==s?0:s.length;for(this.__data__=new u;++o{var u=i(80079),_=i(51420),w=i(90938),x=i(63605),C=i(29817),j=i(80945);function Stack(s){var o=this.__data__=new u(s);this.size=o.size}Stack.prototype.clear=_,Stack.prototype.delete=w,Stack.prototype.get=x,Stack.prototype.has=C,Stack.prototype.set=j,s.exports=Stack},51873:(s,o,i)=>{var u=i(9325).Symbol;s.exports=u},37828:(s,o,i)=>{var u=i(9325).Uint8Array;s.exports=u},28303:(s,o,i)=>{var u=i(56110)(i(9325),"WeakMap");s.exports=u},91033:s=>{s.exports=function apply(s,o,i){switch(i.length){case 0:return s.call(o);case 1:return s.call(o,i[0]);case 2:return s.call(o,i[0],i[1]);case 3:return s.call(o,i[0],i[1],i[2])}return s.apply(o,i)}},83729:s=>{s.exports=function arrayEach(s,o){for(var i=-1,u=null==s?0:s.length;++i{s.exports=function arrayFilter(s,o){for(var i=-1,u=null==s?0:s.length,_=0,w=[];++i{var u=i(96131);s.exports=function arrayIncludes(s,o){return!!(null==s?0:s.length)&&u(s,o,0)>-1}},70695:(s,o,i)=>{var u=i(78096),_=i(72428),w=i(56449),x=i(3656),C=i(30361),j=i(37167),L=Object.prototype.hasOwnProperty;s.exports=function arrayLikeKeys(s,o){var i=w(s),B=!i&&_(s),$=!i&&!B&&x(s),V=!i&&!B&&!$&&j(s),U=i||B||$||V,z=U?u(s.length,String):[],Y=z.length;for(var Z in s)!o&&!L.call(s,Z)||U&&("length"==Z||$&&("offset"==Z||"parent"==Z)||V&&("buffer"==Z||"byteLength"==Z||"byteOffset"==Z)||C(Z,Y))||z.push(Z);return z}},34932:s=>{s.exports=function arrayMap(s,o){for(var i=-1,u=null==s?0:s.length,_=Array(u);++i{s.exports=function arrayPush(s,o){for(var i=-1,u=o.length,_=s.length;++i{s.exports=function arrayReduce(s,o,i,u){var _=-1,w=null==s?0:s.length;for(u&&w&&(i=s[++_]);++_{s.exports=function arraySome(s,o){for(var i=-1,u=null==s?0:s.length;++i{s.exports=function asciiToArray(s){return s.split("")}},1733:s=>{var o=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;s.exports=function asciiWords(s){return s.match(o)||[]}},87805:(s,o,i)=>{var u=i(43360),_=i(75288);s.exports=function assignMergeValue(s,o,i){(void 0!==i&&!_(s[o],i)||void 0===i&&!(o in s))&&u(s,o,i)}},16547:(s,o,i)=>{var u=i(43360),_=i(75288),w=Object.prototype.hasOwnProperty;s.exports=function assignValue(s,o,i){var x=s[o];w.call(s,o)&&_(x,i)&&(void 0!==i||o in s)||u(s,o,i)}},26025:(s,o,i)=>{var u=i(75288);s.exports=function assocIndexOf(s,o){for(var i=s.length;i--;)if(u(s[i][0],o))return i;return-1}},74733:(s,o,i)=>{var u=i(21791),_=i(95950);s.exports=function baseAssign(s,o){return s&&u(o,_(o),s)}},43838:(s,o,i)=>{var u=i(21791),_=i(37241);s.exports=function baseAssignIn(s,o){return s&&u(o,_(o),s)}},43360:(s,o,i)=>{var u=i(93243);s.exports=function baseAssignValue(s,o,i){"__proto__"==o&&u?u(s,o,{configurable:!0,enumerable:!0,value:i,writable:!0}):s[o]=i}},9999:(s,o,i)=>{var u=i(37217),_=i(83729),w=i(16547),x=i(74733),C=i(43838),j=i(93290),L=i(23007),B=i(92271),$=i(48948),V=i(50002),U=i(83349),z=i(5861),Y=i(76189),Z=i(77199),ee=i(35529),ie=i(56449),ae=i(3656),le=i(87730),ce=i(23805),pe=i(38440),de=i(95950),fe=i(37241),ye="[object Arguments]",be="[object Function]",_e="[object Object]",we={};we[ye]=we["[object Array]"]=we["[object ArrayBuffer]"]=we["[object DataView]"]=we["[object Boolean]"]=we["[object Date]"]=we["[object Float32Array]"]=we["[object Float64Array]"]=we["[object Int8Array]"]=we["[object Int16Array]"]=we["[object Int32Array]"]=we["[object Map]"]=we["[object Number]"]=we[_e]=we["[object RegExp]"]=we["[object Set]"]=we["[object String]"]=we["[object Symbol]"]=we["[object Uint8Array]"]=we["[object Uint8ClampedArray]"]=we["[object Uint16Array]"]=we["[object Uint32Array]"]=!0,we["[object Error]"]=we[be]=we["[object WeakMap]"]=!1,s.exports=function baseClone(s,o,i,Se,xe,Pe){var Te,Re=1&o,qe=2&o,$e=4&o;if(i&&(Te=xe?i(s,Se,xe,Pe):i(s)),void 0!==Te)return Te;if(!ce(s))return s;var ze=ie(s);if(ze){if(Te=Y(s),!Re)return L(s,Te)}else{var We=z(s),He=We==be||"[object GeneratorFunction]"==We;if(ae(s))return j(s,Re);if(We==_e||We==ye||He&&!xe){if(Te=qe||He?{}:ee(s),!Re)return qe?$(s,C(Te,s)):B(s,x(Te,s))}else{if(!we[We])return xe?s:{};Te=Z(s,We,Re)}}Pe||(Pe=new u);var Ye=Pe.get(s);if(Ye)return Ye;Pe.set(s,Te),pe(s)?s.forEach((function(u){Te.add(baseClone(u,o,i,u,s,Pe))})):le(s)&&s.forEach((function(u,_){Te.set(_,baseClone(u,o,i,_,s,Pe))}));var Xe=ze?void 0:($e?qe?U:V:qe?fe:de)(s);return _(Xe||s,(function(u,_){Xe&&(u=s[_=u]),w(Te,_,baseClone(u,o,i,_,s,Pe))})),Te}},39344:(s,o,i)=>{var u=i(23805),_=Object.create,w=function(){function object(){}return function(s){if(!u(s))return{};if(_)return _(s);object.prototype=s;var o=new object;return object.prototype=void 0,o}}();s.exports=w},80909:(s,o,i)=>{var u=i(30641),_=i(38329)(u);s.exports=_},2523:s=>{s.exports=function baseFindIndex(s,o,i,u){for(var _=s.length,w=i+(u?1:-1);u?w--:++w<_;)if(o(s[w],w,s))return w;return-1}},83120:(s,o,i)=>{var u=i(14528),_=i(45891);s.exports=function baseFlatten(s,o,i,w,x){var C=-1,j=s.length;for(i||(i=_),x||(x=[]);++C0&&i(L)?o>1?baseFlatten(L,o-1,i,w,x):u(x,L):w||(x[x.length]=L)}return x}},86649:(s,o,i)=>{var u=i(83221)();s.exports=u},30641:(s,o,i)=>{var u=i(86649),_=i(95950);s.exports=function baseForOwn(s,o){return s&&u(s,o,_)}},47422:(s,o,i)=>{var u=i(31769),_=i(77797);s.exports=function baseGet(s,o){for(var i=0,w=(o=u(o,s)).length;null!=s&&i{var u=i(14528),_=i(56449);s.exports=function baseGetAllKeys(s,o,i){var w=o(s);return _(s)?w:u(w,i(s))}},72552:(s,o,i)=>{var u=i(51873),_=i(659),w=i(59350),x=u?u.toStringTag:void 0;s.exports=function baseGetTag(s){return null==s?void 0===s?"[object Undefined]":"[object Null]":x&&x in Object(s)?_(s):w(s)}},20426:s=>{var o=Object.prototype.hasOwnProperty;s.exports=function baseHas(s,i){return null!=s&&o.call(s,i)}},28077:s=>{s.exports=function baseHasIn(s,o){return null!=s&&o in Object(s)}},96131:(s,o,i)=>{var u=i(2523),_=i(85463),w=i(76959);s.exports=function baseIndexOf(s,o,i){return o==o?w(s,o,i):u(s,_,i)}},27534:(s,o,i)=>{var u=i(72552),_=i(40346);s.exports=function baseIsArguments(s){return _(s)&&"[object Arguments]"==u(s)}},60270:(s,o,i)=>{var u=i(87068),_=i(40346);s.exports=function baseIsEqual(s,o,i,w,x){return s===o||(null==s||null==o||!_(s)&&!_(o)?s!=s&&o!=o:u(s,o,i,w,baseIsEqual,x))}},87068:(s,o,i)=>{var u=i(37217),_=i(25911),w=i(21986),x=i(50689),C=i(5861),j=i(56449),L=i(3656),B=i(37167),$="[object Arguments]",V="[object Array]",U="[object Object]",z=Object.prototype.hasOwnProperty;s.exports=function baseIsEqualDeep(s,o,i,Y,Z,ee){var ie=j(s),ae=j(o),le=ie?V:C(s),ce=ae?V:C(o),pe=(le=le==$?U:le)==U,de=(ce=ce==$?U:ce)==U,fe=le==ce;if(fe&&L(s)){if(!L(o))return!1;ie=!0,pe=!1}if(fe&&!pe)return ee||(ee=new u),ie||B(s)?_(s,o,i,Y,Z,ee):w(s,o,le,i,Y,Z,ee);if(!(1&i)){var ye=pe&&z.call(s,"__wrapped__"),be=de&&z.call(o,"__wrapped__");if(ye||be){var _e=ye?s.value():s,we=be?o.value():o;return ee||(ee=new u),Z(_e,we,i,Y,ee)}}return!!fe&&(ee||(ee=new u),x(s,o,i,Y,Z,ee))}},29172:(s,o,i)=>{var u=i(5861),_=i(40346);s.exports=function baseIsMap(s){return _(s)&&"[object Map]"==u(s)}},41799:(s,o,i)=>{var u=i(37217),_=i(60270);s.exports=function baseIsMatch(s,o,i,w){var x=i.length,C=x,j=!w;if(null==s)return!C;for(s=Object(s);x--;){var L=i[x];if(j&&L[2]?L[1]!==s[L[0]]:!(L[0]in s))return!1}for(;++x{s.exports=function baseIsNaN(s){return s!=s}},45083:(s,o,i)=>{var u=i(1882),_=i(87296),w=i(23805),x=i(47473),C=/^\[object .+?Constructor\]$/,j=Function.prototype,L=Object.prototype,B=j.toString,$=L.hasOwnProperty,V=RegExp("^"+B.call($).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");s.exports=function baseIsNative(s){return!(!w(s)||_(s))&&(u(s)?V:C).test(x(s))}},16038:(s,o,i)=>{var u=i(5861),_=i(40346);s.exports=function baseIsSet(s){return _(s)&&"[object Set]"==u(s)}},4901:(s,o,i)=>{var u=i(72552),_=i(30294),w=i(40346),x={};x["[object Float32Array]"]=x["[object Float64Array]"]=x["[object Int8Array]"]=x["[object Int16Array]"]=x["[object Int32Array]"]=x["[object Uint8Array]"]=x["[object Uint8ClampedArray]"]=x["[object Uint16Array]"]=x["[object Uint32Array]"]=!0,x["[object Arguments]"]=x["[object Array]"]=x["[object ArrayBuffer]"]=x["[object Boolean]"]=x["[object DataView]"]=x["[object Date]"]=x["[object Error]"]=x["[object Function]"]=x["[object Map]"]=x["[object Number]"]=x["[object Object]"]=x["[object RegExp]"]=x["[object Set]"]=x["[object String]"]=x["[object WeakMap]"]=!1,s.exports=function baseIsTypedArray(s){return w(s)&&_(s.length)&&!!x[u(s)]}},15389:(s,o,i)=>{var u=i(93663),_=i(87978),w=i(83488),x=i(56449),C=i(50583);s.exports=function baseIteratee(s){return"function"==typeof s?s:null==s?w:"object"==typeof s?x(s)?_(s[0],s[1]):u(s):C(s)}},88984:(s,o,i)=>{var u=i(55527),_=i(3650),w=Object.prototype.hasOwnProperty;s.exports=function baseKeys(s){if(!u(s))return _(s);var o=[];for(var i in Object(s))w.call(s,i)&&"constructor"!=i&&o.push(i);return o}},72903:(s,o,i)=>{var u=i(23805),_=i(55527),w=i(90181),x=Object.prototype.hasOwnProperty;s.exports=function baseKeysIn(s){if(!u(s))return w(s);var o=_(s),i=[];for(var C in s)("constructor"!=C||!o&&x.call(s,C))&&i.push(C);return i}},94033:s=>{s.exports=function baseLodash(){}},93663:(s,o,i)=>{var u=i(41799),_=i(10776),w=i(67197);s.exports=function baseMatches(s){var o=_(s);return 1==o.length&&o[0][2]?w(o[0][0],o[0][1]):function(i){return i===s||u(i,s,o)}}},87978:(s,o,i)=>{var u=i(60270),_=i(58156),w=i(80631),x=i(28586),C=i(30756),j=i(67197),L=i(77797);s.exports=function baseMatchesProperty(s,o){return x(s)&&C(o)?j(L(s),o):function(i){var x=_(i,s);return void 0===x&&x===o?w(i,s):u(o,x,3)}}},85250:(s,o,i)=>{var u=i(37217),_=i(87805),w=i(86649),x=i(42824),C=i(23805),j=i(37241),L=i(14974);s.exports=function baseMerge(s,o,i,B,$){s!==o&&w(o,(function(w,j){if($||($=new u),C(w))x(s,o,j,i,baseMerge,B,$);else{var V=B?B(L(s,j),w,j+"",s,o,$):void 0;void 0===V&&(V=w),_(s,j,V)}}),j)}},42824:(s,o,i)=>{var u=i(87805),_=i(93290),w=i(71961),x=i(23007),C=i(35529),j=i(72428),L=i(56449),B=i(83693),$=i(3656),V=i(1882),U=i(23805),z=i(11331),Y=i(37167),Z=i(14974),ee=i(69884);s.exports=function baseMergeDeep(s,o,i,ie,ae,le,ce){var pe=Z(s,i),de=Z(o,i),fe=ce.get(de);if(fe)u(s,i,fe);else{var ye=le?le(pe,de,i+"",s,o,ce):void 0,be=void 0===ye;if(be){var _e=L(de),we=!_e&&$(de),Se=!_e&&!we&&Y(de);ye=de,_e||we||Se?L(pe)?ye=pe:B(pe)?ye=x(pe):we?(be=!1,ye=_(de,!0)):Se?(be=!1,ye=w(de,!0)):ye=[]:z(de)||j(de)?(ye=pe,j(pe)?ye=ee(pe):U(pe)&&!V(pe)||(ye=C(de))):be=!1}be&&(ce.set(de,ye),ae(ye,de,ie,le,ce),ce.delete(de)),u(s,i,ye)}}},47237:s=>{s.exports=function baseProperty(s){return function(o){return null==o?void 0:o[s]}}},17255:(s,o,i)=>{var u=i(47422);s.exports=function basePropertyDeep(s){return function(o){return u(o,s)}}},54552:s=>{s.exports=function basePropertyOf(s){return function(o){return null==s?void 0:s[o]}}},85558:s=>{s.exports=function baseReduce(s,o,i,u,_){return _(s,(function(s,_,w){i=u?(u=!1,s):o(i,s,_,w)})),i}},69302:(s,o,i)=>{var u=i(83488),_=i(56757),w=i(32865);s.exports=function baseRest(s,o){return w(_(s,o,u),s+"")}},73170:(s,o,i)=>{var u=i(16547),_=i(31769),w=i(30361),x=i(23805),C=i(77797);s.exports=function baseSet(s,o,i,j){if(!x(s))return s;for(var L=-1,B=(o=_(o,s)).length,$=B-1,V=s;null!=V&&++L{var u=i(83488),_=i(48152),w=_?function(s,o){return _.set(s,o),s}:u;s.exports=w},19570:(s,o,i)=>{var u=i(37334),_=i(93243),w=i(83488),x=_?function(s,o){return _(s,"toString",{configurable:!0,enumerable:!1,value:u(o),writable:!0})}:w;s.exports=x},25160:s=>{s.exports=function baseSlice(s,o,i){var u=-1,_=s.length;o<0&&(o=-o>_?0:_+o),(i=i>_?_:i)<0&&(i+=_),_=o>i?0:i-o>>>0,o>>>=0;for(var w=Array(_);++u<_;)w[u]=s[u+o];return w}},90916:(s,o,i)=>{var u=i(80909);s.exports=function baseSome(s,o){var i;return u(s,(function(s,u,_){return!(i=o(s,u,_))})),!!i}},78096:s=>{s.exports=function baseTimes(s,o){for(var i=-1,u=Array(s);++i{var u=i(51873),_=i(34932),w=i(56449),x=i(44394),C=u?u.prototype:void 0,j=C?C.toString:void 0;s.exports=function baseToString(s){if("string"==typeof s)return s;if(w(s))return _(s,baseToString)+"";if(x(s))return j?j.call(s):"";var o=s+"";return"0"==o&&1/s==-1/0?"-0":o}},54128:(s,o,i)=>{var u=i(31800),_=/^\s+/;s.exports=function baseTrim(s){return s?s.slice(0,u(s)+1).replace(_,""):s}},27301:s=>{s.exports=function baseUnary(s){return function(o){return s(o)}}},19931:(s,o,i)=>{var u=i(31769),_=i(68090),w=i(68969),x=i(77797);s.exports=function baseUnset(s,o){return o=u(o,s),null==(s=w(s,o))||delete s[x(_(o))]}},51234:s=>{s.exports=function baseZipObject(s,o,i){for(var u=-1,_=s.length,w=o.length,x={};++u<_;){var C=u{s.exports=function cacheHas(s,o){return s.has(o)}},31769:(s,o,i)=>{var u=i(56449),_=i(28586),w=i(61802),x=i(13222);s.exports=function castPath(s,o){return u(s)?s:_(s,o)?[s]:w(x(s))}},28754:(s,o,i)=>{var u=i(25160);s.exports=function castSlice(s,o,i){var _=s.length;return i=void 0===i?_:i,!o&&i>=_?s:u(s,o,i)}},49653:(s,o,i)=>{var u=i(37828);s.exports=function cloneArrayBuffer(s){var o=new s.constructor(s.byteLength);return new u(o).set(new u(s)),o}},93290:(s,o,i)=>{s=i.nmd(s);var u=i(9325),_=o&&!o.nodeType&&o,w=_&&s&&!s.nodeType&&s,x=w&&w.exports===_?u.Buffer:void 0,C=x?x.allocUnsafe:void 0;s.exports=function cloneBuffer(s,o){if(o)return s.slice();var i=s.length,u=C?C(i):new s.constructor(i);return s.copy(u),u}},76169:(s,o,i)=>{var u=i(49653);s.exports=function cloneDataView(s,o){var i=o?u(s.buffer):s.buffer;return new s.constructor(i,s.byteOffset,s.byteLength)}},73201:s=>{var o=/\w*$/;s.exports=function cloneRegExp(s){var i=new s.constructor(s.source,o.exec(s));return i.lastIndex=s.lastIndex,i}},93736:(s,o,i)=>{var u=i(51873),_=u?u.prototype:void 0,w=_?_.valueOf:void 0;s.exports=function cloneSymbol(s){return w?Object(w.call(s)):{}}},71961:(s,o,i)=>{var u=i(49653);s.exports=function cloneTypedArray(s,o){var i=o?u(s.buffer):s.buffer;return new s.constructor(i,s.byteOffset,s.length)}},91596:s=>{var o=Math.max;s.exports=function composeArgs(s,i,u,_){for(var w=-1,x=s.length,C=u.length,j=-1,L=i.length,B=o(x-C,0),$=Array(L+B),V=!_;++j{var o=Math.max;s.exports=function composeArgsRight(s,i,u,_){for(var w=-1,x=s.length,C=-1,j=u.length,L=-1,B=i.length,$=o(x-j,0),V=Array($+B),U=!_;++w<$;)V[w]=s[w];for(var z=w;++L{s.exports=function copyArray(s,o){var i=-1,u=s.length;for(o||(o=Array(u));++i{var u=i(16547),_=i(43360);s.exports=function copyObject(s,o,i,w){var x=!i;i||(i={});for(var C=-1,j=o.length;++C{var u=i(21791),_=i(4664);s.exports=function copySymbols(s,o){return u(s,_(s),o)}},48948:(s,o,i)=>{var u=i(21791),_=i(86375);s.exports=function copySymbolsIn(s,o){return u(s,_(s),o)}},55481:(s,o,i)=>{var u=i(9325)["__core-js_shared__"];s.exports=u},58523:s=>{s.exports=function countHolders(s,o){for(var i=s.length,u=0;i--;)s[i]===o&&++u;return u}},20999:(s,o,i)=>{var u=i(69302),_=i(36800);s.exports=function createAssigner(s){return u((function(o,i){var u=-1,w=i.length,x=w>1?i[w-1]:void 0,C=w>2?i[2]:void 0;for(x=s.length>3&&"function"==typeof x?(w--,x):void 0,C&&_(i[0],i[1],C)&&(x=w<3?void 0:x,w=1),o=Object(o);++u{var u=i(64894);s.exports=function createBaseEach(s,o){return function(i,_){if(null==i)return i;if(!u(i))return s(i,_);for(var w=i.length,x=o?w:-1,C=Object(i);(o?x--:++x{s.exports=function createBaseFor(s){return function(o,i,u){for(var _=-1,w=Object(o),x=u(o),C=x.length;C--;){var j=x[s?C:++_];if(!1===i(w[j],j,w))break}return o}}},11842:(s,o,i)=>{var u=i(82819),_=i(9325);s.exports=function createBind(s,o,i){var w=1&o,x=u(s);return function wrapper(){return(this&&this!==_&&this instanceof wrapper?x:s).apply(w?i:this,arguments)}}},12507:(s,o,i)=>{var u=i(28754),_=i(49698),w=i(63912),x=i(13222);s.exports=function createCaseFirst(s){return function(o){o=x(o);var i=_(o)?w(o):void 0,C=i?i[0]:o.charAt(0),j=i?u(i,1).join(""):o.slice(1);return C[s]()+j}}},45539:(s,o,i)=>{var u=i(40882),_=i(50828),w=i(66645),x=RegExp("['’]","g");s.exports=function createCompounder(s){return function(o){return u(w(_(o).replace(x,"")),s,"")}}},82819:(s,o,i)=>{var u=i(39344),_=i(23805);s.exports=function createCtor(s){return function(){var o=arguments;switch(o.length){case 0:return new s;case 1:return new s(o[0]);case 2:return new s(o[0],o[1]);case 3:return new s(o[0],o[1],o[2]);case 4:return new s(o[0],o[1],o[2],o[3]);case 5:return new s(o[0],o[1],o[2],o[3],o[4]);case 6:return new s(o[0],o[1],o[2],o[3],o[4],o[5]);case 7:return new s(o[0],o[1],o[2],o[3],o[4],o[5],o[6])}var i=u(s.prototype),w=s.apply(i,o);return _(w)?w:i}}},77078:(s,o,i)=>{var u=i(91033),_=i(82819),w=i(37471),x=i(18073),C=i(11287),j=i(36306),L=i(9325);s.exports=function createCurry(s,o,i){var B=_(s);return function wrapper(){for(var _=arguments.length,$=Array(_),V=_,U=C(wrapper);V--;)$[V]=arguments[V];var z=_<3&&$[0]!==U&&$[_-1]!==U?[]:j($,U);return(_-=z.length){var u=i(15389),_=i(64894),w=i(95950);s.exports=function createFind(s){return function(o,i,x){var C=Object(o);if(!_(o)){var j=u(i,3);o=w(o),i=function(s){return j(C[s],s,C)}}var L=s(o,i,x);return L>-1?C[j?o[L]:L]:void 0}}},37471:(s,o,i)=>{var u=i(91596),_=i(53320),w=i(58523),x=i(82819),C=i(18073),j=i(11287),L=i(68294),B=i(36306),$=i(9325);s.exports=function createHybrid(s,o,i,V,U,z,Y,Z,ee,ie){var ae=128&o,le=1&o,ce=2&o,pe=24&o,de=512&o,fe=ce?void 0:x(s);return function wrapper(){for(var ye=arguments.length,be=Array(ye),_e=ye;_e--;)be[_e]=arguments[_e];if(pe)var we=j(wrapper),Se=w(be,we);if(V&&(be=u(be,V,U,pe)),z&&(be=_(be,z,Y,pe)),ye-=Se,pe&&ye1&&be.reverse(),ae&&ee{var u=i(91033),_=i(82819),w=i(9325);s.exports=function createPartial(s,o,i,x){var C=1&o,j=_(s);return function wrapper(){for(var o=-1,_=arguments.length,L=-1,B=x.length,$=Array(B+_),V=this&&this!==w&&this instanceof wrapper?j:s;++L{var u=i(85087),_=i(54641),w=i(70981);s.exports=function createRecurry(s,o,i,x,C,j,L,B,$,V){var U=8&o;o|=U?32:64,4&(o&=~(U?64:32))||(o&=-4);var z=[s,o,C,U?j:void 0,U?L:void 0,U?void 0:j,U?void 0:L,B,$,V],Y=i.apply(void 0,z);return u(s)&&_(Y,z),Y.placeholder=x,w(Y,s,o)}},66977:(s,o,i)=>{var u=i(68882),_=i(11842),w=i(77078),x=i(37471),C=i(24168),j=i(37381),L=i(3209),B=i(54641),$=i(70981),V=i(61489),U=Math.max;s.exports=function createWrap(s,o,i,z,Y,Z,ee,ie){var ae=2&o;if(!ae&&"function"!=typeof s)throw new TypeError("Expected a function");var le=z?z.length:0;if(le||(o&=-97,z=Y=void 0),ee=void 0===ee?ee:U(V(ee),0),ie=void 0===ie?ie:V(ie),le-=Y?Y.length:0,64&o){var ce=z,pe=Y;z=Y=void 0}var de=ae?void 0:j(s),fe=[s,o,i,z,Y,ce,pe,Z,ee,ie];if(de&&L(fe,de),s=fe[0],o=fe[1],i=fe[2],z=fe[3],Y=fe[4],!(ie=fe[9]=void 0===fe[9]?ae?0:s.length:U(fe[9]-le,0))&&24&o&&(o&=-25),o&&1!=o)ye=8==o||16==o?w(s,o,ie):32!=o&&33!=o||Y.length?x.apply(void 0,fe):C(s,o,i,z);else var ye=_(s,o,i);return $((de?u:B)(ye,fe),s,o)}},53138:(s,o,i)=>{var u=i(11331);s.exports=function customOmitClone(s){return u(s)?void 0:s}},24647:(s,o,i)=>{var u=i(54552)({À:"A",Á:"A",Â:"A",Ã:"A",Ä:"A",Å:"A",à:"a",á:"a",â:"a",ã:"a",ä:"a",å:"a",Ç:"C",ç:"c",Ð:"D",ð:"d",È:"E",É:"E",Ê:"E",Ë:"E",è:"e",é:"e",ê:"e",ë:"e",Ì:"I",Í:"I",Î:"I",Ï:"I",ì:"i",í:"i",î:"i",ï:"i",Ñ:"N",ñ:"n",Ò:"O",Ó:"O",Ô:"O",Õ:"O",Ö:"O",Ø:"O",ò:"o",ó:"o",ô:"o",õ:"o",ö:"o",ø:"o",Ù:"U",Ú:"U",Û:"U",Ü:"U",ù:"u",ú:"u",û:"u",ü:"u",Ý:"Y",ý:"y",ÿ:"y",Æ:"Ae",æ:"ae",Þ:"Th",þ:"th",ß:"ss",Ā:"A",Ă:"A",Ą:"A",ā:"a",ă:"a",ą:"a",Ć:"C",Ĉ:"C",Ċ:"C",Č:"C",ć:"c",ĉ:"c",ċ:"c",č:"c",Ď:"D",Đ:"D",ď:"d",đ:"d",Ē:"E",Ĕ:"E",Ė:"E",Ę:"E",Ě:"E",ē:"e",ĕ:"e",ė:"e",ę:"e",ě:"e",Ĝ:"G",Ğ:"G",Ġ:"G",Ģ:"G",ĝ:"g",ğ:"g",ġ:"g",ģ:"g",Ĥ:"H",Ħ:"H",ĥ:"h",ħ:"h",Ĩ:"I",Ī:"I",Ĭ:"I",Į:"I",İ:"I",ĩ:"i",ī:"i",ĭ:"i",į:"i",ı:"i",Ĵ:"J",ĵ:"j",Ķ:"K",ķ:"k",ĸ:"k",Ĺ:"L",Ļ:"L",Ľ:"L",Ŀ:"L",Ł:"L",ĺ:"l",ļ:"l",ľ:"l",ŀ:"l",ł:"l",Ń:"N",Ņ:"N",Ň:"N",Ŋ:"N",ń:"n",ņ:"n",ň:"n",ŋ:"n",Ō:"O",Ŏ:"O",Ő:"O",ō:"o",ŏ:"o",ő:"o",Ŕ:"R",Ŗ:"R",Ř:"R",ŕ:"r",ŗ:"r",ř:"r",Ś:"S",Ŝ:"S",Ş:"S",Š:"S",ś:"s",ŝ:"s",ş:"s",š:"s",Ţ:"T",Ť:"T",Ŧ:"T",ţ:"t",ť:"t",ŧ:"t",Ũ:"U",Ū:"U",Ŭ:"U",Ů:"U",Ű:"U",Ų:"U",ũ:"u",ū:"u",ŭ:"u",ů:"u",ű:"u",ų:"u",Ŵ:"W",ŵ:"w",Ŷ:"Y",ŷ:"y",Ÿ:"Y",Ź:"Z",Ż:"Z",Ž:"Z",ź:"z",ż:"z",ž:"z",IJ:"IJ",ij:"ij",Œ:"Oe",œ:"oe",ʼn:"'n",ſ:"s"});s.exports=u},93243:(s,o,i)=>{var u=i(56110),_=function(){try{var s=u(Object,"defineProperty");return s({},"",{}),s}catch(s){}}();s.exports=_},25911:(s,o,i)=>{var u=i(38859),_=i(14248),w=i(19219);s.exports=function equalArrays(s,o,i,x,C,j){var L=1&i,B=s.length,$=o.length;if(B!=$&&!(L&&$>B))return!1;var V=j.get(s),U=j.get(o);if(V&&U)return V==o&&U==s;var z=-1,Y=!0,Z=2&i?new u:void 0;for(j.set(s,o),j.set(o,s);++z{var u=i(51873),_=i(37828),w=i(75288),x=i(25911),C=i(20317),j=i(84247),L=u?u.prototype:void 0,B=L?L.valueOf:void 0;s.exports=function equalByTag(s,o,i,u,L,$,V){switch(i){case"[object DataView]":if(s.byteLength!=o.byteLength||s.byteOffset!=o.byteOffset)return!1;s=s.buffer,o=o.buffer;case"[object ArrayBuffer]":return!(s.byteLength!=o.byteLength||!$(new _(s),new _(o)));case"[object Boolean]":case"[object Date]":case"[object Number]":return w(+s,+o);case"[object Error]":return s.name==o.name&&s.message==o.message;case"[object RegExp]":case"[object String]":return s==o+"";case"[object Map]":var U=C;case"[object Set]":var z=1&u;if(U||(U=j),s.size!=o.size&&!z)return!1;var Y=V.get(s);if(Y)return Y==o;u|=2,V.set(s,o);var Z=x(U(s),U(o),u,L,$,V);return V.delete(s),Z;case"[object Symbol]":if(B)return B.call(s)==B.call(o)}return!1}},50689:(s,o,i)=>{var u=i(50002),_=Object.prototype.hasOwnProperty;s.exports=function equalObjects(s,o,i,w,x,C){var j=1&i,L=u(s),B=L.length;if(B!=u(o).length&&!j)return!1;for(var $=B;$--;){var V=L[$];if(!(j?V in o:_.call(o,V)))return!1}var U=C.get(s),z=C.get(o);if(U&&z)return U==o&&z==s;var Y=!0;C.set(s,o),C.set(o,s);for(var Z=j;++${var u=i(35970),_=i(56757),w=i(32865);s.exports=function flatRest(s){return w(_(s,void 0,u),s+"")}},34840:(s,o,i)=>{var u="object"==typeof i.g&&i.g&&i.g.Object===Object&&i.g;s.exports=u},50002:(s,o,i)=>{var u=i(82199),_=i(4664),w=i(95950);s.exports=function getAllKeys(s){return u(s,w,_)}},83349:(s,o,i)=>{var u=i(82199),_=i(86375),w=i(37241);s.exports=function getAllKeysIn(s){return u(s,w,_)}},37381:(s,o,i)=>{var u=i(48152),_=i(63950),w=u?function(s){return u.get(s)}:_;s.exports=w},62284:(s,o,i)=>{var u=i(84629),_=Object.prototype.hasOwnProperty;s.exports=function getFuncName(s){for(var o=s.name+"",i=u[o],w=_.call(u,o)?i.length:0;w--;){var x=i[w],C=x.func;if(null==C||C==s)return x.name}return o}},11287:s=>{s.exports=function getHolder(s){return s.placeholder}},12651:(s,o,i)=>{var u=i(74218);s.exports=function getMapData(s,o){var i=s.__data__;return u(o)?i["string"==typeof o?"string":"hash"]:i.map}},10776:(s,o,i)=>{var u=i(30756),_=i(95950);s.exports=function getMatchData(s){for(var o=_(s),i=o.length;i--;){var w=o[i],x=s[w];o[i]=[w,x,u(x)]}return o}},56110:(s,o,i)=>{var u=i(45083),_=i(10392);s.exports=function getNative(s,o){var i=_(s,o);return u(i)?i:void 0}},28879:(s,o,i)=>{var u=i(74335)(Object.getPrototypeOf,Object);s.exports=u},659:(s,o,i)=>{var u=i(51873),_=Object.prototype,w=_.hasOwnProperty,x=_.toString,C=u?u.toStringTag:void 0;s.exports=function getRawTag(s){var o=w.call(s,C),i=s[C];try{s[C]=void 0;var u=!0}catch(s){}var _=x.call(s);return u&&(o?s[C]=i:delete s[C]),_}},4664:(s,o,i)=>{var u=i(79770),_=i(63345),w=Object.prototype.propertyIsEnumerable,x=Object.getOwnPropertySymbols,C=x?function(s){return null==s?[]:(s=Object(s),u(x(s),(function(o){return w.call(s,o)})))}:_;s.exports=C},86375:(s,o,i)=>{var u=i(14528),_=i(28879),w=i(4664),x=i(63345),C=Object.getOwnPropertySymbols?function(s){for(var o=[];s;)u(o,w(s)),s=_(s);return o}:x;s.exports=C},5861:(s,o,i)=>{var u=i(55580),_=i(68223),w=i(32804),x=i(76545),C=i(28303),j=i(72552),L=i(47473),B="[object Map]",$="[object Promise]",V="[object Set]",U="[object WeakMap]",z="[object DataView]",Y=L(u),Z=L(_),ee=L(w),ie=L(x),ae=L(C),le=j;(u&&le(new u(new ArrayBuffer(1)))!=z||_&&le(new _)!=B||w&&le(w.resolve())!=$||x&&le(new x)!=V||C&&le(new C)!=U)&&(le=function(s){var o=j(s),i="[object Object]"==o?s.constructor:void 0,u=i?L(i):"";if(u)switch(u){case Y:return z;case Z:return B;case ee:return $;case ie:return V;case ae:return U}return o}),s.exports=le},10392:s=>{s.exports=function getValue(s,o){return null==s?void 0:s[o]}},75251:s=>{var o=/\{\n\/\* \[wrapped with (.+)\] \*/,i=/,? & /;s.exports=function getWrapDetails(s){var u=s.match(o);return u?u[1].split(i):[]}},49326:(s,o,i)=>{var u=i(31769),_=i(72428),w=i(56449),x=i(30361),C=i(30294),j=i(77797);s.exports=function hasPath(s,o,i){for(var L=-1,B=(o=u(o,s)).length,$=!1;++L{var o=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");s.exports=function hasUnicode(s){return o.test(s)}},45434:s=>{var o=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;s.exports=function hasUnicodeWord(s){return o.test(s)}},22032:(s,o,i)=>{var u=i(81042);s.exports=function hashClear(){this.__data__=u?u(null):{},this.size=0}},63862:s=>{s.exports=function hashDelete(s){var o=this.has(s)&&delete this.__data__[s];return this.size-=o?1:0,o}},66721:(s,o,i)=>{var u=i(81042),_=Object.prototype.hasOwnProperty;s.exports=function hashGet(s){var o=this.__data__;if(u){var i=o[s];return"__lodash_hash_undefined__"===i?void 0:i}return _.call(o,s)?o[s]:void 0}},12749:(s,o,i)=>{var u=i(81042),_=Object.prototype.hasOwnProperty;s.exports=function hashHas(s){var o=this.__data__;return u?void 0!==o[s]:_.call(o,s)}},35749:(s,o,i)=>{var u=i(81042);s.exports=function hashSet(s,o){var i=this.__data__;return this.size+=this.has(s)?0:1,i[s]=u&&void 0===o?"__lodash_hash_undefined__":o,this}},76189:s=>{var o=Object.prototype.hasOwnProperty;s.exports=function initCloneArray(s){var i=s.length,u=new s.constructor(i);return i&&"string"==typeof s[0]&&o.call(s,"index")&&(u.index=s.index,u.input=s.input),u}},77199:(s,o,i)=>{var u=i(49653),_=i(76169),w=i(73201),x=i(93736),C=i(71961);s.exports=function initCloneByTag(s,o,i){var j=s.constructor;switch(o){case"[object ArrayBuffer]":return u(s);case"[object Boolean]":case"[object Date]":return new j(+s);case"[object DataView]":return _(s,i);case"[object Float32Array]":case"[object Float64Array]":case"[object Int8Array]":case"[object Int16Array]":case"[object Int32Array]":case"[object Uint8Array]":case"[object Uint8ClampedArray]":case"[object Uint16Array]":case"[object Uint32Array]":return C(s,i);case"[object Map]":case"[object Set]":return new j;case"[object Number]":case"[object String]":return new j(s);case"[object RegExp]":return w(s);case"[object Symbol]":return x(s)}}},35529:(s,o,i)=>{var u=i(39344),_=i(28879),w=i(55527);s.exports=function initCloneObject(s){return"function"!=typeof s.constructor||w(s)?{}:u(_(s))}},62060:s=>{var o=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;s.exports=function insertWrapDetails(s,i){var u=i.length;if(!u)return s;var _=u-1;return i[_]=(u>1?"& ":"")+i[_],i=i.join(u>2?", ":" "),s.replace(o,"{\n/* [wrapped with "+i+"] */\n")}},45891:(s,o,i)=>{var u=i(51873),_=i(72428),w=i(56449),x=u?u.isConcatSpreadable:void 0;s.exports=function isFlattenable(s){return w(s)||_(s)||!!(x&&s&&s[x])}},30361:s=>{var o=/^(?:0|[1-9]\d*)$/;s.exports=function isIndex(s,i){var u=typeof s;return!!(i=null==i?9007199254740991:i)&&("number"==u||"symbol"!=u&&o.test(s))&&s>-1&&s%1==0&&s{var u=i(75288),_=i(64894),w=i(30361),x=i(23805);s.exports=function isIterateeCall(s,o,i){if(!x(i))return!1;var C=typeof o;return!!("number"==C?_(i)&&w(o,i.length):"string"==C&&o in i)&&u(i[o],s)}},28586:(s,o,i)=>{var u=i(56449),_=i(44394),w=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,x=/^\w*$/;s.exports=function isKey(s,o){if(u(s))return!1;var i=typeof s;return!("number"!=i&&"symbol"!=i&&"boolean"!=i&&null!=s&&!_(s))||(x.test(s)||!w.test(s)||null!=o&&s in Object(o))}},74218:s=>{s.exports=function isKeyable(s){var o=typeof s;return"string"==o||"number"==o||"symbol"==o||"boolean"==o?"__proto__"!==s:null===s}},85087:(s,o,i)=>{var u=i(30980),_=i(37381),w=i(62284),x=i(53758);s.exports=function isLaziable(s){var o=w(s),i=x[o];if("function"!=typeof i||!(o in u.prototype))return!1;if(s===i)return!0;var C=_(i);return!!C&&s===C[0]}},87296:(s,o,i)=>{var u,_=i(55481),w=(u=/[^.]+$/.exec(_&&_.keys&&_.keys.IE_PROTO||""))?"Symbol(src)_1."+u:"";s.exports=function isMasked(s){return!!w&&w in s}},55527:s=>{var o=Object.prototype;s.exports=function isPrototype(s){var i=s&&s.constructor;return s===("function"==typeof i&&i.prototype||o)}},30756:(s,o,i)=>{var u=i(23805);s.exports=function isStrictComparable(s){return s==s&&!u(s)}},63702:s=>{s.exports=function listCacheClear(){this.__data__=[],this.size=0}},70080:(s,o,i)=>{var u=i(26025),_=Array.prototype.splice;s.exports=function listCacheDelete(s){var o=this.__data__,i=u(o,s);return!(i<0)&&(i==o.length-1?o.pop():_.call(o,i,1),--this.size,!0)}},24739:(s,o,i)=>{var u=i(26025);s.exports=function listCacheGet(s){var o=this.__data__,i=u(o,s);return i<0?void 0:o[i][1]}},48655:(s,o,i)=>{var u=i(26025);s.exports=function listCacheHas(s){return u(this.__data__,s)>-1}},31175:(s,o,i)=>{var u=i(26025);s.exports=function listCacheSet(s,o){var i=this.__data__,_=u(i,s);return _<0?(++this.size,i.push([s,o])):i[_][1]=o,this}},63040:(s,o,i)=>{var u=i(21549),_=i(80079),w=i(68223);s.exports=function mapCacheClear(){this.size=0,this.__data__={hash:new u,map:new(w||_),string:new u}}},17670:(s,o,i)=>{var u=i(12651);s.exports=function mapCacheDelete(s){var o=u(this,s).delete(s);return this.size-=o?1:0,o}},90289:(s,o,i)=>{var u=i(12651);s.exports=function mapCacheGet(s){return u(this,s).get(s)}},4509:(s,o,i)=>{var u=i(12651);s.exports=function mapCacheHas(s){return u(this,s).has(s)}},72949:(s,o,i)=>{var u=i(12651);s.exports=function mapCacheSet(s,o){var i=u(this,s),_=i.size;return i.set(s,o),this.size+=i.size==_?0:1,this}},20317:s=>{s.exports=function mapToArray(s){var o=-1,i=Array(s.size);return s.forEach((function(s,u){i[++o]=[u,s]})),i}},67197:s=>{s.exports=function matchesStrictComparable(s,o){return function(i){return null!=i&&(i[s]===o&&(void 0!==o||s in Object(i)))}}},62224:(s,o,i)=>{var u=i(50104);s.exports=function memoizeCapped(s){var o=u(s,(function(s){return 500===i.size&&i.clear(),s})),i=o.cache;return o}},3209:(s,o,i)=>{var u=i(91596),_=i(53320),w=i(36306),x="__lodash_placeholder__",C=128,j=Math.min;s.exports=function mergeData(s,o){var i=s[1],L=o[1],B=i|L,$=B<131,V=L==C&&8==i||L==C&&256==i&&s[7].length<=o[8]||384==L&&o[7].length<=o[8]&&8==i;if(!$&&!V)return s;1&L&&(s[2]=o[2],B|=1&i?0:4);var U=o[3];if(U){var z=s[3];s[3]=z?u(z,U,o[4]):U,s[4]=z?w(s[3],x):o[4]}return(U=o[5])&&(z=s[5],s[5]=z?_(z,U,o[6]):U,s[6]=z?w(s[5],x):o[6]),(U=o[7])&&(s[7]=U),L&C&&(s[8]=null==s[8]?o[8]:j(s[8],o[8])),null==s[9]&&(s[9]=o[9]),s[0]=o[0],s[1]=B,s}},48152:(s,o,i)=>{var u=i(28303),_=u&&new u;s.exports=_},81042:(s,o,i)=>{var u=i(56110)(Object,"create");s.exports=u},3650:(s,o,i)=>{var u=i(74335)(Object.keys,Object);s.exports=u},90181:s=>{s.exports=function nativeKeysIn(s){var o=[];if(null!=s)for(var i in Object(s))o.push(i);return o}},86009:(s,o,i)=>{s=i.nmd(s);var u=i(34840),_=o&&!o.nodeType&&o,w=_&&s&&!s.nodeType&&s,x=w&&w.exports===_&&u.process,C=function(){try{var s=w&&w.require&&w.require("util").types;return s||x&&x.binding&&x.binding("util")}catch(s){}}();s.exports=C},59350:s=>{var o=Object.prototype.toString;s.exports=function objectToString(s){return o.call(s)}},74335:s=>{s.exports=function overArg(s,o){return function(i){return s(o(i))}}},56757:(s,o,i)=>{var u=i(91033),_=Math.max;s.exports=function overRest(s,o,i){return o=_(void 0===o?s.length-1:o,0),function(){for(var w=arguments,x=-1,C=_(w.length-o,0),j=Array(C);++x{var u=i(47422),_=i(25160);s.exports=function parent(s,o){return o.length<2?s:u(s,_(o,0,-1))}},84629:s=>{s.exports={}},68294:(s,o,i)=>{var u=i(23007),_=i(30361),w=Math.min;s.exports=function reorder(s,o){for(var i=s.length,x=w(o.length,i),C=u(s);x--;){var j=o[x];s[x]=_(j,i)?C[j]:void 0}return s}},36306:s=>{var o="__lodash_placeholder__";s.exports=function replaceHolders(s,i){for(var u=-1,_=s.length,w=0,x=[];++u<_;){var C=s[u];C!==i&&C!==o||(s[u]=o,x[w++]=u)}return x}},9325:(s,o,i)=>{var u=i(34840),_="object"==typeof self&&self&&self.Object===Object&&self,w=u||_||Function("return this")();s.exports=w},14974:s=>{s.exports=function safeGet(s,o){if(("constructor"!==o||"function"!=typeof s[o])&&"__proto__"!=o)return s[o]}},31380:s=>{s.exports=function setCacheAdd(s){return this.__data__.set(s,"__lodash_hash_undefined__"),this}},51459:s=>{s.exports=function setCacheHas(s){return this.__data__.has(s)}},54641:(s,o,i)=>{var u=i(68882),_=i(51811)(u);s.exports=_},84247:s=>{s.exports=function setToArray(s){var o=-1,i=Array(s.size);return s.forEach((function(s){i[++o]=s})),i}},32865:(s,o,i)=>{var u=i(19570),_=i(51811)(u);s.exports=_},70981:(s,o,i)=>{var u=i(75251),_=i(62060),w=i(32865),x=i(75948);s.exports=function setWrapToString(s,o,i){var C=o+"";return w(s,_(C,x(u(C),i)))}},51811:s=>{var o=Date.now;s.exports=function shortOut(s){var i=0,u=0;return function(){var _=o(),w=16-(_-u);if(u=_,w>0){if(++i>=800)return arguments[0]}else i=0;return s.apply(void 0,arguments)}}},51420:(s,o,i)=>{var u=i(80079);s.exports=function stackClear(){this.__data__=new u,this.size=0}},90938:s=>{s.exports=function stackDelete(s){var o=this.__data__,i=o.delete(s);return this.size=o.size,i}},63605:s=>{s.exports=function stackGet(s){return this.__data__.get(s)}},29817:s=>{s.exports=function stackHas(s){return this.__data__.has(s)}},80945:(s,o,i)=>{var u=i(80079),_=i(68223),w=i(53661);s.exports=function stackSet(s,o){var i=this.__data__;if(i instanceof u){var x=i.__data__;if(!_||x.length<199)return x.push([s,o]),this.size=++i.size,this;i=this.__data__=new w(x)}return i.set(s,o),this.size=i.size,this}},76959:s=>{s.exports=function strictIndexOf(s,o,i){for(var u=i-1,_=s.length;++u<_;)if(s[u]===o)return u;return-1}},63912:(s,o,i)=>{var u=i(61074),_=i(49698),w=i(42054);s.exports=function stringToArray(s){return _(s)?w(s):u(s)}},61802:(s,o,i)=>{var u=i(62224),_=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,w=/\\(\\)?/g,x=u((function(s){var o=[];return 46===s.charCodeAt(0)&&o.push(""),s.replace(_,(function(s,i,u,_){o.push(u?_.replace(w,"$1"):i||s)})),o}));s.exports=x},77797:(s,o,i)=>{var u=i(44394);s.exports=function toKey(s){if("string"==typeof s||u(s))return s;var o=s+"";return"0"==o&&1/s==-1/0?"-0":o}},47473:s=>{var o=Function.prototype.toString;s.exports=function toSource(s){if(null!=s){try{return o.call(s)}catch(s){}try{return s+""}catch(s){}}return""}},31800:s=>{var o=/\s/;s.exports=function trimmedEndIndex(s){for(var i=s.length;i--&&o.test(s.charAt(i)););return i}},42054:s=>{var o="\\ud800-\\udfff",i="["+o+"]",u="[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",_="\\ud83c[\\udffb-\\udfff]",w="[^"+o+"]",x="(?:\\ud83c[\\udde6-\\uddff]){2}",C="[\\ud800-\\udbff][\\udc00-\\udfff]",j="(?:"+u+"|"+_+")"+"?",L="[\\ufe0e\\ufe0f]?",B=L+j+("(?:\\u200d(?:"+[w,x,C].join("|")+")"+L+j+")*"),$="(?:"+[w+u+"?",u,x,C,i].join("|")+")",V=RegExp(_+"(?="+_+")|"+$+B,"g");s.exports=function unicodeToArray(s){return s.match(V)||[]}},22225:s=>{var o="\\ud800-\\udfff",i="\\u2700-\\u27bf",u="a-z\\xdf-\\xf6\\xf8-\\xff",_="A-Z\\xc0-\\xd6\\xd8-\\xde",w="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",x="["+w+"]",C="\\d+",j="["+i+"]",L="["+u+"]",B="[^"+o+w+C+i+u+_+"]",$="(?:\\ud83c[\\udde6-\\uddff]){2}",V="[\\ud800-\\udbff][\\udc00-\\udfff]",U="["+_+"]",z="(?:"+L+"|"+B+")",Y="(?:"+U+"|"+B+")",Z="(?:['’](?:d|ll|m|re|s|t|ve))?",ee="(?:['’](?:D|LL|M|RE|S|T|VE))?",ie="(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?",ae="[\\ufe0e\\ufe0f]?",le=ae+ie+("(?:\\u200d(?:"+["[^"+o+"]",$,V].join("|")+")"+ae+ie+")*"),ce="(?:"+[j,$,V].join("|")+")"+le,pe=RegExp([U+"?"+L+"+"+Z+"(?="+[x,U,"$"].join("|")+")",Y+"+"+ee+"(?="+[x,U+z,"$"].join("|")+")",U+"?"+z+"+"+Z,U+"+"+ee,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",C,ce].join("|"),"g");s.exports=function unicodeWords(s){return s.match(pe)||[]}},75948:(s,o,i)=>{var u=i(83729),_=i(15325),w=[["ary",128],["bind",1],["bindKey",2],["curry",8],["curryRight",16],["flip",512],["partial",32],["partialRight",64],["rearg",256]];s.exports=function updateWrapDetails(s,o){return u(w,(function(i){var u="_."+i[0];o&i[1]&&!_(s,u)&&s.push(u)})),s.sort()}},80257:(s,o,i)=>{var u=i(30980),_=i(56017),w=i(23007);s.exports=function wrapperClone(s){if(s instanceof u)return s.clone();var o=new _(s.__wrapped__,s.__chain__);return o.__actions__=w(s.__actions__),o.__index__=s.__index__,o.__values__=s.__values__,o}},64626:(s,o,i)=>{var u=i(66977);s.exports=function ary(s,o,i){return o=i?void 0:o,o=s&&null==o?s.length:o,u(s,128,void 0,void 0,void 0,void 0,o)}},84058:(s,o,i)=>{var u=i(14792),_=i(45539)((function(s,o,i){return o=o.toLowerCase(),s+(i?u(o):o)}));s.exports=_},14792:(s,o,i)=>{var u=i(13222),_=i(55808);s.exports=function capitalize(s){return _(u(s).toLowerCase())}},32629:(s,o,i)=>{var u=i(9999);s.exports=function clone(s){return u(s,4)}},37334:s=>{s.exports=function constant(s){return function(){return s}}},49747:(s,o,i)=>{var u=i(66977);function curry(s,o,i){var _=u(s,8,void 0,void 0,void 0,void 0,void 0,o=i?void 0:o);return _.placeholder=curry.placeholder,_}curry.placeholder={},s.exports=curry},38221:(s,o,i)=>{var u=i(23805),_=i(10124),w=i(99374),x=Math.max,C=Math.min;s.exports=function debounce(s,o,i){var j,L,B,$,V,U,z=0,Y=!1,Z=!1,ee=!0;if("function"!=typeof s)throw new TypeError("Expected a function");function invokeFunc(o){var i=j,u=L;return j=L=void 0,z=o,$=s.apply(u,i)}function shouldInvoke(s){var i=s-U;return void 0===U||i>=o||i<0||Z&&s-z>=B}function timerExpired(){var s=_();if(shouldInvoke(s))return trailingEdge(s);V=setTimeout(timerExpired,function remainingWait(s){var i=o-(s-U);return Z?C(i,B-(s-z)):i}(s))}function trailingEdge(s){return V=void 0,ee&&j?invokeFunc(s):(j=L=void 0,$)}function debounced(){var s=_(),i=shouldInvoke(s);if(j=arguments,L=this,U=s,i){if(void 0===V)return function leadingEdge(s){return z=s,V=setTimeout(timerExpired,o),Y?invokeFunc(s):$}(U);if(Z)return clearTimeout(V),V=setTimeout(timerExpired,o),invokeFunc(U)}return void 0===V&&(V=setTimeout(timerExpired,o)),$}return o=w(o)||0,u(i)&&(Y=!!i.leading,B=(Z="maxWait"in i)?x(w(i.maxWait)||0,o):B,ee="trailing"in i?!!i.trailing:ee),debounced.cancel=function cancel(){void 0!==V&&clearTimeout(V),z=0,j=U=L=V=void 0},debounced.flush=function flush(){return void 0===V?$:trailingEdge(_())},debounced}},50828:(s,o,i)=>{var u=i(24647),_=i(13222),w=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,x=RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]","g");s.exports=function deburr(s){return(s=_(s))&&s.replace(w,u).replace(x,"")}},75288:s=>{s.exports=function eq(s,o){return s===o||s!=s&&o!=o}},60680:(s,o,i)=>{var u=i(13222),_=/[\\^$.*+?()[\]{}|]/g,w=RegExp(_.source);s.exports=function escapeRegExp(s){return(s=u(s))&&w.test(s)?s.replace(_,"\\$&"):s}},7309:(s,o,i)=>{var u=i(62006)(i(24713));s.exports=u},24713:(s,o,i)=>{var u=i(2523),_=i(15389),w=i(61489),x=Math.max;s.exports=function findIndex(s,o,i){var C=null==s?0:s.length;if(!C)return-1;var j=null==i?0:w(i);return j<0&&(j=x(C+j,0)),u(s,_(o,3),j)}},35970:(s,o,i)=>{var u=i(83120);s.exports=function flatten(s){return(null==s?0:s.length)?u(s,1):[]}},73424:(s,o,i)=>{var u=i(16962),_=i(2874),w=Array.prototype.push;function baseAry(s,o){return 2==o?function(o,i){return s(o,i)}:function(o){return s(o)}}function cloneArray(s){for(var o=s?s.length:0,i=Array(o);o--;)i[o]=s[o];return i}function wrapImmutable(s,o){return function(){var i=arguments.length;if(i){for(var u=Array(i);i--;)u[i]=arguments[i];var _=u[0]=o.apply(void 0,u);return s.apply(void 0,u),_}}}s.exports=function baseConvert(s,o,i,x){var C="function"==typeof o,j=o===Object(o);if(j&&(x=i,i=o,o=void 0),null==i)throw new TypeError;x||(x={});var L=!("cap"in x)||x.cap,B=!("curry"in x)||x.curry,$=!("fixed"in x)||x.fixed,V=!("immutable"in x)||x.immutable,U=!("rearg"in x)||x.rearg,z=C?i:_,Y="curry"in x&&x.curry,Z="fixed"in x&&x.fixed,ee="rearg"in x&&x.rearg,ie=C?i.runInContext():void 0,ae=C?i:{ary:s.ary,assign:s.assign,clone:s.clone,curry:s.curry,forEach:s.forEach,isArray:s.isArray,isError:s.isError,isFunction:s.isFunction,isWeakMap:s.isWeakMap,iteratee:s.iteratee,keys:s.keys,rearg:s.rearg,toInteger:s.toInteger,toPath:s.toPath},le=ae.ary,ce=ae.assign,pe=ae.clone,de=ae.curry,fe=ae.forEach,ye=ae.isArray,be=ae.isError,_e=ae.isFunction,we=ae.isWeakMap,Se=ae.keys,xe=ae.rearg,Pe=ae.toInteger,Te=ae.toPath,Re=Se(u.aryMethod),qe={castArray:function(s){return function(){var o=arguments[0];return ye(o)?s(cloneArray(o)):s.apply(void 0,arguments)}},iteratee:function(s){return function(){var o=arguments[1],i=s(arguments[0],o),u=i.length;return L&&"number"==typeof o?(o=o>2?o-2:1,u&&u<=o?i:baseAry(i,o)):i}},mixin:function(s){return function(o){var i=this;if(!_e(i))return s(i,Object(o));var u=[];return fe(Se(o),(function(s){_e(o[s])&&u.push([s,i.prototype[s]])})),s(i,Object(o)),fe(u,(function(s){var o=s[1];_e(o)?i.prototype[s[0]]=o:delete i.prototype[s[0]]})),i}},nthArg:function(s){return function(o){var i=o<0?1:Pe(o)+1;return de(s(o),i)}},rearg:function(s){return function(o,i){var u=i?i.length:0;return de(s(o,i),u)}},runInContext:function(o){return function(i){return baseConvert(s,o(i),x)}}};function castCap(s,o){if(L){var i=u.iterateeRearg[s];if(i)return function iterateeRearg(s,o){return overArg(s,(function(s){var i=o.length;return function baseArity(s,o){return 2==o?function(o,i){return s.apply(void 0,arguments)}:function(o){return s.apply(void 0,arguments)}}(xe(baseAry(s,i),o),i)}))}(o,i);var _=!C&&u.iterateeAry[s];if(_)return function iterateeAry(s,o){return overArg(s,(function(s){return"function"==typeof s?baseAry(s,o):s}))}(o,_)}return o}function castFixed(s,o,i){if($&&(Z||!u.skipFixed[s])){var _=u.methodSpread[s],x=_&&_.start;return void 0===x?le(o,i):function flatSpread(s,o){return function(){for(var i=arguments.length,u=i-1,_=Array(i);i--;)_[i]=arguments[i];var x=_[o],C=_.slice(0,o);return x&&w.apply(C,x),o!=u&&w.apply(C,_.slice(o+1)),s.apply(this,C)}}(o,x)}return o}function castRearg(s,o,i){return U&&i>1&&(ee||!u.skipRearg[s])?xe(o,u.methodRearg[s]||u.aryRearg[i]):o}function cloneByPath(s,o){for(var i=-1,u=(o=Te(o)).length,_=u-1,w=pe(Object(s)),x=w;null!=x&&++i1?de(o,i):o}(0,_=castCap(w,_),s),!1}})),!_})),_||(_=x),_==o&&(_=Y?de(_,1):function(){return o.apply(this,arguments)}),_.convert=createConverter(w,o),_.placeholder=o.placeholder=i,_}if(!j)return wrap(o,i,z);var $e=i,ze=[];return fe(Re,(function(s){fe(u.aryMethod[s],(function(s){var o=$e[u.remap[s]||s];o&&ze.push([s,wrap(s,o,$e)])}))})),fe(Se($e),(function(s){var o=$e[s];if("function"==typeof o){for(var i=ze.length;i--;)if(ze[i][0]==s)return;o.convert=createConverter(s,o),ze.push([s,o])}})),fe(ze,(function(s){$e[s[0]]=s[1]})),$e.convert=function convertLib(s){return $e.runInContext.convert(s)(void 0)},$e.placeholder=$e,fe(Se($e),(function(s){fe(u.realToAlias[s]||[],(function(o){$e[o]=$e[s]}))})),$e}},16962:(s,o)=>{o.aliasToReal={each:"forEach",eachRight:"forEachRight",entries:"toPairs",entriesIn:"toPairsIn",extend:"assignIn",extendAll:"assignInAll",extendAllWith:"assignInAllWith",extendWith:"assignInWith",first:"head",conforms:"conformsTo",matches:"isMatch",property:"get",__:"placeholder",F:"stubFalse",T:"stubTrue",all:"every",allPass:"overEvery",always:"constant",any:"some",anyPass:"overSome",apply:"spread",assoc:"set",assocPath:"set",complement:"negate",compose:"flowRight",contains:"includes",dissoc:"unset",dissocPath:"unset",dropLast:"dropRight",dropLastWhile:"dropRightWhile",equals:"isEqual",identical:"eq",indexBy:"keyBy",init:"initial",invertObj:"invert",juxt:"over",omitAll:"omit",nAry:"ary",path:"get",pathEq:"matchesProperty",pathOr:"getOr",paths:"at",pickAll:"pick",pipe:"flow",pluck:"map",prop:"get",propEq:"matchesProperty",propOr:"getOr",props:"at",symmetricDifference:"xor",symmetricDifferenceBy:"xorBy",symmetricDifferenceWith:"xorWith",takeLast:"takeRight",takeLastWhile:"takeRightWhile",unapply:"rest",unnest:"flatten",useWith:"overArgs",where:"conformsTo",whereEq:"isMatch",zipObj:"zipObject"},o.aryMethod={1:["assignAll","assignInAll","attempt","castArray","ceil","create","curry","curryRight","defaultsAll","defaultsDeepAll","floor","flow","flowRight","fromPairs","invert","iteratee","memoize","method","mergeAll","methodOf","mixin","nthArg","over","overEvery","overSome","rest","reverse","round","runInContext","spread","template","trim","trimEnd","trimStart","uniqueId","words","zipAll"],2:["add","after","ary","assign","assignAllWith","assignIn","assignInAllWith","at","before","bind","bindAll","bindKey","chunk","cloneDeepWith","cloneWith","concat","conformsTo","countBy","curryN","curryRightN","debounce","defaults","defaultsDeep","defaultTo","delay","difference","divide","drop","dropRight","dropRightWhile","dropWhile","endsWith","eq","every","filter","find","findIndex","findKey","findLast","findLastIndex","findLastKey","flatMap","flatMapDeep","flattenDepth","forEach","forEachRight","forIn","forInRight","forOwn","forOwnRight","get","groupBy","gt","gte","has","hasIn","includes","indexOf","intersection","invertBy","invoke","invokeMap","isEqual","isMatch","join","keyBy","lastIndexOf","lt","lte","map","mapKeys","mapValues","matchesProperty","maxBy","meanBy","merge","mergeAllWith","minBy","multiply","nth","omit","omitBy","overArgs","pad","padEnd","padStart","parseInt","partial","partialRight","partition","pick","pickBy","propertyOf","pull","pullAll","pullAt","random","range","rangeRight","rearg","reject","remove","repeat","restFrom","result","sampleSize","some","sortBy","sortedIndex","sortedIndexOf","sortedLastIndex","sortedLastIndexOf","sortedUniqBy","split","spreadFrom","startsWith","subtract","sumBy","take","takeRight","takeRightWhile","takeWhile","tap","throttle","thru","times","trimChars","trimCharsEnd","trimCharsStart","truncate","union","uniqBy","uniqWith","unset","unzipWith","without","wrap","xor","zip","zipObject","zipObjectDeep"],3:["assignInWith","assignWith","clamp","differenceBy","differenceWith","findFrom","findIndexFrom","findLastFrom","findLastIndexFrom","getOr","includesFrom","indexOfFrom","inRange","intersectionBy","intersectionWith","invokeArgs","invokeArgsMap","isEqualWith","isMatchWith","flatMapDepth","lastIndexOfFrom","mergeWith","orderBy","padChars","padCharsEnd","padCharsStart","pullAllBy","pullAllWith","rangeStep","rangeStepRight","reduce","reduceRight","replace","set","slice","sortedIndexBy","sortedLastIndexBy","transform","unionBy","unionWith","update","xorBy","xorWith","zipWith"],4:["fill","setWith","updateWith"]},o.aryRearg={2:[1,0],3:[2,0,1],4:[3,2,0,1]},o.iterateeAry={dropRightWhile:1,dropWhile:1,every:1,filter:1,find:1,findFrom:1,findIndex:1,findIndexFrom:1,findKey:1,findLast:1,findLastFrom:1,findLastIndex:1,findLastIndexFrom:1,findLastKey:1,flatMap:1,flatMapDeep:1,flatMapDepth:1,forEach:1,forEachRight:1,forIn:1,forInRight:1,forOwn:1,forOwnRight:1,map:1,mapKeys:1,mapValues:1,partition:1,reduce:2,reduceRight:2,reject:1,remove:1,some:1,takeRightWhile:1,takeWhile:1,times:1,transform:2},o.iterateeRearg={mapKeys:[1],reduceRight:[1,0]},o.methodRearg={assignInAllWith:[1,0],assignInWith:[1,2,0],assignAllWith:[1,0],assignWith:[1,2,0],differenceBy:[1,2,0],differenceWith:[1,2,0],getOr:[2,1,0],intersectionBy:[1,2,0],intersectionWith:[1,2,0],isEqualWith:[1,2,0],isMatchWith:[2,1,0],mergeAllWith:[1,0],mergeWith:[1,2,0],padChars:[2,1,0],padCharsEnd:[2,1,0],padCharsStart:[2,1,0],pullAllBy:[2,1,0],pullAllWith:[2,1,0],rangeStep:[1,2,0],rangeStepRight:[1,2,0],setWith:[3,1,2,0],sortedIndexBy:[2,1,0],sortedLastIndexBy:[2,1,0],unionBy:[1,2,0],unionWith:[1,2,0],updateWith:[3,1,2,0],xorBy:[1,2,0],xorWith:[1,2,0],zipWith:[1,2,0]},o.methodSpread={assignAll:{start:0},assignAllWith:{start:0},assignInAll:{start:0},assignInAllWith:{start:0},defaultsAll:{start:0},defaultsDeepAll:{start:0},invokeArgs:{start:2},invokeArgsMap:{start:2},mergeAll:{start:0},mergeAllWith:{start:0},partial:{start:1},partialRight:{start:1},without:{start:1},zipAll:{start:0}},o.mutate={array:{fill:!0,pull:!0,pullAll:!0,pullAllBy:!0,pullAllWith:!0,pullAt:!0,remove:!0,reverse:!0},object:{assign:!0,assignAll:!0,assignAllWith:!0,assignIn:!0,assignInAll:!0,assignInAllWith:!0,assignInWith:!0,assignWith:!0,defaults:!0,defaultsAll:!0,defaultsDeep:!0,defaultsDeepAll:!0,merge:!0,mergeAll:!0,mergeAllWith:!0,mergeWith:!0},set:{set:!0,setWith:!0,unset:!0,update:!0,updateWith:!0}},o.realToAlias=function(){var s=Object.prototype.hasOwnProperty,i=o.aliasToReal,u={};for(var _ in i){var w=i[_];s.call(u,w)?u[w].push(_):u[w]=[_]}return u}(),o.remap={assignAll:"assign",assignAllWith:"assignWith",assignInAll:"assignIn",assignInAllWith:"assignInWith",curryN:"curry",curryRightN:"curryRight",defaultsAll:"defaults",defaultsDeepAll:"defaultsDeep",findFrom:"find",findIndexFrom:"findIndex",findLastFrom:"findLast",findLastIndexFrom:"findLastIndex",getOr:"get",includesFrom:"includes",indexOfFrom:"indexOf",invokeArgs:"invoke",invokeArgsMap:"invokeMap",lastIndexOfFrom:"lastIndexOf",mergeAll:"merge",mergeAllWith:"mergeWith",padChars:"pad",padCharsEnd:"padEnd",padCharsStart:"padStart",propertyOf:"get",rangeStep:"range",rangeStepRight:"rangeRight",restFrom:"rest",spreadFrom:"spread",trimChars:"trim",trimCharsEnd:"trimEnd",trimCharsStart:"trimStart",zipAll:"zip"},o.skipFixed={castArray:!0,flow:!0,flowRight:!0,iteratee:!0,mixin:!0,rearg:!0,runInContext:!0},o.skipRearg={add:!0,assign:!0,assignIn:!0,bind:!0,bindKey:!0,concat:!0,difference:!0,divide:!0,eq:!0,gt:!0,gte:!0,isEqual:!0,lt:!0,lte:!0,matchesProperty:!0,merge:!0,multiply:!0,overArgs:!0,partial:!0,partialRight:!0,propertyOf:!0,random:!0,range:!0,rangeRight:!0,subtract:!0,zip:!0,zipObject:!0,zipObjectDeep:!0}},47934:(s,o,i)=>{s.exports={ary:i(64626),assign:i(74733),clone:i(32629),curry:i(49747),forEach:i(83729),isArray:i(56449),isError:i(23546),isFunction:i(1882),isWeakMap:i(47886),iteratee:i(33855),keys:i(88984),rearg:i(84195),toInteger:i(61489),toPath:i(42072)}},56367:(s,o,i)=>{s.exports=i(77731)},79920:(s,o,i)=>{var u=i(73424),_=i(47934);s.exports=function convert(s,o,i){return u(_,s,o,i)}},2874:s=>{s.exports={}},77731:(s,o,i)=>{var u=i(79920)("set",i(63560));u.placeholder=i(2874),s.exports=u},58156:(s,o,i)=>{var u=i(47422);s.exports=function get(s,o,i){var _=null==s?void 0:u(s,o);return void 0===_?i:_}},61448:(s,o,i)=>{var u=i(20426),_=i(49326);s.exports=function has(s,o){return null!=s&&_(s,o,u)}},80631:(s,o,i)=>{var u=i(28077),_=i(49326);s.exports=function hasIn(s,o){return null!=s&&_(s,o,u)}},83488:s=>{s.exports=function identity(s){return s}},72428:(s,o,i)=>{var u=i(27534),_=i(40346),w=Object.prototype,x=w.hasOwnProperty,C=w.propertyIsEnumerable,j=u(function(){return arguments}())?u:function(s){return _(s)&&x.call(s,"callee")&&!C.call(s,"callee")};s.exports=j},56449:s=>{var o=Array.isArray;s.exports=o},64894:(s,o,i)=>{var u=i(1882),_=i(30294);s.exports=function isArrayLike(s){return null!=s&&_(s.length)&&!u(s)}},83693:(s,o,i)=>{var u=i(64894),_=i(40346);s.exports=function isArrayLikeObject(s){return _(s)&&u(s)}},53812:(s,o,i)=>{var u=i(72552),_=i(40346);s.exports=function isBoolean(s){return!0===s||!1===s||_(s)&&"[object Boolean]"==u(s)}},3656:(s,o,i)=>{s=i.nmd(s);var u=i(9325),_=i(89935),w=o&&!o.nodeType&&o,x=w&&s&&!s.nodeType&&s,C=x&&x.exports===w?u.Buffer:void 0,j=(C?C.isBuffer:void 0)||_;s.exports=j},62193:(s,o,i)=>{var u=i(88984),_=i(5861),w=i(72428),x=i(56449),C=i(64894),j=i(3656),L=i(55527),B=i(37167),$=Object.prototype.hasOwnProperty;s.exports=function isEmpty(s){if(null==s)return!0;if(C(s)&&(x(s)||"string"==typeof s||"function"==typeof s.splice||j(s)||B(s)||w(s)))return!s.length;var o=_(s);if("[object Map]"==o||"[object Set]"==o)return!s.size;if(L(s))return!u(s).length;for(var i in s)if($.call(s,i))return!1;return!0}},2404:(s,o,i)=>{var u=i(60270);s.exports=function isEqual(s,o){return u(s,o)}},23546:(s,o,i)=>{var u=i(72552),_=i(40346),w=i(11331);s.exports=function isError(s){if(!_(s))return!1;var o=u(s);return"[object Error]"==o||"[object DOMException]"==o||"string"==typeof s.message&&"string"==typeof s.name&&!w(s)}},1882:(s,o,i)=>{var u=i(72552),_=i(23805);s.exports=function isFunction(s){if(!_(s))return!1;var o=u(s);return"[object Function]"==o||"[object GeneratorFunction]"==o||"[object AsyncFunction]"==o||"[object Proxy]"==o}},30294:s=>{s.exports=function isLength(s){return"number"==typeof s&&s>-1&&s%1==0&&s<=9007199254740991}},87730:(s,o,i)=>{var u=i(29172),_=i(27301),w=i(86009),x=w&&w.isMap,C=x?_(x):u;s.exports=C},5187:s=>{s.exports=function isNull(s){return null===s}},98023:(s,o,i)=>{var u=i(72552),_=i(40346);s.exports=function isNumber(s){return"number"==typeof s||_(s)&&"[object Number]"==u(s)}},23805:s=>{s.exports=function isObject(s){var o=typeof s;return null!=s&&("object"==o||"function"==o)}},40346:s=>{s.exports=function isObjectLike(s){return null!=s&&"object"==typeof s}},11331:(s,o,i)=>{var u=i(72552),_=i(28879),w=i(40346),x=Function.prototype,C=Object.prototype,j=x.toString,L=C.hasOwnProperty,B=j.call(Object);s.exports=function isPlainObject(s){if(!w(s)||"[object Object]"!=u(s))return!1;var o=_(s);if(null===o)return!0;var i=L.call(o,"constructor")&&o.constructor;return"function"==typeof i&&i instanceof i&&j.call(i)==B}},38440:(s,o,i)=>{var u=i(16038),_=i(27301),w=i(86009),x=w&&w.isSet,C=x?_(x):u;s.exports=C},85015:(s,o,i)=>{var u=i(72552),_=i(56449),w=i(40346);s.exports=function isString(s){return"string"==typeof s||!_(s)&&w(s)&&"[object String]"==u(s)}},44394:(s,o,i)=>{var u=i(72552),_=i(40346);s.exports=function isSymbol(s){return"symbol"==typeof s||_(s)&&"[object Symbol]"==u(s)}},37167:(s,o,i)=>{var u=i(4901),_=i(27301),w=i(86009),x=w&&w.isTypedArray,C=x?_(x):u;s.exports=C},47886:(s,o,i)=>{var u=i(5861),_=i(40346);s.exports=function isWeakMap(s){return _(s)&&"[object WeakMap]"==u(s)}},33855:(s,o,i)=>{var u=i(9999),_=i(15389);s.exports=function iteratee(s){return _("function"==typeof s?s:u(s,1))}},95950:(s,o,i)=>{var u=i(70695),_=i(88984),w=i(64894);s.exports=function keys(s){return w(s)?u(s):_(s)}},37241:(s,o,i)=>{var u=i(70695),_=i(72903),w=i(64894);s.exports=function keysIn(s){return w(s)?u(s,!0):_(s)}},68090:s=>{s.exports=function last(s){var o=null==s?0:s.length;return o?s[o-1]:void 0}},50104:(s,o,i)=>{var u=i(53661);function memoize(s,o){if("function"!=typeof s||null!=o&&"function"!=typeof o)throw new TypeError("Expected a function");var memoized=function(){var i=arguments,u=o?o.apply(this,i):i[0],_=memoized.cache;if(_.has(u))return _.get(u);var w=s.apply(this,i);return memoized.cache=_.set(u,w)||_,w};return memoized.cache=new(memoize.Cache||u),memoized}memoize.Cache=u,s.exports=memoize},55364:(s,o,i)=>{var u=i(85250),_=i(20999)((function(s,o,i){u(s,o,i)}));s.exports=_},6048:s=>{s.exports=function negate(s){if("function"!=typeof s)throw new TypeError("Expected a function");return function(){var o=arguments;switch(o.length){case 0:return!s.call(this);case 1:return!s.call(this,o[0]);case 2:return!s.call(this,o[0],o[1]);case 3:return!s.call(this,o[0],o[1],o[2])}return!s.apply(this,o)}}},63950:s=>{s.exports=function noop(){}},10124:(s,o,i)=>{var u=i(9325);s.exports=function(){return u.Date.now()}},90179:(s,o,i)=>{var u=i(34932),_=i(9999),w=i(19931),x=i(31769),C=i(21791),j=i(53138),L=i(38816),B=i(83349),$=L((function(s,o){var i={};if(null==s)return i;var L=!1;o=u(o,(function(o){return o=x(o,s),L||(L=o.length>1),o})),C(s,B(s),i),L&&(i=_(i,7,j));for(var $=o.length;$--;)w(i,o[$]);return i}));s.exports=$},50583:(s,o,i)=>{var u=i(47237),_=i(17255),w=i(28586),x=i(77797);s.exports=function property(s){return w(s)?u(x(s)):_(s)}},84195:(s,o,i)=>{var u=i(66977),_=i(38816),w=_((function(s,o){return u(s,256,void 0,void 0,void 0,o)}));s.exports=w},40860:(s,o,i)=>{var u=i(40882),_=i(80909),w=i(15389),x=i(85558),C=i(56449);s.exports=function reduce(s,o,i){var j=C(s)?u:x,L=arguments.length<3;return j(s,w(o,4),i,L,_)}},63560:(s,o,i)=>{var u=i(73170);s.exports=function set(s,o,i){return null==s?s:u(s,o,i)}},42426:(s,o,i)=>{var u=i(14248),_=i(15389),w=i(90916),x=i(56449),C=i(36800);s.exports=function some(s,o,i){var j=x(s)?u:w;return i&&C(s,o,i)&&(o=void 0),j(s,_(o,3))}},63345:s=>{s.exports=function stubArray(){return[]}},89935:s=>{s.exports=function stubFalse(){return!1}},17400:(s,o,i)=>{var u=i(99374),_=1/0;s.exports=function toFinite(s){return s?(s=u(s))===_||s===-1/0?17976931348623157e292*(s<0?-1:1):s==s?s:0:0===s?s:0}},61489:(s,o,i)=>{var u=i(17400);s.exports=function toInteger(s){var o=u(s),i=o%1;return o==o?i?o-i:o:0}},80218:(s,o,i)=>{var u=i(13222);s.exports=function toLower(s){return u(s).toLowerCase()}},99374:(s,o,i)=>{var u=i(54128),_=i(23805),w=i(44394),x=/^[-+]0x[0-9a-f]+$/i,C=/^0b[01]+$/i,j=/^0o[0-7]+$/i,L=parseInt;s.exports=function toNumber(s){if("number"==typeof s)return s;if(w(s))return NaN;if(_(s)){var o="function"==typeof s.valueOf?s.valueOf():s;s=_(o)?o+"":o}if("string"!=typeof s)return 0===s?s:+s;s=u(s);var i=C.test(s);return i||j.test(s)?L(s.slice(2),i?2:8):x.test(s)?NaN:+s}},42072:(s,o,i)=>{var u=i(34932),_=i(23007),w=i(56449),x=i(44394),C=i(61802),j=i(77797),L=i(13222);s.exports=function toPath(s){return w(s)?u(s,j):x(s)?[s]:_(C(L(s)))}},69884:(s,o,i)=>{var u=i(21791),_=i(37241);s.exports=function toPlainObject(s){return u(s,_(s))}},13222:(s,o,i)=>{var u=i(77556);s.exports=function toString(s){return null==s?"":u(s)}},55808:(s,o,i)=>{var u=i(12507)("toUpperCase");s.exports=u},66645:(s,o,i)=>{var u=i(1733),_=i(45434),w=i(13222),x=i(22225);s.exports=function words(s,o,i){return s=w(s),void 0===(o=i?void 0:o)?_(s)?x(s):u(s):s.match(o)||[]}},53758:(s,o,i)=>{var u=i(30980),_=i(56017),w=i(94033),x=i(56449),C=i(40346),j=i(80257),L=Object.prototype.hasOwnProperty;function lodash(s){if(C(s)&&!x(s)&&!(s instanceof u)){if(s instanceof _)return s;if(L.call(s,"__wrapped__"))return j(s)}return new _(s)}lodash.prototype=w.prototype,lodash.prototype.constructor=lodash,s.exports=lodash},47248:(s,o,i)=>{var u=i(16547),_=i(51234);s.exports=function zipObject(s,o){return _(s||[],o||[],u)}},43768:(s,o,i)=>{"use strict";var u=i(45981),_=i(85587);o.highlight=highlight,o.highlightAuto=function highlightAuto(s,o){var i,x,C,j,L=o||{},B=L.subset||u.listLanguages(),$=L.prefix,V=B.length,U=-1;null==$&&($=w);if("string"!=typeof s)throw _("Expected `string` for value, got `%s`",s);x={relevance:0,language:null,value:[]},i={relevance:0,language:null,value:[]};for(;++Ux.relevance&&(x=C),C.relevance>i.relevance&&(x=i,i=C));x.language&&(i.secondBest=x);return i},o.registerLanguage=function registerLanguage(s,o){u.registerLanguage(s,o)},o.listLanguages=function listLanguages(){return u.listLanguages()},o.registerAlias=function registerAlias(s,o){var i,_=s;o&&((_={})[s]=o);for(i in _)u.registerAliases(_[i],{languageName:i})},Emitter.prototype.addText=function text(s){var o,i,u=this.stack;if(""===s)return;o=u[u.length-1],(i=o.children[o.children.length-1])&&"text"===i.type?i.value+=s:o.children.push({type:"text",value:s})},Emitter.prototype.addKeyword=function addKeyword(s,o){this.openNode(o),this.addText(s),this.closeNode()},Emitter.prototype.addSublanguage=function addSublanguage(s,o){var i=this.stack,u=i[i.length-1],_=s.rootNode.children,w=o?{type:"element",tagName:"span",properties:{className:[o]},children:_}:_;u.children=u.children.concat(w)},Emitter.prototype.openNode=function open(s){var o=this.stack,i=this.options.classPrefix+s,u=o[o.length-1],_={type:"element",tagName:"span",properties:{className:[i]},children:[]};u.children.push(_),o.push(_)},Emitter.prototype.closeNode=function close(){this.stack.pop()},Emitter.prototype.closeAllNodes=noop,Emitter.prototype.finalize=noop,Emitter.prototype.toHTML=function toHtmlNoop(){return""};var w="hljs-";function highlight(s,o,i){var x,C=u.configure({}),j=(i||{}).prefix;if("string"!=typeof s)throw _("Expected `string` for name, got `%s`",s);if(!u.getLanguage(s))throw _("Unknown language: `%s` is not registered",s);if("string"!=typeof o)throw _("Expected `string` for value, got `%s`",o);if(null==j&&(j=w),u.configure({__emitter:Emitter,classPrefix:j}),x=u.highlight(o,{language:s,ignoreIllegals:!0}),u.configure(C||{}),x.errorRaised)throw x.errorRaised;return{relevance:x.relevance,language:x.language,value:x.emitter.rootNode.children}}function Emitter(s){this.options=s,this.rootNode={children:[]},this.stack=[this.rootNode]}function noop(){}},92340:(s,o,i)=>{const u=i(6048);function coerceElementMatchingCallback(s){return"string"==typeof s?o=>o.element===s:s.constructor&&s.extend?o=>o instanceof s:s}class ArraySlice{constructor(s){this.elements=s||[]}toValue(){return this.elements.map((s=>s.toValue()))}map(s,o){return this.elements.map(s,o)}flatMap(s,o){return this.map(s,o).reduce(((s,o)=>s.concat(o)),[])}compactMap(s,o){const i=[];return this.forEach((u=>{const _=s.bind(o)(u);_&&i.push(_)})),i}filter(s,o){return s=coerceElementMatchingCallback(s),new ArraySlice(this.elements.filter(s,o))}reject(s,o){return s=coerceElementMatchingCallback(s),new ArraySlice(this.elements.filter(u(s),o))}find(s,o){return s=coerceElementMatchingCallback(s),this.elements.find(s,o)}forEach(s,o){this.elements.forEach(s,o)}reduce(s,o){return this.elements.reduce(s,o)}includes(s){return this.elements.some((o=>o.equals(s)))}shift(){return this.elements.shift()}unshift(s){this.elements.unshift(this.refract(s))}push(s){return this.elements.push(this.refract(s)),this}add(s){this.push(s)}get(s){return this.elements[s]}getValue(s){const o=this.elements[s];if(o)return o.toValue()}get length(){return this.elements.length}get isEmpty(){return 0===this.elements.length}get first(){return this.elements[0]}}"undefined"!=typeof Symbol&&(ArraySlice.prototype[Symbol.iterator]=function symbol(){return this.elements[Symbol.iterator]()}),s.exports=ArraySlice},55973:s=>{class KeyValuePair{constructor(s,o){this.key=s,this.value=o}clone(){const s=new KeyValuePair;return this.key&&(s.key=this.key.clone()),this.value&&(s.value=this.value.clone()),s}}s.exports=KeyValuePair},3110:(s,o,i)=>{const u=i(5187),_=i(85015),w=i(98023),x=i(53812),C=i(23805),j=i(85105),L=i(86804);class Namespace{constructor(s){this.elementMap={},this.elementDetection=[],this.Element=L.Element,this.KeyValuePair=L.KeyValuePair,s&&s.noDefault||this.useDefault(),this._attributeElementKeys=[],this._attributeElementArrayKeys=[]}use(s){return s.namespace&&s.namespace({base:this}),s.load&&s.load({base:this}),this}useDefault(){return this.register("null",L.NullElement).register("string",L.StringElement).register("number",L.NumberElement).register("boolean",L.BooleanElement).register("array",L.ArrayElement).register("object",L.ObjectElement).register("member",L.MemberElement).register("ref",L.RefElement).register("link",L.LinkElement),this.detect(u,L.NullElement,!1).detect(_,L.StringElement,!1).detect(w,L.NumberElement,!1).detect(x,L.BooleanElement,!1).detect(Array.isArray,L.ArrayElement,!1).detect(C,L.ObjectElement,!1),this}register(s,o){return this._elements=void 0,this.elementMap[s]=o,this}unregister(s){return this._elements=void 0,delete this.elementMap[s],this}detect(s,o,i){return void 0===i||i?this.elementDetection.unshift([s,o]):this.elementDetection.push([s,o]),this}toElement(s){if(s instanceof this.Element)return s;let o;for(let i=0;i{const o=s[0].toUpperCase()+s.substr(1);this._elements[o]=this.elementMap[s]}))),this._elements}get serialiser(){return new j(this)}}j.prototype.Namespace=Namespace,s.exports=Namespace},10866:(s,o,i)=>{const u=i(6048),_=i(92340);class ObjectSlice extends _{map(s,o){return this.elements.map((i=>s.bind(o)(i.value,i.key,i)))}filter(s,o){return new ObjectSlice(this.elements.filter((i=>s.bind(o)(i.value,i.key,i))))}reject(s,o){return this.filter(u(s.bind(o)))}forEach(s,o){return this.elements.forEach(((i,u)=>{s.bind(o)(i.value,i.key,i,u)}))}keys(){return this.map(((s,o)=>o.toValue()))}values(){return this.map((s=>s.toValue()))}}s.exports=ObjectSlice},86804:(s,o,i)=>{const u=i(10316),_=i(41067),w=i(71167),x=i(40239),C=i(12242),j=i(6233),L=i(87726),B=i(61045),$=i(86303),V=i(14540),U=i(92340),z=i(10866),Y=i(55973);function refract(s){if(s instanceof u)return s;if("string"==typeof s)return new w(s);if("number"==typeof s)return new x(s);if("boolean"==typeof s)return new C(s);if(null===s)return new _;if(Array.isArray(s))return new j(s.map(refract));if("object"==typeof s){return new B(s)}return s}u.prototype.ObjectElement=B,u.prototype.RefElement=V,u.prototype.MemberElement=L,u.prototype.refract=refract,U.prototype.refract=refract,s.exports={Element:u,NullElement:_,StringElement:w,NumberElement:x,BooleanElement:C,ArrayElement:j,MemberElement:L,ObjectElement:B,LinkElement:$,RefElement:V,refract,ArraySlice:U,ObjectSlice:z,KeyValuePair:Y}},86303:(s,o,i)=>{const u=i(10316);s.exports=class LinkElement extends u{constructor(s,o,i){super(s||[],o,i),this.element="link"}get relation(){return this.attributes.get("relation")}set relation(s){this.attributes.set("relation",s)}get href(){return this.attributes.get("href")}set href(s){this.attributes.set("href",s)}}},14540:(s,o,i)=>{const u=i(10316);s.exports=class RefElement extends u{constructor(s,o,i){super(s||[],o,i),this.element="ref",this.path||(this.path="element")}get path(){return this.attributes.get("path")}set path(s){this.attributes.set("path",s)}}},34035:(s,o,i)=>{const u=i(3110),_=i(86804);o.g$=u,o.KeyValuePair=i(55973),o.G6=_.ArraySlice,o.ot=_.ObjectSlice,o.Hg=_.Element,o.Om=_.StringElement,o.kT=_.NumberElement,o.bd=_.BooleanElement,o.Os=_.NullElement,o.wE=_.ArrayElement,o.Sh=_.ObjectElement,o.Pr=_.MemberElement,o.sI=_.RefElement,o.Ft=_.LinkElement,o.e=_.refract,i(85105),i(75147)},6233:(s,o,i)=>{const u=i(6048),_=i(10316),w=i(92340);class ArrayElement extends _{constructor(s,o,i){super(s||[],o,i),this.element="array"}primitive(){return"array"}get(s){return this.content[s]}getValue(s){const o=this.get(s);if(o)return o.toValue()}getIndex(s){return this.content[s]}set(s,o){return this.content[s]=this.refract(o),this}remove(s){const o=this.content.splice(s,1);return o.length?o[0]:null}map(s,o){return this.content.map(s,o)}flatMap(s,o){return this.map(s,o).reduce(((s,o)=>s.concat(o)),[])}compactMap(s,o){const i=[];return this.forEach((u=>{const _=s.bind(o)(u);_&&i.push(_)})),i}filter(s,o){return new w(this.content.filter(s,o))}reject(s,o){return this.filter(u(s),o)}reduce(s,o){let i,u;void 0!==o?(i=0,u=this.refract(o)):(i=1,u="object"===this.primitive()?this.first.value:this.first);for(let o=i;o{s.bind(o)(i,this.refract(u))}))}shift(){return this.content.shift()}unshift(s){this.content.unshift(this.refract(s))}push(s){return this.content.push(this.refract(s)),this}add(s){this.push(s)}findElements(s,o){const i=o||{},u=!!i.recursive,_=void 0===i.results?[]:i.results;return this.forEach(((o,i,w)=>{u&&void 0!==o.findElements&&o.findElements(s,{results:_,recursive:u}),s(o,i,w)&&_.push(o)})),_}find(s){return new w(this.findElements(s,{recursive:!0}))}findByElement(s){return this.find((o=>o.element===s))}findByClass(s){return this.find((o=>o.classes.includes(s)))}getById(s){return this.find((o=>o.id.toValue()===s)).first}includes(s){return this.content.some((o=>o.equals(s)))}contains(s){return this.includes(s)}empty(){return new this.constructor([])}"fantasy-land/empty"(){return this.empty()}concat(s){return new this.constructor(this.content.concat(s.content))}"fantasy-land/concat"(s){return this.concat(s)}"fantasy-land/map"(s){return new this.constructor(this.map(s))}"fantasy-land/chain"(s){return this.map((o=>s(o)),this).reduce(((s,o)=>s.concat(o)),this.empty())}"fantasy-land/filter"(s){return new this.constructor(this.content.filter(s))}"fantasy-land/reduce"(s,o){return this.content.reduce(s,o)}get length(){return this.content.length}get isEmpty(){return 0===this.content.length}get first(){return this.getIndex(0)}get second(){return this.getIndex(1)}get last(){return this.getIndex(this.length-1)}}ArrayElement.empty=function empty(){return new this},ArrayElement["fantasy-land/empty"]=ArrayElement.empty,"undefined"!=typeof Symbol&&(ArrayElement.prototype[Symbol.iterator]=function symbol(){return this.content[Symbol.iterator]()}),s.exports=ArrayElement},12242:(s,o,i)=>{const u=i(10316);s.exports=class BooleanElement extends u{constructor(s,o,i){super(s,o,i),this.element="boolean"}primitive(){return"boolean"}}},10316:(s,o,i)=>{const u=i(2404),_=i(55973),w=i(92340);class Element{constructor(s,o,i){o&&(this.meta=o),i&&(this.attributes=i),this.content=s}freeze(){Object.isFrozen(this)||(this._meta&&(this.meta.parent=this,this.meta.freeze()),this._attributes&&(this.attributes.parent=this,this.attributes.freeze()),this.children.forEach((s=>{s.parent=this,s.freeze()}),this),this.content&&Array.isArray(this.content)&&Object.freeze(this.content),Object.freeze(this))}primitive(){}clone(){const s=new this.constructor;return s.element=this.element,this.meta.length&&(s._meta=this.meta.clone()),this.attributes.length&&(s._attributes=this.attributes.clone()),this.content?this.content.clone?s.content=this.content.clone():Array.isArray(this.content)?s.content=this.content.map((s=>s.clone())):s.content=this.content:s.content=this.content,s}toValue(){return this.content instanceof Element?this.content.toValue():this.content instanceof _?{key:this.content.key.toValue(),value:this.content.value?this.content.value.toValue():void 0}:this.content&&this.content.map?this.content.map((s=>s.toValue()),this):this.content}toRef(s){if(""===this.id.toValue())throw Error("Cannot create reference to an element that does not contain an ID");const o=new this.RefElement(this.id.toValue());return s&&(o.path=s),o}findRecursive(...s){if(arguments.length>1&&!this.isFrozen)throw new Error("Cannot find recursive with multiple element names without first freezing the element. Call `element.freeze()`");const o=s.pop();let i=new w;const append=(s,o)=>(s.push(o),s),checkElement=(s,i)=>{i.element===o&&s.push(i);const u=i.findRecursive(o);return u&&u.reduce(append,s),i.content instanceof _&&(i.content.key&&checkElement(s,i.content.key),i.content.value&&checkElement(s,i.content.value)),s};return this.content&&(this.content.element&&checkElement(i,this.content),Array.isArray(this.content)&&this.content.reduce(checkElement,i)),s.isEmpty||(i=i.filter((o=>{let i=o.parents.map((s=>s.element));for(const o in s){const u=s[o],_=i.indexOf(u);if(-1===_)return!1;i=i.splice(0,_)}return!0}))),i}set(s){return this.content=s,this}equals(s){return u(this.toValue(),s)}getMetaProperty(s,o){if(!this.meta.hasKey(s)){if(this.isFrozen){const s=this.refract(o);return s.freeze(),s}this.meta.set(s,o)}return this.meta.get(s)}setMetaProperty(s,o){this.meta.set(s,o)}get element(){return this._storedElement||"element"}set element(s){this._storedElement=s}get content(){return this._content}set content(s){if(s instanceof Element)this._content=s;else if(s instanceof w)this.content=s.elements;else if("string"==typeof s||"number"==typeof s||"boolean"==typeof s||"null"===s||null==s)this._content=s;else if(s instanceof _)this._content=s;else if(Array.isArray(s))this._content=s.map(this.refract);else{if("object"!=typeof s)throw new Error("Cannot set content to given value");this._content=Object.keys(s).map((o=>new this.MemberElement(o,s[o])))}}get meta(){if(!this._meta){if(this.isFrozen){const s=new this.ObjectElement;return s.freeze(),s}this._meta=new this.ObjectElement}return this._meta}set meta(s){s instanceof this.ObjectElement?this._meta=s:this.meta.set(s||{})}get attributes(){if(!this._attributes){if(this.isFrozen){const s=new this.ObjectElement;return s.freeze(),s}this._attributes=new this.ObjectElement}return this._attributes}set attributes(s){s instanceof this.ObjectElement?this._attributes=s:this.attributes.set(s||{})}get id(){return this.getMetaProperty("id","")}set id(s){this.setMetaProperty("id",s)}get classes(){return this.getMetaProperty("classes",[])}set classes(s){this.setMetaProperty("classes",s)}get title(){return this.getMetaProperty("title","")}set title(s){this.setMetaProperty("title",s)}get description(){return this.getMetaProperty("description","")}set description(s){this.setMetaProperty("description",s)}get links(){return this.getMetaProperty("links",[])}set links(s){this.setMetaProperty("links",s)}get isFrozen(){return Object.isFrozen(this)}get parents(){let{parent:s}=this;const o=new w;for(;s;)o.push(s),s=s.parent;return o}get children(){if(Array.isArray(this.content))return new w(this.content);if(this.content instanceof _){const s=new w([this.content.key]);return this.content.value&&s.push(this.content.value),s}return this.content instanceof Element?new w([this.content]):new w}get recursiveChildren(){const s=new w;return this.children.forEach((o=>{s.push(o),o.recursiveChildren.forEach((o=>{s.push(o)}))})),s}}s.exports=Element},87726:(s,o,i)=>{const u=i(55973),_=i(10316);s.exports=class MemberElement extends _{constructor(s,o,i,_){super(new u,i,_),this.element="member",this.key=s,this.value=o}get key(){return this.content.key}set key(s){this.content.key=this.refract(s)}get value(){return this.content.value}set value(s){this.content.value=this.refract(s)}}},41067:(s,o,i)=>{const u=i(10316);s.exports=class NullElement extends u{constructor(s,o,i){super(s||null,o,i),this.element="null"}primitive(){return"null"}set(){return new Error("Cannot set the value of null")}}},40239:(s,o,i)=>{const u=i(10316);s.exports=class NumberElement extends u{constructor(s,o,i){super(s,o,i),this.element="number"}primitive(){return"number"}}},61045:(s,o,i)=>{const u=i(6048),_=i(23805),w=i(6233),x=i(87726),C=i(10866);s.exports=class ObjectElement extends w{constructor(s,o,i){super(s||[],o,i),this.element="object"}primitive(){return"object"}toValue(){return this.content.reduce(((s,o)=>(s[o.key.toValue()]=o.value?o.value.toValue():void 0,s)),{})}get(s){const o=this.getMember(s);if(o)return o.value}getMember(s){if(void 0!==s)return this.content.find((o=>o.key.toValue()===s))}remove(s){let o=null;return this.content=this.content.filter((i=>i.key.toValue()!==s||(o=i,!1))),o}getKey(s){const o=this.getMember(s);if(o)return o.key}set(s,o){if(_(s))return Object.keys(s).forEach((o=>{this.set(o,s[o])})),this;const i=s,u=this.getMember(i);return u?u.value=o:this.content.push(new x(i,o)),this}keys(){return this.content.map((s=>s.key.toValue()))}values(){return this.content.map((s=>s.value.toValue()))}hasKey(s){return this.content.some((o=>o.key.equals(s)))}items(){return this.content.map((s=>[s.key.toValue(),s.value.toValue()]))}map(s,o){return this.content.map((i=>s.bind(o)(i.value,i.key,i)))}compactMap(s,o){const i=[];return this.forEach(((u,_,w)=>{const x=s.bind(o)(u,_,w);x&&i.push(x)})),i}filter(s,o){return new C(this.content).filter(s,o)}reject(s,o){return this.filter(u(s),o)}forEach(s,o){return this.content.forEach((i=>s.bind(o)(i.value,i.key,i)))}}},71167:(s,o,i)=>{const u=i(10316);s.exports=class StringElement extends u{constructor(s,o,i){super(s,o,i),this.element="string"}primitive(){return"string"}get length(){return this.content.length}}},75147:(s,o,i)=>{const u=i(85105);s.exports=class JSON06Serialiser extends u{serialise(s){if(!(s instanceof this.namespace.elements.Element))throw new TypeError(`Given element \`${s}\` is not an Element instance`);let o;s._attributes&&s.attributes.get("variable")&&(o=s.attributes.get("variable"));const i={element:s.element};s._meta&&s._meta.length>0&&(i.meta=this.serialiseObject(s.meta));const u="enum"===s.element||-1!==s.attributes.keys().indexOf("enumerations");if(u){const o=this.enumSerialiseAttributes(s);o&&(i.attributes=o)}else if(s._attributes&&s._attributes.length>0){let{attributes:u}=s;u.get("metadata")&&(u=u.clone(),u.set("meta",u.get("metadata")),u.remove("metadata")),"member"===s.element&&o&&(u=u.clone(),u.remove("variable")),u.length>0&&(i.attributes=this.serialiseObject(u))}if(u)i.content=this.enumSerialiseContent(s,i);else if(this[`${s.element}SerialiseContent`])i.content=this[`${s.element}SerialiseContent`](s,i);else if(void 0!==s.content){let u;o&&s.content.key?(u=s.content.clone(),u.key.attributes.set("variable",o),u=this.serialiseContent(u)):u=this.serialiseContent(s.content),this.shouldSerialiseContent(s,u)&&(i.content=u)}else this.shouldSerialiseContent(s,s.content)&&s instanceof this.namespace.elements.Array&&(i.content=[]);return i}shouldSerialiseContent(s,o){return"parseResult"===s.element||"httpRequest"===s.element||"httpResponse"===s.element||"category"===s.element||"link"===s.element||void 0!==o&&(!Array.isArray(o)||0!==o.length)}refSerialiseContent(s,o){return delete o.attributes,{href:s.toValue(),path:s.path.toValue()}}sourceMapSerialiseContent(s){return s.toValue()}dataStructureSerialiseContent(s){return[this.serialiseContent(s.content)]}enumSerialiseAttributes(s){const o=s.attributes.clone(),i=o.remove("enumerations")||new this.namespace.elements.Array([]),u=o.get("default");let _=o.get("samples")||new this.namespace.elements.Array([]);if(u&&u.content&&(u.content.attributes&&u.content.attributes.remove("typeAttributes"),o.set("default",new this.namespace.elements.Array([u.content]))),_.forEach((s=>{s.content&&s.content.element&&s.content.attributes.remove("typeAttributes")})),s.content&&0!==i.length&&_.unshift(s.content),_=_.map((s=>s instanceof this.namespace.elements.Array?[s]:new this.namespace.elements.Array([s.content]))),_.length&&o.set("samples",_),o.length>0)return this.serialiseObject(o)}enumSerialiseContent(s){if(s._attributes){const o=s.attributes.get("enumerations");if(o&&o.length>0)return o.content.map((s=>{const o=s.clone();return o.attributes.remove("typeAttributes"),this.serialise(o)}))}if(s.content){const o=s.content.clone();return o.attributes.remove("typeAttributes"),[this.serialise(o)]}return[]}deserialise(s){if("string"==typeof s)return new this.namespace.elements.String(s);if("number"==typeof s)return new this.namespace.elements.Number(s);if("boolean"==typeof s)return new this.namespace.elements.Boolean(s);if(null===s)return new this.namespace.elements.Null;if(Array.isArray(s))return new this.namespace.elements.Array(s.map(this.deserialise,this));const o=this.namespace.getElementClass(s.element),i=new o;i.element!==s.element&&(i.element=s.element),s.meta&&this.deserialiseObject(s.meta,i.meta),s.attributes&&this.deserialiseObject(s.attributes,i.attributes);const u=this.deserialiseContent(s.content);if(void 0===u&&null!==i.content||(i.content=u),"enum"===i.element){i.content&&i.attributes.set("enumerations",i.content);let s=i.attributes.get("samples");if(i.attributes.remove("samples"),s){const u=s;s=new this.namespace.elements.Array,u.forEach((u=>{u.forEach((u=>{const _=new o(u);_.element=i.element,s.push(_)}))}));const _=s.shift();i.content=_?_.content:void 0,i.attributes.set("samples",s)}else i.content=void 0;let u=i.attributes.get("default");if(u&&u.length>0){u=u.get(0);const s=new o(u);s.element=i.element,i.attributes.set("default",s)}}else if("dataStructure"===i.element&&Array.isArray(i.content))[i.content]=i.content;else if("category"===i.element){const s=i.attributes.get("meta");s&&(i.attributes.set("metadata",s),i.attributes.remove("meta"))}else"member"===i.element&&i.key&&i.key._attributes&&i.key._attributes.getValue("variable")&&(i.attributes.set("variable",i.key.attributes.get("variable")),i.key.attributes.remove("variable"));return i}serialiseContent(s){if(s instanceof this.namespace.elements.Element)return this.serialise(s);if(s instanceof this.namespace.KeyValuePair){const o={key:this.serialise(s.key)};return s.value&&(o.value=this.serialise(s.value)),o}return s&&s.map?s.map(this.serialise,this):s}deserialiseContent(s){if(s){if(s.element)return this.deserialise(s);if(s.key){const o=new this.namespace.KeyValuePair(this.deserialise(s.key));return s.value&&(o.value=this.deserialise(s.value)),o}if(s.map)return s.map(this.deserialise,this)}return s}shouldRefract(s){return!!(s._attributes&&s.attributes.keys().length||s._meta&&s.meta.keys().length)||"enum"!==s.element&&(s.element!==s.primitive()||"member"===s.element)}convertKeyToRefract(s,o){return this.shouldRefract(o)?this.serialise(o):"enum"===o.element?this.serialiseEnum(o):"array"===o.element?o.map((o=>this.shouldRefract(o)||"default"===s?this.serialise(o):"array"===o.element||"object"===o.element||"enum"===o.element?o.children.map((s=>this.serialise(s))):o.toValue())):"object"===o.element?(o.content||[]).map(this.serialise,this):o.toValue()}serialiseEnum(s){return s.children.map((s=>this.serialise(s)))}serialiseObject(s){const o={};return s.forEach(((s,i)=>{if(s){const u=i.toValue();o[u]=this.convertKeyToRefract(u,s)}})),o}deserialiseObject(s,o){Object.keys(s).forEach((i=>{o.set(i,this.deserialise(s[i]))}))}}},85105:s=>{s.exports=class JSONSerialiser{constructor(s){this.namespace=s||new this.Namespace}serialise(s){if(!(s instanceof this.namespace.elements.Element))throw new TypeError(`Given element \`${s}\` is not an Element instance`);const o={element:s.element};s._meta&&s._meta.length>0&&(o.meta=this.serialiseObject(s.meta)),s._attributes&&s._attributes.length>0&&(o.attributes=this.serialiseObject(s.attributes));const i=this.serialiseContent(s.content);return void 0!==i&&(o.content=i),o}deserialise(s){if(!s.element)throw new Error("Given value is not an object containing an element name");const o=new(this.namespace.getElementClass(s.element));o.element!==s.element&&(o.element=s.element),s.meta&&this.deserialiseObject(s.meta,o.meta),s.attributes&&this.deserialiseObject(s.attributes,o.attributes);const i=this.deserialiseContent(s.content);return void 0===i&&null!==o.content||(o.content=i),o}serialiseContent(s){if(s instanceof this.namespace.elements.Element)return this.serialise(s);if(s instanceof this.namespace.KeyValuePair){const o={key:this.serialise(s.key)};return s.value&&(o.value=this.serialise(s.value)),o}if(s&&s.map){if(0===s.length)return;return s.map(this.serialise,this)}return s}deserialiseContent(s){if(s){if(s.element)return this.deserialise(s);if(s.key){const o=new this.namespace.KeyValuePair(this.deserialise(s.key));return s.value&&(o.value=this.deserialise(s.value)),o}if(s.map)return s.map(this.deserialise,this)}return s}serialiseObject(s){const o={};if(s.forEach(((s,i)=>{s&&(o[i.toValue()]=this.serialise(s))})),0!==Object.keys(o).length)return o}deserialiseObject(s,o){Object.keys(s).forEach((i=>{o.set(i,this.deserialise(s[i]))}))}}},65606:s=>{var o,i,u=s.exports={};function defaultSetTimout(){throw new Error("setTimeout has not been defined")}function defaultClearTimeout(){throw new Error("clearTimeout has not been defined")}function runTimeout(s){if(o===setTimeout)return setTimeout(s,0);if((o===defaultSetTimout||!o)&&setTimeout)return o=setTimeout,setTimeout(s,0);try{return o(s,0)}catch(i){try{return o.call(null,s,0)}catch(i){return o.call(this,s,0)}}}!function(){try{o="function"==typeof setTimeout?setTimeout:defaultSetTimout}catch(s){o=defaultSetTimout}try{i="function"==typeof clearTimeout?clearTimeout:defaultClearTimeout}catch(s){i=defaultClearTimeout}}();var _,w=[],x=!1,C=-1;function cleanUpNextTick(){x&&_&&(x=!1,_.length?w=_.concat(w):C=-1,w.length&&drainQueue())}function drainQueue(){if(!x){var s=runTimeout(cleanUpNextTick);x=!0;for(var o=w.length;o;){for(_=w,w=[];++C1)for(var i=1;i{"use strict";var u=i(6925);function emptyFunction(){}function emptyFunctionWithReset(){}emptyFunctionWithReset.resetWarningCache=emptyFunction,s.exports=function(){function shim(s,o,i,_,w,x){if(x!==u){var C=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");throw C.name="Invariant Violation",C}}function getShim(){return shim}shim.isRequired=shim;var s={array:shim,bigint:shim,bool:shim,func:shim,number:shim,object:shim,string:shim,symbol:shim,any:shim,arrayOf:getShim,element:shim,elementType:shim,instanceOf:getShim,node:shim,objectOf:getShim,oneOf:getShim,oneOfType:getShim,shape:getShim,exact:getShim,checkPropTypes:emptyFunctionWithReset,resetWarningCache:emptyFunction};return s.PropTypes=s,s}},5556:(s,o,i)=>{s.exports=i(2694)()},6925:s=>{"use strict";s.exports="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"},73992:(s,o)=>{"use strict";var i=Object.prototype.hasOwnProperty;function decode(s){try{return decodeURIComponent(s.replace(/\+/g," "))}catch(s){return null}}function encode(s){try{return encodeURIComponent(s)}catch(s){return null}}o.stringify=function querystringify(s,o){o=o||"";var u,_,w=[];for(_ in"string"!=typeof o&&(o="?"),s)if(i.call(s,_)){if((u=s[_])||null!=u&&!isNaN(u)||(u=""),_=encode(_),u=encode(u),null===_||null===u)continue;w.push(_+"="+u)}return w.length?o+w.join("&"):""},o.parse=function querystring(s){for(var o,i=/([^=?#&]+)=?([^&]*)/g,u={};o=i.exec(s);){var _=decode(o[1]),w=decode(o[2]);null===_||null===w||_ in u||(u[_]=w)}return u}},41859:(s,o,i)=>{const u=i(27096),_=i(78004),w=u.types;s.exports=class RandExp{constructor(s,o){if(this._setDefaults(s),s instanceof RegExp)this.ignoreCase=s.ignoreCase,this.multiline=s.multiline,s=s.source;else{if("string"!=typeof s)throw new Error("Expected a regexp or string");this.ignoreCase=o&&-1!==o.indexOf("i"),this.multiline=o&&-1!==o.indexOf("m")}this.tokens=u(s)}_setDefaults(s){this.max=null!=s.max?s.max:null!=RandExp.prototype.max?RandExp.prototype.max:100,this.defaultRange=s.defaultRange?s.defaultRange:this.defaultRange.clone(),s.randInt&&(this.randInt=s.randInt)}gen(){return this._gen(this.tokens,[])}_gen(s,o){var i,u,_,x,C;switch(s.type){case w.ROOT:case w.GROUP:if(s.followedBy||s.notFollowedBy)return"";for(s.remember&&void 0===s.groupNumber&&(s.groupNumber=o.push(null)-1),u="",x=0,C=(i=s.options?this._randSelect(s.options):s.stack).length;x{"use strict";var u=i(65606),_=65536,w=4294967295;var x=i(92861).Buffer,C=i.g.crypto||i.g.msCrypto;C&&C.getRandomValues?s.exports=function randomBytes(s,o){if(s>w)throw new RangeError("requested too many random bytes");var i=x.allocUnsafe(s);if(s>0)if(s>_)for(var j=0;j{"use strict";function _typeof(s){return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(s){return typeof s}:function(s){return s&&"function"==typeof Symbol&&s.constructor===Symbol&&s!==Symbol.prototype?"symbol":typeof s},_typeof(s)}Object.defineProperty(o,"__esModule",{value:!0}),o.CopyToClipboard=void 0;var u=_interopRequireDefault(i(96540)),_=_interopRequireDefault(i(17965)),w=["text","onCopy","options","children"];function _interopRequireDefault(s){return s&&s.__esModule?s:{default:s}}function ownKeys(s,o){var i=Object.keys(s);if(Object.getOwnPropertySymbols){var u=Object.getOwnPropertySymbols(s);o&&(u=u.filter((function(o){return Object.getOwnPropertyDescriptor(s,o).enumerable}))),i.push.apply(i,u)}return i}function _objectSpread(s){for(var o=1;o=0||(_[i]=s[i]);return _}(s,o);if(Object.getOwnPropertySymbols){var w=Object.getOwnPropertySymbols(s);for(u=0;u=0||Object.prototype.propertyIsEnumerable.call(s,i)&&(_[i]=s[i])}return _}function _defineProperties(s,o){for(var i=0;i{"use strict";var u=i(25264).CopyToClipboard;u.CopyToClipboard=u,s.exports=u},81214:(s,o,i)=>{"use strict";function _typeof(s){return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(s){return typeof s}:function(s){return s&&"function"==typeof Symbol&&s.constructor===Symbol&&s!==Symbol.prototype?"symbol":typeof s},_typeof(s)}Object.defineProperty(o,"__esModule",{value:!0}),o.DebounceInput=void 0;var u=_interopRequireDefault(i(96540)),_=_interopRequireDefault(i(20181)),w=["element","onChange","value","minLength","debounceTimeout","forceNotifyByEnter","forceNotifyOnBlur","onKeyDown","onBlur","inputRef"];function _interopRequireDefault(s){return s&&s.__esModule?s:{default:s}}function _objectWithoutProperties(s,o){if(null==s)return{};var i,u,_=function _objectWithoutPropertiesLoose(s,o){if(null==s)return{};var i,u,_={},w=Object.keys(s);for(u=0;u=0||(_[i]=s[i]);return _}(s,o);if(Object.getOwnPropertySymbols){var w=Object.getOwnPropertySymbols(s);for(u=0;u=0||Object.prototype.propertyIsEnumerable.call(s,i)&&(_[i]=s[i])}return _}function ownKeys(s,o){var i=Object.keys(s);if(Object.getOwnPropertySymbols){var u=Object.getOwnPropertySymbols(s);o&&(u=u.filter((function(o){return Object.getOwnPropertyDescriptor(s,o).enumerable}))),i.push.apply(i,u)}return i}function _objectSpread(s){for(var o=1;o=u?i.notify(s):o.length>_.length&&i.notify(_objectSpread(_objectSpread({},s),{},{target:_objectSpread(_objectSpread({},s.target),{},{value:""})}))}))})),_defineProperty(_assertThisInitialized(i),"onKeyDown",(function(s){"Enter"===s.key&&i.forceNotify(s);var o=i.props.onKeyDown;o&&(s.persist(),o(s))})),_defineProperty(_assertThisInitialized(i),"onBlur",(function(s){i.forceNotify(s);var o=i.props.onBlur;o&&(s.persist(),o(s))})),_defineProperty(_assertThisInitialized(i),"createNotifier",(function(s){if(s<0)i.notify=function(){return null};else if(0===s)i.notify=i.doNotify;else{var o=(0,_.default)((function(s){i.isDebouncing=!1,i.doNotify(s)}),s);i.notify=function(s){i.isDebouncing=!0,o(s)},i.flush=function(){return o.flush()},i.cancel=function(){i.isDebouncing=!1,o.cancel()}}})),_defineProperty(_assertThisInitialized(i),"doNotify",(function(){i.props.onChange.apply(void 0,arguments)})),_defineProperty(_assertThisInitialized(i),"forceNotify",(function(s){var o=i.props.debounceTimeout;if(i.isDebouncing||!(o>0)){i.cancel&&i.cancel();var u=i.state.value,_=i.props.minLength;u.length>=_?i.doNotify(s):i.doNotify(_objectSpread(_objectSpread({},s),{},{target:_objectSpread(_objectSpread({},s.target),{},{value:u})}))}})),i.isDebouncing=!1,i.state={value:void 0===s.value||null===s.value?"":s.value};var u=i.props.debounceTimeout;return i.createNotifier(u),i}return function _createClass(s,o,i){return o&&_defineProperties(s.prototype,o),i&&_defineProperties(s,i),Object.defineProperty(s,"prototype",{writable:!1}),s}(DebounceInput,[{key:"componentDidUpdate",value:function componentDidUpdate(s){if(!this.isDebouncing){var o=this.props,i=o.value,u=o.debounceTimeout,_=s.debounceTimeout,w=s.value,x=this.state.value;void 0!==i&&w!==i&&x!==i&&this.setState({value:i}),u!==_&&this.createNotifier(u)}}},{key:"componentWillUnmount",value:function componentWillUnmount(){this.flush&&this.flush()}},{key:"render",value:function render(){var s,o,i=this.props,_=i.element,x=(i.onChange,i.value,i.minLength,i.debounceTimeout,i.forceNotifyByEnter),C=i.forceNotifyOnBlur,j=i.onKeyDown,L=i.onBlur,B=i.inputRef,$=_objectWithoutProperties(i,w),V=this.state.value;s=x?{onKeyDown:this.onKeyDown}:j?{onKeyDown:j}:{},o=C?{onBlur:this.onBlur}:L?{onBlur:L}:{};var U=B?{ref:B}:{};return u.default.createElement(_,_objectSpread(_objectSpread(_objectSpread(_objectSpread({},$),{},{onChange:this.onChange,value:V},s),o),U))}}]),DebounceInput}(u.default.PureComponent);o.DebounceInput=x,_defineProperty(x,"defaultProps",{element:"input",type:"text",onKeyDown:void 0,onBlur:void 0,value:void 0,minLength:0,debounceTimeout:100,forceNotifyByEnter:!0,forceNotifyOnBlur:!0,inputRef:void 0})},24677:(s,o,i)=>{"use strict";var u=i(81214).DebounceInput;u.DebounceInput=u,s.exports=u},22551:(s,o,i)=>{"use strict";var u=i(96540),_=i(69982);function p(s){for(var o="https://reactjs.org/docs/error-decoder.html?invariant="+s,i=1;i