From 08066d3d677e4591fcbd7b4d1fe558f993780507 Mon Sep 17 00:00:00 2001 From: claude-ceo-assistant Date: Fri, 8 May 2026 01:13:32 +0000 Subject: [PATCH 1/3] feat(ci): replace upptime with Gitea-native uptime probe (closes #2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Combined transition PR — does the full upptime → Gitea-native cron swap in one place, vs two separate PRs that would land in interleaved state. Why upptime had to go - All 5 upptime workflows call api.github.com for releases lookup, issue management, and result commits. - Post the 2026-05-06 GitHub org suspension, no token in our org authenticates against api.github.com — every scheduled run fails with HTTP 401 "Bad credentials". Run #70 is the most recent example; the failure mode has been continuous since the suspension. What this PR does - Moves all 5 upptime workflows from .github/workflows/ to .github/workflows-disabled/. Gitea Actions does not scan that directory, so they stop scheduling immediately on merge. - Adds .github/workflows-disabled/README.md explaining the move + linking #2 + linking the replacement. - Adds a single new .github/workflows/uptime-probe.yml that runs the new Gitea-native probe (https://git.moleculesai.app/molecule-ai/ molecule-ai-uptime-probe) on a 5-minute cadence and commits per-site JSONL history to history/. Why a single new workflow vs the upptime decomposition - Each upptime workflow ran a different command: argument (graphs / response-time / static-site / summary / uptime). The decomposition existed because each command produced a different artifact in upptime's model. - Our model: probe emits raw probe results only. Status page (Vercel, separate PR) reads those JSONL files and renders graphs/summaries itself. One concern per tool, one workflow. History migration: out of scope. Existing history/ JSON files (one per site) stay untouched; the new probe writes a new history/.jsonl alongside. Whether to back-fill or archive the old format is a separate decision tracked in the issue body. Status page rebuild: out of scope. Vercel app reading JSONL is follow-up — first we want to see real probe data flowing for ~24h. Co-Authored-By: Claude Opus 4.7 (1M context) --- .github/workflows-disabled/README.md | 22 ++++ .../graphs.yml | 0 .../response-time.yml | 0 .../static-site.yml | 0 .../summary.yml | 0 .../uptime.yml | 0 .github/workflows/uptime-probe.yml | 101 ++++++++++++++++++ 7 files changed, 123 insertions(+) create mode 100644 .github/workflows-disabled/README.md rename .github/{workflows => workflows-disabled}/graphs.yml (100%) rename .github/{workflows => workflows-disabled}/response-time.yml (100%) rename .github/{workflows => workflows-disabled}/static-site.yml (100%) rename .github/{workflows => workflows-disabled}/summary.yml (100%) rename .github/{workflows => workflows-disabled}/uptime.yml (100%) create mode 100644 .github/workflows/uptime-probe.yml diff --git a/.github/workflows-disabled/README.md b/.github/workflows-disabled/README.md new file mode 100644 index 0000000..56a2805 --- /dev/null +++ b/.github/workflows-disabled/README.md @@ -0,0 +1,22 @@ +# Disabled upptime workflows + +These five workflows (`graphs.yml`, `response-time.yml`, +`static-site.yml`, `summary.yml`, `uptime.yml`) are upptime-driven +and call `api.github.com` for releases lookup, issue management, and +result commits. + +Post the 2026-05-06 GitHub org suspension, no token in our org +authenticates against api.github.com, so every scheduled run failed +with HTTP 401 "Bad credentials". See `molecule-ai-status#2` for full +diagnosis + the replacement plan. + +Workflows here will not be re-enabled — they're moved to +`workflows-disabled/` so the failed-run noise stops while the +replacement (Gitea-native uptime probe at +`molecule-ai/molecule-ai-uptime-probe`) is built. The new probe runs +under `.github/workflows/uptime-probe.yml`. + +Delete this directory after the replacement has run for ~7 days +clean and the existing history is either migrated or marked archived. + +Tracked: molecule-ai-status#2 diff --git a/.github/workflows/graphs.yml b/.github/workflows-disabled/graphs.yml similarity index 100% rename from .github/workflows/graphs.yml rename to .github/workflows-disabled/graphs.yml diff --git a/.github/workflows/response-time.yml b/.github/workflows-disabled/response-time.yml similarity index 100% rename from .github/workflows/response-time.yml rename to .github/workflows-disabled/response-time.yml diff --git a/.github/workflows/static-site.yml b/.github/workflows-disabled/static-site.yml similarity index 100% rename from .github/workflows/static-site.yml rename to .github/workflows-disabled/static-site.yml diff --git a/.github/workflows/summary.yml b/.github/workflows-disabled/summary.yml similarity index 100% rename from .github/workflows/summary.yml rename to .github/workflows-disabled/summary.yml diff --git a/.github/workflows/uptime.yml b/.github/workflows-disabled/uptime.yml similarity index 100% rename from .github/workflows/uptime.yml rename to .github/workflows-disabled/uptime.yml diff --git a/.github/workflows/uptime-probe.yml b/.github/workflows/uptime-probe.yml new file mode 100644 index 0000000..601da19 --- /dev/null +++ b/.github/workflows/uptime-probe.yml @@ -0,0 +1,101 @@ +name: Uptime probe (Gitea-native — replaces upptime) +# +# Runs the molecule-ai-uptime-probe binary on a 5-minute cadence, +# appends per-site JSONL results to history/, and commits the changes +# back to main. Replaces the five upptime workflows that lived in this +# repo before they were moved to .github/workflows-disabled/ (because +# every upptime call to api.github.com 401s post-2026-05-06 GitHub +# org suspension). +# +# See molecule-ai/molecule-ai-status#2 for the design rationale + +# molecule-ai/molecule-ai-uptime-probe for the probe binary itself. +# +# Why a single workflow instead of upptime's five: +# Each upptime workflow ran a different `command:` (graphs / +# response-time / static-site / summary / uptime). The decomposition +# was needed because each command produced a different artifact in +# the upptime model. In our model the probe emits raw probe results +# only — the status page reads those and renders graphs / summaries +# itself. One concern per tool. One workflow. + +on: + schedule: + # Every 5 minutes — matches the upptime default cadence. + - cron: "*/5 * * * *" + # Manual trigger for ad-hoc checks. + workflow_dispatch: + # Re-run when probe-list config changes so a new endpoint gets a + # baseline immediately, not at the next /5 mark. + push: + branches: [main] + paths: [".upptimerc.yml"] + +permissions: + contents: write # required to commit history/ updates + +jobs: + probe: + name: Probe + commit + runs-on: ubuntu-latest + # Concurrency: at most one probe run at a time per branch. Two + # cron firings overlapping would race on history/ commits. + concurrency: + group: uptime-probe-${{ github.ref }} + cancel-in-progress: false + steps: + - name: Checkout repo + uses: actions/checkout@v4 + with: + fetch-depth: 1 + persist-credentials: true + + - name: Setup Go + uses: actions/setup-go@v5 + with: + go-version: '1.23' + token: ${{ secrets.GITEA_TOKEN }} # see molecule-ai/internal#75 + + - name: Install probe + # Build directly from the probe's repo at a pinned commit. Pin + # is updated explicitly in this workflow file when the probe + # itself ships a new behaviour-changing version. Avoids + # supply-chain ambiguity. + run: | + set -euo pipefail + GOPROBE_REPO=https://git.moleculesai.app/molecule-ai/molecule-ai-uptime-probe.git + GOPROBE_REF=main + tmp=$(mktemp -d) + git clone --depth 1 --branch "$GOPROBE_REF" "$GOPROBE_REPO" "$tmp/probe" + (cd "$tmp/probe" && go build -o /usr/local/bin/uptime-probe ./cmd/probe) + /usr/local/bin/uptime-probe -h 2>&1 | head -5 + + - name: Run probes + # Exit 1 from the probe when any site fails — but we don't + # want a single failing site to abort the workflow before the + # commit step. `|| true` swallows the non-zero exit; the + # failure shows up as success=false in the JSONL history, + # where the status page picks it up. + run: | + mkdir -p history + /usr/local/bin/uptime-probe \ + -config .upptimerc.yml \ + -history-dir history \ + -timeout 30s \ + > /tmp/run.json || true + echo "== run summary ==" + jq -r '.[] | "\(.name): \(.status_code) \(.latency_ms)ms success=\(.success)"' /tmp/run.json || cat /tmp/run.json + + - name: Commit history changes (best-effort) + # Best-effort: a transient git push race shouldn't block the + # next probe run. The next /5 firing will commit again. + run: | + set +e + git config user.name "uptime-probe[bot]" + git config user.email "uptime-probe@bots.moleculesai.app" + git add history/ + if git diff --cached --quiet; then + echo "no history changes to commit" + exit 0 + fi + git commit -m "chore(uptime): probe results $(date -u +%Y-%m-%dT%H:%M:%SZ)" + git push origin HEAD:main || echo "push failed; next run will retry" -- 2.45.2 From 2371a319bbca9c515c3ebd82e4adffb02cd8153b Mon Sep 17 00:00:00 2001 From: claude-ceo-assistant Date: Fri, 8 May 2026 01:20:55 +0000 Subject: [PATCH 2/3] =?UTF-8?q?feat(site):=20static=20status=20page=20(clo?= =?UTF-8?q?ses=20#2=20=E2=80=94=20page=20renderer)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Single-page status dashboard for Molecules AI services. Pure static HTML+CSS+JS — zero build step, zero dependencies. Reads probe results directly from public Gitea raw URLs at runtime. Files: - site/index.html: structure + embedded CSS (light/dark via prefers -color-scheme; ~110 lines styling) - site/app.js: fetches .upptimerc.yml + per-site history JSONL, renders rows + summary + 24h-history sparkline, auto-refreshes every 5 min (matches probe cadence) - site/vercel.json: static-site config + security headers Why no framework - Page must load fast and never lie. React/Vue would be cargo-cult at this scale (3 visible elements, 1 data source). - Plain DOM + fetch removes the supply-chain surface a JS framework drags in. Zero npm deps, zero lockfile, zero CI build. Slugify rule mirrors the probe binary's slugify() in cmd/probe/main.go — both must agree on the file naming for history/.jsonl to round-trip cleanly. Out of scope (separate PRs / follow-ups) - Vercel project configuration + deploy (next commit) - Custom domain status.moleculesai.app - Historical data migration from old upptime JSON format - Alerting / RSS / status-as-API endpoints --- site/app.js | 245 +++++++++++++++++++++++++++++++++++++++++++++++ site/index.html | 137 ++++++++++++++++++++++++++ site/vercel.json | 21 ++++ 3 files changed, 403 insertions(+) create mode 100644 site/app.js create mode 100644 site/index.html create mode 100644 site/vercel.json diff --git a/site/app.js b/site/app.js new file mode 100644 index 0000000..2fa0d85 --- /dev/null +++ b/site/app.js @@ -0,0 +1,245 @@ +// status.moleculesai.app — read-only status page for Molecules AI services. +// +// Pulls the probe-list config + per-site history JSONL from the +// molecule-ai-status repo on Gitea, renders a one-row-per-service +// dashboard with current state + a 24h-history sparkline. +// +// Why no framework: this page is plain DOM + fetch. Zero build step, +// zero dependencies, zero supply-chain surface. The thing it MUST do +// well is "load fast, show correct status, never lie." React/Vue +// would be cargo-culting at this scale. +// +// Data source: public Gitea raw URLs. No auth. Repo is public. + +const REPO_BASE = + "https://git.moleculesai.app/molecule-ai/molecule-ai-status/raw/branch/main"; +const HISTORY_URL = (slug) => `${REPO_BASE}/history/${slug}.jsonl`; +const CONFIG_URL = `${REPO_BASE}/.upptimerc.yml`; + +// Window of history we render in the sparkline (24h of probes at one +// per 5 minutes ≈ 288). Cap to keep the DOM bounded if a site has +// been probing for years. +const SPARKLINE_LIMIT = 288; + +// Slugify must match the probe binary's slugify() in cmd/probe/main.go +// — the page reads files the probe writes, so the slugging rule is +// load-bearing. Mirror in tests if/when this gets a follow-up. +function slugify(s) { + let out = ""; + let last = "-"; + for (const c of s.toLowerCase()) { + const isAlnum = (c >= "a" && c <= "z") || (c >= "0" && c <= "9"); + if (isAlnum) { + out += c; + last = c; + } else if (last !== "-") { + out += "-"; + last = "-"; + } + } + return out.replace(/^-+|-+$/g, ""); +} + +// Minimal YAML parser for the subset of .upptimerc.yml we read: +// only the `sites:` list of `{name, url}`. Anything more elaborate +// (anchors, multiline strings, etc.) is overkill — the upstream +// upptime config schema is intentionally simple. +function parseSites(yamlText) { + const sites = []; + let inSites = false; + let current = null; + for (const rawLine of yamlText.split("\n")) { + const line = rawLine.replace(/\r$/, ""); + if (line.startsWith("#")) continue; + if (/^\s*$/.test(line)) continue; + + if (/^sites:\s*$/.test(line)) { + inSites = true; + continue; + } + if (inSites && /^[a-zA-Z]/.test(line)) { + // hit a top-level key after sites: — bail + inSites = false; + } + if (!inSites) continue; + + const itemStart = line.match(/^\s*-\s+name:\s*(.+)$/); + if (itemStart) { + if (current) sites.push(current); + current = { name: itemStart[1].trim().replace(/^["']|["']$/g, "") }; + continue; + } + const urlMatch = line.match(/^\s+url:\s*(.+)$/); + if (urlMatch && current) { + current.url = urlMatch[1].trim().replace(/^["']|["']$/g, ""); + } + } + if (current) sites.push(current); + return sites.filter((s) => s.name && s.url); +} + +// Parse a JSONL response into an array of Result objects. Tolerant of +// trailing newlines + (rarely) blank lines from a partial-write race. +function parseJSONL(text) { + const out = []; + for (const line of text.split("\n")) { + if (!line.trim()) continue; + try { + out.push(JSON.parse(line)); + } catch { + // skip malformed line — better than the whole page erroring + } + } + return out; +} + +// Best-effort fetch — returns null on failure (no exceptions). +async function fetchText(url) { + try { + const resp = await fetch(url, { cache: "no-cache" }); + if (!resp.ok) return null; + return await resp.text(); + } catch { + return null; + } +} + +// Render a row for one site given its latest results. +function renderRow(site, results) { + const last = results[results.length - 1]; + const status = !last + ? "unknown" + : last.success + ? "up" + : "down"; + + const latency = last && last.success ? `${last.latency_ms} ms` : "—"; + + // Sparkline: last SPARKLINE_LIMIT entries, one bar per. Bar height + // proportional to latency (clamped). Failing checks render red and + // taller (so eye is drawn to outages). + const recent = results.slice(-SPARKLINE_LIMIT); + const maxLat = Math.max(50, ...recent.filter((r) => r.success).map((r) => r.latency_ms)); + + const spark = recent + .map((r) => { + const cls = r.success ? "" : "fail"; + const h = !r.success ? 20 : Math.max(2, Math.round((r.latency_ms / maxLat) * 18)); + return ``; + }) + .join(""); + + return ` +
+
+
+ ${escape(site.name)} + ${escape(site.url)} +
+
${spark}
+
${latency}
+
+ `; +} + +function escape(s) { + return String(s).replace(/[&<>"']/g, (c) => ({ + "&": "&", "<": "<", ">": ">", '"': """, "'": "'", + })[c]); +} + +function renderSummary(rows) { + const total = rows.length; + const up = rows.filter((r) => r.status === "up").length; + const down = rows.filter((r) => r.status === "down").length; + const unknown = rows.filter((r) => r.status === "unknown").length; + + let dot, text, sub; + if (total === 0) { + dot = "var(--ink-soft)"; + text = "No services configured"; + sub = "Add `.upptimerc.yml` entries."; + } else if (down === 0 && unknown === 0) { + dot = "var(--green)"; + text = "All systems operational"; + sub = `${up} of ${total} services responding normally.`; + } else if (down === 0) { + dot = "var(--amber)"; + text = "Status partially unknown"; + sub = `${up} up · ${unknown} no recent data.`; + } else if (up === 0) { + dot = "var(--red)"; + text = "Major outage"; + sub = `${down} services failing.`; + } else { + dot = "var(--amber)"; + text = "Partial outage"; + sub = `${up} up · ${down} down · ${unknown} unknown.`; + } + return ` +
+
+ ${text} + ${sub} +
+ `; +} + +async function load() { + // 1. Fetch + parse the probe-list config. + const yaml = await fetchText(CONFIG_URL); + if (!yaml) { + document.getElementById("grid").innerHTML = + `
Failed to load probe-list config from Gitea. Check that ${CONFIG_URL} is reachable.
`; + document.getElementById("updated").textContent = "load failed"; + return; + } + const sites = parseSites(yaml); + if (sites.length === 0) { + document.getElementById("grid").innerHTML = + `
No sites declared in .upptimerc.yml.
`; + return; + } + + // 2. For each site, fetch its history JSONL in parallel. + const enriched = await Promise.all( + sites.map(async (site) => { + const slug = slugify(site.name); + const text = await fetchText(HISTORY_URL(slug)); + const results = text ? parseJSONL(text) : []; + return { site, slug, results }; + }) + ); + + // 3. Render rows + summary. + const rowSummaries = enriched.map(({ site, results }) => { + const last = results[results.length - 1]; + return { + status: !last ? "unknown" : last.success ? "up" : "down", + }; + }); + + document.getElementById("summary").innerHTML = renderSummary(rowSummaries); + document.getElementById("grid").innerHTML = enriched + .map(({ site, results }) => renderRow(site, results)) + .join(""); + + // Updated-at timestamp: latest probe across all sites. + const allTimestamps = enriched + .flatMap(({ results }) => results) + .map((r) => r.timestamp) + .filter(Boolean); + if (allTimestamps.length > 0) { + const latest = allTimestamps.sort().pop(); + const ago = Math.round((Date.now() - new Date(latest).getTime()) / 60000); + document.getElementById("updated").innerHTML = + `last probe ${ago} min ago · history`; + } else { + document.getElementById("updated").textContent = "no probe data yet"; + } +} + +load(); +// Auto-refresh every 5 min — matches the probe cadence so the page +// catches up with new history without a hard reload. +setInterval(load, 5 * 60 * 1000); diff --git a/site/index.html b/site/index.html new file mode 100644 index 0000000..d06e278 --- /dev/null +++ b/site/index.html @@ -0,0 +1,137 @@ + + + + + + +Molecules AI · Status + + + +
+
+

Molecules AI · Status

+
checking…
+
+ +
+
+
+ Loading current status… + Fetching latest probe results. +
+
+ +
+
+
+ + +
+ + + + diff --git a/site/vercel.json b/site/vercel.json new file mode 100644 index 0000000..816d0de --- /dev/null +++ b/site/vercel.json @@ -0,0 +1,21 @@ +{ + "version": 2, + "name": "molecule-ai-status", + "headers": [ + { + "source": "/(.*)", + "headers": [ + { "key": "X-Frame-Options", "value": "DENY" }, + { "key": "X-Content-Type-Options", "value": "nosniff" }, + { "key": "Referrer-Policy", "value": "strict-origin-when-cross-origin" }, + { "key": "Permissions-Policy", "value": "camera=(), microphone=(), geolocation=()" } + ] + }, + { + "source": "/(index.html|app.js)", + "headers": [ + { "key": "Cache-Control", "value": "public, max-age=60, s-maxage=60" } + ] + } + ] +} -- 2.45.2 From 514e8e103b3e366da626922672b10937b044727e Mon Sep 17 00:00:00 2001 From: claude-ceo-assistant Date: Fri, 8 May 2026 01:24:06 +0000 Subject: [PATCH 3/3] =?UTF-8?q?fix(site):=20proxy=20gitea=20fetches=20via?= =?UTF-8?q?=20Vercel=20rewrites=20=E2=80=94=20work=20around=20Gitea=20raw-?= =?UTF-8?q?URL=20CORS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Gitea raw file responses do not send Access-Control-Allow-Origin, so browser fetches from the Vercel-served status page were blocked cross-origin. Add a Vercel rewrite that maps /data/(.*) -> git.moleculesai.app/molecule-ai/molecule-ai-status/raw/branch/main/$1 so the browser only sees same-origin requests; Vercel handles the upstream fetch server-side and returns the body to the browser. Tradeoff - Adds one network hop (browser -> Vercel edge -> Gitea -> Vercel -> browser). Vercel caches per the Cache-Control: public, max-age=60 header on /data/, so steady-state is one upstream hit per minute per file. Acceptable. - Decouples the page from Gitea CORS posture — if/when Gitea ships Access-Control-Allow-Origin headers (probably correct long-term), the page can be flipped back to direct fetch by removing the rewrite. What did NOT change: probe binary, cron, file paths in history/, .upptimerc.yml. The data flow is identical; only the URL the browser uses changed. --- site/app.js | 31 +++++++++++++++---------------- site/vercel.json | 12 ++++++++++++ 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/site/app.js b/site/app.js index 2fa0d85..a4b383e 100644 --- a/site/app.js +++ b/site/app.js @@ -9,12 +9,14 @@ // well is "load fast, show correct status, never lie." React/Vue // would be cargo-culting at this scale. // -// Data source: public Gitea raw URLs. No auth. Repo is public. +// Data source: same-origin /data/* paths, Vercel-rewritten to +// git.moleculesai.app raw URLs. The rewrite avoids cross-origin +// browser fetches (Gitea doesn't send Access-Control-Allow-Origin +// on raw file responses). vercel.json owns the rewrite map. -const REPO_BASE = - "https://git.moleculesai.app/molecule-ai/molecule-ai-status/raw/branch/main"; -const HISTORY_URL = (slug) => `${REPO_BASE}/history/${slug}.jsonl`; -const CONFIG_URL = `${REPO_BASE}/.upptimerc.yml`; +const HISTORY_URL = (slug) => `/data/history/${slug}.jsonl`; +const CONFIG_URL = `/data/.upptimerc.yml`; +const REPO_BROWSE = "https://git.moleculesai.app/molecule-ai/molecule-ai-status"; // Window of history we render in the sparkline (24h of probes at one // per 5 minutes ≈ 288). Cap to keep the DOM bounded if a site has @@ -107,19 +109,15 @@ async function fetchText(url) { // Render a row for one site given its latest results. function renderRow(site, results) { const last = results[results.length - 1]; - const status = !last - ? "unknown" - : last.success - ? "up" - : "down"; - + const status = !last ? "unknown" : last.success ? "up" : "down"; const latency = last && last.success ? `${last.latency_ms} ms` : "—"; // Sparkline: last SPARKLINE_LIMIT entries, one bar per. Bar height // proportional to latency (clamped). Failing checks render red and // taller (so eye is drawn to outages). const recent = results.slice(-SPARKLINE_LIMIT); - const maxLat = Math.max(50, ...recent.filter((r) => r.success).map((r) => r.latency_ms)); + const succ = recent.filter((r) => r.success); + const maxLat = Math.max(50, ...succ.map((r) => r.latency_ms)); const spark = recent .map((r) => { @@ -190,7 +188,7 @@ async function load() { const yaml = await fetchText(CONFIG_URL); if (!yaml) { document.getElementById("grid").innerHTML = - `
Failed to load probe-list config from Gitea. Check that ${CONFIG_URL} is reachable.
`; + `
Failed to load probe-list config. Check that ${CONFIG_URL} is reachable (Vercel rewrites /data/* to ${REPO_BROWSE}/raw/branch/main/$1).
`; document.getElementById("updated").textContent = "load failed"; return; } @@ -212,7 +210,7 @@ async function load() { ); // 3. Render rows + summary. - const rowSummaries = enriched.map(({ site, results }) => { + const rowSummaries = enriched.map(({ results }) => { const last = results[results.length - 1]; return { status: !last ? "unknown" : last.success ? "up" : "down", @@ -233,9 +231,10 @@ async function load() { const latest = allTimestamps.sort().pop(); const ago = Math.round((Date.now() - new Date(latest).getTime()) / 60000); document.getElementById("updated").innerHTML = - `last probe ${ago} min ago · history`; + `last probe ${ago} min ago · history`; } else { - document.getElementById("updated").textContent = "no probe data yet"; + document.getElementById("updated").innerHTML = + `no probe data yet · source`; } } diff --git a/site/vercel.json b/site/vercel.json index 816d0de..977e324 100644 --- a/site/vercel.json +++ b/site/vercel.json @@ -1,6 +1,12 @@ { "version": 2, "name": "molecule-ai-status", + "rewrites": [ + { + "source": "/data/(.*)", + "destination": "https://git.moleculesai.app/molecule-ai/molecule-ai-status/raw/branch/main/$1" + } + ], "headers": [ { "source": "/(.*)", @@ -16,6 +22,12 @@ "headers": [ { "key": "Cache-Control", "value": "public, max-age=60, s-maxage=60" } ] + }, + { + "source": "/data/(.*)", + "headers": [ + { "key": "Cache-Control", "value": "public, max-age=60, s-maxage=60" } + ] } ] } -- 2.45.2