@rubytech/create-maxy-code 0.1.459 → 0.1.461

package/payload/platform/plugins/cloudflare/mcp/__tests__/auth-route.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { processAuth } from '../../skills/data-portal/template/functions/api/auth'
+import {
+  generatePasscode,
+  hashPasscode,
+} from '../../skills/data-portal/template/functions/api/_lib/passcode.mjs'
+import type { PortalEnv } from '../../skills/data-portal/template/functions/api/_lib/types'
+
+const SALT = '000102030405060708090a0b0c0d0e0f'
+// Real passcodes, because hashPasscode now refuses anything below the pinned
+// strength — 'right' and 'wrong' would throw before they ever reached a route.
+const RIGHT = generatePasscode()
+const WRONG = generatePasscode()
+const IP = '203.0.113.7'
+
+async function envWith(people: Array<{ ownerId: string; passcode: string }>, attemptCount = 0) {
+  const rows = await Promise.all(
+    people.map(async (p) => ({
+      ownerId: p.ownerId,
+      salt: SALT,
+      hash: await hashPasscode(p.passcode, SALT),
+    })),
+  )
+  const sessions: unknown[][] = []
+  const cleared: unknown[][] = []
+  const scopes: unknown[] = []
+  const env = {
+    DB: {
+      prepare(query: string) {
+        let bound: unknown[] = []
+        const stmt = {
+          bind(...v: unknown[]) {
+            bound = v
+            if (/auth_attempts/i.test(query)) scopes.push(v[0])
+            return stmt
+          },
+          async run() {
+            if (/INSERT INTO sessions/i.test(query)) sessions.push(bound)
+            if (/DELETE FROM auth_attempts/i.test(query)) cleared.push(bound)
+            return { meta: { changes: 1 } }
+          },
+          async all() {
+            return { results: [] }
+          },
+          async first<T>() {
+            if (/FROM auth_attempts/i.test(query)) return { count: attemptCount + 1 } as T
+            if (/FROM people/i.test(query)) {
+              return (rows.find((r) => r.ownerId === bound[0]) ?? null) as T | null
+            }
+            return null as T | null
+          },
+        }
+        return stmt
+      },
+    },
+    BUCKET: {} as never,
+  } as unknown as PortalEnv
+  return { env, sessions, cleared, scopes }
+}
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('processAuth', () => {
+  it('accepts the right passcode and mints a session', async () => {
+    const { env, sessions } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const lines: string[] = []
+    const res = await processAuth(
+      { ownerId: 'alice', passcode: RIGHT },
+      env,
+      (l) => lines.push(l),
+      () => 'sess-1',
+      1_000_000,
+      IP,
+    )
+    expect(res.status).toBe(200)
+    expect(res.sessionId).toBe('sess-1')
+    expect(sessions.length).toBe(1)
+    expect(lines.join('\n')).toContain('op=auth owner="alice" result=ok')
+  })
+
+  it('denies the wrong passcode and mints no session', async () => {
+    const { env, sessions } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const lines: string[] = []
+    const res = await processAuth(
+      { ownerId: 'alice', passcode: WRONG },
+      env,
+      (l) => lines.push(l),
+      () => 'sess-1',
+      1_000_000,
+      IP,
+    )
+    expect(res.status).toBe(401)
+    expect(sessions.length).toBe(0)
+    expect(lines.join('\n')).toContain('result=denied')
+  })
+
+  it('denies an unknown owner without revealing that it is unknown', async () => {
+    const { env } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const res = await processAuth(
+      { ownerId: 'nobody', passcode: RIGHT },
+      env,
+      () => {},
+      () => 'sess-1',
+      1_000_000,
+      IP,
+    )
+    expect(res.status).toBe(401)
+    // Same payload as a wrong passcode: an enumeration oracle would otherwise
+    // tell an attacker which people exist.
+    expect(res.payload).toEqual({ ok: false, error: 'denied' })
+  })
+
+  it('rate-limits before comparing the passcode', async () => {
+    const { env, sessions } = await envWith([{ ownerId: 'alice', passcode: RIGHT }], 5)
+    const lines: string[] = []
+    const res = await processAuth(
+      { ownerId: 'alice', passcode: RIGHT },
+      env,
+      (l) => lines.push(l),
+      () => 'sess-1',
+      1_000_000,
+      IP,
+    )
+    expect(res.status).toBe(429)
+    expect(sessions.length).toBe(0)
+    expect(lines.join('\n')).toContain('result=rate-limited')
+  })
+
+  it('never logs the passcode', async () => {
+    const { env } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const lines: string[] = []
+    await processAuth(
+      { ownerId: 'alice', passcode: RIGHT },
+      env,
+      (l) => lines.push(l),
+      () => 'sess-1',
+      1_000_000,
+      IP,
+    )
+    expect(lines.join('\n')).not.toContain(RIGHT)
+  })
+
+  it('rejects a malformed body', async () => {
+    const { env } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const res = await processAuth({} as never, env, () => {}, () => 'sess-1', 1_000_000, IP)
+    expect(res.status).toBe(400)
+  })
+
+  it('hashes for an unknown owner too, closing the timing oracle', async () => {
+    // The identical DENIED payload is cosmetic on its own: an unknown owner
+    // returning after one D1 read while a known one also hashes enumerates the
+    // enrolled people outright. Both paths must pay.
+    //
+    // 1689 closed a ~5ms-vs-250ms gap here. 1708 replaced PBKDF2 with one
+    // SHA-256, shrinking the gap to a measured 43.8us — still inside the band
+    // remote timing attacks have been shown to resolve, so the dummy stays. A
+    // call count is the right instrument: it is deterministic where a clock is
+    // not, and it fails if someone drops the dummy without restoring the cost.
+    // Both envs are built BEFORE the spy: envWith hashes its own fixtures, and
+    // counting that setup work would let the two totals match without the route
+    // hashing at all.
+    const known = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const unknown = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const spy = vi.spyOn(crypto.subtle, 'digest')
+
+    await processAuth({ ownerId: 'alice', passcode: WRONG }, known.env, () => {}, () => 's', 1_000_000, IP)
+    const hashesForKnown = spy.mock.calls.length
+    spy.mockClear()
+
+    await processAuth({ ownerId: 'nobody', passcode: WRONG }, unknown.env, () => {}, () => 's', 1_000_000, IP)
+    const hashesForUnknown = spy.mock.calls.length
+
+    expect(hashesForKnown).toBeGreaterThan(0)
+    expect(hashesForUnknown).toBe(hashesForKnown)
+  })
+
+  it('scopes the rate limiter on owner AND ip, so one caller cannot lock out another', async () => {
+    // Keyed on the owner alone the counter is a weapon: six unauthenticated
+    // requests naming a person lock that person out of their own portal.
+    const { env, scopes } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    await processAuth({ ownerId: 'alice', passcode: RIGHT }, env, () => {}, () => 's', 1_000_000, IP)
+    expect(scopes[0]).toBe(`alice|${IP}`)
+    expect(String(scopes[0])).toContain(IP)
+  })
+
+  it('clears the counter on a successful sign-in, so a person cannot self-lock', async () => {
+    const { env, cleared } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    await processAuth({ ownerId: 'alice', passcode: RIGHT }, env, () => {}, () => 's', 1_000_000, IP)
+    expect(cleared.length).toBe(1)
+    expect(cleared[0][0]).toBe(`alice|${IP}`)
+  })
+
+  it('does not clear the counter on a failed sign-in', async () => {
+    const { env, cleared } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    await processAuth({ ownerId: 'alice', passcode: WRONG }, env, () => {}, () => 's', 1_000_000, IP)
+    expect(cleared.length).toBe(0)
+  })
+
+  it('binds the session to the passcode, so rotation revokes it', async () => {
+    // sessions carries pcCheck; resolveSession joins people and requires it to
+    // still match. Rotation changes the hash, so old sessions die by
+    // construction rather than by an operator remembering a cleanup step.
+    const { env, sessions } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    await processAuth({ ownerId: 'alice', passcode: RIGHT }, env, () => {}, () => 's', 1_000_000, IP)
+    const expected = (await hashPasscode(RIGHT, SALT)).slice(0, 16)
+    // bind order: sessionId, ownerId, pcCheck, expiresAt, createdAt
+    expect(sessions[0][2]).toBe(expected)
+  })
+
+  it('quotes the owner in log lines, so a crafted ownerId cannot forge one', async () => {
+    const { env } = await envWith([{ ownerId: 'alice', passcode: RIGHT }])
+    const lines: string[] = []
+    const forged = 'x result=ok\n[data-portal] op=auth owner=alice result=ok'
+    await processAuth({ ownerId: forged, passcode: WRONG }, env, (l) => lines.push(l), () => 's', 1_000_000, IP)
+    // Exactly one line, and the injected newline must not have started another.
+    expect(lines.length).toBe(1)
+    expect(lines[0].split('\n').length).toBe(1)
+    expect(lines[0]).toMatch(/result=denied/)
+  })
+})

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]')
+  })
+})