@rubytech/create-maxy-code 0.1.459 → 0.1.460

package/payload/platform/plugins/cloudflare/mcp/__tests__/authorize.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest'
+import {
+  SESSION_COOKIE,
+  SESSION_TTL_MS,
+  mintSession,
+  resolveSession,
+  readSessionCookie,
+} from '../../skills/data-portal/template/functions/api/_lib/session'
+import {
+  ownerPrefix,
+  authorizeKey,
+} from '../../skills/data-portal/template/functions/api/_lib/authorize'
+import type { D1Database } from '../../skills/data-portal/template/functions/api/_lib/types'
+
+// Models the real resolveSession query: sessions JOIN people, requiring the
+// session's pcCheck to still match substr(people.hash, 1, 16). A fake that
+// skipped the join would let the revocation tests below pass vacuously.
+function fakeDb(
+  seed: Array<{ sessionId: string; ownerId: string; pcCheck: string; expiresAt: number }> = [],
+  people: Array<{ ownerId: string; hash: string }> = [{ ownerId: 'alice', hash: 'HASH-v1-padded00' }],
+) {
+  const rows = [...seed]
+  const peopleRows = [...people]
+  const db: D1Database = {
+    prepare(query: string) {
+      let bound: unknown[] = []
+      const stmt = {
+        bind(...v: unknown[]) {
+          bound = v
+          return stmt
+        },
+        async run() {
+          if (/INSERT INTO sessions/i.test(query)) {
+            const [sessionId, ownerId, pcCheck, expiresAt] = bound as [string, string, string, number]
+            rows.push({ sessionId, ownerId, pcCheck, expiresAt })
+          }
+          if (/DELETE FROM sessions/i.test(query)) {
+            const [ownerId, nowMs] = bound as [string, number]
+            for (let i = rows.length - 1; i >= 0; i--) {
+              if (rows[i].ownerId === ownerId && rows[i].expiresAt <= nowMs) rows.splice(i, 1)
+            }
+          }
+          return { meta: { changes: 1 } }
+        },
+        async all() {
+          return { results: [] }
+        },
+        async first<T>() {
+          const [sessionId, nowMs] = bound as [string, number]
+          const hit = rows.find((r) => r.sessionId === sessionId && r.expiresAt > nowMs)
+          if (!hit) return null as T | null
+          const person = peopleRows.find((p) => p.ownerId === hit.ownerId)
+          if (!person) return null as T | null // unenrolled -> the JOIN drops it
+          if (person.hash.slice(0, 16) !== hit.pcCheck) return null as T | null // rotated
+          return { ownerId: hit.ownerId } as T
+        },
+      }
+      return stmt
+    },
+  }
+  return { db, rows, peopleRows }
+}
+
+const PC = 'HASH-v1-padded00'.slice(0, 16)
+
+describe('sessions', () => {
+  it('mints a session resolvable to its owner', async () => {
+    const { db } = fakeDb()
+    await mintSession(db, 'alice', 'sess-1', 1_000_000, PC)
+    expect(await resolveSession(db, 'sess-1', 1_000_000)).toEqual({ ownerId: 'alice' })
+  })
+
+  it('does not resolve an expired session', async () => {
+    const { db } = fakeDb()
+    await mintSession(db, 'alice', 'sess-1', 1_000_000, PC)
+    expect(await resolveSession(db, 'sess-1', 1_000_000 + SESSION_TTL_MS + 1)).toBeNull()
+  })
+
+  it('does not resolve an unknown session', async () => {
+    const { db } = fakeDb()
+    expect(await resolveSession(db, 'nope', 1_000_000)).toBeNull()
+  })
+
+  it('prunes that owner expired rows on mint, so sessions do not grow forever', async () => {
+    const { db, rows } = fakeDb([
+      { sessionId: 'old', ownerId: 'alice', pcCheck: PC, expiresAt: 1 },
+    ])
+    await mintSession(db, 'alice', 'sess-1', 1_000_000, PC)
+    expect(rows.map((r) => r.sessionId)).toEqual(['sess-1'])
+  })
+})
+
+describe('session revocation — the property the design claims', () => {
+  it('stops resolving once the passcode is rotated', async () => {
+    // The whole reason a leaked passcode has a remedy. Rotation changes
+    // people.hash, so pcCheck no longer matches and the live session dies —
+    // by construction, not by remembering to delete anything.
+    const { db, peopleRows } = fakeDb()
+    await mintSession(db, 'alice', 'sess-1', 1_000_000, PC)
+    expect(await resolveSession(db, 'sess-1', 1_000_000)).toEqual({ ownerId: 'alice' })
+
+    peopleRows[0].hash = 'HASH-v2-rotated0' // operator re-runs enrolment
+
+    expect(await resolveSession(db, 'sess-1', 1_000_000)).toBeNull()
+  })
+
+  it('stops resolving once the person is unenrolled', async () => {
+    const { db, peopleRows } = fakeDb()
+    await mintSession(db, 'alice', 'sess-1', 1_000_000, PC)
+    peopleRows.length = 0
+    expect(await resolveSession(db, 'sess-1', 1_000_000)).toBeNull()
+  })
+})
+
+describe('readSessionCookie', () => {
+  it('reads the portal session cookie', () => {
+    expect(readSessionCookie('__Host-__portal_session=abc123')).toBe('abc123')
+  })
+  it('reads it from among other cookies', () => {
+    expect(readSessionCookie('foo=1; __Host-__portal_session=abc123; bar=2')).toBe('abc123')
+  })
+  it('is null when absent', () => {
+    expect(readSessionCookie('foo=1')).toBeNull()
+  })
+  it('is null when the header is absent', () => {
+    expect(readSessionCookie(null)).toBeNull()
+  })
+  it('does not match a lookalike cookie name', () => {
+    expect(readSessionCookie('x__Host-__portal_session=abc123')).toBeNull()
+  })
+  it('uses the __Host- prefix, which forbids a Domain attribute', () => {
+    // Without the prefix, a cookie set on a sibling subdomain with
+    // Domain=.example.com reaches this host and can shadow the real session,
+    // so a victim uploads into the attacker's prefix. The prefix is the only
+    // thing browsers enforce that against, and we already meet its
+    // preconditions (Secure, Path=/, no Domain).
+    expect(SESSION_COOKIE.startsWith('__Host-')).toBe(true)
+  })
+  it('keeps scanning past a valueless duplicate rather than returning null', () => {
+    // An attacker-planted empty cookie sorted first must not blank the real
+    // session — that is a persistent logout denial-of-service.
+    expect(readSessionCookie('__Host-__portal_session=; __Host-__portal_session=real')).toBe('real')
+  })
+})
+
+describe('authorizeKey — the isolation rule', () => {
+  it('allows a key under the owner prefix', () => {
+    expect(authorizeKey('alice', 'alice/invoice.pdf')).toBe(true)
+  })
+
+  it('denies another owner prefix', () => {
+    expect(authorizeKey('alice', 'bob/invoice.pdf')).toBe(false)
+  })
+
+  it('denies a traversal escape', () => {
+    expect(authorizeKey('alice', 'alice/../bob/invoice.pdf')).toBe(false)
+  })
+
+  it('denies a prefix that merely starts with the owner id', () => {
+    // 'alice' must not authorize 'alice-evil/...': a startsWith check on the
+    // bare id would pass this. The separator is part of the rule.
+    expect(authorizeKey('alice', 'alice-evil/invoice.pdf')).toBe(false)
+  })
+
+  it('denies a bare key with no prefix', () => {
+    expect(authorizeKey('alice', 'invoice.pdf')).toBe(false)
+  })
+
+  it('denies an absolute-looking key', () => {
+    expect(authorizeKey('alice', '/alice/invoice.pdf')).toBe(false)
+  })
+
+  it('denies an empty key', () => {
+    expect(authorizeKey('alice', '')).toBe(false)
+  })
+
+  // authorizeKey's correctness silently depends on ownerId containing no
+  // separator. If two people were ever enrolled as 'alice' and 'alice/2024',
+  // then 'alice/2024/x.pdf' starts with 'alice/' and alice reads the other
+  // person's files. Enrolment is an agent writing rows, so the invariant
+  // cannot rest on the skill's prose — enforce it at the gate.
+  it('denies when the ownerId itself contains a separator', () => {
+    expect(authorizeKey('alice/2024', 'alice/2024/invoice.pdf')).toBe(false)
+  })
+
+  it('denies an ownerId outside [a-z0-9-], failing closed', () => {
+    for (const bad of ['alice/2024', 'Alice', 'alice..', 'alice bob', '../alice', 'alice%2f']) {
+      expect(authorizeKey(bad, `${bad}/invoice.pdf`)).toBe(false)
+    }
+  })
+
+  it('still allows a well-formed ownerId', () => {
+    expect(authorizeKey('alice-smith-2', 'alice-smith-2/invoice.pdf')).toBe(true)
+  })
+})
+
+describe('ownerPrefix', () => {
+  it('is the owner id plus a separator', () => {
+    expect(ownerPrefix('alice')).toBe('alice/')
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/file-routes.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest'
+import { processFiles } from '../../skills/data-portal/template/functions/api/files'
+import { processDownload } from '../../skills/data-portal/template/functions/api/download'
+import { processDelete } from '../../skills/data-portal/template/functions/api/delete'
+import type { PortalEnv } from '../../skills/data-portal/template/functions/api/_lib/types'
+
+// alice's session is 'sess-a'; bob owns 'bob/secret.pdf'.
+function makeEnv() {
+  const manifest = [
+    { fileId: 'f1', ownerId: 'alice', filename: 'a.pdf', objectKey: 'alice/a.pdf', size: 10 },
+    { fileId: 'f2', ownerId: 'bob', filename: 'secret.pdf', objectKey: 'bob/secret.pdf', size: 20 },
+  ]
+  const objects = new Map<string, string>([
+    ['alice/a.pdf', 'A'],
+    ['bob/secret.pdf', 'B'],
+  ])
+  const deleted: string[] = []
+  const env = {
+    DB: {
+      prepare(query: string) {
+        let bound: unknown[] = []
+        const stmt = {
+          bind(...v: unknown[]) {
+            bound = v
+            return stmt
+          },
+          async run() {
+            if (/DELETE FROM manifest/i.test(query)) {
+              const i = manifest.findIndex((m) => m.objectKey === bound[0])
+              if (i >= 0) manifest.splice(i, 1)
+            }
+            return { meta: { changes: 1 } }
+          },
+          async all<T>() {
+            const owner = bound[0] as string
+            return { results: manifest.filter((m) => m.ownerId === owner) as T[] }
+          },
+          async first<T>() {
+            if (/FROM sessions/i.test(query)) {
+              const map: Record<string, string> = { 'sess-a': 'alice', 'sess-b': 'bob' }
+              const owner = map[bound[0] as string]
+              return (owner ? { ownerId: owner } : null) as T | null
+            }
+            return (manifest.find((m) => m.objectKey === bound[0]) ?? null) as T | null
+          },
+        }
+        return stmt
+      },
+    },
+    BUCKET: {
+      async get(key: string) {
+        const v = objects.get(key)
+        return v ? { body: null, size: v.length } : null
+      },
+      async delete(key: string) {
+        deleted.push(key)
+        objects.delete(key)
+      },
+      async put() {
+        return {}
+      },
+      async head(key: string) {
+        const v = objects.get(key)
+        return v ? { size: v.length } : null
+      },
+    },
+  } as unknown as PortalEnv
+  return { env, deleted, manifest, objects }
+}
+
+describe('processFiles', () => {
+  it("lists only the session owner's files", async () => {
+    const { env } = makeEnv()
+    const res = await processFiles('sess-a', env, () => {}, 1_000_000)
+    expect(res.status).toBe(200)
+    const files = res.payload.files as Array<{ objectKey: string }>
+    expect(files.map((f) => f.objectKey)).toEqual(['alice/a.pdf'])
+  })
+
+  it("never includes another owner's file", async () => {
+    const { env } = makeEnv()
+    const res = await processFiles('sess-a', env, () => {}, 1_000_000)
+    expect(JSON.stringify(res.payload)).not.toContain('bob')
+    expect(JSON.stringify(res.payload)).not.toContain('secret.pdf')
+  })
+
+  it('denies an unauthenticated caller', async () => {
+    const { env } = makeEnv()
+    expect((await processFiles('', env, () => {}, 1_000_000)).status).toBe(401)
+  })
+})
+
+describe('processDownload — isolation', () => {
+  it("allows the owner's own key", async () => {
+    const { env } = makeEnv()
+    expect((await processDownload('sess-a', 'alice/a.pdf', env, () => {}, 1_000_000)).status).toBe(
+      200,
+    )
+  })
+
+  it("denies person A's session on person B's key", async () => {
+    const { env } = makeEnv()
+    const res = await processDownload('sess-a', 'bob/secret.pdf', env, () => {}, 1_000_000)
+    expect(res.status).toBe(403)
+  })
+
+  it('denies a traversal escape', async () => {
+    const { env } = makeEnv()
+    const res = await processDownload('sess-a', 'alice/../bob/secret.pdf', env, () => {}, 1_000_000)
+    expect(res.status).toBe(403)
+  })
+
+  it('denies an unauthenticated caller', async () => {
+    const { env } = makeEnv()
+    expect((await processDownload('', 'alice/a.pdf', env, () => {}, 1_000_000)).status).toBe(401)
+  })
+})
+
+describe('processDelete — isolation and both-sides', () => {
+  it('removes object and manifest row together', async () => {
+    const { env, deleted, manifest } = makeEnv()
+    const res = await processDelete('sess-a', 'alice/a.pdf', env, () => {}, () => 1_000_000)
+    expect(res.status).toBe(200)
+    expect(deleted).toEqual(['alice/a.pdf'])
+    expect(manifest.find((m) => m.objectKey === 'alice/a.pdf')).toBeUndefined()
+  })
+
+  it("denies person A's session on person B's key, and deletes nothing", async () => {
+    const { env, deleted, manifest } = makeEnv()
+    const res = await processDelete('sess-a', 'bob/secret.pdf', env, () => {}, () => 1_000_000)
+    expect(res.status).toBe(403)
+    expect(deleted).toEqual([])
+    expect(manifest.find((m) => m.objectKey === 'bob/secret.pdf')).toBeDefined()
+  })
+
+  it('denies an unauthenticated caller', async () => {
+    const { env, deleted } = makeEnv()
+    expect((await processDelete('', 'alice/a.pdf', env, () => {}, () => 1_000_000)).status).toBe(401)
+    expect(deleted).toEqual([])
+  })
+
+  it('emits a per-step lifeline, not one bare line', async () => {
+    const { env } = makeEnv()
+    const lines: string[] = []
+    await processDelete('sess-a', 'alice/a.pdf', env, (l) => lines.push(l), () => 1_000_000)
+    const joined = lines.join('\n')
+    expect(joined).toContain('op=r2-delete')
+    expect(joined).toContain('op=manifest-delete')
+    expect(joined).toMatch(/op=complete .*result=ok objectPresent=false rowPresent=false/)
+  })
+
+  it('reports the R2 failure instead of throwing out of the handler', async () => {
+    // Unwrapped, a throw here escapes to a bare Pages 500 with zero
+    // [data-portal] lines — the lifeline goes silent exactly when it is needed.
+    const { env, manifest } = makeEnv()
+    ;(env.BUCKET as unknown as { delete: () => Promise<void> }).delete = () => {
+      throw new Error('r2 unavailable')
+    }
+    const lines: string[] = []
+    const res = await processDelete('sess-a', 'alice/a.pdf', env, (l) => lines.push(l), () => 1_000_000)
+    expect(res.status).toBe(502)
+    expect(lines.join('\n')).toContain('op=r2-delete')
+    expect(lines.join('\n')).toContain('result=failed')
+    // The row must survive an object that was never deleted.
+    expect(manifest.find((m) => m.objectKey === 'alice/a.pdf')).toBeDefined()
+  })
+
+  it('derives result from the post-condition rather than hardcoding ok', async () => {
+    // A delete that left the object behind must not print result=ok next to
+    // objectPresent=true — a self-contradicting line.
+    const { env } = makeEnv()
+    ;(env.BUCKET as unknown as { delete: () => Promise<void> }).delete = async () => {}
+    const lines: string[] = []
+    const res = await processDelete('sess-a', 'alice/a.pdf', env, (l) => lines.push(l), () => 1_000_000)
+    expect(res.status).toBe(500)
+    expect(lines.join('\n')).toMatch(/op=complete .*result=incomplete objectPresent=true/)
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/harness.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { processBooking } from '../../skills/calendar-site/template/functions/api/book'
+
+// The harness must reach code inside a skill's template/ directory, which is
+// part of no tsc project. This pins that reach; if it breaks, every template
+// test below it is unreachable.
+describe('harness reaches skill template functions', () => {
+  it('imports and runs a template Pages Function against an injected fake D1', async () => {
+    const lines: string[] = []
+    const fakeDb = {
+      prepare: () => ({
+        bind() {
+          return this
+        },
+        run: async () => ({ meta: { changes: 1 } }),
+      }),
+    }
+    const res = await processBooking(
+      {
+        slotStart: '2026-01-01T09:00:00Z',
+        slotEnd: '2026-01-01T09:30:00Z',
+        name: 'harness',
+        email: 'h@e.com',
+      } as never,
+      { DB: fakeDb } as never,
+      (l) => lines.push(l),
+      () => 'fixed-id',
+    )
+    expect(res.status).toBe(200)
+    expect(lines.join('\n')).toContain('[calendar-booking]')
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/passcode.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest'
+import {
+  PBKDF2_ITERATIONS,
+  constantTimeEqual,
+  hashPasscode,
+  verifyPasscode,
+  randomSaltHex,
+} from '../../skills/data-portal/template/functions/api/_lib/passcode'
+
+const SALT = '000102030405060708090a0b0c0d0e0f'
+
+describe('constantTimeEqual', () => {
+  it('is true for identical arrays', () => {
+    expect(constantTimeEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true)
+  })
+  it('is false when a byte differs', () => {
+    expect(constantTimeEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))).toBe(false)
+  })
+  it('is false for different lengths, without throwing', () => {
+    expect(constantTimeEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2, 3]))).toBe(false)
+  })
+  it('compares every byte even after a mismatch (no early return)', () => {
+    // A first-byte mismatch and a last-byte mismatch must both be false.
+    // This does not measure timing; it pins that the function does not
+    // short-circuit in a way a rewrite could reintroduce.
+    expect(constantTimeEqual(new Uint8Array([9, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(false)
+    expect(constantTimeEqual(new Uint8Array([1, 2, 9]), new Uint8Array([1, 2, 3]))).toBe(false)
+  })
+})
+
+describe('hashPasscode', () => {
+  it('is deterministic for the same passcode, salt and iterations', async () => {
+    const a = await hashPasscode('hunter2', SALT, 1000)
+    const b = await hashPasscode('hunter2', SALT, 1000)
+    expect(a).toBe(b)
+    expect(a).toMatch(/^[0-9a-f]{64}$/)
+  })
+  it('differs for a different passcode', async () => {
+    const a = await hashPasscode('hunter2', SALT, 1000)
+    const b = await hashPasscode('hunter3', SALT, 1000)
+    expect(a).not.toBe(b)
+  })
+  it('differs for a different salt', async () => {
+    const a = await hashPasscode('hunter2', SALT, 1000)
+    const b = await hashPasscode('hunter2', 'ffffffffffffffffffffffffffffffff', 1000)
+    expect(a).not.toBe(b)
+  })
+})
+
+describe('verifyPasscode', () => {
+  it('accepts the right passcode', async () => {
+    const h = await hashPasscode('hunter2', SALT, 1000)
+    expect(await verifyPasscode('hunter2', SALT, h, 1000)).toBe(true)
+  })
+  it('rejects the wrong passcode', async () => {
+    const h = await hashPasscode('hunter2', SALT, 1000)
+    expect(await verifyPasscode('hunter3', SALT, h, 1000)).toBe(false)
+  })
+  it('rejects a malformed stored hash without throwing', async () => {
+    expect(await verifyPasscode('hunter2', SALT, 'not-hex', 1000)).toBe(false)
+  })
+})
+
+describe('randomSaltHex', () => {
+  it('renders bytes as lowercase hex', () => {
+    expect(randomSaltHex(new Uint8Array([0, 1, 255]))).toBe('0001ff')
+  })
+})
+
+describe('PBKDF2_ITERATIONS', () => {
+  it('is at least the OWASP floor for PBKDF2-SHA256', () => {
+    expect(PBKDF2_ITERATIONS).toBeGreaterThanOrEqual(600_000)
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/ratelimit.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest'
+import {
+  RATE_WINDOW_MS,
+  RATE_MAX_ATTEMPTS,
+  checkAndRecordAttempt,
+} from '../../skills/data-portal/template/functions/api/_lib/ratelimit'
+import type { D1Database } from '../../skills/data-portal/template/functions/api/_lib/types'
+
+// Minimal D1 fake: one row per (scope, windowStart), matching the schema's
+// unique index. The INSERT ... ON CONFLICT DO UPDATE is modelled as an upsert.
+function fakeDb(seed: Array<{ scope: string; windowStart: number; count: number }> = []) {
+  const rows = [...seed]
+  const db: D1Database = {
+    prepare(query: string) {
+      let bound: unknown[] = []
+      const stmt = {
+        bind(...v: unknown[]) {
+          bound = v
+          return stmt
+        },
+        async run() {
+          if (/INSERT/i.test(query)) {
+            const [scope, windowStart] = bound as [string, number]
+            const hit = rows.find((r) => r.scope === scope && r.windowStart === windowStart)
+            if (hit) hit.count++
+            else rows.push({ scope, windowStart, count: 1 })
+          }
+          return { meta: { changes: 1 } }
+        },
+        async all() {
+          return { results: [] }
+        },
+        async first<T>() {
+          const [scope, windowStart] = bound as [string, number]
+          const hit = rows.find((r) => r.scope === scope && r.windowStart === windowStart)
+          return (hit ? { count: hit.count } : null) as T | null
+        },
+      }
+      return stmt
+    },
+  }
+  return { db, rows }
+}
+
+describe('checkAndRecordAttempt', () => {
+  it('allows the first attempt in a window', async () => {
+    const { db } = fakeDb()
+    expect(await checkAndRecordAttempt(db, 'alice', 1_000_000)).toEqual({ allowed: true, count: 1 })
+  })
+
+  it('allows up to the cap', async () => {
+    const w = Math.floor(1_000_000 / RATE_WINDOW_MS) * RATE_WINDOW_MS
+    const { db } = fakeDb([{ scope: 'alice', windowStart: w, count: RATE_MAX_ATTEMPTS - 1 }])
+    expect((await checkAndRecordAttempt(db, 'alice', 1_000_000)).allowed).toBe(true)
+  })
+
+  it('denies past the cap', async () => {
+    const w = Math.floor(1_000_000 / RATE_WINDOW_MS) * RATE_WINDOW_MS
+    const { db } = fakeDb([{ scope: 'alice', windowStart: w, count: RATE_MAX_ATTEMPTS }])
+    const res = await checkAndRecordAttempt(db, 'alice', 1_000_000)
+    expect(res.allowed).toBe(false)
+    expect(res.count).toBeGreaterThan(RATE_MAX_ATTEMPTS)
+  })
+
+  it('starts a fresh count in the next window', async () => {
+    const w = Math.floor(1_000_000 / RATE_WINDOW_MS) * RATE_WINDOW_MS
+    const { db } = fakeDb([{ scope: 'alice', windowStart: w, count: RATE_MAX_ATTEMPTS }])
+    const later = 1_000_000 + RATE_WINDOW_MS
+    expect((await checkAndRecordAttempt(db, 'alice', later)).allowed).toBe(true)
+  })
+
+  it('scopes counts independently per person', async () => {
+    const w = Math.floor(1_000_000 / RATE_WINDOW_MS) * RATE_WINDOW_MS
+    const { db } = fakeDb([{ scope: 'alice', windowStart: w, count: RATE_MAX_ATTEMPTS }])
+    expect((await checkAndRecordAttempt(db, 'bob', 1_000_000)).allowed).toBe(true)
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/skill-contract.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const skill = () => readFileSync(join(__dirname, '../../skills/data-portal/SKILL.md'), 'utf8')
+
+describe('data-portal SKILL.md', () => {
+  it('opens with frontmatter carrying name and description', () => {
+    // Without these the skill is invisible to the available-skills reminder and
+    // to skill-search. The defect is silent: no error, no log line.
+    const text = skill()
+    expect(text.startsWith('---\n')).toBe(true)
+    const fm = text.slice(4, text.indexOf('\n---', 4))
+    expect(fm).toMatch(/^name:\s*data-portal\s*$/m)
+    expect(fm).toMatch(/^description:\s*\S/m)
+  })
+
+  it('declares the plugin-read convention (check-plugin-references.mjs)', () => {
+    expect(skill()).toMatch(/plugin-read/)
+  })
+
+  it('records the two-session provisioning sequence', () => {
+    // The load-bearing sequencing decision: the broker registers a bucket to
+    // whoever creates it, ON CREATE and never reassigned, so the client
+    // account must create its own or its ingestion sweep is denied forever.
+    const text = skill()
+    expect(text).toMatch(/storage-r2-bucket-create/)
+    expect(text).toMatch(/client|sub-account/i)
+  })
+
+  it('names the passcode discipline', () => {
+    expect(skill()).toMatch(/once/i)
+    expect(skill()).toMatch(/never.*plaintext|plaintext.*never/i)
+  })
+
+  it('routes store naming through cf-store-name.sh rather than hand-building', () => {
+    // The script is already tested (bin/__tests__/cf-store-name.test.sh). What
+    // is untested is that this skill defers to it — a hand-built name would
+    // break the "name identifies owner and purpose" contract silently.
+    expect(skill()).toMatch(/cf-store-name\.sh/)
+  })
+
+  it('leaves no unfilled placeholder marker in its own prose', () => {
+    expect(skill()).not.toMatch(/\bTBD\b|\bTODO\b/)
+  })
+})

package/payload/platform/plugins/cloudflare/mcp/__tests__/template-config.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const TEMPLATE = join(__dirname, '../../skills/data-portal/template')
+const wrangler = () => readFileSync(join(TEMPLATE, 'wrangler.toml'), 'utf8')
+const schema = () => readFileSync(join(TEMPLATE, 'schema.sql'), 'utf8')
+
+describe('wrangler.toml', () => {
+  it('binds D1 as DB', () => {
+    expect(wrangler()).toMatch(/\[\[d1_databases\]\]/)
+    expect(wrangler()).toMatch(/binding\s*=\s*"DB"/)
+  })
+
+  it('binds R2 as BUCKET — the resource class the plugin has never bound', () => {
+    expect(wrangler()).toMatch(/\[\[r2_buckets\]\]/)
+    expect(wrangler()).toMatch(/binding\s*=\s*"BUCKET"/)
+    expect(wrangler()).toMatch(/bucket_name\s*=\s*"__R2_BUCKET_NAME__"/)
+  })
+
+  it('declares every placeholder it uses in its header comment', () => {
+    const text = wrangler()
+    const used = [...text.matchAll(/__[A-Z0-9_]+__/g)].map((m) => m[0])
+    for (const p of new Set(used)) {
+      // Each placeholder appears at least twice: once documented, once used.
+      expect(text.split(p).length - 1).toBeGreaterThanOrEqual(2)
+    }
+  })
+})
+
+describe('schema.sql', () => {
+  it('is re-appliable — every create is IF NOT EXISTS', () => {
+    const creates = [...schema().matchAll(/CREATE (TABLE|INDEX|UNIQUE INDEX)/gi)]
+    expect(creates.length).toBeGreaterThan(0)
+    expect(schema()).not.toMatch(/CREATE TABLE (?!IF NOT EXISTS)/i)
+  })
+
+  it('has the four tables the portal needs', () => {
+    for (const t of ['people', 'sessions', 'manifest', 'auth_attempts']) {
+      expect(schema()).toMatch(new RegExp(`CREATE TABLE IF NOT EXISTS ${t}`, 'i'))
+    }
+  })
+
+  it('defaults manifest.ingested to 0', () => {
+    expect(schema()).toMatch(/ingested\s+INTEGER\s+NOT NULL\s+DEFAULT 0/i)
+  })
+
+  it('stores no plaintext passcode column', () => {
+    expect(schema()).not.toMatch(/passcode\s+TEXT/i)
+  })
+
+  it('enforces one attempt row per (scope, window)', () => {
+    expect(schema()).toMatch(/CREATE UNIQUE INDEX IF NOT EXISTS auth_attempts_scope_window/i)
+  })
+})