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.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
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.mddeleted file mode 100644index 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.jsnew file mode 100644index 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');+ });+});