fix: similar-sweep currency remediation, security hardening and v1 API fixes (#1215)
* fix(security): gate replace_sie_import behind owner/admin membership The RPC was SECURITY DEFINER with EXECUTE granted to PUBLIC and anon, no company_members lookup, no auth.uid() reference and no unauthorized raise, while setting gnubok.allow_delete to disarm the BFL immutability and retention triggers. Any caller holding a company_id and an import id could hard delete another tenant's verifikationer. Confirmed live in production. Applies the same fail closed owner/admin guard that undo_sie_import already carries (migration 20260624120000), resolving the actor from COALESCE(p_user_id, auth.uid()) so it denies when the role is NULL, then revokes EXECUTE from PUBLIC and anon. search_path and the raised statement_timeout are restated, since CREATE OR REPLACE drops settings that are not repeated. userId is a required parameter on replaceSIEImport: the service client has a NULL auth.uid(), so a caller without an explicit actor now fails to compile rather than hitting the closed gate at runtime. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(security): validate arcim OAuth callback state server side The callback route is skipAuth and decoded the state parameter as plain base64url JSON, trusting consentId and provider from it. A one time code was minted at flow start and never read. An unauthenticated attacker who learned a consent id could run an OAuth flow on their own provider account and post the callback with a forged state, landing their tokens on another tenant's consent, so the victim's next migration imported the attacker's ledger. State is now an opaque randomBytes(32) pointer to a provider_otc row, consumed by a single atomic UPDATE guarded on used_at IS NULL and expires_at, so a replay loses the row lock race and updates nothing. provider is read from provider_consents rather than trusted from the client. provider_otc already existed for exactly this purpose and was never wired up. Also scopes getConsent to an owning company, closing a cross tenant status oracle where the preview and migrate paths echoed a consent's status before the scoped check ran. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(security): scope documents storage to company_id (phase A) The documents bucket policies matched on auth.uid(), and upload keys were documents/{userId}/..., so company membership was never consulted. Removing a member revoked nothing: their session still authenticated and they kept direct Storage read access to every receipt, supplier invoice and bank statement they had uploaded. The same bug was fixed for sie-files in 20260416120000; this bucket was left behind. Phase A is additive. Company scoped policies are added alongside the uploader scoped ones, uploads move to documents/{companyId}/{userId}/..., and reads accept either layout so nothing breaks mid migration. Phase C, which drops the old policies, is gated on the backfill reporting zero remaining legacy prefix objects. The policy compares the company segment as text rather than casting to uuid the way sie-files does: this bucket holds keys whose second segment is not a uuid (MCP audit packages), and Postgres does not guarantee the bucket prefix qual runs before the cast, so a planner reordering would raise 22P02 and fail the whole query instead of filtering the row out. deleteDocument now removes both candidate keys. Removing only the stored pointer would leave a readable orphan copy of a document the user asked to erase. The backfill script is included but has never been run. It defaults to dry run, refuses .env.local by name, and verifies each copy is readable and SHA-256 identical before repointing the row. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(security): enforce events:read scope and membership on /api/events This was the only one of the three validateApiKey call sites with no downstream guard: v1 and the MCP server both check scope and re-verify company membership, this route did neither. An events:read scope existed and was documented as gating the endpoint but was never called, so a legacy key falling back to DEFAULT_SCOPES read the full log. The bound company id went straight from the api_keys row into a service role query, so a key whose user had been removed from the company kept reading. Adds the scope check before any database access, re-verifies company_members with archived_at IS NULL, honours test mode by stamping X-Gnubok-Mode instead of ignoring it, applies minimisePayload so the pull surface can never return a wider payload than the push surface, and replaces the three flat error strings with the canonical envelope. Test key reads are served rather than blocked: TEST_KEY_WRITE_BLOCKED is gated on mutations in with-api-v1, so a read gets the same treatment as every other v1 read endpoint. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * perf(bookkeeping): sweep remaining journal_entries!inner embeds A previous refactor removed this pattern from lib/reports and introduced fetchEntryLines, but the class was never swept. Seventeen sites remained and had become the top application consumer of production database time: measured across the resulting query shapes, 32,694 calls and 25,848 seconds of execution, mean 790ms, with shapes averaging 2.6s and 3.0s and maxing at 7,962ms against the 8s statement_timeout, which surfaced to users as 500s on the booking path. PostgREST compiles an embed with filters on the embedded side into a correlated INNER JOIN LATERAL with a parameterized LIMIT, which stops Postgres reordering the join, so each query walked the whole journal_entry_lines table across all tenants. Driving from the entries side instead turns that into two indexed round trips. Converted sites keep their existing shape: the helper reattaches the parent entry under the same key the embed produced. Several conversions also remove a latent silent truncation where an unpaginated query was capped at PostgREST's 1000 row ceiling. Two deliberate exceptions. The free text ilike legs of the MCP display query stay on the embed, because each is capped at legLimit and that cap drives the truncation contract the tool reports, while the helper is unbounded. The accounts route moves to the existing get_account_usage_counts RPC instead, since its embed was a head count and the helper returns rows. commitEntry's write path is untouched: the change there is confined to the read query of the pre-commit dimension rule check. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(api): anchor v1 list cursors on created_at Page two returned page one, forever, while still advertising a fresh next_cursor. The three routes sorted by and encoded a Postgres date column, which serializes as YYYY-MM-DD, but decodeDefaultCursor validates the cursor timestamp as full ISO-8601 and returned null, so the keyset filter was never applied and has_more never went false. An integrator syncing verifikat looped on the newest rows indefinitely. The transactions route already solved this and its comment names the trap; the fix was never ported. All three now order and encode on created_at with an id tie break, matching the transactions keyset predicate exactly. ISO_TIMESTAMP is deliberately left alone: relaxing it would silently change sort semantics on the route that currently works. Default ordering therefore moves from business date to insert order. Every business date is still on the row, and the invoices list gains date_from and date_to filters so a date range is still reachable; the other two already had them. The tests use an in-memory PostgREST that actually evaluates the filters, because the repo's pass-through mock cannot catch this class of bug: the bug is that the filter is never sent. They walk to exhaustion with a hard iteration cap, so an unterminated walk fails instead of hanging. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(api): separate dry run from commit in the idempotency hash The request hash was built from url.pathname, which excludes the query string, so a dry run and its commit hashed identically. Following the flow documented in dry-run.ts, re-issuing the request with the same Idempotency-Key returned the cached preview with Idempotent-Replayed set and wrote nothing, while reporting 200. An agent or integrator saw success for a write that never happened. dry_run is folded into the hash only when true, not as an unconditional boolean. Including it as false would change the hash of every ordinary write, and with a 24h idempotency TTL any key in flight across the deploy would fail the request_hash comparison and 409 on a legitimate retry. Both hash call sites now go through one shared helper so they cannot drift into a permanent cache miss, and dry run responses are no longer stored at all. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * ci: install the Bedrock SDK out of tree in the compliance review The Swedish accounting compliance gate had failed ten consecutive runs and so was posting nothing. With --no-package-lock npm discarded the lockfile and re-resolved the whole tree from package.json, floating @hookform/resolvers to 5.4.3, whose valibot ^1 peer conflicts with the pinned valibot 0.39.0. Installing into the parent of the checkout resolves only that one package, so an unrelated peer conflict can never take the gate down again. Node still finds it because ESM bare specifiers walk up parent node_modules; NODE_PATH would not have worked, as it is CommonJS only. --legacy-peer-deps was rejected because it masks future genuine peer conflicts and still reifies the full tree. The same step's SDK version is aligned from 0.31.0 back to the 0.29.1 that package.json and check:guards enforce after the streaming outage. That drift went unnoticed because the pin guard only inspects package.json and the lockfile, never workflow files. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * build(docker): generate crontabs from vercel.json vercel.json defines 16 cron jobs; both Docker crontabs carried 9, and were byte identical to each other. Self hosted deployments therefore never sent recurring invoices, never dispatched webhooks and never cleaned up idempotency keys. tax-deadlines also ran once a year on 2 January instead of daily, and documents/verify weekly instead of daily. Extension crons are included rather than excluded. The Dockerfile copies the whole tree before building, so every extension cron route is compiled into the image regardless of the enabled preset, and each returns 200 when its extension is unconfigured, so curl -sf logs no failure. Two such entries were already present in the crontab for extensions absent from the preset, which settles the intent. documents/verify is treated as drift rather than a self hosted concession: the weekly cadence was present in the hosted crontab too, and the run is capped at 200 documents walking a nulls-first queue, so weekly drains the integrity queue seven times slower on a check that exists for BFL retention. webhooks/dispatch keeps its per minute cadence, adding 1,440 requests a day on self hosted. A gentler tick would silently stretch the first retry, since the retry ladder opens at 60 seconds. SCHEDULE_OVERRIDES is the one line place to change that. A parity test asserts the path sets match minus a documented exclusion list, and ratchets three cron routes that are currently scheduled nowhere so they are named rather than silently rotting. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * chore(observability): add a provider agnostic error sink There is no error tracking in this codebase: logs go to console and Vercel retention and nowhere else, nothing alerts on the 16 cron jobs, and seven code comments across lib, app, components and extensions asserted that Sentry captures errors when Sentry is not a dependency. The two most recent bug fixes on this repo were both discovered by customer email. This adds the sink, not a vendor. No dependency is taken: the interface has a no-op default and a registration point, so behaviour is unchanged until an adapter is registered. Releases are tagged from the build id already inlined by next.config.ts. Redaction moved out of lib/logger.ts into a leaf module that both the logger and the sink import, so there is one denylist and no path from application data to a third party can skip the personnummer regex, including direct sink calls that bypass the logger. That matters here because these logs carry personnummer and financial data. verifyCronSecret now reports its own 401s, which covers all 16 jobs without touching a route file and catches the case where CRON_SECRET is rotated without updating the scheduler and every job silently 401s forever. The threshold is one failure rather than the backup alert's three: suppressing the first occurrence is precisely how an outage stays invisible. The seven misleading comments are corrected to describe what the code actually does, including the two cases that still are not covered: the client side one, since the sink is server side, and a warn level call that is not forwarded. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix: remediate the 2026-07-26 similar-sweep findings across all surfaces Resolves the ~150-finding sweep (dev_docs/similar-sweep-2026-07-26.md) with one agent per finding; every behavioural fix carries a regression test proven to fail at HEAD. Full status, corrections to the sweep, refusals and open decisions in dev_docs/similar-sweep-2026-07-26-remediation-status.md. Structural roots closed: - resolveSekAmountOrNull(): honest SEK resolution refuses instead of booking 1:1; four duplicated toSek closures now refuse via INVOICE_FX_RATE_MISSING - ledger-line-amount.ts: journal_entry_lines.currency labels the document, not the amount; SQL pre-filter decoy proven and fixed - sparse-patch.ts: .partial() does not strip .default() in Zod 4.4.3; the exploitable salary payslip-line PATCH and KPI preferences sinks fixed - tests/schema: migration-replay phantom-column guard (13k+ refs, closed CHECK sets, onConflict targets); found 28 real defects, all fixed, all four baselines now empty - three new ratchet guards: sek-labelled-amount, cross-extension-import, ungated-extension-route Highlights: lawful VAT-rate set on all seven invoice surfaces (ML 6 kap), RC input VAT mismatch wired on web + both MCP callers, missing-underlag resource delegates to the shared RPC predicate, push-notifications consent polarity fail-closed, deadlines undo honours requested state, silent-failure and read-side-fabrication classes fixed across settings/KPI/inbox/Stripe/ Arcim/kassaflodesanalys, error-envelope stringification fixed at 10+ sites with isSwedishUserMessage extended. Also includes the parallel session's MCP invoice tools (update_invoice, recurring schedules, invoice deliveries) which share files with the sweep work and are verified green together. 13 new migrations are NOT applied anywhere; they apply via branch merge. 20260726120000 backfills 1247 supplier-invoice rows. pg tests for new DDL are written but unrun (no local Postgres). Verified: 11088 tests / 881 files green, tsc 0 non-test errors, lint 0 errors, check:guards passing, MCP payload 57475/57500. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(migrations): rename replace_sie_import migration off main's 20260726090000 version origin/main shipped 20260726090000_agent_quota_rpc_caller_guard.sql; keeping our replace_sie_import migration on the same version would abort the Supabase apply with a schema_migrations_pkey duplicate at merge time. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(review): remediate pre-publish deep-review findings across all slices A 13-agent review of the full branch diff surfaced 1 critical, 5 high and ~45 further findings; this commit resolves them in one pass: - replace_sie_import / undo_sie_import: p_user_id honored only for service_role callers; any other caller is pinned to auth.uid() (impersonation gate bypass), authz raise errcode 42501 mapped to a Swedish 403 in the route, new caller-guard migration for undo - bulk_book_transactions refuses homogeneous non-SEK batches instead of writing foreign magnitudes into SEK ledger columns - credit-note cap trigger: company-match on credited_invoice_id, no cross-tenant figures in exception text - link_voucher RPCs resolve NULL invoice currency as SEK end to end - personal-number ciphertext CHECK split into NOT VALID + VALIDATE - same-currency foreign settlements clear 1510 at booking rate and book realized diff to 3960/7960; rate-less foreign write paths refuse - receivables revaluation covers partially_paid and outstanding amounts - period lock guard paginates candidates past the PostgREST 1000 cap - documents: service-client storage removals after authz, dual-layout reads in integrity cron and archive export, backfill delete-source sweep actually deletes with hash verification and shared-key grouping - invoice matching normalizes NULL/lowercase currencies (regression), duplicate candidates stop claiming amount matches they never ran - match-invoice aborts on any booking failure (no paid-without-verifikat) - refresh-exchange-rate reverts on concurrent booking (TOCTOU window) - KPI preferences upsert arbiter aligned to the company-scoped constraint - personnummer_last4 stripped from all salary responses incl. MCP tools - worked-hours batch restores destroyed rows on conflict and error paths - MCP: shared duplicate-claim builder (no more 'null kr'), short-circuit on tag_journal_lines overflow, auto_send schedules stage as high risk - observability sink redacts emails/IBANs/API keys and keeps redacted stacks in prod; assorted small guards (safe-return-to /@, dry_run=True, cursor helper off-by-one, OAuth state TTL 10 min, arcim saveMappings call removed) Full dispositions, deferred items and hand-verified accounting numbers are documented in the PR body and DECISIONS.md. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(personnummer): implement masking and encryption for personal numbers with tests * fix(review): address CI and compliance-bot findings for PR #1215 pg-real: the CI image's auth shim reads the legacy request.jwt.claim.role GUC, so both service-role simulations (runAsServiceRole and the invoice-delivery test's local helper) never satisfied auth.role() = 'service_role' and every legitimate p_user_id path failed closed; the shared helper now sets both GUC shapes plus SET LOCAL ROLE with a fail-loud sanity check, and the delivery test reuses it. The link-voucher migration had recreated both RPCs from pre-rewrite file text, reintroducing the NULL-unsafe membership pattern the null-safe-tenant-guards ratchet bans; both guards now use public.caller_is_company_member() with all currency changes preserved. Compliance bots: the customers export now emits the standard masked form instead of raw AES-256-GCM ciphertext in the Org-/personnummer column, and maskCustomerRow returns a non-round-trippable placeholder on decrypt failure instead of 500ing the list. MCP parity: gnubok_lock_period's staging pre-check now runs the exact countUnbookedInPeriod the commit path enforces (exported from period-service; local mirror deleted), and gnubok_agi_status resolves AGI state run-scoped so a correction run no longer renders as already filed. Declined with evidence: PR-Agent's opening-balances null-zeroing concern (all mergeable columns are NOT NULL with defaults per 20260713101000). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(review): address codex review findings on PR #1215 - restore 20260726140000 to its preview-recorded content and restate the NULL-safe tenant guard under 20260727130000: a recorded migration version never re-runs, so the in-place edit could not reach the preview branch - replace toFixed() with sv-SE two-decimal formatting in the ROT/RUT cap warning texts and update the pinned test expectations - drop the em dash in the fiscal-periods route comment - strip trailing whitespace in import-existing.test.ts Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(reports): raise timeout on real PDF render tests renderToBuffer does real @react-pdf layout work and exceeds the 5s default when the full suite saturates the CPU; tests pass in isolation. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Mattsson
co-authored by
Claude Fable 5
Claude Fable 5
parent
a43a8b03cf
commit
f24b26a139
@@ -0,0 +1,316 @@
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
|
||||
import {
|
||||
consumeInviteCookie,
|
||||
classifyInviteAcceptStatus,
|
||||
isDefinitiveInviteDisposition,
|
||||
readInviteCookie,
|
||||
INVITE_COOKIE_NAME,
|
||||
INVITE_PROBLEM_MESSAGE_KEYS,
|
||||
} from '../consume-invite-cookie'
|
||||
|
||||
/**
|
||||
* Minimal document.cookie stand-in. Vitest runs in the node env, so there is
|
||||
* no DOM: this models the one behaviour the helper depends on, namely that
|
||||
* assigning `name=; max-age=0` removes the entry.
|
||||
*/
|
||||
function installCookieJar(initial: Record<string, string> = {}) {
|
||||
const jar = new Map(Object.entries(initial))
|
||||
|
||||
Object.defineProperty(globalThis, 'document', {
|
||||
configurable: true,
|
||||
value: {
|
||||
get cookie() {
|
||||
return [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ')
|
||||
},
|
||||
set cookie(raw: string) {
|
||||
const [pair, ...attrs] = raw.split(';').map((s) => s.trim())
|
||||
const eq = pair.indexOf('=')
|
||||
const name = pair.slice(0, eq)
|
||||
const value = pair.slice(eq + 1)
|
||||
const expiring = attrs.some((a) => /^max-age=0$/i.test(a))
|
||||
if (expiring || value === '') {
|
||||
jar.delete(name)
|
||||
} else {
|
||||
jar.set(name, value)
|
||||
}
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
return jar
|
||||
}
|
||||
|
||||
const TOKEN = 'gnubok_inv_Zm9vYmFyLXRva2Vu'
|
||||
|
||||
let fetchMock: ReturnType<typeof vi.fn>
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
fetchMock = vi.fn()
|
||||
vi.stubGlobal('fetch', fetchMock)
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
vi.unstubAllGlobals()
|
||||
Reflect.deleteProperty(globalThis, 'document')
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
function respondWith(status: number) {
|
||||
fetchMock.mockResolvedValue({ status, ok: status >= 200 && status < 300 })
|
||||
}
|
||||
|
||||
describe('classifyInviteAcceptStatus', () => {
|
||||
it('treats 2xx and 409 (already a member) as accepted', () => {
|
||||
expect(classifyInviteAcceptStatus(200)).toBe('accepted')
|
||||
expect(classifyInviteAcceptStatus(204)).toBe('accepted')
|
||||
expect(classifyInviteAcceptStatus(409)).toBe('accepted')
|
||||
})
|
||||
|
||||
it('treats 400, 404 and 410 as a spent or invalid token', () => {
|
||||
expect(classifyInviteAcceptStatus(400)).toBe('spent')
|
||||
expect(classifyInviteAcceptStatus(404)).toBe('spent')
|
||||
expect(classifyInviteAcceptStatus(410)).toBe('spent')
|
||||
})
|
||||
|
||||
it('treats 403 email mismatch as its own case, not spent', () => {
|
||||
expect(classifyInviteAcceptStatus(403)).toBe('wrong_email')
|
||||
expect(isDefinitiveInviteDisposition('wrong_email')).toBe(false)
|
||||
})
|
||||
|
||||
it('treats session races, rate limits and server errors as retryable', () => {
|
||||
for (const status of [401, 408, 425, 429, 500, 502, 503, 504]) {
|
||||
expect(classifyInviteAcceptStatus(status)).toBe('retryable')
|
||||
expect(isDefinitiveInviteDisposition('retryable')).toBe(false)
|
||||
}
|
||||
})
|
||||
|
||||
it('marks only accepted and spent as definitive', () => {
|
||||
expect(isDefinitiveInviteDisposition('accepted')).toBe(true)
|
||||
expect(isDefinitiveInviteDisposition('spent')).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('readInviteCookie', () => {
|
||||
it('reads the token out of the cookie jar', () => {
|
||||
installCookieJar({ 'sb-access-token': 'x', [INVITE_COOKIE_NAME]: TOKEN })
|
||||
expect(readInviteCookie()).toBe(TOKEN)
|
||||
})
|
||||
|
||||
it('returns null when no invite cookie is present', () => {
|
||||
installCookieJar({ 'sb-access-token': 'x' })
|
||||
expect(readInviteCookie()).toBeNull()
|
||||
})
|
||||
|
||||
it('does not match a differently-named cookie sharing the suffix', () => {
|
||||
installCookieJar({ [`x-${INVITE_COOKIE_NAME}`]: 'not-the-invite' })
|
||||
expect(readInviteCookie()).toBeNull()
|
||||
})
|
||||
|
||||
it('returns null without a DOM (server render)', () => {
|
||||
expect(readInviteCookie()).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('consumeInviteCookie', () => {
|
||||
it('does nothing when there is no invite cookie', async () => {
|
||||
installCookieJar({})
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result).toEqual({
|
||||
attempted: false,
|
||||
disposition: null,
|
||||
accepted: false,
|
||||
cleared: false,
|
||||
problem: null,
|
||||
})
|
||||
expect(fetchMock).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('happy path: posts the token, clears the cookie, reports accepted', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(200)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(fetchMock).toHaveBeenCalledWith('/api/team/accept', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ token: TOKEN }),
|
||||
})
|
||||
expect(result.accepted).toBe(true)
|
||||
expect(result.problem).toBeNull()
|
||||
expect(result.cleared).toBe(true)
|
||||
expect(jar.has(INVITE_COOKIE_NAME)).toBe(false)
|
||||
})
|
||||
|
||||
it('already a member (409) counts as accepted and clears', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(409)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.accepted).toBe(true)
|
||||
expect(jar.has(INVITE_COOKIE_NAME)).toBe(false)
|
||||
})
|
||||
|
||||
it('definitively invalid (400) clears the cookie and reports the problem', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(400)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.accepted).toBe(false)
|
||||
expect(result.disposition).toBe('spent')
|
||||
expect(result.problem).toBe('spent')
|
||||
expect(result.cleared).toBe(true)
|
||||
expect(jar.has(INVITE_COOKIE_NAME)).toBe(false)
|
||||
})
|
||||
|
||||
it('expired invitation (410) clears the cookie', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(410)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.problem).toBe('spent')
|
||||
expect(jar.has(INVITE_COOKIE_NAME)).toBe(false)
|
||||
})
|
||||
|
||||
// The finding: a transient failure used to destroy the token.
|
||||
it('transient 500 RETAINS the token and reports it', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(500)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.accepted).toBe(false)
|
||||
expect(result.disposition).toBe('retryable')
|
||||
expect(result.problem).toBe('retryable')
|
||||
expect(result.cleared).toBe(false)
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBe(TOKEN)
|
||||
})
|
||||
|
||||
it('session not yet propagated (401) RETAINS the token', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(401)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.problem).toBe('retryable')
|
||||
expect(result.cleared).toBe(false)
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBe(TOKEN)
|
||||
})
|
||||
|
||||
it('network throw RETAINS the token and reports it', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
fetchMock.mockRejectedValue(new TypeError('Failed to fetch'))
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.accepted).toBe(false)
|
||||
expect(result.disposition).toBe('retryable')
|
||||
expect(result.problem).toBe('retryable')
|
||||
expect(result.cleared).toBe(false)
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBe(TOKEN)
|
||||
})
|
||||
|
||||
it('email mismatch (403) RETAINS the token so the right account can still use it', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(403)
|
||||
|
||||
const result = await consumeInviteCookie()
|
||||
|
||||
expect(result.accepted).toBe(false)
|
||||
expect(result.disposition).toBe('wrong_email')
|
||||
expect(result.problem).toBe('wrong_email')
|
||||
expect(result.cleared).toBe(false)
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBe(TOKEN)
|
||||
})
|
||||
|
||||
it('accepts an out-of-band token without reading the cookie', async () => {
|
||||
installCookieJar({})
|
||||
respondWith(200)
|
||||
|
||||
const result = await consumeInviteCookie({ token: 'gnubok_inv_from-the-url' })
|
||||
|
||||
expect(result.accepted).toBe(true)
|
||||
expect(fetchMock).toHaveBeenCalledWith(
|
||||
'/api/team/accept',
|
||||
expect.objectContaining({ body: JSON.stringify({ token: 'gnubok_inv_from-the-url' }) }),
|
||||
)
|
||||
})
|
||||
|
||||
it('every problem disposition has a message key pair', async () => {
|
||||
for (const problem of ['retryable', 'wrong_email', 'spent'] as const) {
|
||||
expect(INVITE_PROBLEM_MESSAGE_KEYS[problem].title).toBeTruthy()
|
||||
expect(INVITE_PROBLEM_MESSAGE_KEYS[problem].body).toBeTruthy()
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
/**
|
||||
* Control: the pre-fix logic, copied verbatim from what login/register/mfa
|
||||
* used to inline. It clears the cookie on the `!res.ok` fall-through and on
|
||||
* the throw, and never tells the user anything. Running the retention
|
||||
* expectations against it proves the tests above are actually load-bearing
|
||||
* and not passing by construction.
|
||||
*/
|
||||
async function legacyInviteHandling(): Promise<{ accepted: boolean; problem: string | null }> {
|
||||
const cookieMatch = document.cookie.match(/gnubok-invite-token=([^;]+)/)
|
||||
const inviteToken = cookieMatch?.[1]
|
||||
|
||||
if (inviteToken) {
|
||||
try {
|
||||
const res = await fetch('/api/team/accept', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ token: inviteToken }),
|
||||
})
|
||||
|
||||
if (res.ok) {
|
||||
document.cookie = 'gnubok-invite-token=; path=/; max-age=0'
|
||||
return { accepted: true, problem: null }
|
||||
}
|
||||
} catch {
|
||||
// swallowed
|
||||
}
|
||||
// Clear cookie even on failure to avoid retrying stale tokens
|
||||
document.cookie = 'gnubok-invite-token=; path=/; max-age=0'
|
||||
}
|
||||
|
||||
return { accepted: false, problem: null }
|
||||
}
|
||||
|
||||
describe('regression control: the old unconditional-clear logic', () => {
|
||||
it('fails the transient-500 retention expectation', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(500)
|
||||
|
||||
const legacy = await legacyInviteHandling()
|
||||
|
||||
// What the new tests assert, and what the old code does not do:
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBeUndefined() // token destroyed
|
||||
expect(legacy.problem).toBeNull() // user told nothing
|
||||
})
|
||||
|
||||
it('fails the network-throw retention expectation', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
fetchMock.mockRejectedValue(new TypeError('Failed to fetch'))
|
||||
|
||||
await legacyInviteHandling()
|
||||
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBeUndefined() // token destroyed
|
||||
})
|
||||
|
||||
it('fails the 403 email-mismatch retention expectation', async () => {
|
||||
const jar = installCookieJar({ [INVITE_COOKIE_NAME]: TOKEN })
|
||||
respondWith(403)
|
||||
|
||||
await legacyInviteHandling()
|
||||
|
||||
expect(jar.get(INVITE_COOKIE_NAME)).toBeUndefined() // token destroyed
|
||||
})
|
||||
})
|
||||
@@ -40,6 +40,44 @@ describe('safeReturnTo', () => {
|
||||
expect(safeReturnTo('javascript:alert(1)', '/')).toBe('/')
|
||||
})
|
||||
|
||||
it('rejects dot segments that normalise into a protocol-relative URL', () => {
|
||||
// The raw input starts with a single '/', so the prefix guards let it
|
||||
// through, and it resolves against the sentinel origin, so the origin
|
||||
// check lets it through too. But URL normalisation collapses it to
|
||||
// '//evil.com', which navigates off-origin the moment a caller uses it
|
||||
// as a bare href (window.location.assign / router.push).
|
||||
expect(safeReturnTo('/..//evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/.//evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/a/../..//evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/../\\evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/..//evil.com?x=1', '/')).toBe('/')
|
||||
})
|
||||
|
||||
it('rejects the percent-encoded spelling of those dot segments', () => {
|
||||
expect(safeReturnTo('/%2e%2e//evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/%2E%2E//evil.com', '/')).toBe('/')
|
||||
})
|
||||
|
||||
it('rejects dot segments that normalise into the /@ form', () => {
|
||||
// The raw-input rule rejects '/@evil.com' outright, but dot-segment
|
||||
// resolution can smuggle it past that guard: '/a/../@evil.com' starts
|
||||
// with an innocent '/a' yet normalises to '/@evil.com'. The
|
||||
// post-normalisation check must reject every prefix the raw check does.
|
||||
expect(safeReturnTo('/a/../@evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/.//@evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/%2e%2e/@evil.com', '/')).toBe('/')
|
||||
expect(safeReturnTo('/a/../@evil.com?x=1', '/')).toBe('/')
|
||||
})
|
||||
|
||||
it('still allows ordinary dot segments that stay on-origin', () => {
|
||||
expect(safeReturnTo('/settings/../invoices', '/')).toBe('/invoices')
|
||||
expect(safeReturnTo('/./settings/tax', '/')).toBe('/settings/tax')
|
||||
})
|
||||
|
||||
it('keeps percent-encoded slashes, which are path data and stay on-origin', () => {
|
||||
expect(safeReturnTo('/%2F%2Fevil.com', '/')).toBe('/%2F%2Fevil.com')
|
||||
})
|
||||
|
||||
it('rejects data: URIs', () => {
|
||||
expect(safeReturnTo('data:text/html,<script>alert(1)</script>', '/')).toBe('/')
|
||||
expect(safeReturnTo('data:,', '/')).toBe('/')
|
||||
|
||||
@@ -189,10 +189,16 @@ export const TOOL_SCOPE_MAP: Record<string, ApiKeyScope> = {
|
||||
gnubok_update_article: 'articles:write',
|
||||
// Invoices
|
||||
gnubok_list_invoices: 'invoices:read',
|
||||
gnubok_get_invoice_deliveries: 'invoices:read',
|
||||
gnubok_create_invoice: 'invoices:write',
|
||||
gnubok_update_invoice: 'invoices:write',
|
||||
gnubok_send_invoice: 'invoices:write',
|
||||
gnubok_mark_invoice_as_paid: 'invoices:write',
|
||||
gnubok_mark_invoice_as_sent: 'invoices:write',
|
||||
// Recurring invoice schedules (staged template writes; no send/book at commit)
|
||||
gnubok_list_recurring_schedules: 'invoices:read',
|
||||
gnubok_create_recurring_schedule: 'invoices:write',
|
||||
gnubok_update_recurring_schedule: 'invoices:write',
|
||||
// Suppliers
|
||||
gnubok_list_suppliers: 'suppliers:read',
|
||||
gnubok_list_supplier_invoices: 'suppliers:read',
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
/**
|
||||
* Shared consumption of the pre-auth invite cookie.
|
||||
*
|
||||
* `app/invite/[token]/page.tsx` drops the raw invite token into
|
||||
* `gnubok-invite-token` before sending an invitee off to log in or register.
|
||||
* Every auth surface that can complete a session (login, register, MFA
|
||||
* verify) has to pick that token back up and POST it to /api/team/accept,
|
||||
* otherwise the invitee lands in the app without the membership they were
|
||||
* invited to.
|
||||
*
|
||||
* The rule this helper exists to enforce: the cookie is deleted ONLY on a
|
||||
* definitive outcome. Those surfaces each used to clear it unconditionally,
|
||||
* so a network blip or a 500 from /api/team/accept destroyed the token even
|
||||
* though the invitation was still `pending` in the database. The cookie is
|
||||
* the only copy the browser holds, so nothing short of the inviter re-sending
|
||||
* the invitation could recover it.
|
||||
*
|
||||
* Retention is a real recovery path, not just a deferral: `/onboarding` and
|
||||
* `/select-company` both re-run acceptance server-side from the surviving
|
||||
* cookie via `acceptPendingInviteByToken()` (lib/company/pending-invites.ts),
|
||||
* and the dashboard root redirects a company-less user straight to
|
||||
* `/onboarding`. A retained token therefore gets retried on the very next
|
||||
* page load.
|
||||
*
|
||||
* Security note: retention does not widen the token's authority. Its lifetime
|
||||
* is bounded server-side by `company_invitations.expires_at` (7 days) and by
|
||||
* the single-use `status` transition, both enforced on every POST in
|
||||
* app/api/team/accept/route.ts; the cookie's own `max-age` is set at write
|
||||
* time and is untouched here. Acceptance is re-authorized on every attempt
|
||||
* (`requireAuth()` plus an email equality check against the invitation), so a
|
||||
* surviving cookie confers nothing on its own.
|
||||
*/
|
||||
|
||||
export const INVITE_COOKIE_NAME = 'gnubok-invite-token'
|
||||
|
||||
const ACCEPT_ENDPOINT = '/api/team/accept'
|
||||
|
||||
/**
|
||||
* What POST /api/team/accept told us about the token's fate.
|
||||
*
|
||||
* - `accepted` the invitee is a member of the company now.
|
||||
* - `spent` the token is genuinely used up or invalid: it can never work.
|
||||
* - `wrong_email` the signed-in account is not the invited one. The invitation
|
||||
* is untouched and still pending; the wrong account simply
|
||||
* cannot redeem it.
|
||||
* - `retryable` nothing conclusive happened. The token is still live.
|
||||
*
|
||||
* `accepted` and `spent` are the only definitive outcomes, and therefore the
|
||||
* only ones that may clear the cookie.
|
||||
*/
|
||||
export type InviteAcceptDisposition = 'accepted' | 'spent' | 'wrong_email' | 'retryable'
|
||||
|
||||
/**
|
||||
* Map an HTTP status from POST /api/team/accept onto a disposition.
|
||||
*
|
||||
* Derived from app/api/team/accept/route.ts:
|
||||
*
|
||||
* | Status | Route meaning | Disposition |
|
||||
* |--------|----------------------------------------|---------------|
|
||||
* | 2xx | membership created, invite accepted | accepted |
|
||||
* | 409 | 'Du är redan medlem.' | accepted |
|
||||
* | 400 | token missing, unknown, or not pending | spent |
|
||||
* | 404 | invitation not found (GET shape) | spent |
|
||||
* | 410 | 'Inbjudan har gått ut.' (+ marked so) | spent |
|
||||
* | 403 | 'E-postadressen matchar inte...' | wrong_email |
|
||||
* | other | 401 session race, 429, 5xx, proxy hiccup | retryable |
|
||||
*
|
||||
* 409 counts as accepted: the invitee is in the company, which is the whole
|
||||
* point of holding the token. 401 is deliberately retryable rather than a
|
||||
* hard failure: it means the session cookie had not propagated yet, and the
|
||||
* next attempt (or the server-side retry on /onboarding) succeeds.
|
||||
*/
|
||||
export function classifyInviteAcceptStatus(status: number): InviteAcceptDisposition {
|
||||
if (status >= 200 && status < 300) return 'accepted'
|
||||
|
||||
switch (status) {
|
||||
case 409:
|
||||
return 'accepted'
|
||||
case 400:
|
||||
case 404:
|
||||
case 410:
|
||||
return 'spent'
|
||||
case 403:
|
||||
return 'wrong_email'
|
||||
default:
|
||||
return 'retryable'
|
||||
}
|
||||
}
|
||||
|
||||
/** Only a definitive disposition may destroy the token. */
|
||||
export function isDefinitiveInviteDisposition(disposition: InviteAcceptDisposition): boolean {
|
||||
return disposition === 'accepted' || disposition === 'spent'
|
||||
}
|
||||
|
||||
/** Non-success dispositions the caller has to surface to the user. */
|
||||
export type InviteAcceptProblem = Exclude<InviteAcceptDisposition, 'accepted'>
|
||||
|
||||
/**
|
||||
* i18n keys (namespace `invite`) for each problem. Kept here so the four auth
|
||||
* surfaces render the same wording instead of inventing their own.
|
||||
*/
|
||||
export const INVITE_PROBLEM_MESSAGE_KEYS: Record<
|
||||
InviteAcceptProblem,
|
||||
{ title: string; body: string }
|
||||
> = {
|
||||
retryable: { title: 'accept_retry_title', body: 'accept_retry_body' },
|
||||
wrong_email: { title: 'accept_wrong_email_title', body: 'accept_wrong_email_body' },
|
||||
spent: { title: 'accept_spent_title', body: 'accept_spent_body' },
|
||||
}
|
||||
|
||||
export interface ConsumeInviteCookieResult {
|
||||
/** False when there was no invite to process: the caller keeps its normal flow. */
|
||||
attempted: boolean
|
||||
/** Null only when `attempted` is false. */
|
||||
disposition: InviteAcceptDisposition | null
|
||||
/** True when the invitee is now a member: land them in the app. */
|
||||
accepted: boolean
|
||||
/** True when the token was removed from the browser. */
|
||||
cleared: boolean
|
||||
/** Null on success; otherwise the message the caller must show. */
|
||||
problem: InviteAcceptProblem | null
|
||||
}
|
||||
|
||||
const NO_INVITE: ConsumeInviteCookieResult = {
|
||||
attempted: false,
|
||||
disposition: null,
|
||||
accepted: false,
|
||||
cleared: false,
|
||||
problem: null,
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the raw invite token from the cookie jar. Anchored on a cookie
|
||||
* boundary so a differently-named cookie ending in the same suffix cannot
|
||||
* masquerade as the invite token.
|
||||
*/
|
||||
export function readInviteCookie(): string | null {
|
||||
if (typeof document === 'undefined') return null
|
||||
const match = document.cookie.match(
|
||||
new RegExp(`(?:^|;\\s*)${INVITE_COOKIE_NAME}=([^;]*)`),
|
||||
)
|
||||
const value = match?.[1]
|
||||
return value ? value : null
|
||||
}
|
||||
|
||||
/**
|
||||
* Expire the invite cookie. Same attributes the auth surfaces have always
|
||||
* used: path-scoped delete, no change to domain, samesite or secure.
|
||||
*/
|
||||
export function clearInviteCookie(): void {
|
||||
if (typeof document === 'undefined') return
|
||||
document.cookie = `${INVITE_COOKIE_NAME}=; path=/; max-age=0`
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the pending invite token, try to accept it, and clear the cookie only
|
||||
* if the outcome was definitive.
|
||||
*
|
||||
* Pass `token` explicitly when the caller already has it out of band (the
|
||||
* invite page reads it from the route params); the cookie is still cleared on
|
||||
* a definitive outcome so a stale copy does not linger.
|
||||
*/
|
||||
export async function consumeInviteCookie(
|
||||
options: { token?: string | null } = {},
|
||||
): Promise<ConsumeInviteCookieResult> {
|
||||
const token = options.token ?? readInviteCookie()
|
||||
if (!token) return NO_INVITE
|
||||
|
||||
let disposition: InviteAcceptDisposition
|
||||
|
||||
try {
|
||||
const res = await fetch(ACCEPT_ENDPOINT, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ token }),
|
||||
})
|
||||
disposition = classifyInviteAcceptStatus(res.status)
|
||||
} catch (err) {
|
||||
// The request never reached the server, so the invitation is certainly
|
||||
// still pending. Keep the token.
|
||||
console.error('[invite] acceptance request failed:', err)
|
||||
disposition = 'retryable'
|
||||
}
|
||||
|
||||
const cleared = isDefinitiveInviteDisposition(disposition)
|
||||
if (cleared) clearInviteCookie()
|
||||
|
||||
return {
|
||||
attempted: true,
|
||||
disposition,
|
||||
accepted: disposition === 'accepted',
|
||||
cleared,
|
||||
problem: disposition === 'accepted' ? null : disposition,
|
||||
}
|
||||
}
|
||||
+235
-4
@@ -1,18 +1,94 @@
|
||||
import crypto from 'crypto'
|
||||
import { NextResponse } from 'next/server'
|
||||
import { captureException, captureMessage } from '@/lib/observability'
|
||||
|
||||
/**
|
||||
* Cron authentication and failure reporting.
|
||||
*
|
||||
* Every scheduled job in `vercel.json` enters through `verifyCronSecret()`,
|
||||
* which makes this the one place that sees all of them without touching 16
|
||||
* route files. A cron that silently stops running is the worst failure mode in
|
||||
* this product: nothing is visibly broken, the work just never happens, and
|
||||
* nobody finds out until a period does not close or a reminder never goes out.
|
||||
*
|
||||
* The reporting shape is generalised from the one well-built alerting path in
|
||||
* the repo, `extensions/general/cloud-backup/lib/backup-alert.ts`: a pure
|
||||
* "should we report" predicate, a throttle window, a consecutive-failure
|
||||
* counter, and best-effort delivery that can never fail the loop it monitors.
|
||||
*
|
||||
* Two deliberate differences from the backup-alert defaults:
|
||||
*
|
||||
* - Threshold defaults to 1, not 3. Backup alerts email a human, so waiting
|
||||
* for three consecutive nights avoids nagging. This sink is a machine
|
||||
* aggregator; suppressing the first occurrence of a failure is exactly how
|
||||
* an outage stays invisible. The consecutive count ships as context so an
|
||||
* alert rule can threshold on it downstream, where it belongs.
|
||||
* - Throttle defaults to 15 minutes, not 7 days. It exists to stop a cron
|
||||
* looping over thousands of failing items from emitting thousands of
|
||||
* events, not to ration notifications.
|
||||
*
|
||||
* The failure state is in-process and therefore per serverless instance. That
|
||||
* is fine for its purpose (storm damping); it is NOT a durable state machine,
|
||||
* and nothing here should be relied on to remember anything across cold
|
||||
* starts. Every distinct failure still reports.
|
||||
*/
|
||||
|
||||
/** At most one report per operation+kind per window. Damps event storms. */
|
||||
export const CRON_REPORT_THROTTLE_MS = 15 * 60 * 1000
|
||||
|
||||
/** Consecutive failures before reporting. 1 = report the first failure. */
|
||||
export const CRON_REPORT_FAILURE_THRESHOLD = 1
|
||||
|
||||
/**
|
||||
* Upper bound on tracked keys. Keys derive from cron operation names (a fixed,
|
||||
* small set), but the fallback keys off the request pathname, so this caps the
|
||||
* map rather than trusting that assumption forever.
|
||||
*/
|
||||
const MAX_TRACKED_CRON_KEYS = 200
|
||||
|
||||
export type CronFailureKind = 'auth' | 'run' | 'item'
|
||||
|
||||
interface CronReportState {
|
||||
consecutiveFailures: number
|
||||
lastReportAt: number | null
|
||||
}
|
||||
|
||||
const cronReportState = new Map<string, CronReportState>()
|
||||
|
||||
export interface VerifyCronSecretOptions {
|
||||
/**
|
||||
* Stable name for this cron, used as the reporting key. Defaults to the
|
||||
* request pathname, which is already unique per scheduled job.
|
||||
*/
|
||||
operation?: string
|
||||
/** Set false to skip sink reporting entirely (tests, probes). */
|
||||
report?: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify cron secret using constant-time comparison to prevent timing attacks.
|
||||
* Expects `Authorization: Bearer <CRON_SECRET>` header.
|
||||
*
|
||||
* Returns null if authorized, or a 401 NextResponse if not.
|
||||
*
|
||||
* A 401 here is reported to the observability sink (throttled, best-effort).
|
||||
* That is the highest-value automatic signal available: if CRON_SECRET is
|
||||
* rotated in Vercel but not in the scheduler (or unset entirely), all 16 jobs
|
||||
* start failing auth and stop doing their work, while every endpoint keeps
|
||||
* answering "fine, 401" to anyone looking at status codes.
|
||||
*/
|
||||
export function verifyCronSecret(request: Request): NextResponse | null {
|
||||
export function verifyCronSecret(
|
||||
request: Request,
|
||||
options: VerifyCronSecretOptions = {},
|
||||
): NextResponse | null {
|
||||
const authHeader = request.headers.get('authorization')
|
||||
const cronSecret = process.env.CRON_SECRET
|
||||
|
||||
if (!cronSecret || !authHeader) {
|
||||
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
|
||||
if (!cronSecret) {
|
||||
return denyCron(request, options, 'secret_not_configured')
|
||||
}
|
||||
if (!authHeader) {
|
||||
return denyCron(request, options, 'missing_authorization')
|
||||
}
|
||||
|
||||
const token = authHeader.startsWith('Bearer ')
|
||||
@@ -25,8 +101,163 @@ export function verifyCronSecret(request: Request): NextResponse | null {
|
||||
const secretHash = crypto.createHash('sha256').update(cronSecret).digest()
|
||||
|
||||
if (!crypto.timingSafeEqual(tokenHash, secretHash)) {
|
||||
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
|
||||
return denyCron(request, options, 'token_mismatch')
|
||||
}
|
||||
|
||||
// A good run clears the auth failure streak so the next outage reports from
|
||||
// a clean count rather than inheriting an old one.
|
||||
if (options.report !== false) {
|
||||
reportCronSuccess(resolveCronOperation(request, options), 'auth')
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
function denyCron(
|
||||
request: Request,
|
||||
options: VerifyCronSecretOptions,
|
||||
reason: string,
|
||||
): NextResponse {
|
||||
if (options.report !== false) {
|
||||
reportCronFailure({
|
||||
operation: resolveCronOperation(request, options),
|
||||
kind: 'auth',
|
||||
status: 401,
|
||||
reason,
|
||||
})
|
||||
}
|
||||
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
|
||||
}
|
||||
|
||||
function resolveCronOperation(request: Request, options: VerifyCronSecretOptions): string {
|
||||
if (options.operation) return options.operation
|
||||
try {
|
||||
return new URL(request.url).pathname
|
||||
} catch {
|
||||
return 'unknown'
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Pure predicate: given the current streak and the last report time, should
|
||||
* this failure be reported? Mirrors `shouldSendBackupAlert()` so the two
|
||||
* alerting paths stay recognisably the same shape.
|
||||
*/
|
||||
export function shouldReportCronFailure(params: {
|
||||
consecutiveFailures: number
|
||||
lastReportAt: number | null
|
||||
threshold?: number
|
||||
throttleMs?: number
|
||||
now?: number
|
||||
}): boolean {
|
||||
const threshold = params.threshold ?? CRON_REPORT_FAILURE_THRESHOLD
|
||||
const throttleMs = params.throttleMs ?? CRON_REPORT_THROTTLE_MS
|
||||
const now = params.now ?? Date.now()
|
||||
|
||||
if (params.consecutiveFailures < threshold) return false
|
||||
if (
|
||||
params.lastReportAt !== null &&
|
||||
Number.isFinite(params.lastReportAt) &&
|
||||
now - params.lastReportAt < throttleMs
|
||||
) {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
export interface CronFailureReport {
|
||||
/** Stable cron identity, e.g. 'cron.invoice-reminders' or the route path. */
|
||||
operation: string
|
||||
/** auth = rejected at the door, run = the whole run failed, item = one unit failed. */
|
||||
kind?: CronFailureKind
|
||||
/** HTTP status the cron is about to return, when there is one. */
|
||||
status?: number
|
||||
/** The thrown value, if any. Serialized and redacted before it leaves. */
|
||||
error?: unknown
|
||||
/** Short machine-readable cause, e.g. 'token_mismatch', 'timeout'. */
|
||||
reason?: string
|
||||
/** Correlation id, matching the one in the cron's log lines. */
|
||||
requestId?: string
|
||||
itemsTotal?: number
|
||||
itemsFailed?: number
|
||||
/** Extra structured context. Redacted by the sink before delivery. */
|
||||
context?: Record<string, unknown>
|
||||
/** Overrides, mainly for tests. */
|
||||
threshold?: number
|
||||
throttleMs?: number
|
||||
now?: number
|
||||
}
|
||||
|
||||
/**
|
||||
* Report a non-2xx cron outcome to the observability sink.
|
||||
*
|
||||
* Best-effort by design and by contract: synchronous, swallows everything, and
|
||||
* can never throw into the cron's own path. A monitoring call that breaks the
|
||||
* job it monitors is worse than no monitoring.
|
||||
*/
|
||||
export function reportCronFailure(report: CronFailureReport): void {
|
||||
try {
|
||||
const kind = report.kind ?? 'run'
|
||||
const key = `${report.operation}:${kind}`
|
||||
const now = report.now ?? Date.now()
|
||||
|
||||
if (!cronReportState.has(key) && cronReportState.size >= MAX_TRACKED_CRON_KEYS) {
|
||||
// Evict the oldest entry only (Map preserves insertion order). A
|
||||
// wholesale clear() would drop every live throttle at once, so an
|
||||
// in-progress failure storm would re-report immediately: the exact
|
||||
// event flood the throttle exists to damp.
|
||||
const oldestKey = cronReportState.keys().next().value
|
||||
if (oldestKey !== undefined) cronReportState.delete(oldestKey)
|
||||
}
|
||||
|
||||
const state = cronReportState.get(key) ?? { consecutiveFailures: 0, lastReportAt: null }
|
||||
state.consecutiveFailures += 1
|
||||
cronReportState.set(key, state)
|
||||
|
||||
const shouldReport = shouldReportCronFailure({
|
||||
consecutiveFailures: state.consecutiveFailures,
|
||||
lastReportAt: state.lastReportAt,
|
||||
threshold: report.threshold,
|
||||
throttleMs: report.throttleMs,
|
||||
now,
|
||||
})
|
||||
if (!shouldReport) return
|
||||
|
||||
state.lastReportAt = now
|
||||
|
||||
const context: Record<string, unknown> = {
|
||||
...(report.context ?? {}),
|
||||
cron: true,
|
||||
alert: true,
|
||||
operation: report.operation,
|
||||
cronKind: kind,
|
||||
consecutiveFailures: state.consecutiveFailures,
|
||||
}
|
||||
if (report.status !== undefined) context.status = report.status
|
||||
if (report.reason !== undefined) context.reason = report.reason
|
||||
if (report.requestId !== undefined) context.requestId = report.requestId
|
||||
if (report.itemsTotal !== undefined) context.itemsTotal = report.itemsTotal
|
||||
if (report.itemsFailed !== undefined) context.itemsFailed = report.itemsFailed
|
||||
|
||||
if (report.error !== undefined) {
|
||||
captureException(report.error, context)
|
||||
} else {
|
||||
captureMessage(`cron failed: ${report.operation}`, 'error', context)
|
||||
}
|
||||
} catch {
|
||||
// Best-effort by design: reporting must never fail the cron it monitors.
|
||||
}
|
||||
}
|
||||
|
||||
/** Clear the failure streak for an operation after a good run. Never throws. */
|
||||
export function reportCronSuccess(operation: string, kind: CronFailureKind = 'run'): void {
|
||||
try {
|
||||
cronReportState.delete(`${operation}:${kind}`)
|
||||
} catch {
|
||||
// Best-effort by design.
|
||||
}
|
||||
}
|
||||
|
||||
/** Test helper: drop all in-process throttle and streak state. */
|
||||
export function resetCronReportingState(): void {
|
||||
cronReportState.clear()
|
||||
}
|
||||
|
||||
@@ -20,7 +20,26 @@ export function safeReturnTo(value: string | null | undefined, fallback: string)
|
||||
const base = 'https://gnubok.invalid'
|
||||
const parsed = new URL(value, base)
|
||||
if (parsed.origin !== base) return fallback
|
||||
return parsed.pathname + parsed.search + parsed.hash
|
||||
const path = parsed.pathname + parsed.search + parsed.hash
|
||||
// Re-check the NORMALISED path, not just the raw input. Dot-segment
|
||||
// resolution turns several innocent-looking inputs into a
|
||||
// protocol-relative one: `/..//evil.com`, `/.//evil.com` and
|
||||
// `/%2e%2e//evil.com` all normalise to `//evil.com`, and
|
||||
// `/a/../@evil.com` normalises to `/@evil.com`. Those keep the
|
||||
// sentinel origin above (they are relative to it), so the origin check
|
||||
// passes, but the returned string navigates off-origin the moment a
|
||||
// caller uses it as a bare href (window.location.assign, router.push).
|
||||
// Every prefix the raw-input guard rejects is re-rejected here, in
|
||||
// normal form, so the post-check cannot itself be re-normalised around.
|
||||
if (
|
||||
!path.startsWith('/') ||
|
||||
path.startsWith('//') ||
|
||||
path.startsWith('/\\') ||
|
||||
path.startsWith('/@')
|
||||
) {
|
||||
return fallback
|
||||
}
|
||||
return path
|
||||
} catch {
|
||||
return fallback
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user