Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

test(v1-market): pin that a rejected aixbt key answers 503, not the caller's 401

nirholas53199caa9825
diff --git a/prompts/swarm-100/api-v1-02.md b/prompts/swarm-100/api-v1-02.md
deleted file mode 100644
index 1d6a440bf..000000000
--- a/prompts/swarm-100/api-v1-02.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# API audit: api/v1 batch 02 (10 files)
-
-How to run: paste this file's repo path into a fresh Claude Code chat in this
-repository and say "run this work order". This file is fully self-contained:
-it depends on no other prompt file anywhere. If neighboring files in
-prompts/swarm-100/ are gone, that work is done; if present, ignore them.
-Every claim below rots; step 0 re-measures, and what you measure wins.
-
-## Operating clause (binding)
-
-- Read CLAUDE.md first. Its rules override everything, including this file.
-- Finish 100% in this session. Never end the turn with a question, an option
- list, or an unexecuted plan. A judgment call goes in one line of the final
- report; it never becomes a question that halts work.
-- The only permitted stops are the CLAUDE.md stop-and-ask gates: spending real
- funds or any irreversible on-chain write, git push or a production deploy,
- committing content that references a crypto project other than $THREE, and
- destroying unrecoverable data.
-- No mocks, no fake data, no placeholder stubs, no unfinished-work markers, no
- commented-out code. Real APIs and real integrations only.
-- The em-dash and en-dash characters are banned in everything you write.
-- Concurrent agents share this worktree: stage explicit paths only (never a
- bare add-everything), and commit finished work promptly.
-- Before committing, run: npm run check:rules -- --paths <files you touched>.
- It must exit 0.
-
-## Step 0: re-derive the current state
-
-1. Confirm each file below still exists; deleted ones are done, skip them.
-2. For each, decide routability: grep its path in vercel.json and read how
- server/index.mjs maps filesystem handlers. Routed files get an endpoint
- audit; internal modules get a code and test audit.
-3. Start a local server for endpoint checks: node server/index.mjs with .env
- loaded, on a free PORT if 3000 is busy.
-
-## Task: audit these api files, then fix everything found
-
-Files in this batch:
-
-- api/v1/index.js
-- api/v1/market/intel.js
-- api/v1/market/projects.js
-- api/v1/pump/curve.js
-- api/v1/pump/launches.js
-- api/v1/pump/search.js
-- api/v1/pump/trending.js
-- api/v1/pump/whales.js
-- api/v1/resolve.js
-- api/v1/robinhood/chain.js
-
-For every routed handler:
-
-1. Exercise it with curl against the local server: the success path returns
- real data with the correct status; malformed input returns a 4xx JSON
- error, never a stack trace or an HTML error page; auth is enforced where
- the code intends it; CORS matches neighboring handlers.
-2. Hard-rule scan: no mock fallbacks, no fake-data arrays, no stubbed
- responses, no unfinished markers. Errors are handled at the boundary and
- internal code trusts itself.
-3. Do not spend funds or sign anything on-chain while probing. Payment and
- trading handlers get their validation and error paths exercised, never a
- live settlement.
-
-For every internal (non-routed) module:
-
-4. Something must import it; if nothing does, delete it as dead code (verify
- with a repo-wide grep first).
-5. Its main path and one failure path must be covered in tests/; add the
- missing test if not.
-
-## Definition of done
-
-- [ ] Every listed file has recorded evidence: a curl transcript for routed
- handlers, a passing test or a deletion for internal modules.
-- [ ] Zero hard-rule violations remain in these files.
-- [ ] vitest run passes; npm run check:rules -- --paths <touched files>
- exits 0.
-
-## Never blocked
-
-| Blocker | Resolution (act, do not ask) |
-|---|---|
-| Missing env var or credential | Check .env and .env.local, then the Cloud Run service env, then Secret Manager (the CLAUDE.md self-unblock playbook has the exact commands). If it truly exists nowhere, wire the code fully behind the env var, prove the wiring with a dry run, and name the single missing var in the report. |
-| gcloud not on PATH | Run: export PATH="$HOME/google-cloud-sdk/bin:$PATH" |
-| Dev server port 3000 busy | Another agent may be serving this repo; probe it and reuse if so. Otherwise start your own on a free port: npx vite --port 3101 |
-| Playwright browser missing | npx playwright install chromium |
-| A surface needs a signed-in user | Register a fresh account through the real /register flow against the real API and use it. Never mock the session. |
-| A defect sits in code you did not touch | Fix it if it blocks a Definition of done line (root cause it, never mask it). Otherwise note it in the report and continue. |
-| An unrelated test is red | Same rule. Never pipe npm test through tail; it masks exit codes. |
-
-## Close out (required)
-
-1. Verify every Definition of done line with the actual command output in
- front of you. Never claim a line you did not verify.
-2. Commit with explicit paths and a subject that describes the diff (house
- style: type(scope): what changed and why a reader cares).
-3. Delete this prompt file in that same commit:
-
- git rm prompts/swarm-100/api-v1-02.md
-
- The shrinking directory is this campaign's only progress ledger; there is
- no progress log to update.
-4. Final report: what step 0 measured, what changed (file list), evidence per
- Definition of done line, and any one-line judgment calls. No trailing
- questions, no unexecuted plans.
-
-If a line genuinely cannot pass inside this session (an external party must
-respond, or an owner-gated action is the final step), finish everything else,
-leave this file in place, and state exactly which line remains and who owns
-it. Never delete this file on a partial.
diff --git a/tests/api/v1-market.test.js b/tests/api/v1-market.test.js
new file mode 100644
index 000000000..e03badfbc
--- /dev/null
+++ b/tests/api/v1-market.test.js
@@ -0,0 +1,179 @@
+// GET /api/v1/market/{intel,projects}: the two aixbt-backed reads under the
+// versioned /api/v1 surface.
+//
+// Both doors take NO client credential: the deployment holds the upstream key.
+// So the case that matters most here is whose fault a failure is. When aixbt
+// stopped accepting our key, these two handlers relayed its raw 401 with its
+// own wording, which reads to an agent as "your credentials were rejected" and
+// sends it into a re-auth loop it can never win, while the older /api/aixbt/*
+// doors had long since classified that as a 503 deployment fault. The
+// classification now lives in one shared place (api/_lib/aixbt.js
+// `mapAixbtFailure`, unit-pinned in tests/aixbt-failure-map.test.js); these
+// cases pin that the v1 doors actually answer through it.
+//
+// The upstream client is mocked at the module boundary with the exact error
+// shape api/_lib/aixbt.js throws, so no network call is made.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Readable } from 'node:stream';
+
+let globalQuotaOk = true;
+vi.mock('../../api/_lib/rate-limit.js', () => ({
+ limits: {
+ apiV1: async () => ({ success: true, limit: 120, remaining: 119, reset: Date.now() + 60_000 }),
+ aixbtGlobal: async () =>
+ globalQuotaOk
+ ? { success: true, limit: 300, remaining: 299, reset: Date.now() + 60_000 }
+ : { success: false, limit: 300, remaining: 0, reset: Date.now() + 60_000 },
+ },
+ clientIp: () => '203.0.113.12',
+}));
+
+let intelImpl = async () => ({ intel: [], pagination: null });
+let projectsImpl = async () => ({ projects: [], pagination: null });
+vi.mock('../../api/_lib/aixbt.js', async (importActual) => {
+ const actual = await importActual();
+ return {
+ ...actual,
+ // The classifier stays REAL: it is the behavior under test.
+ aixbtEnabled: () => true,
+ getIntel: (...a) => intelImpl(...a),
+ getProjects: (...a) => projectsImpl(...a),
+ };
+});
+
+/** The shape api/_lib/aixbt.js throws for a non-2xx upstream response. */
+function upstreamError(message, status, code) {
+ return Object.assign(new Error(message), { status, code });
+}
+
+beforeEach(() => {
+ globalQuotaOk = true;
+ intelImpl = async () => ({ intel: [], pagination: null });
+ projectsImpl = async () => ({ projects: [], pagination: null });
+});
+afterEach(() => {
+ vi.restoreAllMocks();
+});
+
+function makeReq({ url, host = 'three.ws' } = {}) {
+ const stream = Readable.from([]);
+ stream.method = 'GET';
+ stream.url = url;
+ stream.headers = { host };
+ return stream;
+}
+
+function makeRes() {
+ return {
+ statusCode: 200,
+ _h: {},
+ writableEnded: false,
+ headersSent: false,
+ setHeader(k, v) { this._h[k.toLowerCase()] = v; },
+ getHeader(k) { return this._h[k.toLowerCase()]; },
+ end(body) { this._body = body; this.writableEnded = true; },
+ };
+}
+
+async function dispatch(modulePath, url) {
+ const mod = await import(modulePath);
+ const res = makeRes();
+ await mod.default(makeReq({ url }), res);
+ return { res, body: res._body ? JSON.parse(res._body) : null };
+}
+
+const DOORS = [
+ {
+ label: 'intel',
+ module: '../../api/v1/market/intel.js',
+ url: '/api/v1/market/intel?limit=2',
+ set: (fn) => { intelImpl = fn; },
+ ok: () => ({
+ intel: [{ category: 'narrative', description: 'real-shaped item', source: 'aixbt' }],
+ pagination: { limit: 2, page: 1 },
+ }),
+ key: 'intel',
+ },
+ {
+ label: 'projects',
+ module: '../../api/v1/market/projects.js',
+ url: '/api/v1/market/projects?limit=2',
+ set: (fn) => { projectsImpl = fn; },
+ ok: () => ({
+ projects: [{ id: 'three-ws', name: 'three.ws', ticker: 'THREE', source: 'aixbt' }],
+ pagination: { limit: 2, page: 1 },
+ }),
+ key: 'projects',
+ },
+];
+
+describe.each(DOORS)('GET /api/v1/market/$label', (door) => {
+ it('returns the upstream rows with the source named', async () => {
+ door.set(async () => door.ok());
+ const { res, body } = await dispatch(door.module, door.url);
+ expect(res.statusCode).toBe(200);
+ expect(body.data[door.key]).toHaveLength(1);
+ expect(body.data.source).toBe('aixbt');
+ expect(body.data.pagination).toEqual({ limit: 2, page: 1 });
+ });
+
+ for (const status of [401, 403]) {
+ it(`answers a ${status} from aixbt as a 503, never as the caller's auth failure`, async () => {
+ door.set(async () => {
+ throw upstreamError(`aixbt /${door.key} failed: Unauthorized`, status, 'aixbt_unauthorized');
+ });
+ const { res, body } = await dispatch(door.module, door.url);
+ // The regression: this used to be relayed verbatim as a 401 on a door
+ // that takes no client credential.
+ expect(res.statusCode).toBe(503);
+ expect(body.error).toBe('aixbt_unauthorized');
+ expect(body.error_description).toMatch(/deployment key/);
+ expect(body.error_description).not.toMatch(/Unauthorized/);
+ });
+ }
+
+ it('relays upstream throttling as a 429 the caller can back off from', async () => {
+ door.set(async () => {
+ throw upstreamError('aixbt rate limit exceeded', 429, 'aixbt_rate_limited');
+ });
+ const { res, body } = await dispatch(door.module, door.url);
+ expect(res.statusCode).toBe(429);
+ expect(body.error).toBe('aixbt_rate_limited');
+ });
+
+ it('relays an upstream outage as a 504 instead of a blank internal error', async () => {
+ door.set(async () => {
+ throw upstreamError('aixbt unreachable: fetch failed', 504, 'aixbt_upstream_error');
+ });
+ const { res, body } = await dispatch(door.module, door.url);
+ expect(res.statusCode).toBe(504);
+ expect(body.error).toBe('aixbt_upstream_error');
+ });
+
+ it('sanitizes an internal fault instead of leaking it', async () => {
+ door.set(async () => {
+ throw new TypeError('cannot read properties of undefined');
+ });
+ const { res, body } = await dispatch(door.module, door.url);
+ expect(res.statusCode).toBe(500);
+ expect(body.error).toBe('internal_error');
+ expect(res._body).not.toContain('cannot read properties');
+ });
+
+ it('429s when the shared per-deployment aixbt ceiling is spent', async () => {
+ globalQuotaOk = false;
+ door.set(async () => door.ok());
+ const { res, body } = await dispatch(door.module, door.url);
+ expect(res.statusCode).toBe(429);
+ expect(body.error).toBe('rate_limited');
+ });
+
+ it('never lets an error response be cached', async () => {
+ door.set(async () => {
+ throw upstreamError('aixbt down', 502, 'aixbt_upstream_error');
+ });
+ const { res } = await dispatch(door.module, door.url);
+ expect(res.getHeader('cache-control')).toBe('no-store');
+ });
+});