Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🌊 feat: Add GitNexus DigitalOcean Pipeline with PR Index Serving (#12612)
Danny Avila8eab39bc8fe0
diff --git a/.do/gitnexus/Caddyfile b/.do/gitnexus/Caddyfilenew file mode 100644index 0000000000..3c5dac2c6f--- /dev/null+++ b/.do/gitnexus/Caddyfile@@ -0,0 +1,25 @@+# Caddy reverse proxy with bearer token auth and automatic HTTPS.+# The domain is supplied via environment variable GITNEXUS_DOMAIN,+# and the auth token via API_TOKEN. Both are set in docker-compose.yml.++{$GITNEXUS_DOMAIN} {+ # Health check — unauthenticated so monitoring can probe it+ @health path /health+ handle @health {+ reverse_proxy gitnexus:4747 {+ rewrite /api/info+ }+ }++ # All other routes require bearer token+ @authed {+ header Authorization "Bearer {$API_TOKEN}"+ }++ handle @authed {+ reverse_proxy gitnexus:4747+ }++ # Reject unauthenticated requests+ respond "Unauthorized" 401+}diff --git a/.fly/gitnexus/Dockerfile b/.do/gitnexus/Dockerfilesimilarity index 52%rename from .fly/gitnexus/Dockerfilerename to .do/gitnexus/Dockerfileindex 3362eb658d..a1266d5a13 100644--- a/.fly/gitnexus/Dockerfile+++ b/.do/gitnexus/Dockerfile@@ -1,62 +1,45 @@+# Long-lived GitNexus image for DigitalOcean droplet deployment.+#+# This image does NOT bake in the index data. Indexes are mounted from+# the host at /indexes/<repo>/.gitnexus/ and registered at container+# startup. A fresh index only requires rsync + container restart — no+# image rebuild on every push.+FROM node:24-slimARG GITNEXUS_VERSION=1.5.3-# 1. Build native addons with Bookworm toolchain, then remove build tools+# 1. Build native addons with Bookworm toolchain, then remove build tools.+# curl stays for the docker healthcheck; Caddy lives in its own container.RUN apt-get update \- && apt-get install -y --no-install-recommends python3 make g++ caddy curl \+ && apt-get install -y --no-install-recommends python3 make g++ curl \&& npm install -g gitnexus@${GITNEXUS_VERSION} \&& apt-get purge -y --auto-remove python3 make g++ \&& rm -rf /var/lib/apt/lists/* /root/.npm# 2. Upgrade libstdc++ from Trixie — @ladybugdb/core prebuilt binary needs# GLIBCXX_3.4.32 which Bookworm (3.4.31) doesn't ship.-# Done AFTER removing g++ to avoid libc6-dev version conflict.RUN echo "deb http://deb.debian.org/debian trixie main" > /etc/apt/sources.list.d/trixie.list \&& apt-get update \&& apt-get install -y -t trixie libstdc++6 \&& rm /etc/apt/sources.list.d/trixie.list \&& rm -rf /var/lib/apt/lists/*-# 3. Pre-install LadybugDB FTS + vector extensions so the cache in-# ~/.kuzu/extension/ is baked into the image. Workaround for upstream-# bug: gitnexus serve's pool-adapter calls LOAD EXTENSION but never-# INSTALL, so without this step, query()'s BM25 + semantic search-# silently return empty.+# 3. Pre-install LadybugDB FTS + vector extensions so ~/.kuzu/extension/+# is baked into the image. Workaround for upstream GitNexus 1.5.3 bug.COPY install-extensions.js /tmp/install-extensions.jsRUN node /tmp/install-extensions.js && rm -rf /tmp/install-extensions.js /tmp/lbug-ext-install-# 4. Patch mcp/core/lbug-adapter.js to also LOAD EXTENSION vector after FTS.-# Upstream only loads FTS at serve time; without vector extension-# loaded, semantic search's CALL QUERY_VECTOR_INDEX fails silently.-# Note: the published npm package compiles the source pool-adapter.ts-# to dist/mcp/core/lbug-adapter.js (not a 'pool-adapter.js' file).+# 4. Patch lbug-adapter.js to also LOAD EXTENSION vector after FTS.RUN LBUG_ADAPTER=/usr/local/lib/node_modules/gitnexus/dist/mcp/core/lbug-adapter.js \&& grep -q "LOAD EXTENSION fts" "$LBUG_ADAPTER" \&& sed -i "s|await available\[0\]\.query('LOAD EXTENSION fts');|await available[0].query('LOAD EXTENSION fts'); try { await available[0].query('LOAD EXTENSION vector'); } catch (e) { /* vector extension may not be installed */ }|g" "$LBUG_ADAPTER" \&& grep -c "LOAD EXTENSION vector" "$LBUG_ADAPTER" \&& echo "lbug-adapter.js patched to load vector extension"-# Copy pre-built GitNexus indexes (one per branch) and register each.-# The directory name becomes the repo name in `list_repos` output, so-# each branch lands in /LibreChat or /LibreChat-dev etc.-COPY indexes/ /indexes/-RUN set -e && \- for dir in /indexes/*/; do \- name=$(basename "$dir"); \- target="/$name"; \- mkdir -p "$target"; \- cp -r "$dir.gitnexus" "$target/.gitnexus"; \- gitnexus index "$target" --allow-non-git; \- done && \- rm -rf /indexes--# Caddy reverse proxy: bearer token auth in front of gitnexus serve-COPY Caddyfile /etc/caddy/Caddyfile-COPY entrypoint.sh /entrypoint.shRUN chmod +x /entrypoint.sh-EXPOSE 8080+EXPOSE 4747ENTRYPOINT ["/entrypoint.sh"]diff --git a/.do/gitnexus/docker-compose.yml b/.do/gitnexus/docker-compose.ymlnew file mode 100644index 0000000000..7761a89a30--- /dev/null+++ b/.do/gitnexus/docker-compose.yml@@ -0,0 +1,87 @@+# GitNexus stack for the DigitalOcean droplet.+#+# Two services: the gitnexus server (bound to an internal network only)+# and a Caddy reverse proxy that handles TLS + auth.+#+# Index data lives on the host at /opt/gitnexus/indexes/ and is+# bind-mounted read-write into the gitnexus container. The deploy+# workflow rsyncs fresh indexes into that directory and restarts+# only the gitnexus container — Caddy keeps running undisturbed.+#+# Break-glass: if gitnexus is stuck unhealthy and you need to restart+# just Caddy (e.g. to push an emergency Caddyfile fix), the+# `depends_on: condition: service_healthy` would block:+# docker compose up -d caddy+# Use --no-deps to bypass the dependency check:+# docker compose up -d --no-deps caddy++name: gitnexus++# Shared logging defaults applied to both services so the droplet's+# disk doesn't fill up with unbounded json-file logs.+x-logging: &default-logging+ driver: json-file+ options:+ max-size: '50m'+ max-file: '3'++services:+ gitnexus:+ # Override via GITNEXUS_IMAGE in /opt/gitnexus/.env to use a fork or+ # a pinned version tag like :v1.5.3 for reproducible rollbacks.+ image: ${GITNEXUS_IMAGE:-ghcr.io/danny-avila/librechat-gitnexus:latest}+ container_name: gitnexus+ restart: unless-stopped+ networks:+ - gitnexus-net+ volumes:+ - /opt/gitnexus/indexes:/indexes+ # memswap_limit equal to mem_limit disables swap for this container.+ # Without it, Docker lets the process silently swap onto host disk,+ # turning sub-second graph queries into multi-second ones. Hard+ # OOM-kill is preferable — the container restarts via unless-stopped,+ # the deploy health poll catches it, and the failure is explicit.+ mem_limit: 1792m+ memswap_limit: 1792m+ logging: *default-logging+ healthcheck:+ test: ['CMD', 'curl', '-fsS', 'http://127.0.0.1:4747/api/info']+ interval: 30s+ timeout: 5s+ retries: 3+ start_period: 60s++ caddy:+ image: caddy:2-alpine+ container_name: gitnexus-caddy+ restart: unless-stopped+ # service_healthy (not just service_started) ensures Caddy doesn't+ # start routing traffic until gitnexus passes its initial healthcheck+ # on a cold `compose up`. This only governs initial startup ordering —+ # during force-recreates of gitnexus, Caddy stays up and may briefly+ # return 502 while the new gitnexus container binds its port. The+ # deploy workflow's health poll catches any sustained failure.+ depends_on:+ gitnexus:+ condition: service_healthy+ ports:+ - '80:80'+ - '443:443'+ networks:+ - gitnexus-net+ volumes:+ - /opt/gitnexus/Caddyfile:/etc/caddy/Caddyfile:ro+ - caddy-data:/data+ - caddy-config:/config+ logging: *default-logging+ environment:+ GITNEXUS_DOMAIN: ${GITNEXUS_DOMAIN}+ API_TOKEN: ${API_TOKEN}++networks:+ gitnexus-net:+ driver: bridge++volumes:+ caddy-data:+ caddy-config:diff --git a/.do/gitnexus/entrypoint.sh b/.do/gitnexus/entrypoint.shnew file mode 100644index 0000000000..a5f0e7e54a--- /dev/null+++ b/.do/gitnexus/entrypoint.sh@@ -0,0 +1,48 @@+#!/bin/sh+set -e++# Cap Node heap below the container's cgroup limit (1792m in compose),+# leaving room for @ladybugdb/core's C++ heap and OS overhead. Native+# allocations happen outside V8's view, so a slim V8 budget is the only+# thing between a heavy query and a cgroup OOM-kill. Without this cap,+# gitnexus defaults to --max-old-space-size=8192 and reserves memory+# the container doesn't have.+export NODE_OPTIONS="${NODE_OPTIONS:---max-old-space-size=1280}"++# Register every index mounted under /indexes/<name>/.gitnexus/.+# This is idempotent — re-registering an existing repo updates the+# metadata pointer without touching the index data.+#+# Registration failure handling:+# - main (LibreChat) and dev (LibreChat-dev) are critical. If either+# fails to register, exit 1 so docker marks the container unhealthy+# and the deploy workflow's readiness check surfaces the error.+# - PR indexes (LibreChat-pr-*) are best-effort. A corrupt PR index+# shouldn't take the whole server down.+if [ -d /indexes ]; then+ for dir in /indexes/*/; do+ [ -d "$dir" ] || continue+ name=$(basename "$dir")+ [ -d "$dir.gitnexus" ] || continue+ echo "Registering index: $name"+ if ! gitnexus index "$dir" --allow-non-git; then+ case "$name" in+ LibreChat|LibreChat-dev)+ echo "ERROR: failed to register critical index $name" >&2+ exit 1+ ;;+ *)+ echo "WARN: failed to register PR index $name — skipping" >&2+ ;;+ esac+ fi+ done+else+ echo "WARN: /indexes directory not mounted" >&2+fi++# Bind 0.0.0.0 inside the container so Caddy (in a separate container+# on the same docker network) can reach gitnexus at gitnexus:4747.+# docker-compose.yml intentionally does NOT expose port 4747 on the+# host — only Caddy's 80/443 are published.+exec gitnexus serve --host 0.0.0.0 --port 4747diff --git a/.fly/gitnexus/install-extensions.js b/.do/gitnexus/install-extensions.jssimilarity index 65%rename from .fly/gitnexus/install-extensions.jsrename to .do/gitnexus/install-extensions.jsindex f8cb1b5183..231741e949 100644--- a/.fly/gitnexus/install-extensions.js+++ b/.do/gitnexus/install-extensions.js@@ -1,27 +1,30 @@/*** Pre-install LadybugDB extensions (FTS + vector) into the Docker image's* extension cache (~/.kuzu/extension/). Without this, gitnexus serve's- * pool-adapter calls LOAD EXTENSION fts at runtime but fails silently+ * lbug-adapter calls LOAD EXTENSION fts at runtime but fails silently* because the extension was never installed, causing all BM25 and* semantic queries via the query() tool to return empty.*- * This is a workaround for an upstream GitNexus 1.5.3 bug:- * pool-adapter.ts loads extensions but never installs them, and the- * CI-produced .gitnexus/ artifact doesn't include the extension cache.+ * Workaround for upstream GitNexus 1.5.3 bug where the CI-produced+ * .gitnexus/ artifact doesn't include the extension cache.*/const path = require('path');const fs = require('fs');-// @ladybugdb/core lives under the globally-installed gitnexus package+// @ladybugdb/core lives under the globally-installed gitnexus package.+// This path is stable across gitnexus versions because npm always nests+// transitive deps under the installed package's node_modules.const lbugPath = '/usr/local/lib/node_modules/gitnexus/node_modules/@ladybugdb/core';const lbug = require(lbugPath);const tmpDir = '/tmp/lbug-ext-install';fs.mkdirSync(tmpDir, { recursive: true });-// Open a throwaway database to run INSTALL against. The extension cache-// persists in ~/.kuzu/extension/ regardless of which database was used.+// Open a throwaway database just to run INSTALL against. The extension+// cache persists in ~/.kuzu/extension/ regardless of which database was+// used to install it, so the throwaway db and tmpDir are deleted in the+// Dockerfile after this script finishes.const db = new lbug.Database(path.join(tmpDir, 'db'), 0, false, false);const conn = new lbug.Connection(db);diff --git a/.fly/gitnexus/Caddyfile b/.fly/gitnexus/Caddyfiledeleted file mode 100644index ac69e6e775..0000000000--- a/.fly/gitnexus/Caddyfile+++ /dev/null@@ -1,21 +0,0 @@-:8080 {- # Health check — unauthenticated so Fly.io can probe it- @health path /health- handle @health {- reverse_proxy localhost:4747 {- rewrite /api/info- }- }-- # All other routes require bearer token- @authed {- header Authorization "Bearer {env.API_TOKEN}"- }-- handle @authed {- reverse_proxy localhost:4747- }-- # Reject unauthenticated requests- respond "Unauthorized" 401-}diff --git a/.fly/gitnexus/entrypoint.sh b/.fly/gitnexus/entrypoint.shdeleted file mode 100644index 42ada8499c..0000000000--- a/.fly/gitnexus/entrypoint.sh+++ /dev/null@@ -1,41 +0,0 @@-#!/bin/sh-set -e--if [ -z "$API_TOKEN" ]; then- echo "ERROR: API_TOKEN secret is not set."- echo "Run: flyctl secrets set API_TOKEN=<your-token>"- exit 1-fi--# Cap Node heap to match the Fly machine (leaves headroom for Caddy + OS).-# Without this, gitnexus defaults to --max-old-space-size=8192 which over-commits-# and gets killed by the OOM killer on small machines.-export NODE_OPTIONS="${NODE_OPTIONS:---max-old-space-size=768}"--# Start gitnexus serve in background, pipe output to stdout/stderr-gitnexus serve --host 127.0.0.1 --port 4747 2>&1 &-GITNEXUS_PID=$!--# Wait for gitnexus to be ready (up to 30s)-echo "Waiting for gitnexus serve to start..."-for i in $(seq 1 30); do- if curl -sf http://127.0.0.1:4747/api/info > /dev/null 2>&1; then- echo "gitnexus serve is ready (pid $GITNEXUS_PID)"- break- fi- # Check if process died- if ! kill -0 "$GITNEXUS_PID" 2>/dev/null; then- echo "ERROR: gitnexus serve exited prematurely"- exit 1- fi- sleep 1-done--# Final check-if ! curl -sf http://127.0.0.1:4747/api/info > /dev/null 2>&1; then- echo "ERROR: gitnexus serve failed to start within 30s"- exit 1-fi--# Start caddy auth proxy in foreground-exec caddy run --config /etc/caddy/Caddyfilediff --git a/.fly/gitnexus/fly.toml b/.fly/gitnexus/fly.tomldeleted file mode 100644index 65417bc3db..0000000000--- a/.fly/gitnexus/fly.toml+++ /dev/null@@ -1,27 +0,0 @@-app = 'librechat-gitnexus'-primary_region = 'iad'--[build]- dockerfile = 'Dockerfile'--[http_service]- internal_port = 8080- force_https = true- auto_stop_machines = 'stop'- auto_start_machines = true- min_machines_running = 1--[[vm]]- size = 'shared-cpu-1x'- memory = '1gb'--# 512MB swap file to absorb transient memory spikes-swap_size_mb = 512--[checks]- [checks.health]- type = 'http'- port = 8080- path = '/health'- interval = '30s'- timeout = '5s'diff --git a/.github/workflows/gitnexus-cleanup-pr.yml b/.github/workflows/gitnexus-cleanup-pr.ymlnew file mode 100644index 0000000000..d3c9628321--- /dev/null+++ b/.github/workflows/gitnexus-cleanup-pr.yml@@ -0,0 +1,91 @@+# Removes a PR's GitNexus index from the droplet when the PR is closed+# (merged or not). The deploy workflow also prunes stale folders as a+# safety net, but this gives us immediate cleanup without waiting for+# the next deploy trigger.++name: GitNexus Cleanup PR++on:+ pull_request:+ types: [closed]++permissions:+ contents: read+ actions: read++concurrency:+ group: gitnexus-cleanup-pr-${{ github.event.pull_request.number }}+ cancel-in-progress: false++jobs:+ cleanup:+ # Skip fork PRs entirely. GitHub withholds repository secrets from+ # pull_request events originating on forks, so an SSH deploy job run+ # from a fork close would fail noisily. The deploy workflow's stale-+ # folder pruning step catches any fork-contributor indexes that+ # actually made it onto the droplet.+ if: github.event.pull_request.head.repo.full_name == github.repository+ runs-on: ubuntu-latest+ timeout-minutes: 5+ steps:+ # Skip the SSH round-trip entirely when no index artifact was ever+ # built for this PR (docs-only PRs, paths-ignored PRs, PRs closed+ # before indexing finished, etc). Eliminates ~95% of no-op SSH+ # sessions on a busy repo.+ - name: Check for index artifact+ id: check+ uses: actions/github-script@v7+ with:+ script: |+ const { data } = await github.rest.actions.listArtifactsForRepo({+ owner: context.repo.owner,+ repo: context.repo.repo,+ name: `gitnexus-index-pr-${context.payload.pull_request.number}`,+ per_page: 1,+ });+ const hasArtifact = data.total_count > 0;+ core.info(`Artifact exists: ${hasArtifact}`);+ core.setOutput('has_artifact', hasArtifact ? 'true' : 'false');++ - name: Setup SSH+ if: steps.check.outputs.has_artifact == 'true'+ env:+ SSH_KEY: ${{ secrets.GITNEXUS_DO_SSH_KEY }}+ KNOWN_HOST: ${{ secrets.GITNEXUS_DO_KNOWN_HOST }}+ run: |+ set -e+ mkdir -p ~/.ssh+ chmod 700 ~/.ssh+ printf '%s\n' "$SSH_KEY" > ~/.ssh/deploy_key+ chmod 600 ~/.ssh/deploy_key+ if [ -z "$KNOWN_HOST" ]; then+ echo "::error::GITNEXUS_DO_KNOWN_HOST secret is empty"+ exit 1+ fi+ printf '%s\n' "$KNOWN_HOST" > ~/.ssh/known_hosts+ chmod 600 ~/.ssh/known_hosts++ - name: Remove PR index from droplet+ if: steps.check.outputs.has_artifact == 'true'+ env:+ SSH_USER: ${{ secrets.GITNEXUS_DO_USER }}+ SSH_HOST: ${{ secrets.GITNEXUS_DO_HOST }}+ PR_NUM: ${{ github.event.pull_request.number }}+ run: |+ ssh -i ~/.ssh/deploy_key "$SSH_USER@$SSH_HOST" PR_NUM="$PR_NUM" bash <<'REMOTE'+ set -e+ TARGET="/opt/gitnexus/indexes/LibreChat-pr-$PR_NUM"+ if [ -d "$TARGET" ]; then+ echo "Removing $TARGET"+ rm -rf "$TARGET"+ cd /opt/gitnexus+ docker compose up -d --force-recreate gitnexus+ echo "GitNexus restarted without PR #$PR_NUM"+ else+ echo "No index to clean up for PR #$PR_NUM (artifact existed but droplet folder did not)"+ fi+ REMOTE++ - name: Cleanup SSH key+ if: always()+ run: rm -f ~/.ssh/deploy_keydiff --git a/.github/workflows/gitnexus-deploy-do.yml b/.github/workflows/gitnexus-deploy-do.ymlnew file mode 100644index 0000000000..875ff34105--- /dev/null+++ b/.github/workflows/gitnexus-deploy-do.yml@@ -0,0 +1,431 @@+# Deploys GitNexus indexes to a DigitalOcean droplet via SSH + rsync.+#+# Architecture:+# GitHub Actions (deploy)+# 1. Resolves latest successful index runs for main, dev, and every+# open PR that already has an index artifact (contributor-gated+# upstream by the index workflow's author_association check)+# 2. Downloads each matching .gitnexus/ artifact+# 3. Rsyncs them into /opt/gitnexus/indexes/<name>/ on the droplet+# 4. Removes any stale folders on the droplet for PRs that closed+# (even though gitnexus-cleanup-pr.yml also handles that path,+# this is a safety net in case the close event was missed)+# 5. Pulls latest image, force-recreates gitnexus, reloads Caddy,+# and polls docker health until the container reports healthy+# The caddy container is untouched — no TLS churn.+#+# First-time droplet bootstrap (run once, manually):+# 1. Create 2GB+ Ubuntu 24.04 droplet, add SSH key+# 2. Point DNS A record for your subdomain at the droplet IP+# 3. SSH in and run:+# curl -fsSL https://get.docker.com | sh+# systemctl enable --now docker+# mkdir -p /opt/gitnexus/indexes+# useradd -m -s /bin/bash deploy+# usermod -aG docker deploy+# mkdir -p /home/deploy/.ssh+# # Add deploy pubkey to /home/deploy/.ssh/authorized_keys+# chown -R deploy:deploy /home/deploy/.ssh /opt/gitnexus+# chmod 700 /home/deploy/.ssh+# ufw allow 22,80,443/tcp+# ufw --force enable+# 4. Copy .do/gitnexus/docker-compose.yml and Caddyfile into /opt/gitnexus/+# 5. Create /opt/gitnexus/.env with: GITNEXUS_DOMAIN=... and API_TOKEN=...+# 6. cd /opt/gitnexus && docker compose up -d+#+# Then capture the droplet's SSH host key from your workstation and+# save it as the GITNEXUS_DO_KNOWN_HOST secret (below) so CI can pin it:+# ssh-keyscan -H gitnexus.yourdomain.com+#+# GHCR image: the workflow runs `docker login ghcr.io` on the droplet+# on every deploy using GITHUB_TOKEN, so the package can stay private.+# If you'd rather not have CI manage droplet auth, make the package+# public under repo Settings -> Packages.+#+# Required GitHub secrets:+# GITNEXUS_DO_HOST — droplet IP or hostname+# GITNEXUS_DO_USER — SSH user (e.g. "deploy")+# GITNEXUS_DO_SSH_KEY — private key matching the authorized pubkey+# GITNEXUS_DO_KNOWN_HOST — output of `ssh-keyscan -H <host>` pinning the+# droplet's host keys (prevents MITM/TOFU risk)++name: GitNexus Deploy (DigitalOcean)++on:+ workflow_run:+ workflows: ['GitNexus Index']+ types: [completed]+ workflow_dispatch:++permissions:+ actions: read+ contents: read+ pull-requests: read++# Per-ref concurrency: rapid pushes to the same branch/PR coalesce, but+# deploys targeting different refs can still run in parallel. Safe because+# each deploy only rsync's its own folder; final step always reflects the+# latest state for all refs discovered at resolve time.+concurrency:+ group: gitnexus-deploy-do-${{ github.event.workflow_run.head_branch || github.ref }}+ cancel-in-progress: true++env:+ GITNEXUS_VERSION: '1.5.3'+ IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/librechat-gitnexus++jobs:+ # Rebuilds the long-lived image only when Dockerfile/entrypoint/extensions+ # change. Skipped on every other run, so index-only deploys are fast.+ build-image:+ if: |+ github.event_name == 'workflow_dispatch' ||+ github.event.workflow_run.conclusion == 'success'+ runs-on: ubuntu-latest+ timeout-minutes: 20+ permissions:+ contents: read+ packages: write # push image to GHCR+ outputs:+ image_tag: ${{ steps.tag.outputs.value }}+ steps:+ - name: Checkout+ uses: actions/checkout@v4+ with:+ fetch-depth: 2++ - name: Detect image changes+ id: changes+ run: |+ # Default to rebuild when we can't cleanly diff (first commit,+ # workflow_run from a PR branch where HEAD isn't the trigger, etc).+ # Rebuild on miss > skip when we should have rebuilt.+ if git rev-parse --verify HEAD~1 >/dev/null 2>&1 && \+ git diff --quiet HEAD~1 HEAD -- .do/gitnexus/Dockerfile .do/gitnexus/entrypoint.sh .do/gitnexus/install-extensions.js; then+ echo "changed=false" >> "$GITHUB_OUTPUT"+ else+ echo "changed=true" >> "$GITHUB_OUTPUT"+ fi++ - name: Compute image tag+ id: tag+ run: echo "value=v${{ env.GITNEXUS_VERSION }}" >> "$GITHUB_OUTPUT"++ - name: Log in to GHCR+ if: steps.changes.outputs.changed == 'true' || github.event_name == 'workflow_dispatch'+ uses: docker/login-action@v3+ with:+ registry: ghcr.io+ username: ${{ github.actor }}+ password: ${{ secrets.GITHUB_TOKEN }}++ - name: Build and push image+ if: steps.changes.outputs.changed == 'true' || github.event_name == 'workflow_dispatch'+ uses: docker/build-push-action@v5+ with:+ context: .do/gitnexus+ file: .do/gitnexus/Dockerfile+ push: true+ tags: |+ ${{ env.IMAGE_NAME }}:latest+ ${{ env.IMAGE_NAME }}:${{ steps.tag.outputs.value }}+ build-args: |+ GITNEXUS_VERSION=${{ env.GITNEXUS_VERSION }}+ cache-from: type=gha+ cache-to: type=gha,mode=max++ deploy:+ needs: build-image+ runs-on: ubuntu-latest+ timeout-minutes: 20+ permissions:+ actions: read+ contents: read+ pull-requests: read+ steps:+ - name: Checkout deploy config+ uses: actions/checkout@v4+ with:+ sparse-checkout: .do/gitnexus+ fetch-depth: 1++ # Resolve every index to serve. For main/dev this is simple: latest+ # successful run per branch. For PRs, we list artifacts across recent+ # workflow runs, match gitnexus-index-pr-<N>, then cross-reference+ # GitHub PR state and only keep artifacts whose PR is still open.+ - name: Resolve indexes to serve+ id: resolve+ uses: actions/github-script@v7+ with:+ script: |+ const serve = []; // [{ name, artifactName, runId }]++ // --- main and dev branches ---+ for (const branch of ['main', 'dev']) {+ const { data } = await github.rest.actions.listWorkflowRuns({+ owner: context.repo.owner,+ repo: context.repo.repo,+ workflow_id: 'gitnexus-index.yml',+ branch,+ status: 'success',+ per_page: 1,+ });+ if (data.workflow_runs.length) {+ const runId = data.workflow_runs[0].id;+ const name = branch === 'main' ? 'LibreChat' : `LibreChat-${branch}`;+ serve.push({ name, artifactName: `gitnexus-index-${branch}`, runId });+ core.info(`${branch}: run ${runId} -> ${name}`);+ } else {+ core.warning(`No successful index run found for ${branch}`);+ }+ }++ // --- open PRs with at least one successful index run ---+ const { data: openPrs } = await github.rest.pulls.list({+ owner: context.repo.owner,+ repo: context.repo.repo,+ state: 'open',+ per_page: 100,+ });+ core.info(`Found ${openPrs.length} open PRs`);+ if (openPrs.length === 100) {+ core.warning(+ 'Open PR list was truncated at 100 (GitHub API maximum). ' ++ 'Some PR indexes may be skipped. Add pagination if the repo ' ++ 'regularly exceeds 100 concurrent open PRs.',+ );+ }++ for (const pr of openPrs) {+ // PR branches live on forks too. listWorkflowRuns for a fork+ // branch name doesn't return anything useful, so we instead+ // query artifacts directly filtered by name.+ const artifactName = `gitnexus-index-pr-${pr.number}`;+ const { data: arts } = await github.rest.actions.listArtifactsForRepo({+ owner: context.repo.owner,+ repo: context.repo.repo,+ name: artifactName,+ per_page: 5,+ });+ // Pick the most recent non-expired artifact+ const fresh = arts.artifacts+ .filter((a) => !a.expired)+ .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))[0];+ if (!fresh) continue;+ serve.push({+ name: `LibreChat-pr-${pr.number}`,+ artifactName,+ runId: fresh.workflow_run.id,+ });+ core.info(`PR #${pr.number}: run ${fresh.workflow_run.id} -> LibreChat-pr-${pr.number}`);+ }++ if (!serve.length) {+ core.setFailed('No indexes to serve');+ return;+ }++ core.setOutput('matrix', JSON.stringify(serve));+ core.setOutput('active_names', serve.map((s) => s.name).join(','));++ - name: Download each index artifact+ env:+ MATRIX: ${{ steps.resolve.outputs.matrix }}+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}+ run: |+ set -e+ mkdir -p staging+ # main/dev artifact download failures are fatal — a missing+ # main/dev index is a real deploy failure. PR artifact failures+ # are soft — a PR artifact deleted mid-deploy shouldn't abort+ # the whole deploy and take main/dev down with it.+ echo "$MATRIX" | jq -c '.[]' | while read -r entry; do+ name=$(echo "$entry" | jq -r '.name')+ artifact=$(echo "$entry" | jq -r '.artifactName')+ runId=$(echo "$entry" | jq -r '.runId')+ target="staging/${name}/.gitnexus"+ echo "Downloading $artifact from run $runId -> $target"+ mkdir -p "$target"+ if ! gh run download "$runId" \+ --repo "${{ github.repository }}" \+ --name "$artifact" \+ --dir "$target"; then+ case "$name" in+ LibreChat|LibreChat-dev)+ echo "::error::Failed to download critical artifact $artifact"+ exit 1+ ;;+ *)+ # The name stays in active_names so the prune step+ # won't remove the droplet's existing copy. The old+ # index keeps being served instead of being wiped to+ # nothing — stale beats empty — but observability+ # requires an explicit notice since this path is+ # invisible in the happy-path deploy log.+ echo "::warning::Failed to download PR artifact $artifact — skipping fresh sync; previous index (if any) will continue being served from the droplet"+ rm -rf "staging/${name}"+ ;;+ esac+ fi+ done+ echo ""+ echo "Staged for rsync:"+ du -sh staging/*/.gitnexus/ 2>/dev/null || echo "(none)"++ - name: Setup SSH+ env:+ SSH_KEY: ${{ secrets.GITNEXUS_DO_SSH_KEY }}+ KNOWN_HOST: ${{ secrets.GITNEXUS_DO_KNOWN_HOST }}+ run: |+ set -e+ mkdir -p ~/.ssh+ chmod 700 ~/.ssh+ printf '%s\n' "$SSH_KEY" > ~/.ssh/deploy_key+ chmod 600 ~/.ssh/deploy_key+ # Pin the droplet's SSH host key from a repository secret instead+ # of trusting whatever ssh-keyscan returns at deploy time. The+ # secret is populated from `ssh-keyscan -H <host>` at bootstrap.+ if [ -z "$KNOWN_HOST" ]; then+ echo "::error::GITNEXUS_DO_KNOWN_HOST secret is empty. Run ssh-keyscan -H <host> and paste the output as this secret."+ exit 1+ fi+ printf '%s\n' "$KNOWN_HOST" > ~/.ssh/known_hosts+ chmod 600 ~/.ssh/known_hosts++ - name: Authenticate droplet with GHCR+ # GHCR packages pushed by GITHUB_TOKEN start private. The droplet+ # pulls the image on every deploy, so we re-authenticate it here+ # using the same short-lived token. If the package is public, this+ # step is redundant but harmless.+ #+ # The token MUST travel through SSH stdin (not as a command arg)+ # so it's never visible in the droplet's process table via+ # /proc/<pid>/cmdline. `printf '%s'` is preferred over `echo`+ # so the exact byte sequence sent is explicit — docker login+ # tolerates a trailing newline but `printf` makes the intent+ # obvious and portable across shells.+ env:+ SSH_USER: ${{ secrets.GITNEXUS_DO_USER }}+ SSH_HOST: ${{ secrets.GITNEXUS_DO_HOST }}+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}+ GH_ACTOR: ${{ github.actor }}+ run: |+ printf '%s' "$GH_TOKEN" | ssh -i ~/.ssh/deploy_key "$SSH_USER@$SSH_HOST" \+ "docker login ghcr.io -u '$GH_ACTOR' --password-stdin"++ - name: Upload config files+ env:+ SSH_USER: ${{ secrets.GITNEXUS_DO_USER }}+ SSH_HOST: ${{ secrets.GITNEXUS_DO_HOST }}+ run: |+ rsync -az -e "ssh -i ~/.ssh/deploy_key" \+ .do/gitnexus/docker-compose.yml \+ .do/gitnexus/Caddyfile \+ "$SSH_USER@$SSH_HOST:/opt/gitnexus/"++ - name: Rsync indexes and prune stale ones+ env:+ SSH_USER: ${{ secrets.GITNEXUS_DO_USER }}+ SSH_HOST: ${{ secrets.GITNEXUS_DO_HOST }}+ ACTIVE_NAMES: ${{ steps.resolve.outputs.active_names }}+ run: |+ set -e+ # Push every active index up+ for dir in staging/*/; do+ [ -d "$dir" ] || continue+ name=$(basename "$dir")+ echo "Syncing $name"+ ssh -i ~/.ssh/deploy_key "$SSH_USER@$SSH_HOST" \+ "mkdir -p /opt/gitnexus/indexes/$name"+ rsync -az --delete -e "ssh -i ~/.ssh/deploy_key" \+ "$dir" \+ "$SSH_USER@$SSH_HOST:/opt/gitnexus/indexes/$name/"+ done++ # Prune any folders on the droplet that aren't in the active set.+ # This cleans up closed PRs the cleanup workflow might have missed,+ # and is safe because main/dev/PR-<N> are always present if active.+ echo "Pruning stale indexes (keeping: $ACTIVE_NAMES)"+ ssh -i ~/.ssh/deploy_key "$SSH_USER@$SSH_HOST" \+ ACTIVE_NAMES="$ACTIVE_NAMES" bash <<'REMOTE'+ set -e+ cd /opt/gitnexus/indexes || exit 0+ # nullglob makes `for dir in */` expand to nothing when the+ # directory is empty (first deploy), instead of the literal+ # string "*/". Explicit no-op > relying on rm -f to silently+ # tolerate a nonexistent file named "*".+ shopt -s nullglob+ IFS=',' read -ra ACTIVE <<< "$ACTIVE_NAMES"+ for dir in */; do+ dir="${dir%/}"+ keep=false+ for a in "${ACTIVE[@]}"; do+ if [ "$dir" = "$a" ]; then keep=true; break; fi+ done+ if [ "$keep" = false ]; then+ echo "Removing stale index: $dir"+ rm -rf "$dir"+ fi+ done+ REMOTE++ - name: Pull image, restart gitnexus, reload Caddy, wait for healthy+ env:+ SSH_USER: ${{ secrets.GITNEXUS_DO_USER }}+ SSH_HOST: ${{ secrets.GITNEXUS_DO_HOST }}+ run: |+ ssh -i ~/.ssh/deploy_key "$SSH_USER@$SSH_HOST" bash <<'REMOTE'+ set -e+ cd /opt/gitnexus+ docker compose pull gitnexus+ docker compose up -d --force-recreate gitnexus++ # Reload Caddy in-place so a changed Caddyfile takes effect+ # without losing TLS certs or restarting connections. If caddy+ # isn't running yet (first-time bootstrap), bring it up.+ if docker compose ps --status running caddy 2>/dev/null | grep -q caddy; then+ echo "Reloading Caddy config"+ docker compose exec -T caddy caddy reload --config /etc/caddy/Caddyfile || {+ echo "Caddy reload failed — forcing restart"+ docker compose up -d --force-recreate caddy+ }+ else+ echo "Caddy not running — starting"+ docker compose up -d caddy+ fi++ # Poll gitnexus health until ready or timeout. Docker's own+ # unhealthy detection takes up to 150s (start_period 60s ++ # retries 3 * interval 30s), so the poll ceiling must clear+ # that to avoid false negatives when gitnexus legitimately+ # takes ~2.5 min to warm up.+ # Max wait = 36 sleeps * 5s = 180s (final iteration exits+ # before its sleep on failure, so 37 iterations is the+ # correct upper bound for a true 180s ceiling).+ echo "Waiting for gitnexus to report healthy..."+ for i in $(seq 1 37); do+ STATUS=$(docker inspect --format='{{.State.Health.Status}}' gitnexus 2>/dev/null || echo unknown)+ echo "[$i/37] gitnexus health: $STATUS"+ if [ "$STATUS" = "healthy" ]; then+ echo "gitnexus is healthy"+ break+ fi+ if [ "$i" -eq 37 ]; then+ echo "ERROR: gitnexus failed to become healthy after 180s"+ docker compose ps+ docker compose logs --tail 80 gitnexus+ exit 1+ fi+ sleep 5+ done++ docker compose ps+ echo "--- Caddy logs (last 20 lines) ---"+ docker compose logs --tail 20 caddy || true+ echo "--- GitNexus logs (last 30 lines) ---"+ docker compose logs --tail 30 gitnexus || true+ REMOTE++ - name: Cleanup SSH key+ if: always()+ run: rm -f ~/.ssh/deploy_keydiff --git a/.github/workflows/gitnexus-deploy.yml b/.github/workflows/gitnexus-deploy.ymldeleted file mode 100644index 4a647d787b..0000000000--- a/.github/workflows/gitnexus-deploy.yml+++ /dev/null@@ -1,122 +0,0 @@-# Deploys the GitNexus indexes for both main and dev to Fly.io as a-# persistent MCP + REST server, serving both branches simultaneously.-#-# Endpoints available after deploy:-# /api/mcp — MCP-over-HTTP (StreamableHTTP transport)-# /api/query — Search execution flows (specify repo: LibreChat or LibreChat-dev)-# /api/search — Hybrid BM25 + semantic search-# /api/repos — List indexed repositories-# /api/info — Server version and status-#-# First-time setup:-# 1. flyctl apps create librechat-gitnexus-# 2. flyctl tokens create deploy -x 999999h-# 3. flyctl secrets set API_TOKEN=$(openssl rand -hex 32)-# 4. Add FLY_API_TOKEN as a GitHub repo secret-#-# All requests (except /health) require: Authorization: Bearer <API_TOKEN>--name: GitNexus Deploy--on:- workflow_run:- workflows: ['GitNexus Index']- branches: [main, dev]- types: [completed]- workflow_dispatch:--permissions:- actions: read--concurrency:- group: gitnexus-deploy- cancel-in-progress: false--env:- GITNEXUS_VERSION: '1.5.3'--jobs:- deploy:- if: |- github.event_name == 'workflow_dispatch' ||- github.event.workflow_run.conclusion == 'success'- runs-on: ubuntu-latest- timeout-minutes: 15- steps:- - name: Checkout deploy config- uses: actions/checkout@v4- with:- sparse-checkout: .fly/gitnexus- fetch-depth: 1-- - name: Resolve latest successful index runs per branch- id: resolve- uses: actions/github-script@v7- with:- script: |- const branches = ['main', 'dev'];- const result = {};- for (const branch of branches) {- const { data } = await github.rest.actions.listWorkflowRuns({- owner: context.repo.owner,- repo: context.repo.repo,- workflow_id: 'gitnexus-index.yml',- branch,- status: 'success',- per_page: 1,- });- if (data.workflow_runs.length) {- result[branch] = data.workflow_runs[0].id;- core.info(`${branch}: run ${result[branch]}`);- } else {- core.warning(`No successful index run found for ${branch}`);- }- }- if (!Object.keys(result).length) {- core.setFailed('No successful index runs found for any branch');- return;- }- core.setOutput('main_run', result.main || '');- core.setOutput('dev_run', result.dev || '');-- - name: Download main index- if: steps.resolve.outputs.main_run != ''- uses: actions/download-artifact@v4- with:- name: gitnexus-index-main- path: deploy/indexes/LibreChat/.gitnexus- run-id: ${{ steps.resolve.outputs.main_run }}- github-token: ${{ secrets.GITHUB_TOKEN }}-- - name: Download dev index- if: steps.resolve.outputs.dev_run != ''- uses: actions/download-artifact@v4- with:- name: gitnexus-index-dev- path: deploy/indexes/LibreChat-dev/.gitnexus- run-id: ${{ steps.resolve.outputs.dev_run }}- github-token: ${{ secrets.GITHUB_TOKEN }}-- - name: Prepare deploy context- run: |- cp .fly/gitnexus/Dockerfile deploy/Dockerfile- cp .fly/gitnexus/Caddyfile deploy/Caddyfile- cp .fly/gitnexus/entrypoint.sh deploy/entrypoint.sh- cp .fly/gitnexus/install-extensions.js deploy/install-extensions.js- echo "Deploy context:"- ls -la deploy/- echo "Indexes staged:"- ls -la deploy/indexes/ || echo "(none)"-- - name: Setup Fly- uses: superfly/flyctl-actions/setup-flyctl@master-- - name: Deploy to Fly.io- working-directory: deploy- run: |- flyctl deploy \- --config ../.fly/gitnexus/fly.toml \- --build-arg GITNEXUS_VERSION=${{ env.GITNEXUS_VERSION }} \- --remote-only- env:- FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}diff --git a/.github/workflows/gitnexus-index.yml b/.github/workflows/gitnexus-index.ymlindex bd395247b9..914b0a35f9 100644--- a/.github/workflows/gitnexus-index.yml+++ b/.github/workflows/gitnexus-index.yml@@ -17,12 +17,25 @@ on:description: 'Force full re-index'type: booleandefault: false+ # When invoked from the /gitnexus index PR command, the command+ # workflow fills these so the index is built from the PR's head+ # ref and uploaded under the PR-numbered artifact name.+ pr_number:+ description: 'PR number to index (set by /gitnexus command)'+ type: string+ default: ''+ pr_ref:+ description: 'PR head SHA or ref to check out (set by /gitnexus command)'+ type: string+ default: ''permissions:contents: readconcurrency:- group: gitnexus-${{ github.ref }}+ # When triggered by the /gitnexus command, group by PR number so rapid+ # re-runs coalesce. Otherwise group by git ref as before.+ group: gitnexus-${{ inputs.pr_number != '' && format('pr-{0}', inputs.pr_number) || github.ref }}cancel-in-progress: trueenv:@@ -30,7 +43,10 @@ env:jobs:index:- # Allow push + dispatch unconditionally; filter PRs to contributors only+ # Allow push + dispatch unconditionally; filter native pull_request+ # events to contributors only. The /gitnexus command workflow does+ # its own contributor check before it dispatches this workflow, so+ # workflow_dispatch is always trusted here.if: |github.event_name != 'pull_request' ||github.event.pull_request.author_association == 'OWNER' ||@@ -42,6 +58,9 @@ jobs:- name: Checkout repositoryuses: actions/checkout@v4with:+ # When the /gitnexus command dispatches us with a pr_ref, check+ # out that exact SHA. Otherwise fall back to the default ref.+ ref: ${{ inputs.pr_ref || '' }}fetch-depth: 1- name: Setup Node.js@@ -83,11 +102,17 @@ jobs:- name: Upload GitNexus indexuses: actions/upload-artifact@v4with:+ # Artifact naming order of precedence:+ # 1. /gitnexus command dispatch: inputs.pr_number -> pr-<N>+ # 2. Native pull_request event: github.event.pull_request.number+ # 3. Push or manual dispatch without pr_number: github.ref_namename: >-gitnexus-index-${{- github.event_name == 'pull_request'- && format('pr-{0}', github.event.pull_request.number)- || github.ref_name+ inputs.pr_number != ''+ && format('pr-{0}', inputs.pr_number)+ || (github.event_name == 'pull_request'+ && format('pr-{0}', github.event.pull_request.number)+ || github.ref_name)}}path: .gitnexus/include-hidden-files: truediff --git a/.github/workflows/gitnexus-pr-command.yml b/.github/workflows/gitnexus-pr-command.ymlnew file mode 100644index 0000000000..4ce58bb2b8--- /dev/null+++ b/.github/workflows/gitnexus-pr-command.yml@@ -0,0 +1,100 @@+# Responds to `/gitnexus index` comments on pull requests.+#+# Gated to the same author_association roles (OWNER, MEMBER, COLLABORATOR)+# as the automatic PR index trigger. When a matching comment lands on a+# PR, this workflow dispatches `gitnexus-index.yml` with the PR number+# and head SHA so the existing indexing pipeline does the actual work.+#+# Use cases:+# - Re-index a PR after a rebase without pushing a new commit+# - Index a docs-only PR that was skipped by paths-ignore+# - Re-run a failed index+#+# Supported commands:+# /gitnexus index — index with defaults (no embeddings)+# /gitnexus index embeddings — index with --embeddings enabled++name: GitNexus PR Command++on:+ issue_comment:+ types: [created]++permissions:+ contents: read+ pull-requests: write+ actions: write # needed to dispatch gitnexus-index.yml++concurrency:+ group: gitnexus-pr-command-${{ github.event.issue.number }}+ cancel-in-progress: false++jobs:+ dispatch:+ # Only run for PR comments that start with /gitnexus from trusted users+ if: |+ github.event.issue.pull_request != null &&+ startsWith(github.event.comment.body, '/gitnexus') &&+ (github.event.comment.author_association == 'OWNER' ||+ github.event.comment.author_association == 'MEMBER' ||+ github.event.comment.author_association == 'COLLABORATOR')+ runs-on: ubuntu-latest+ timeout-minutes: 5+ steps:+ - name: Parse command and resolve PR head+ id: parse+ uses: actions/github-script@v7+ with:+ script: |+ const body = context.payload.comment.body.trim();+ const match = body.match(/^\/gitnexus\s+(\w+)(?:\s+(\w+))?/);+ if (!match) {+ core.setFailed(`Unrecognized command: ${body}. Try: /gitnexus index [embeddings]`);+ return;+ }+ const [, subcommand, modifier] = match;+ if (subcommand !== 'index') {+ core.setFailed(`Unknown subcommand: ${subcommand}. Only 'index' is supported.`);+ return;+ }+ const embeddings = modifier === 'embeddings' ? 'true' : 'false';++ // Resolve the PR's head SHA — listWorkflowDispatchRun needs a real ref.+ const prNum = context.payload.issue.number;+ const { data: pr } = await github.rest.pulls.get({+ owner: context.repo.owner,+ repo: context.repo.repo,+ pull_number: prNum,+ });+ core.setOutput('pr_number', String(prNum));+ core.setOutput('pr_ref', pr.head.sha);+ core.setOutput('embeddings', embeddings);+ core.info(`Dispatching index for PR #${prNum} at ${pr.head.sha} (embeddings=${embeddings})`);++ - name: Dispatch gitnexus-index workflow+ uses: actions/github-script@v7+ with:+ script: |+ await github.rest.actions.createWorkflowDispatch({+ owner: context.repo.owner,+ repo: context.repo.repo,+ workflow_id: 'gitnexus-index.yml',+ ref: 'main',+ inputs: {+ pr_number: '${{ steps.parse.outputs.pr_number }}',+ pr_ref: '${{ steps.parse.outputs.pr_ref }}',+ embeddings: '${{ steps.parse.outputs.embeddings }}',+ force: 'false',+ },+ });++ - name: React to the comment+ uses: actions/github-script@v7+ with:+ script: |+ await github.rest.reactions.createForIssueComment({+ owner: context.repo.owner,+ repo: context.repo.repo,+ comment_id: context.payload.comment.id,+ content: 'rocket',+ });