cachegate 1.1.0 → 1.2.0

package/ROADMAP.md

@@ -1,281 +0,0 @@
-# MemoCode Model Router — Roadmap & Review
-
-> Review of `210_apps/001_model_router/` as it stands, and the plan to take it
-> from an internal MemoCode utility to a standalone self-hosted product.
-> Originally written by DeepSeek, 2026-08-23, auditing the version that
-> existed on `deepseek/memocode-chat-and-router` at the time. **Corrected the
-> same day**: that audit's "gaps" section was accurate for the version it was
-> looking at, but a second, much more complete implementation had been built
-> in parallel on `claude/memocode-project-review-v0ohnx` and never merged
-> anywhere shared — neither branch's author knew the other's existed. This
-> file now reflects the merged, actual state. See section 0.
-
-## 0. What happened, so it doesn't happen again
-
-Two independent model-router implementations existed at once: this one
-(minimal - proxy, exact-match cache, provider mapping) on
-`deepseek/memocode-chat-and-router`, and a materially more complete one
-(routing strategies, semantic cache, streaming, JSONL metrics with rotation,
-a cost dashboard, hardened auth, 68 tests) built the same day on
-`claude/memocode-project-review-v0ohnx` - a branch neither this file's
-original audit nor DeepSeek's own semantic-cache attempt knew to check.
-Discovered when the CEO asked to test the semantic cache and DeepSeek,
-checking `master`/`deepseek/memocode-chat-and-router`/
-`claude/session-import-feature`, correctly found it on none of them - but
-hadn't checked the actual branch it lived on. Resolved by replacing this
-directory's contents with the more complete version (a strict superset
-except for this file) and keeping this file's own market/monetization
-analysis, which stands independent of which codebase it's describing.
-**The lesson, not just the fix**: a feature branch that never gets
-merged toward `master` (or at least announced on the coordination board
-with its branch name) is invisible to everyone not already looking at it,
-no matter how complete the work on it is - completeness doesn't substitute
-for discoverability.
-
-## 1. What's actually here (audited 2026-08-23, post-merge)
-
-**Working, tested, pushed** (`210_apps/001_model_router/`, this directory,
-now matching `claude/memocode-project-review-v0ohnx`):
-- `server.js` — Express, OpenAI-compatible `POST /v1/chat/completions`
-  (streaming and non-streaming), internal bearer-key auth (fails CLOSED by
-  default - `ALLOW_INSECURE_LOCAL_DEV=true` required to opt into running
-  without a key), rate limiting, `/health`, `/stats`, `/dashboard`.
-- `providers/anthropic.js` + `providers/openai.js` — request mapping,
-  token/cost estimation, `chatStream()` for SSE.
-- `cache.js` — Redis exact-match cache keyed by a content hash of
-  `{model, messages, temperature, max_tokens, tools, tool_choice}`.
-- `semanticCache.js` + `embeddings.js` — near-duplicate matching via
-  embeddings + cosine similarity over a bounded per-model Redis list
-  (brute-force, not RediSearch/vector-indexed - an honest, documented
-  scale limit, not a hidden one). Tool-calling requests excluded. Semantic
-  hits tracked separately from exact hits in metrics, never blended into
-  one number.
-- `router.js` — three explicit `router:` virtual-model strategies (cost /
-  latency / latency-guarded-cost), no invented blended score.
-- `metrics.js` — JSONL logs with day-rotation, bounded reads, opt-in
-  pruning.
-- `public/dashboard.html` — a real cost dashboard (KPI tiles, charts,
-  auto-refresh, table-view twins), built to this project's own `dataviz`
-  skill standard.
-- 68 tests across 8 test files, all passing.
-- Live: dogfooded by `210_apps/000_backend/chat-import-logic.mjs`
-  (`localhost:4000/v1/chat/completions` for chat segmentation).
-
-**Real remaining gaps** (honest, not "nothing left to do"; updated
-2026-08-29 after re-auditing against the actual code - two of the four
-gaps below turned out to already be closed):
-1. Semantic cache is brute-force cosine over a capped list, not a real
-   vector index - fine at self-hosted single-instance volume, not meant to
-   scale past `SEMANTIC_CACHE_MAX_CANDIDATES` (default 200) per model.
-2. ~~No provider failover on a 5xx/rate-limit~~ **Closed 2026-08-29.**
-   `failover.js` + `server.js`'s non-streaming dispatch path now walk
-   `router.js`'s full ranked-candidate list, retrying the next candidate
-   when one fails for a reason that isn't the request's own fault (a
-   400/404 still fails immediately - retrying elsewhere wouldn't help).
-   Streaming is a deliberate exception, documented inline in
-   `handleStreamingDispatch` - SSE headers and the first frame commit to
-   a model name before a failure could be known, so silent mid-stream
-   provider switching is a materially harder problem, left open rather
-   than shipped half-working.
-3. ~~No persistence layer under the dashboard~~ **Closed** (already true
-   before this pass, just never updated here): `metrics.js` has stored
-   metrics in Postgres since the `feat(model-router): persistent metrics
-   storage via Postgres` commit, with automatic JSONL fallback when no
-   database is configured.
-4. Not yet open-sourced/packaged standalone (Phase 5, section 4 below).
-
-**What this actually is today, said plainly**: working, tested internal
-infrastructure with zero users outside this codebase — not an app, not a
-published package, not a running public service, not something anyone has
-paid for or even tried. Everything from here through section 3 (market
-position, monetization tiers, MRR estimates) describes a *hypothetical*
-product this code could become, not a claim about what it is right now.
-Read it as a plan, not a status report - a CEO challenge on 2026-08-23
-("this is not an app, it's not portable, we build nothing") is a fair
-description of today's reality and is what section 4's Phase 5 (open
-source release) exists to close.
-
-## 2. Honest market position
-
-Do **not** try to out-LiteLLM LiteLLM (140+ providers, Python, huge community)
-or OpenRouter (acquired by Stripe). The winnable niche:
-
-- **Self-hosted first** — prompts/PII never leave your infra.
-- **Semantic cache**, not just exact-match (most OSS options still hash-match).
-- **Node.js/TypeScript** — the JS/TS AI-app crowd is underserved.
-- **Embeddable** — usable as a module inside an existing app before it's sold.
-
-**Correction, same day, on the semantic-cache claim specifically**: verified
-via WebSearch that LiteLLM shipped a real vector-indexed (Valkey-search +
-HNSW) semantic cache in 2026 - more sophisticated than this router's
-brute-force cosine scan. "Semantic cache, not just exact-match" is no longer
-a differentiator against LiteLLM by name, even though it's still true against
-"most OSS options." The honest remaining edges: small/auditable codebase,
-Node-native, and already dogfooded inside a real app.
-
-The sellable, honest claim (do not quote inflated 86–95%): **"Caching alone
-typically saves 20–45%; add routing and it can reach 47–90% on well-tuned
-traffic."** Being the vendor that quotes the real number is the credibility
-edge with the buyer who has been burned by an inflated claim.
-
-## 3. How this router makes money (open-core, honest)
-
-Self-hosted OSS infrastructure monetizes by **open-core**, not by charging for
-the free thing:
-
-| Tier | What | Price | Why someone pays |
-|---|---|---|---|
-| **OSS core (free)** | exact-match cache, 2–3 providers, basic proxy | $0 | top-of-funnel; builds trust |
-| **Pro** | semantic cache, cost-based routing + failover, cost dashboard | $49–99/mo | the "save 40–80% on LLM spend" features; charge ~10–20% of the savings |
-| **Team** | multi-user, SSO, audit log, priority support | $199–499/mo | small teams running production workloads |
-| **Hosted** | we run it for you (no ops) | usage-based, $99–999/mo | teams that don't want to self-host (where LiteLLM makes its money) |
-| **Enterprise** | on-prem, compliance, SLAs | custom | regulated buyers |
-
-**Honest caveats:** OSS → paid conversion is typically 1–5%; the money is in
-the small fraction who want the semantic cache + dashboard and don't want to
-self-host. It is a crowded market. Realistic: **$5–20K MRR in 12 months** by
-owning the self-hosted Node.js niche. The metric that makes it work: a buyer
-spending $1,000/mo on LLM APIs saves $400–800/mo with this — paying $50–100/mo
-for the tool is an easy yes.
-
-## 4. Phases
-
-**Note on an older numbering (added 2026-08-29):** early journal entries
-(2026-08-24) refer to this work as a flat "20-step roadmap" (steps
-13-17 individually named there; 18 marked done but never described; 19
-= the semantic-cache vector-index upgrade, paused; 20 = the standalone
-product). That numbering was never written down as one document - it
-only ever existed as scattered journal references, which made it
-genuinely hard to reconstruct later (confirmed 2026-08-29: step 18's
-actual content couldn't be found anywhere). **The 6 phases below
-supersede that numbering entirely.** If an old "step N" reference ever
-surfaces again, map it here rather than trying to revive the flat list.
-
-### Phase 1 — make what exists real — **done**
-Redis verified end-to-end, honest README, tests (68, not the "no test files"
-this section originally reported), the honest cost claim above.
-
-### Phase 2 — semantic cache — **done**
-Embeddings + cosine similarity, `SEMANTIC_CACHE_THRESHOLD` default 0.93 (this
-section's own original draft proposed ~0.95 - close, tuned during real
-testing; see `semanticCache.js`'s own comment for the reasoning), tool-calls
-excluded, tracked separately from exact-match hits.
-
-### Phase 3 — real routing — **done**
-Three explicit strategies (`router.js`) rather than a single invented
-blended score - cost-ascending, latency-then-cost, and latency-guarded-cost
-(excludes anything too much slower than the fastest known candidate).
-Failover on error for non-streaming requests shipped 2026-08-29
-(`failover.js`) - see section 1, gap 2, for what it does and doesn't cover.
-
-### Phase 4 — cost visibility — **done**
-`metrics.js` (JSONL, day-rotation, bounded reads) + `public/dashboard.html`
-(KPI tiles, charts, auto-refresh, table-view twins).
-
-### Phase 5 — open-source release — not started
-Public GitHub repo → npm package → Docker image → announce (Hacker News,
-r/LocalLLaMA, r/selfhosted, Dev.to). Still the real next milestone - none of
-phases 1-4 being done changes that this hasn't shipped to anyone outside
-this project yet. **Execution plan, added 2026-08-29:**
-[`OPEN_SOURCE_ROADMAP.md`](./OPEN_SOURCE_ROADMAP.md) - the 20-step
-breakdown of everything this one-liner actually requires, written down
-as one document on purpose (see that file's own note on why).
-
-### Phase 6 — hosted tier (only after OSS traction)
-Render/Fly hosted; usage-based pricing.
-
-## 5. One honest caveat on dogfooding
-
-Chat-import's one segmentation call per session is too low-repeat to prove
-the *cache* saves money — it only proves the *proxy* works. **2026-08-23
-update**: `210_apps/000_backend/ai-providers.mjs`'s "Generate with AI" now
-routes through this router too (app's own shared key only, never a
-signed-in user's BYOK key — the router is one shared-secret proxy today,
-not multi-tenant).
-
-**Correction, same day, on how that update was first worded here**: this
-section originally called that traffic "a genuinely more promising source
-of real cache hits" — that was a hunch stated as a finding, and a CEO
-challenge caught it (fair: "what are the odds two people ask the same
-thing" is the right question, and for this app's actual traffic the honest
-answer is "mostly low, and nobody has measured it"). The one real
-structural fact in favor of *some* hits: `ai-providers.mjs` builds that
-prompt as `"Subject: <topic>. Generate about N <label> worth of
-content."` — short and templated, with `topic` the only variable — so two
-different users both studying, say, "the Roman Empire" would produce an
-identical or near-identical request, which chat-import's full conversation
-transcripts basically never do. That's a plausible *mechanism* for a
-non-zero hit rate on a study app whose users cluster around common
-curriculum topics — it is not a measured hit rate, and treating it as one
-would repeat the same mistake. Nobody has looked at MemoCode's actual
-topic distribution. `MODEL_ROUTER_URL` is also still unset in the current
-Render deploy (`render.yaml` declares no router service), so none of this
-runs in production yet regardless.
-
-To validate savings for real, you need either that traffic running through
-the router in production with real measurement, or synthetic load testing
-against a realistic topic distribution — not a plausible-sounding argument
-for why it might work, however structurally reasonable that argument is.
-
-## 6. Two-version architecture (decision 2026-08-23)
-
-One engine (routing + cache + metrics), two wrappers — NOT two codebases:
-
-| | Embedded | Standalone |
-|---|---|---|
-| Lives | inside MemoCode (own process) | its own hosted service (Render) |
-| Keys | you bring Anthropic/OpenAI | it holds keys, issues its own key + URL |
-| Login/billing | none | yes (login, payment, multi-tenancy) |
-| Serves | your apps (fallback) | everybody, including your apps |
-| Status | done — needs Redis + production wiring | future project (OpenRouter/LiteLLM competitor) |
-
-Fallback: apps point at the standalone and drop back to the embedded
-(localhost or MemoCode's own instance) when the standalone is down. Same job,
-so the switch is invisible to the caller. Do NOT fork the router — wrap it:
-same core logic, two thin deployment shells, so the two can never drift apart
-the way the two parallel implementations did (section 0).
-
-The embedded version **stays embedded in each new app** (each app inherits
-this directory as-is) — it is NOT extracted to a shared repo. A shared repo
-means maintaining one router copy per repo plus separate hosting/db, which
-isn't worth it; a new app just copies `210_apps/001_model_router/` into its
-own backend and points `MODEL_ROUTER_URL` at it. The standalone's key+URL are
-left as comments in the app's `.env` as a future reminder, not wired yet.
-
-Sequencing: finish the embedded first (cheap, real, no risk), then decide
-whether to build the standalone's billing layer (the hard, deferred part).
-
-## 7. Embedded — production checklist
-
-1. Hosted Redis (Render Key Value) → set `REDIS_URL`.
-2. Deploy this directory as its own service (or co-locate with the backend).
-   The repo `render.yaml` now declares a `memocode-router` service (Node
-   runtime, `npm ci` + `npm start`) and a `Dockerfile` is included for
-   Docker-based deploys.
-3. Set production env: `MODEL_ROUTER_INTERNAL_KEY` (strong, `openssl rand -hex 32`),
-   `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `REDIS_URL`,
-   `SEMANTIC_CACHE_ENABLED=false` (low-repeat traffic: semantic cache spends
-   an embedding call on every miss for nothing), `ROUTER_STRATEGY=cost`.
-4. Route MemoCode's AI call sites through it via `MODEL_ROUTER_URL`.
-   **Corrected 2026-08-29**: this item previously named "image gen" and
-   "transcription" as call sites to route through the router - checked
-   directly, and that's not actually possible as scoped. The router is an
-   OpenAI-*chat-completions*-compatible proxy only; image generation
-   (`images.generate`) and Whisper transcription
-   (`audio.transcriptions.create`) are different API shapes it doesn't
-   speak. What's actually wired today: chat-import's segmentation call
-   (`chat-import-logic.mjs`) and "Generate with AI" text generation
-   (`ai-providers.mjs`'s `generateStructuredText`), both gated behind
-   `MODEL_ROUTER_URL` being set (`shouldRouteToModelRouter()`). Extending
-   the router to proxy image/audio calls too would be new scope, not a
-   pending item on this checklist.
-5. Verify `/health`, `/dashboard`, `/stats` on production with real traffic.
-
-**Note on items 1 and 3 above (2026-08-29):** `render.yaml` declares the
-env var slots for `REDIS_URL`, `MODEL_ROUTER_INTERNAL_KEY`,
-`ANTHROPIC_API_KEY`, and `OPENAI_API_KEY` (all `sync: false` - filled in
-manually on Render's dashboard), and the metrics Postgres connection is
-wired automatically via `fromDatabase`. Whether those manual slots are
-actually populated with real values on the live Render service isn't
-something a sandboxed session can check - that verification needs
-whoever has the Render dashboard.

package/SECURITY.md

@@ -1,39 +0,0 @@
-# Security Policy
-
-## Reporting a vulnerability
-
-**Please do not open a public GitHub issue for a security
-vulnerability.** A public issue is a disclosure before a fix exists.
-
-Instead, use GitHub's private vulnerability reporting:
-
-1. Go to this repository's **Security** tab.
-2. Click **Report a vulnerability**.
-3. Describe the issue — what it is, how to reproduce it, and its
-   likely impact (e.g. "bypasses auth," "leaks another deployment's
-   cached data," "exhausts memory regardless of rate limiting").
-
-This opens a private conversation with the maintainers, visible only to
-you and them, and lets a fix be prepared and released before the
-vulnerability is public.
-
-*(Maintainer note, remove once live: this requires "Private vulnerability
-reporting" to be turned on for the repository — Settings → Security →
-Private vulnerability reporting — as part of step 15's repo setup.)*
-
-## What counts as a security issue here
-
-Concretely, for this project: anything that lets a request bypass
-`MODEL_ROUTER_INTERNAL_KEY` auth, read or corrupt another deployment's
-cached data or metrics, or exhaust CPU/memory/Redis storage in a way
-`RATE_LIMIT_MAX`/`RATE_LIMIT_WINDOW_MS` doesn't already bound. A
-provider returning an unexpected error, a routing decision you disagree
-with, or a missing feature are regular bugs — open a normal issue for
-those (see `CONTRIBUTING.md`).
-
-## Supported versions
-
-This project is pre-1.0 (see `OPEN_SOURCE_ROADMAP.md` on the version
-plan) — security fixes go into the latest release only. Once a stable
-1.0 line exists, this section will name which major versions still
-receive fixes.

package/sync-oss-release.sh

@@ -1,160 +0,0 @@
-#!/usr/bin/env bash
-#
-# sync-oss-release.sh - mirrors THIS directory's git-tracked files into
-# a checkout of the public cachegate repo, as ONE NEW COMMIT there.
-#
-# See OPEN_SOURCE_ROADMAP.md step 11 for why this direction (this
-# monorepo directory is the source of truth, not the public repo) and
-# step 1 for why the ONE-TIME initial extraction (step 16) uses fresh,
-# curated history. This script is different from that: it's what runs
-# on every sync AFTER the initial extraction, and it does NOT rewrite
-# history - it adds a single normal commit on top of whatever the
-# target repo already has, exactly like any other change to that repo.
-# Rewriting history on every sync would break clones, forks, and
-# in-flight PRs on the public side; that's not what this does.
-#
-# This is a MIRROR, not a merge: after syncing, the target's tracked
-# files exactly match this directory's. A file that exists only in the
-# target (added directly on GitHub, not here) gets REMOVED on sync.
-# That's deliberate - if a file should persist in the public repo, add
-# it here, in the monorepo, since this directory is the source of truth
-# (see step 11). This script will refuse to run against a target that
-# isn't a git repository, specifically so an accidental wipe of some
-# unrelated directory can't happen by pointing this at the wrong path.
-#
-# Usage:
-#   ./sync-oss-release.sh <path-to-public-repo-checkout> [--version X.Y.Z]
-#
-# What it does, in order:
-#   1. Refuses to run if the secrets scan (same patterns as the manual
-#      step-3 audit: API key shapes, email addresses) finds anything in
-#      this directory's tracked files - loud failure, nothing touched,
-#      rather than a quiet publish of a leak.
-#   2. If --version is given, bumps THIS directory's own package.json
-#      to that version first, so the synced copy carries it too. Omits
-#      this by default - the script doesn't invent a version-bump
-#      policy on its own (see step 6's deferred semver plan); a
-#      no-flag run is a plain resync at whatever version is already
-#      set (e.g. reapplying a cherry-picked external PR - see
-#      CONTRIBUTING.md's note on that flow).
-#   3. Mirrors every git-tracked file from this directory into the
-#      target checkout (removes everything else from the target's
-#      working tree first, except its own .git/) - a file removed here
-#      also disappears there, never a manual, error-prone diff to keep
-#      in sync by hand.
-#   4. Commits in the TARGET repo (one new commit, normal history).
-#      Does NOT push - pushing is a deliberate, separate, human/CI step.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-TARGET=""
-NEW_VERSION=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --version)
-      NEW_VERSION="$2"
-      shift 2
-      ;;
-    *)
-      if [[ -z "$TARGET" ]]; then
-        TARGET="$1"
-        shift
-      else
-        echo "Unexpected extra argument: $1" >&2
-        exit 1
-      fi
-      ;;
-  esac
-done
-
-if [[ -z "$TARGET" ]]; then
-  echo "Usage: $0 <path-to-public-repo-checkout> [--version X.Y.Z]" >&2
-  exit 1
-fi
-
-if [[ ! -d "$TARGET/.git" ]]; then
-  echo "❌ Refusing to run: $TARGET is not a git repository (no .git/ found)." >&2
-  echo "   This is deliberate - pointing this at the wrong path would wipe it." >&2
-  exit 1
-fi
-
-TARGET="$(cd "$TARGET" && pwd)"
-
-echo "🔍 Step 1/4: scanning tracked files for secrets before touching anything..."
-# Same shape of check as step 3's manual audit: API key patterns and
-# email addresses, restricted to git-tracked files only (never
-# node_modules, .env, data/ - those aren't tracked, so git ls-files
-# already excludes them).
-SECRET_HIT=0
-while IFS= read -r -d '' file; do
-  if grep -qE "sk-[a-zA-Z0-9_-]{20,}|AIza[0-9A-Za-z_-]{20,}|xai-[a-zA-Z0-9_-]{20,}" "$file" 2>/dev/null; then
-    echo "  ❌ Possible API key in $file" >&2
-    SECRET_HIT=1
-  fi
-  if grep -qE "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}" "$file" 2>/dev/null; then
-    # .env.example intentionally has no real emails; this still flags
-    # anything matching the shape so a human confirms it's a placeholder.
-    match=$(grep -oE "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}" "$file" | grep -v -E "example\.com|your-|@anthropic\.com" || true)
-    if [[ -n "$match" ]]; then
-      echo "  ⚠️  Email-shaped string in $file: $match (confirm this is a placeholder, not real)" >&2
-      SECRET_HIT=1
-    fi
-  fi
-done < <(git ls-files -z)
-
-if [[ "$SECRET_HIT" -eq 1 ]]; then
-  echo "❌ Aborting sync - resolve the findings above first. Nothing was copied." >&2
-  exit 1
-fi
-echo "  ✅ Clean."
-
-if [[ -n "$NEW_VERSION" ]]; then
-  echo "🔢 Step 2/4: bumping package.json to $NEW_VERSION..."
-  node -e "
-    const fs = require('fs');
-    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-    pkg.version = process.argv[1];
-    fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
-  " "$NEW_VERSION"
-  echo "  ✅ package.json now at $NEW_VERSION."
-else
-  echo "🔢 Step 2/4: no --version given, leaving package.json's version as-is."
-fi
-
-echo "📦 Step 3/4: mirroring tracked files into $TARGET..."
-# Wipe the target's working tree except .git/, then copy this
-# directory's tracked files in - guarantees the target ends up an
-# EXACT mirror, not an accumulation of whatever used to be there.
-find "$TARGET" -mindepth 1 -maxdepth 1 -not -name ".git" -exec rm -rf {} +
-
-while IFS= read -r -d '' file; do
-  dest="$TARGET/$file"
-  mkdir -p "$(dirname "$dest")"
-  cp "$file" "$dest"
-done < <(git ls-files -z)
-
-echo "  ✅ Copied $(git ls-files | wc -l | tr -d ' ') tracked files."
-
-echo "💾 Step 4/4: committing in the target repo (not pushing)..."
-SOURCE_SHA="$(git rev-parse --short HEAD)"
-(
-  cd "$TARGET"
-  git add -A
-  if git diff --cached --quiet; then
-    echo "  ℹ️  Nothing changed - target already matches this directory. No commit made."
-  else
-    git commit -m "Sync from internal monorepo @ ${SOURCE_SHA}
-
-Mirrors 210_apps/001_model_router/ as of that commit. This commit was
-generated by sync-oss-release.sh, not written by hand - see
-OPEN_SOURCE_ROADMAP.md step 11 in the source repo for why this
-direction (monorepo -> public repo, not the reverse)."
-    echo "  ✅ Committed. Review with 'git show' in $TARGET, then push when ready - this script never pushes."
-  fi
-)
-
-echo "✅ Sync complete."

package/test/auth-config.test.js

@@ -1,27 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-
-// server.js reads its env vars once at require time, so each case here
-// resets env + require cache before requiring fresh.
-function freshServer(env) {
-  delete process.env.MODEL_ROUTER_INTERNAL_KEY;
-  delete process.env.ALLOW_INSECURE_LOCAL_DEV;
-  Object.assign(process.env, env);
-  delete require.cache[require.resolve('../server')];
-  return require('../server');
-}
-
-test('isAuthConfigured() is false with neither key nor opt-in set', () => {
-  const { isAuthConfigured } = freshServer({});
-  assert.equal(isAuthConfigured(), false);
-});
-
-test('isAuthConfigured() is true once MODEL_ROUTER_INTERNAL_KEY is set', () => {
-  const { isAuthConfigured } = freshServer({ MODEL_ROUTER_INTERNAL_KEY: 'some-key' });
-  assert.equal(isAuthConfigured(), true);
-});
-
-test('isAuthConfigured() is true with the explicit insecure opt-in, even with no key', () => {
-  const { isAuthConfigured } = freshServer({ ALLOW_INSECURE_LOCAL_DEV: 'true' });
-  assert.equal(isAuthConfigured(), true);
-});

package/test/cache.test.js

@@ -1,33 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const cache = require('../cache');
-
-test('buildCacheKey is deterministic for identical payloads', () => {
-  const payload = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hi' }] };
-  assert.equal(cache.buildCacheKey(payload), cache.buildCacheKey({ ...payload }));
-});
-
-test('buildCacheKey differs when messages differ', () => {
-  const a = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hi' }] };
-  const b = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'bye' }] };
-  assert.notEqual(cache.buildCacheKey(a), cache.buildCacheKey(b));
-});
-
-test('buildCacheKey differs when model differs, same messages', () => {
-  const messages = [{ role: 'user', content: 'hi' }];
-  const a = { model: 'gpt-4o-mini', messages };
-  const b = { model: 'claude-haiku-4-5-20251001', messages };
-  assert.notEqual(cache.buildCacheKey(a), cache.buildCacheKey(b));
-});
-
-test('buildCacheKey treats an unset temperature the same as 0.0 (documented default)', () => {
-  const a = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hi' }] };
-  const b = { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hi' }], temperature: 0.0 };
-  assert.equal(cache.buildCacheKey(a), cache.buildCacheKey(b));
-});
-
-test('isConnected() is false with no REDIS_URL configured', () => {
-  // This test suite never sets REDIS_URL, matching the documented
-  // graceful-degradation path (cache disabled, not crashed).
-  assert.equal(cache.isConnected(), false);
-});

package/test/embeddings.test.js

@@ -1,24 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-
-function freshEmbeddings(env) {
-  delete process.env.OPENAI_API_KEY;
-  Object.assign(process.env, env);
-  delete require.cache[require.resolve('../embeddings')];
-  return require('../embeddings');
-}
-
-test('isEnabled() is false with no OPENAI_API_KEY', () => {
-  const embeddings = freshEmbeddings({});
-  assert.equal(embeddings.isEnabled(), false);
-});
-
-test('isEnabled() is true once OPENAI_API_KEY is set', () => {
-  const embeddings = freshEmbeddings({ OPENAI_API_KEY: 'sk-test-fake' });
-  assert.equal(embeddings.isEnabled(), true);
-});
-
-test('embed() rejects clearly when disabled, without attempting a network call', async () => {
-  const embeddings = freshEmbeddings({});
-  await assert.rejects(() => embeddings.embed('hello'), /OPENAI_API_KEY not configured/);
-});

package/test/env-path.test.js

@@ -1,41 +0,0 @@
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('path');
-
-// server.js reads its env vars once at require time; set a key so
-// requiring it here never trips the fail-closed check for unrelated
-// reasons (resolveEnvPathFromArgv itself doesn't touch env at all).
-process.env.MODEL_ROUTER_INTERNAL_KEY = 'test-internal-key';
-
-const { resolveEnvPathFromArgv } = require('../server');
-
-test('resolveEnvPathFromArgv returns undefined when --env-path is absent - default cwd behavior unchanged', () => {
-  const argv = ['node', 'server.js'];
-  assert.equal(resolveEnvPathFromArgv(argv), undefined);
-});
-
-test('resolveEnvPathFromArgv resolves a space-separated --env-path value', () => {
-  const argv = ['node', 'server.js', '--env-path', './router/.env'];
-  assert.equal(resolveEnvPathFromArgv(argv), path.resolve('./router/.env'));
-});
-
-test('resolveEnvPathFromArgv resolves an --env-path=value (equals) form', () => {
-  const argv = ['node', 'server.js', '--env-path=./router/.env'];
-  assert.equal(resolveEnvPathFromArgv(argv), path.resolve('./router/.env'));
-});
-
-test('resolveEnvPathFromArgv resolves an absolute path unchanged', () => {
-  const absolute = path.resolve('/tmp/some/other/.env');
-  const argv = ['node', 'server.js', '--env-path', absolute];
-  assert.equal(resolveEnvPathFromArgv(argv), absolute);
-});
-
-test('resolveEnvPathFromArgv returns undefined if --env-path is the last arg with no value after it', () => {
-  const argv = ['node', 'server.js', '--env-path'];
-  assert.equal(resolveEnvPathFromArgv(argv), undefined);
-});
-
-test('resolveEnvPathFromArgv is unaffected by other, unrelated flags', () => {
-  const argv = ['node', 'server.js', '--some-other-flag', '--env-path', './x/.env'];
-  assert.equal(resolveEnvPathFromArgv(argv), path.resolve('./x/.env'));
-});