mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-17 21:43:06 +00:00
* feat: Scaffold the @librechat/chat package Adds packages/chat with core, react and components entries, a tsdown build, a node-environment jest config, turbo and root build wiring, import boundary rules, design-lint scope, and core types for the chat transport, stream, host and status. No code moves yet. * test: Cover the @librechat/chat boundaries as scenarios * fix: Run the chat suite in test:turbo and build it for the mock lane test:turbo now selects @librechat/chat, the mock e2e job builds the package the chat-package scenarios load, and the synthetic repository in the suppression scenarios carries the packages/chat/src root lint:design:record names. * chore: Build the chat package in frontend:ci too * chore: Run the chat suite in test:all * fix: Hold core TSX to the chat boundary and scan the package for cycles * fix: Apply the chat import boundary to JavaScript sources * fix: Keep nested core files off the components entry * fix: Close the remaining chat package gates and fence aborts by generation Blocks imports through the @librechat/frontend workspace name, adds the chat sources to the i18n scan, the CSS color gate and the client Tailwind content, and lets ChatAbortRequest carry the generation it means to stop. * fix: Keep JSX out of the chat core and carry abort and reconnect outcomes Rejects JSX under the core, copies the chat manifest before the Docker install, keys the client app build caches on the chat sources, fences reconnects by generation, and types the abort result the transport returns. * test: Give the CSS gate's scratch tree the chat root it now scans * fix: Close the remaining @librechat/chat gates and wiring Rejects import() and require() across the package boundaries, holds chat components to the literal-copy rule, compiles TSX in the package's jest transform, builds the package in Frontend Unit Tests, requires its test job for main promotion, adds it to the unused-dependency scan, and lists it wherever a sibling workspace is listed: Dockerfile.multi, the docker smoke paths, the remaining node_modules caches, the reinstall helper, the bun build chain and AGENTS.md. * fix: Tighten the chat boundaries and carry steering and Assistants aborts Template-literal import() and require() and self-imports through the package name are rejected, user-facing JSX attributes need localized text, the cycle scan resolves self-imports, Dockerfile.multi builds the package for the client stage, and the transport carries steer, cancelSteer, armSteer and the Assistants abort key. * feat: Match the chat transport and host contracts to the client's The transport now reports settled and replaced starts, the stream's protocol version and resumed flag, reconnect replay, generation status, paused-run resume with approvals or answers, abort and steer protocol versions, and the request error shape. The host config and auth carry what the client's ChatSettings now supplies: rename-while-running, model specs, retention mode and the user. * fix: Keep lazy React-entry loads out of the core and type the Assistants stop Relative import() and require() of the /react entry from core are rejected, and an abortKey stop resolves to the terminal conversation and run messages the Assistants route returns. * fix: Fence start controls by protocol and close extension-bearing entry loads Settled and replaced start results carry the protocol version, core loads of the /react or /components entry with a file extension are rejected, and test:packages:chat builds data-provider first.
259 lines
11 KiB
YAML
259 lines
11 KiB
YAML
name: Docker Build Smoke Tests
|
|
|
|
on:
|
|
workflow_dispatch:
|
|
pull_request:
|
|
paths:
|
|
- '.github/workflows/docker-smoke.yml'
|
|
- '.dockerignore'
|
|
- 'Dockerfile'
|
|
- 'Dockerfile.multi'
|
|
- 'package.json'
|
|
- 'package-lock.json'
|
|
- 'api/**'
|
|
- 'client/**'
|
|
- 'config/**'
|
|
- 'skill/**'
|
|
- 'packages/api/**'
|
|
- 'packages/client/**'
|
|
- 'packages/chat/**'
|
|
- 'packages/data-provider/**'
|
|
- 'packages/data-schemas/**'
|
|
- '!**.md'
|
|
|
|
permissions:
|
|
contents: read
|
|
pull-requests: read
|
|
|
|
concurrency:
|
|
group: docker-smoke-${{ github.workflow }}-${{ github.ref }}
|
|
cancel-in-progress: true
|
|
|
|
jobs:
|
|
# Stage 2 of codegraph gating (stage 1 = backend jest in backend-review.yml). Two of the three
|
|
# smokes are graph-decidable: the client package build only matters when the change reaches the
|
|
# client build context, and the production-image boot only when it reaches the api image's build
|
|
# context (Dockerfile.multi's api-build stage never builds client). Monotone and fail-open: a
|
|
# smoke is dropped ONLY on an explicit `false`; unavailable/unconfigured/non-synchronize events
|
|
# run everything. Lock attribution rides along so a dependency bump keeps the image smoke.
|
|
# Kill switch: repo variable CODEGRAPH_GATING=off.
|
|
codegraph_select:
|
|
name: Codegraph select
|
|
runs-on: ubuntu-latest
|
|
timeout-minutes: 5
|
|
if: >-
|
|
github.event_name == 'pull_request' &&
|
|
github.event.action == 'synchronize' &&
|
|
vars.CODEGRAPH_GATING != 'off'
|
|
outputs:
|
|
decided: ${{ steps.sel.outputs.decided }}
|
|
client_run: ${{ steps.sel.outputs.client_run }}
|
|
api_run: ${{ steps.sel.outputs.api_run }}
|
|
steps:
|
|
- name: Select smokes, fail open on any doubt
|
|
id: sel
|
|
env:
|
|
URL: ${{ secrets.CODEGRAPH_URL }}
|
|
TOKEN: ${{ secrets.CODEGRAPH_TOKEN }}
|
|
GH_TOKEN: ${{ github.token }}
|
|
REPO: ${{ github.repository }}
|
|
PR: ${{ github.event.pull_request.number }}
|
|
BASE_SHA: ${{ github.event.pull_request.base.sha }}
|
|
HEAD_SHA: ${{ github.event.pull_request.head.sha }}
|
|
CHANGED: ${{ github.event.pull_request.changed_files }}
|
|
run: |
|
|
set +e
|
|
note() { echo "$1" >> "$GITHUB_STEP_SUMMARY"; }
|
|
note "### Codegraph select — GATING (docker smokes)"
|
|
if [ -z "$URL" ] || [ -z "$TOKEN" ]; then note "_no codegraph config; running FULL_"; exit 0; fi
|
|
# A failed or truncated page must not become a shorter file list: the pipeline would hide
|
|
# gh's exit status behind jq, and a partial list can turn a required lane off. Check the
|
|
# fetch status AND the count against the PR's own changed_files (Codex P1, #15136).
|
|
if ! gh api "repos/$REPO/pulls/$PR/files" --paginate \
|
|
--jq '.[] | {path: .filename, status, patch}' > files.ndjson; then
|
|
note "_could not fetch changed files; running FULL_"; exit 0
|
|
fi
|
|
jq -s . files.ndjson > files.json
|
|
N=$(jq 'length' files.json)
|
|
if [ "$N" -eq 0 ] || { [ -n "$CHANGED" ] && [ "$N" -ne "$CHANGED" ]; }; then
|
|
note "_changed-file list incomplete ($N of ${CHANGED:-?}); running FULL_"; exit 0
|
|
fi
|
|
jq -c --arg b "$BASE_SHA" --arg h "$HEAD_SHA" \
|
|
'{files: ., mode: "safe", lockBaseSha: $b, lockHeadSha: $h}' files.json > body.json
|
|
# curl's status is checked explicitly: a transfer that times out or truncates after a
|
|
# parseable body must fail open, not be honoured (Codex P1, #15136). --fail-with-body
|
|
# also turns HTTP errors into a failure while keeping the error text for the summary.
|
|
RESP=$(curl -sS --fail-with-body -m 45 -H "Authorization: Bearer $TOKEN" \
|
|
-H 'content-type: application/json' --data-binary @body.json "$URL/v1/select"); RC=$?
|
|
if [ "$RC" -ne 0 ] || [ -z "$RESP" ] || ! echo "$RESP" | jq -e '.matrix["docker-smoke"]' >/dev/null 2>&1; then
|
|
note "_codegraph unavailable (curl exit $RC: ${RESP:0:120}); running FULL_"
|
|
exit 0
|
|
fi
|
|
# A smoke is skipped only on the JSON boolean false — tested inside jq, because `jq -r`
|
|
# prints the string "false" and the boolean identically (Codex P1, #15136). Anything
|
|
# else (true, null, a string, missing) runs.
|
|
if echo "$RESP" | jq -e '.e2e.fail_open == true' >/dev/null 2>&1; then
|
|
note "_fail-open decision (root/workflow/lockfile change or stale graph): everything runs_"
|
|
fi
|
|
note "| smoke | decision |"
|
|
note "|---|---|"
|
|
emit() {
|
|
key="$1"; hint="$2"; label="$3"
|
|
if echo "$RESP" | jq -e --arg h "$hint" '.matrix["docker-smoke"][$h] == false' >/dev/null 2>&1; then
|
|
echo "${key}_run=false" >> "$GITHUB_OUTPUT"
|
|
note "| $label | skip (no reach into its build context) |"
|
|
else
|
|
echo "${key}_run=true" >> "$GITHUB_OUTPUT"
|
|
note "| $label | run |"
|
|
fi
|
|
}
|
|
emit client client_package_target "client package build"
|
|
emit api api_runtime_smoke "api runtime smoke"
|
|
echo "codegraph-select: $(echo "$RESP" | jq -c '.matrix["docker-smoke"]')"
|
|
echo "decided=true" >> "$GITHUB_OUTPUT"
|
|
note ""
|
|
note "node image smoke keeps its own path filter · kill switch: repo variable \`CODEGRAPH_GATING=off\` · everything runs on PR open"
|
|
exit 0
|
|
|
|
client-package-target:
|
|
name: Build Docker client package target
|
|
needs: [codegraph_select]
|
|
if: ${{ !cancelled() && needs.codegraph_select.outputs.client_run != 'false' }}
|
|
runs-on: ubuntu-latest
|
|
timeout-minutes: 25
|
|
steps:
|
|
- uses: actions/checkout@v5
|
|
|
|
- name: Set up Docker Buildx
|
|
uses: docker/setup-buildx-action@v4
|
|
|
|
- name: Build client package target
|
|
uses: docker/build-push-action@v7
|
|
with:
|
|
context: .
|
|
file: Dockerfile.multi
|
|
platforms: linux/amd64
|
|
push: false
|
|
target: client-package-build
|
|
|
|
# The plain single-stage Dockerfile ships via dev-images/tag-images but had no
|
|
# PR-time validation. The npm build pipeline itself is already smoked on every
|
|
# matching PR by the Dockerfile.multi jobs above, so the full build here is
|
|
# gated to changes of the Dockerfile or the build-context definition.
|
|
node-image-smoke:
|
|
name: Node image smoke (plain Dockerfile builds)
|
|
runs-on: ubuntu-latest
|
|
timeout-minutes: 25
|
|
steps:
|
|
- uses: actions/checkout@v5
|
|
|
|
- name: Detect plain Dockerfile changes
|
|
id: paths
|
|
if: github.event_name == 'pull_request'
|
|
uses: dorny/paths-filter@v4
|
|
with:
|
|
filters: |
|
|
dockerfile:
|
|
- 'Dockerfile'
|
|
- '.dockerignore'
|
|
- '.github/workflows/docker-smoke.yml'
|
|
|
|
- name: Set up Docker Buildx
|
|
if: github.event_name == 'workflow_dispatch' || steps.paths.outputs.dockerfile == 'true'
|
|
uses: docker/setup-buildx-action@v4
|
|
|
|
- name: Build node image
|
|
if: github.event_name == 'workflow_dispatch' || steps.paths.outputs.dockerfile == 'true'
|
|
uses: docker/build-push-action@v7
|
|
with:
|
|
context: .
|
|
file: Dockerfile
|
|
platforms: linux/amd64
|
|
push: false
|
|
target: node
|
|
cache-from: type=gha,scope=docker-smoke-node
|
|
cache-to: type=gha,mode=max,scope=docker-smoke-node
|
|
|
|
api-runtime-smoke:
|
|
name: API runtime smoke (production image boots)
|
|
needs: [codegraph_select]
|
|
if: ${{ !cancelled() && needs.codegraph_select.outputs.api_run != 'false' }}
|
|
runs-on: ubuntu-latest
|
|
timeout-minutes: 30
|
|
steps:
|
|
- uses: actions/checkout@v5
|
|
|
|
- name: Set up Docker Buildx
|
|
uses: docker/setup-buildx-action@v4
|
|
|
|
# Build the real production image (final `api-build` stage), which installs
|
|
# with `npm ci --omit=dev` — the same prune that, in prod, exposed runtime
|
|
# dependencies the tsdown bundle externalizes but were never declared.
|
|
- name: Build production image
|
|
uses: docker/build-push-action@v7
|
|
with:
|
|
context: .
|
|
file: Dockerfile.multi
|
|
platforms: linux/amd64
|
|
push: false
|
|
load: true
|
|
tags: librechat-api-smoke:ci
|
|
cache-from: type=gha,scope=docker-smoke-api
|
|
cache-to: type=gha,mode=max,scope=docker-smoke-api
|
|
|
|
# Loads the entire externalized require graph of the built @librechat/api
|
|
# bundle inside the pruned production image. A missing or ESM-incompatible
|
|
# runtime dependency (e.g. the `get-stream` regression) fails here with a
|
|
# non-zero exit — deterministically, with no database required.
|
|
- name: Verify production image resolves all runtime modules
|
|
run: |
|
|
docker run --rm librechat-api-smoke:ci \
|
|
node -e "require('@librechat/api'); require('@librechat/api/telemetry'); console.log('module resolution OK')"
|
|
|
|
# Boot the real entrypoint against a real MongoDB so the *entire* server
|
|
# require graph loads (api/db throws at module scope without MONGO_URI, and
|
|
# is imported before models/services/routes), then gate on /readyz AND the
|
|
# container staying alive. /readyz only returns 200 after the post-listen
|
|
# startup (initializeMCPs + checkMigrations) sets serverReady, and those
|
|
# steps process.exit(1) on failure — so ANY startup crash (missing module,
|
|
# ReferenceError, bad config, post-listen failure) fails the smoke.
|
|
- name: Boot production image against MongoDB and poll /readyz
|
|
run: |
|
|
set -u
|
|
docker network create lc-smoke
|
|
docker run -d --name lc-mongo --network lc-smoke mongo:8.0.20
|
|
docker run -d --name lc-api --network lc-smoke -p 3080:3080 \
|
|
-e HOST=0.0.0.0 -e PORT=3080 \
|
|
-e NODE_ENV=production \
|
|
-e MONGO_URI=mongodb://lc-mongo:27017/LibreChat \
|
|
-e CREDS_KEY=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef \
|
|
-e CREDS_IV=0123456789abcdef0123456789abcdef \
|
|
-e JWT_SECRET=docker-smoke-jwt-secret \
|
|
-e JWT_REFRESH_SECRET=docker-smoke-jwt-refresh-secret \
|
|
-e SEARCH=false \
|
|
librechat-api-smoke:ci
|
|
|
|
healthy=""
|
|
for i in $(seq 1 60); do
|
|
if [ "$(docker inspect -f '{{.State.Running}}' lc-api 2>/dev/null)" != "true" ]; then
|
|
echo "::error::API container exited during startup (exit code $(docker inspect -f '{{.State.ExitCode}}' lc-api 2>/dev/null))"
|
|
break
|
|
fi
|
|
if [ "$(curl -sS -o /dev/null -w '%{http_code}' http://localhost:3080/readyz 2>/dev/null || true)" = "200" ]; then
|
|
healthy="yes"
|
|
echo "/readyz returned 200 — server fully booted (post-listen startup complete)."
|
|
break
|
|
fi
|
|
sleep 2
|
|
done
|
|
|
|
echo "----- last 100 lines of api container logs -----"
|
|
docker logs lc-api 2>&1 | tail -100 || true
|
|
echo "------------------------------------------------"
|
|
docker rm -f lc-api lc-mongo >/dev/null 2>&1 || true
|
|
docker network rm lc-smoke >/dev/null 2>&1 || true
|
|
|
|
if [ -z "$healthy" ]; then
|
|
echo "::error::Production image failed to reach a ready /readyz within timeout"
|
|
exit 1
|
|
fi
|