From a27d02bd19df4b6772bf4a6fd5894de0dacd1e06 Mon Sep 17 00:00:00 2001 From: Rickylabs Date: Mon, 16 Nov 2026 19:34:02 +0100 Subject: [PATCH 1/5] docs(harness): plan auth endpoint rate-limit configuration --- .../context-pack.md | 3 +++ .../drift.md | 3 +++ .../plan.md | 25 +++++++++++++++++++ .../research.md | 7 ++++++ .../supervisor.md | 3 +++ .../worklog.md | 7 ++++++ 6 files changed, 48 insertions(+) create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/drift.md create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/plan.md create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/research.md create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/supervisor.md create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md new file mode 100644 index 0000000000..1119502e49 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md @@ -0,0 +1,3 @@ +# Context pack + +Issue2634, branch fix/auth-sign-in-rate-limit from origin/main b0eb07957. Bootstrap/design committed first and draft PR opens immediately. Implement serially with red schema/provider behavior tests before fixing. Keep absence unchanged; use validated native customRules and real production rate requests. No source edit to auth-service-runtime.ts (separate PR2641), no scaffolds/Aspire changes, no full CLI E2E needed. Mandatory independent straightforward IMPL-EVAL and required head checks before ready. Never merge/rebase/force-push/release or mark ready-merge. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/drift.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/drift.md new file mode 100644 index 0000000000..8408dcd4a6 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/drift.md @@ -0,0 +1,3 @@ +# Drift + +rtk/rg absent; commands run directly as node. Use pinned Deno2.9.7 via mise. Native tool names on current main: check:review-threads, maint:leak-check and maint:teardown. All public evidence uses repo-relative paths and omits operator identities. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/plan.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/plan.md new file mode 100644 index 0000000000..c4c6cab7ba --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/plan.md @@ -0,0 +1,25 @@ +# Plan + +## SKILL + +netscript-doctrine, netscript-harness, netscript-pr, netscript-tools, netscript-deno-toolchain and jsr-audit. + +## Contract and locked decisions + +Add optional AuthConfig.rateLimit and AuthConfigInput.rateLimit with native customRules: a record of endpoint paths/patterns to positive integer window (seconds) and max. Match provider field vocabulary; permit JSON data only, no disabling booleans, callbacks or unrelated provider options. Validate paths start with slash. Absence remains absence, with no forced enabled/global defaults. + +AuthServiceAppsettings accepts auth.rateLimit and Auth.RateLimit, each using the same nested customRules shape. Lowercase wins when both styles supplied, matching existing appsettings precedence. Better-auth registry validates the section through AuthConfigSchema and forwards only configured customRules via the existing betterAuthOptions.rateLimit. Other backends remain unchanged. + +No new production factory/test seam. A native Deno import-map test wrapper observes the provider constructed by the real registry, calls the original factory, and sends real production sign-in Fetch requests to prove configured throttling. This preserves the existing backend port and its non-interactive semantics. + +## Slices + +S1: bootstrap artifacts, red schema and real provider behavior regressions (under15files). +S2: schema/type first, registry forwarding, tests green and docs for native path patterns, seconds, production default and per-instance storage (under15files). +S3: generated docs/consumer refresh; scoped check/test/lint/fmt, quality:gate, doc lint/JSR audit, release:preflight, docs:accuracy; independent IMPL-EVAL; issue/body evidence and required head checks/thread gate (under20files). + +No full scaffold.runtime: no scaffold output, Aspire helper generation or executable/runtime wiring changes; only auth config/provider options. No changes to auth service runtime (owned by independent PR2641), saga transports or Redis Streams. No lock/dependency changes. + +## Risks + +Changing absent defaults -> omit provider rateLimit entirely when not configured. Global override ineffective on sign-in -> customRules only and real production request test. Provider IP buckets shared per path -> subprocess isolation per contract case; fixture IPs only. Config casing drift -> test both appsettings styles. Validation bypass -> registry parses through shared schema. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/research.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/research.md new file mode 100644 index 0000000000..9f974540f7 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/research.md @@ -0,0 +1,7 @@ +# Research + +Read issue #2634 in full. AuthConfigSchema drops unknown rateLimit input; registry passes only Prisma/provider/secret to createNetscriptBetterAuth. Existing betterAuthOptions already forwards provider-native options. Installed better-auth1.7.14 primary source confirms production-only default enabled, sign-in special rule3 requests/10seconds per IP and normalized path, special rules replace global max/window, customRules run after special rules. Storage defaults to provider in-memory buckets unless secondary storage exists. + +Plugin better-auth backend is non-interactive; its provider owns sign-in routes. This fix configures that provider and does not add interactive unified-auth endpoints. Existing lower auth and upper Auth appsettings styles are supported. + +Read doctrine public-surface/composition, harness Archetype2 Integration plus contract and service/docs concerns, skills netscript-doctrine/harness/pr/tools/deno-toolchain/jsr-audit, relevant package exports/README and provider tests. Inspected public AuthConfig through deno doc and resolved installed provider through deno why. No dependency change needed. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/supervisor.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/supervisor.md new file mode 100644 index 0000000000..3dba633034 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/supervisor.md @@ -0,0 +1,3 @@ +# Implementation lane + +Issue #2634, milestone0.0.10, branch fix/auth-sign-in-rate-limit from freshly fetched origin/main b0eb079575968e843b781579673c9fe2ae250e07. Owner-selected generator Codex gpt-6.1-sol/xhigh. Straightforward tier: small validated JSON contract and existing provider-option forwarding, no lifecycle or auth-flow redesign. PLAN-EVAL N/A: native data passthrough with locked defaults, no unresolved design decision. Mandatory IMPL-EVAL from live matrix: glm_5_3_flash/provider_default, fallback deepseek_v4_pro/provider_default, independent session/vendor family. No other implementation subagents. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md new file mode 100644 index 0000000000..2724a30df7 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md @@ -0,0 +1,7 @@ +# Worklog + +## Design + +Public surface is an optional data-only rateLimit.customRules config, native window/max vocabulary, positive integer validation and path-pattern keys. Lifecycle unchanged. Registry composition forwards the validated section to the existing provider passthrough only for better-auth. Tests observe real production provider rate behavior through a native import-map wrapper, with no product test seam. Documentation states effective default and provider-owned route scope. PLAN-EVAL N/A for this narrow native data passthrough with locked defaults; independent final evaluation required. + +Fresh main confirmed b0eb07957 before branch creation. Existing runtime PR2641 has completed source implementation and is awaiting supported CI; this separate implementation starts serially afterward. No source changes yet. From c70f6e564cdc06cadf0fd995f463f5c20db37a5f Mon Sep 17 00:00:00 2001 From: Rickylabs Date: Mon, 16 Nov 2026 19:36:56 +0100 Subject: [PATCH 2/5] test(auth): reproduce dropped endpoint rate-limit configuration --- .../context-pack.md | 2 + .../worklog.md | 7 ++ .../src/config/config_test.ts | 30 +++++- .../services/rate-limit-production_test.ts | 100 ++++++++++++++++++ 4 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 plugins/auth/tests/services/rate-limit-production_test.ts diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md index 1119502e49..4ef718afdb 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md @@ -1,3 +1,5 @@ # Context pack Issue2634, branch fix/auth-sign-in-rate-limit from origin/main b0eb07957. Bootstrap/design committed first and draft PR opens immediately. Implement serially with red schema/provider behavior tests before fixing. Keep absence unchanged; use validated native customRules and real production rate requests. No source edit to auth-service-runtime.ts (separate PR2641), no scaffolds/Aspire changes, no full CLI E2E needed. Mandatory independent straightforward IMPL-EVAL and required head checks before ready. Never merge/rebase/force-push/release or mark ready-merge. + +Red baseline established at unchanged main source: schema2pass/8fail; real production provider1pass/2fail, both configured casing styles ignore max1 while absent default3 works. Scoped native import map captures real registry provider construction and invokes its real factory. Next implement schema/types then registry forwarding, preserving absent behavior. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md index 2724a30df7..9790f2d8ac 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md @@ -5,3 +5,10 @@ Public surface is an optional data-only rateLimit.customRules config, native window/max vocabulary, positive integer validation and path-pattern keys. Lifecycle unchanged. Registry composition forwards the validated section to the existing provider passthrough only for better-auth. Tests observe real production provider rate behavior through a native import-map wrapper, with no product test seam. Documentation states effective default and provider-owned route scope. PLAN-EVAL N/A for this narrow native data passthrough with locked defaults; independent final evaluation required. Fresh main confirmed b0eb07957 before branch creation. Existing runtime PR2641 has completed source implementation and is awaiting supported CI; this separate implementation starts serially afterward. No source changes yet. + + +## Red baseline + +On unchanged main production source: schema tests have2pass/8fail (section dropped, invalid values/patterns silently ignored). Real production provider tests have1pass/2fail: absent configuration returns400,400,400,429, but both configured styles return400,400 rather than400,429 and omit forwarded customRules. This is actual better-auth Fetch handling, not a fake limiter. HTTP400 is the provider's disabled email/password endpoint response; counting occurs before that validation and no database/account state is needed. The test observes rate429 and captures the exact provider options on the plugin path. + +Initial unscoped import-map override was shadowed by workspace package mappings and failed to observe construction; that fixture failure is excluded. An explicit native scope for the real registry module now wraps its provider import and calls the original factory. No product seam was added. diff --git a/packages/plugin-auth-core/src/config/config_test.ts b/packages/plugin-auth-core/src/config/config_test.ts index 056c9fec9a..1bf868e158 100644 --- a/packages/plugin-auth-core/src/config/config_test.ts +++ b/packages/plugin-auth-core/src/config/config_test.ts @@ -1,4 +1,4 @@ -import { assertEquals } from '@std/assert'; +import { assertEquals, assertObjectMatch, assertThrows } from '@std/assert'; import { AuthConfigSchema, AuthSessionPolicySchema } from './mod.ts'; Deno.test('AuthConfigSchema applies backend and session defaults', () => { @@ -23,3 +23,31 @@ Deno.test('AuthSessionPolicySchema validates cookie policy knobs', () => { assertEquals(parsed.sameSite, 'strict'); assertEquals(parsed.ttlSeconds, 60); }); + +Deno.test('AuthConfigSchema retains native endpoint rate-limit rules', () => { + const rateLimit = { customRules: { '/sign-in/*': { window: 60, max: 7 } } }; + assertObjectMatch(AuthConfigSchema.parse({ rateLimit }), { rateLimit }); +}); + +for ( + const rule of [ + { window: 0, max: 1 }, + { window: 10, max: -1 }, + { window: 1.5, max: 1 }, + { window: 10, max: 1.5 }, + { window: '10', max: 1 }, + false, + ] +) { + Deno.test(`AuthConfigSchema rejects invalid endpoint rate rule ${JSON.stringify(rule)}`, () => { + assertThrows(() => + AuthConfigSchema.parse({ rateLimit: { customRules: { '/sign-in/*': rule } } }) + ); + }); +} + +Deno.test('AuthConfigSchema rejects rate-limit patterns without a leading slash', () => { + assertThrows(() => + AuthConfigSchema.parse({ rateLimit: { customRules: { 'sign-in/*': { window: 10, max: 1 } } } }) + ); +}); diff --git a/plugins/auth/tests/services/rate-limit-production_test.ts b/plugins/auth/tests/services/rate-limit-production_test.ts new file mode 100644 index 0000000000..2d091dec0c --- /dev/null +++ b/plugins/auth/tests/services/rate-limit-production_test.ts @@ -0,0 +1,100 @@ +import { assertEquals } from '@std/assert'; +import { fromFileUrl, toFileUrl } from '@std/path'; + +const CONFIG = fromFileUrl(new URL('../../../../deno.json', import.meta.url)); +const PROVIDER = new URL('../../../../packages/auth-better-auth/mod.ts', import.meta.url).href; +const REGISTRY = new URL('../../services/src/backend-registry.ts', import.meta.url).href; + +for (const style of ['absent', 'lower', 'upper'] as const) { + Deno.test(`auth plugin production sign-in rate rule uses ${style} configuration`, async () => { + const root = await Deno.makeTempDir(); + const wrapper = `${root}/provider.ts`; + const customRules = { '/sign-in/*': { window: 60, max: 1 } }; + const appsettings = style === 'lower' + ? { auth: { rateLimit: { customRules } } } + : style === 'upper' + ? { Auth: { RateLimit: { customRules } } } + : {}; + try { + // Observe the real provider made by the plugin registry without adding a + // product injection hook. This wrapper always invokes the original factory. + await Deno.writeTextFile( + wrapper, + `export * from ${JSON.stringify(PROVIDER)}; +import { createNetscriptBetterAuth as createReal } from ${JSON.stringify(PROVIDER)}; +export let auth; +export let received; +export function createNetscriptBetterAuth(options) { + received = options; + auth = createReal(options); + return auth; +} +`, + ); + const importMap = `${root}/import-map.json`; + await Deno.writeTextFile( + importMap, + JSON.stringify({ + scopes: { [REGISTRY]: { '@netscript/auth-better-auth': toFileUrl(wrapper).href } }, + }), + ); + const child = new Deno.Command(Deno.execPath(), { + args: [ + 'eval', + '--no-check', + '--unstable-kv', + '--config', + CONFIG, + '--import-map', + importMap, + `import { createAuthServiceBackendRegistry } from ${JSON.stringify(REGISTRY)}; +import * as provider from ${JSON.stringify(toFileUrl(wrapper).href)}; +await createAuthServiceBackendRegistry({ + env: { NETSCRIPT_AUTH_BACKEND: 'better-auth', BETTER_AUTH_SECRET: 'test-secret-that-is-at-least-32-characters-long' }, + appsettings: ${JSON.stringify(appsettings)}, +}); +if (!provider.auth) throw new Error('The import-map wrapper did not observe provider construction.'); +const statuses = []; +for (let attempt = 0; attempt < ${style === 'absent' ? 4 : 2}; attempt++) { + const response = await provider.auth.handler(new Request('http://localhost:3000/api/auth/sign-in/email', { + method: 'POST', + headers: { 'content-type': 'application/json', origin: 'http://localhost:3000', 'x-forwarded-for': '192.0.2.15' }, + body: JSON.stringify({ email: 'fixture@example.test', password: 'test-password' }), + })); + statuses.push(response.status); + await response.body?.cancel(); +} +console.log('RATE_PROBE:' + JSON.stringify({ statuses, rateLimit: provider.received.betterAuthOptions?.rateLimit })); +Deno.exit(0);`, + ], + env: { + NODE_ENV: 'production', + DENO_ENV: 'production', + BETTER_AUTH_URL: 'http://localhost:3000', + }, + stdout: 'piped', + stderr: 'piped', + }).spawn(); + const timer = setTimeout(() => { + try { + child.kill('SIGKILL'); + } catch { /* The owned child already exited. */ } + }, 20_000); + try { + const result = await child.output(); + assertEquals(result.code, 0, new TextDecoder().decode(result.stderr)); + const line = new TextDecoder().decode(result.stdout).split('\n').find((line) => + line.startsWith('RATE_PROBE:') + ); + assertEquals(JSON.parse(line?.slice('RATE_PROBE:'.length) ?? 'null'), { + statuses: style === 'absent' ? [400, 400, 400, 429] : [400, 429], + ...(style === 'absent' ? {} : { rateLimit: { customRules } }), + }); + } finally { + clearTimeout(timer); + } + } finally { + await Deno.remove(root, { recursive: true }); + } + }); +} From e1a60851186b23f99d6c32d69a1277ddec3a8b93 Mon Sep 17 00:00:00 2001 From: Rickylabs Date: Mon, 16 Nov 2026 19:44:47 +0100 Subject: [PATCH 3/5] fix(auth): validate and forward provider endpoint rate limits --- .../worklog.md | 7 ++++ docs/site/identity-access/auth.md | 35 +++++++++++++++++ .../identity-access/better-auth-plugins.md | 6 +++ docs/site/reference/plugin-auth-core/index.md | 2 + packages/plugin-auth-core/README.md | 21 ++++++++++ .../src/config/config_test.ts | 1 + packages/plugin-auth-core/src/config/mod.ts | 27 +++++++++++++ packages/plugin-auth-core/src/public/mod.ts | 2 + plugins/auth/services/src/backend-registry.ts | 12 +++++- .../services/rate-limit-production_test.ts | 38 +++++++++++++++---- 10 files changed, 142 insertions(+), 9 deletions(-) diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md index 9790f2d8ac..5c622d76e3 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md @@ -12,3 +12,10 @@ Fresh main confirmed b0eb07957 before branch creation. Existing runtime PR2641 h On unchanged main production source: schema tests have2pass/8fail (section dropped, invalid values/patterns silently ignored). Real production provider tests have1pass/2fail: absent configuration returns400,400,400,429, but both configured styles return400,400 rather than400,429 and omit forwarded customRules. This is actual better-auth Fetch handling, not a fake limiter. HTTP400 is the provider's disabled email/password endpoint response; counting occurs before that validation and no database/account state is needed. The test observes rate429 and captures the exact provider options on the plugin path. Initial unscoped import-map override was shadowed by workspace package mappings and failed to observe construction; that fixture failure is excluded. An explicit native scope for the real registry module now wraps its provider import and calls the original factory. No product seam was added. + + +## Contract and provider implementation + +Added documented AuthRateLimitRule/AuthRateLimitConfig types, optional data-only customRules in input/parsed config, positive integer window/max and slash-prefixed pattern validation. Missing section stays omitted. Registry accepts lower auth.rateLimit and upper Auth.RateLimit, validates through shared AuthConfigSchema, and passes configured customRules through existing betterAuthOptions; no enabled/storage/global changes and no production test seam. Public auth/core/reference docs describe native paths, first-match semantics, units, production3/10default, per-IP/path or missing-IP shared buckets, per-process memory storage and the provider-owned route boundary. + +Initial focused suite13/13 pass. Extended core/service/provider suite69/69 pass, including development enablement unchanged, lowercase precedence and invalid-config rejection before construction. Structured check/lint/fmt, quality:gate, release:preflight and docs:accuracy pass. Both JSR audits/dry-runs pass with existing warnings (core slow types; plugin directory cardinality/slow types). Full export-map doc lint reports core3 private references; measured base comparison and plugin report are being completed. Wrapper permission fixture errors are excluded from gate evidence. diff --git a/docs/site/identity-access/auth.md b/docs/site/identity-access/auth.md index 29f99af5be..db6ee32bde 100644 --- a/docs/site/identity-access/auth.md +++ b/docs/site/identity-access/auth.md @@ -270,6 +270,41 @@ rows: [ [Session lifecycles](/identity-access/session-lifecycles/) shows the HTTP wiring for each backend. +## Sign-in rate limits with better-auth + +The better-auth backend accepts `auth.rateLimit.customRules` in appsettings: + +```json +{ + "auth": { + "backend": "better-auth", + "rateLimit": { + "customRules": { + "/sign-in/*": { "window": 60, "max": 10 } + } + } + } +} +``` + +`Auth.RateLimit` is the equivalent section when using the capitalized `Auth` group; its nested +`customRules`, `window` and `max` keys keep the spelling shown above. If both sections exist, +`auth.rateLimit` takes precedence. The config schema validates positive integer windows (seconds) +and request counts, plus slash-prefixed paths or wildcard patterns. Paths are relative to +better-auth's base path: use `/sign-in/*`, without the `/api/auth` prefix. The provider uses the +first matching custom rule. + +With no section, the effective production sign-in default remains **three requests per ten seconds +per client IP and path**. This endpoint rule takes precedence over better-auth's global `window` +and `max`; set `customRules` to change it. The section forwards those rules without changing +production-only enablement or the provider's default in-memory storage, which applies separately +in each process. Requests without a trusted client IP share a bucket per path. + +These are better-auth's own sign-in endpoints. The unified NetScript `signin` endpoint remains +unsupported on this backend; [session lifecycles](/identity-access/session-lifecycles/#better-auth-mounting-and-header-forwarding) +describes mounting the provider handler. For a host-created provider, pass the same native rules +through `createNetscriptBetterAuth({ ..., betterAuthOptions: { rateLimit: { customRules } } })`. + ## How auth integrates with services The auth plugin signs users in and resolves their sessions. A NetScript service gates its own routes diff --git a/docs/site/identity-access/better-auth-plugins.md b/docs/site/identity-access/better-auth-plugins.md index 51a3bd0436..e9098082c5 100644 --- a/docs/site/identity-access/better-auth-plugins.md +++ b/docs/site/identity-access/better-auth-plugins.md @@ -49,6 +49,12 @@ session (`activeOrganizationId`, role, roles and permissions) and the user's rol NetScript's authenticator onto the `Principal` scopes, roles and claims. Downstream services and pages can authorize on organization context with no extra wiring. +Endpoint throttling uses `betterAuthOptions.rateLimit.customRules` on a host-created provider, or +`auth.rateLimit.customRules` in plugin appsettings. The effective production sign-in default is +three requests per ten seconds per client IP and path; a global window/max override does not replace +that endpoint rule. [Sign-in rate limits](/identity-access/auth/#sign-in-rate-limits-with-better-auth) +shows validated configuration, path patterns, units and storage behavior. + ## Plugin prerequisites A plugin enabled through the passthrough type-checks and is mounted at the better-auth layer. diff --git a/docs/site/reference/plugin-auth-core/index.md b/docs/site/reference/plugin-auth-core/index.md index f36bfb4404..1bae1e1154 100644 --- a/docs/site/reference/plugin-auth-core/index.md +++ b/docs/site/reference/plugin-auth-core/index.md @@ -76,6 +76,8 @@ the auth contract. | Symbol | Kind | Description | | --- | --- | --- | | `AuthConfig` | type alias | Parsed auth runtime configuration. | +| `AuthRateLimitConfig` | type alias | Optional native endpoint overrides in `rateLimit.customRules`. | +| `AuthRateLimitRule` | type alias | Positive integer `window` in seconds and `max` requests per IP and path. | | `AuthBackendRegistry` | type alias | Named backend registry type. | | `ResolvedAuthBackendRegistry` | type alias | Resolved backend registry state. | | `AuthProviderDescriptor` | type alias | Provider descriptor exposed by provider registries. | diff --git a/packages/plugin-auth-core/README.md b/packages/plugin-auth-core/README.md index 2cdc11d5c4..fcd1e1890d 100644 --- a/packages/plugin-auth-core/README.md +++ b/packages/plugin-auth-core/README.md @@ -39,6 +39,27 @@ NetScript host. streams, and `createAuthTelemetry` plus `redactAuthPrincipal` emit redacted spans, keeping principals out of your telemetry backend. +## Endpoint rate limits + +`AuthConfigSchema` accepts optional provider-native endpoint quotas: + +```ts +import { AuthConfigSchema } from '@netscript/plugin-auth-core/config'; + +const config = AuthConfigSchema.parse({ + backend: 'better-auth', + rateLimit: { customRules: { '/sign-in/*': { window: 60, max: 10 } } }, +}); +``` + +`window` is seconds and `max` is requests; both must be positive integers. Pattern keys start with +`/` and are relative to the provider's auth base path. The auth plugin reads this section from +`auth.rateLimit` or `Auth.RateLimit` appsettings and forwards it as better-auth +`rateLimit.customRules`. Omitting it preserves provider defaults: production sign-in allows three +requests per ten seconds per client IP and path. These endpoint rules take precedence over the +provider's global window/max. Configuration does not enable rate limiting outside production or +change the provider's default in-memory, per-process storage. + ## Architecture ```mermaid diff --git a/packages/plugin-auth-core/src/config/config_test.ts b/packages/plugin-auth-core/src/config/config_test.ts index 1bf868e158..310f4bf906 100644 --- a/packages/plugin-auth-core/src/config/config_test.ts +++ b/packages/plugin-auth-core/src/config/config_test.ts @@ -7,6 +7,7 @@ Deno.test('AuthConfigSchema applies backend and session defaults', () => { assertEquals(parsed.backend, 'default'); assertEquals(parsed.session.cookieName, '__Host-netscript-auth'); assertEquals(parsed.providers, []); + assertEquals('rateLimit' in parsed, false); }); Deno.test('AuthSessionPolicySchema validates cookie policy knobs', () => { diff --git a/packages/plugin-auth-core/src/config/mod.ts b/packages/plugin-auth-core/src/config/mod.ts index 01b2eb1e0c..5d245435e5 100644 --- a/packages/plugin-auth-core/src/config/mod.ts +++ b/packages/plugin-auth-core/src/config/mod.ts @@ -33,11 +33,27 @@ export type AuthProviderConfig = Readonly<{ metadata?: Readonly>; }>; +/** Data-only endpoint quota using the provider's native window/max vocabulary. */ +export type AuthRateLimitRule = Readonly<{ + /** Window length in seconds; must be a positive integer. */ + window: number; + /** Requests allowed per client IP and path in the window; a positive integer. */ + max: number; +}>; + +/** Optional provider endpoint overrides; omission preserves provider defaults. */ +export type AuthRateLimitConfig = Readonly<{ + /** Slash-prefixed paths or wildcard patterns relative to the provider's auth base path. */ + customRules: Readonly>; +}>; + /** Auth plugin configuration accepted from NetScript app settings. */ export type AuthConfig = Readonly<{ backend: string; session: AuthSessionPolicy; providers: readonly AuthProviderConfig[]; + /** Endpoint quotas forwarded to better-auth without changing production enablement. */ + rateLimit?: AuthRateLimitConfig; }>; /** Loose auth plugin configuration input accepted before defaults are applied. */ @@ -45,6 +61,8 @@ export type AuthConfigInput = Readonly<{ backend?: string; session?: Partial; providers?: readonly AuthProviderConfig[]; + /** Optional native endpoint quota overrides. */ + rateLimit?: AuthRateLimitConfig; }>; const AuthSessionPolicyZodSchema = z.object({ @@ -76,10 +94,18 @@ const AuthProviderConfigZodSchema: z.ZodType = z.object({ /** Schema for one auth provider configuration entry. */ export const AuthProviderConfigSchema: AuthSchema = AuthProviderConfigZodSchema; +const AuthRateLimitConfigZodSchema = z.object({ + customRules: z.record( + z.string().startsWith('/'), + z.object({ window: z.number().int().positive(), max: z.number().int().positive() }), + ), +}); + const AuthConfigInputZodSchema = z.object({ backend: z.string().min(1).default('default'), session: z.record(z.string(), z.unknown()).optional(), providers: z.array(AuthProviderConfigZodSchema).default([]), + rateLimit: AuthRateLimitConfigZodSchema.optional(), }); /** Schema for auth plugin configuration. */ @@ -88,4 +114,5 @@ export const AuthConfigSchema: AuthSchema = AuthConfigInputZodSchema backend: raw.backend, session: AuthSessionPolicyZodSchema.parse(raw.session ?? {}), providers: raw.providers, + ...(raw.rateLimit === undefined ? {} : { rateLimit: raw.rateLimit }), })); diff --git a/packages/plugin-auth-core/src/public/mod.ts b/packages/plugin-auth-core/src/public/mod.ts index de63a3b1fc..e83511dedd 100644 --- a/packages/plugin-auth-core/src/public/mod.ts +++ b/packages/plugin-auth-core/src/public/mod.ts @@ -59,6 +59,8 @@ export type { AuthConfig, AuthConfigInput, AuthProviderConfig, + AuthRateLimitConfig, + AuthRateLimitRule, AuthSessionPolicy, } from '../config/mod.ts'; export { authContract, authContractV1 } from '../contracts/v1/mod.ts'; diff --git a/plugins/auth/services/src/backend-registry.ts b/plugins/auth/services/src/backend-registry.ts index 80722655b9..b3d1fa2c11 100644 --- a/plugins/auth/services/src/backend-registry.ts +++ b/plugins/auth/services/src/backend-registry.ts @@ -20,7 +20,7 @@ import { type WorkosSessionRefreshResult, } from '@netscript/auth-workos'; import { getKv, MemoryKvAdapter, type WatchableKv } from '@netscript/kv'; -import { AuthConfigSchema } from '@netscript/plugin-auth-core/config'; +import { AuthConfigSchema, type AuthRateLimitConfig } from '@netscript/plugin-auth-core/config'; import { AuthBackendNotFoundError, type AuthBackendPort, @@ -43,11 +43,15 @@ export type AuthServiceAppsettings = Readonly<{ backend?: string; audit?: { salt?: string }; environment?: Readonly>; + /** Native endpoint quotas; lower-case appsettings take precedence. */ + rateLimit?: AuthRateLimitConfig; }; Auth?: { Backend?: string; Audit?: { Salt?: string }; Environment?: Readonly>; + /** Native endpoint quotas for the capitalized appsettings group. */ + RateLimit?: AuthRateLimitConfig; }; }>; @@ -247,11 +251,17 @@ async function createActiveBackend( }); } + const { rateLimit } = AuthConfigSchema.parse({ + rateLimit: options.appsettings?.auth?.rateLimit ?? options.appsettings?.Auth?.RateLimit, + }); return createBetterAuthBackend({ auth: createNetscriptBetterAuth({ prisma: options.dbClient ?? {}, provider: betterAuthPrismaProvider(env.DB_PROVIDER), secret: requiredEnv(env, 'BETTER_AUTH_SECRET'), + ...(rateLimit === undefined ? {} : { + betterAuthOptions: { rateLimit: { customRules: rateLimit.customRules } }, + }), }), sessionTokenSecret: requiredEnv(env, 'BETTER_AUTH_SECRET'), providers: [{ id: 'better-auth', displayName: 'better-auth' }], diff --git a/plugins/auth/tests/services/rate-limit-production_test.ts b/plugins/auth/tests/services/rate-limit-production_test.ts index 2d091dec0c..69dd17a9f6 100644 --- a/plugins/auth/tests/services/rate-limit-production_test.ts +++ b/plugins/auth/tests/services/rate-limit-production_test.ts @@ -1,16 +1,22 @@ -import { assertEquals } from '@std/assert'; +import { assertEquals, assertRejects } from '@std/assert'; import { fromFileUrl, toFileUrl } from '@std/path'; +import { createAuthServiceBackendRegistry } from '../../services/src/backend-registry.ts'; const CONFIG = fromFileUrl(new URL('../../../../deno.json', import.meta.url)); const PROVIDER = new URL('../../../../packages/auth-better-auth/mod.ts', import.meta.url).href; const REGISTRY = new URL('../../services/src/backend-registry.ts', import.meta.url).href; -for (const style of ['absent', 'lower', 'upper'] as const) { - Deno.test(`auth plugin production sign-in rate rule uses ${style} configuration`, async () => { +for (const style of ['absent', 'lower', 'upper', 'both', 'development'] as const) { + Deno.test(`auth plugin sign-in rate rule uses ${style} configuration`, async () => { const root = await Deno.makeTempDir(); const wrapper = `${root}/provider.ts`; const customRules = { '/sign-in/*': { window: 60, max: 1 } }; - const appsettings = style === 'lower' + const appsettings = style === 'both' + ? { + auth: { rateLimit: { customRules } }, + Auth: { RateLimit: { customRules: { '/sign-in/*': { window: 60, max: 5 } } } }, + } + : style === 'lower' || style === 'development' ? { auth: { rateLimit: { customRules } } } : style === 'upper' ? { Auth: { RateLimit: { customRules } } } @@ -55,7 +61,9 @@ await createAuthServiceBackendRegistry({ }); if (!provider.auth) throw new Error('The import-map wrapper did not observe provider construction.'); const statuses = []; -for (let attempt = 0; attempt < ${style === 'absent' ? 4 : 2}; attempt++) { +for (let attempt = 0; attempt < ${ + style === 'absent' || style === 'development' ? 4 : 2 + }; attempt++) { const response = await provider.auth.handler(new Request('http://localhost:3000/api/auth/sign-in/email', { method: 'POST', headers: { 'content-type': 'application/json', origin: 'http://localhost:3000', 'x-forwarded-for': '192.0.2.15' }, @@ -68,8 +76,8 @@ console.log('RATE_PROBE:' + JSON.stringify({ statuses, rateLimit: provider.recei Deno.exit(0);`, ], env: { - NODE_ENV: 'production', - DENO_ENV: 'production', + NODE_ENV: style === 'development' ? 'development' : 'production', + DENO_ENV: style === 'development' ? 'development' : 'production', BETTER_AUTH_URL: 'http://localhost:3000', }, stdout: 'piped', @@ -87,7 +95,11 @@ Deno.exit(0);`, line.startsWith('RATE_PROBE:') ); assertEquals(JSON.parse(line?.slice('RATE_PROBE:'.length) ?? 'null'), { - statuses: style === 'absent' ? [400, 400, 400, 429] : [400, 429], + statuses: style === 'absent' + ? [400, 400, 400, 429] + : style === 'development' + ? [400, 400, 400, 400] + : [400, 429], ...(style === 'absent' ? {} : { rateLimit: { customRules } }), }); } finally { @@ -98,3 +110,13 @@ Deno.exit(0);`, } }); } + +Deno.test('auth plugin validates configured provider quotas before construction', async () => { + await assertRejects(() => + createAuthServiceBackendRegistry({ + env: { NETSCRIPT_AUTH_BACKEND: 'better-auth', BETTER_AUTH_SECRET: 'test-secret' }, + appsettings: { + auth: { rateLimit: { customRules: { '/sign-in/*': { window: 0, max: 1 } } } }, + }, + }), Error); +}); From 86ffff9a61bf784840f3a744404c7cf960c14816 Mon Sep 17 00:00:00 2001 From: Rickylabs Date: Mon, 16 Nov 2026 19:48:21 +0100 Subject: [PATCH 4/5] chore(auth): refresh rate-limit documentation consumers --- .../context-pack.md | 10 ++++++++-- .../fix-auth-sign-in-rate-limit--issue-2634/worklog.md | 4 ++++ .../infrastructure/docs/agent-docs-prose.generated.ts | 6 +++--- .../export-surfaces/export-surface-corpus.generated.ts | 4 ++-- packages/mcp/src/publish-assets.generated.ts | 4 ++-- 5 files changed, 19 insertions(+), 9 deletions(-) diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md index 4ef718afdb..5ed4927258 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md @@ -1,5 +1,11 @@ # Context pack -Issue2634, branch fix/auth-sign-in-rate-limit from origin/main b0eb07957. Bootstrap/design committed first and draft PR opens immediately. Implement serially with red schema/provider behavior tests before fixing. Keep absence unchanged; use validated native customRules and real production rate requests. No source edit to auth-service-runtime.ts (separate PR2641), no scaffolds/Aspire changes, no full CLI E2E needed. Mandatory independent straightforward IMPL-EVAL and required head checks before ready. Never merge/rebase/force-push/release or mark ready-merge. +Issue2634, PR2642, branch fix/auth-sign-in-rate-limit from freshly fetched origin/main b0eb07957. Straightforward tier, PLAN-EVAL N/A (native data passthrough, locked defaults); mandatory separate-session IMPL-EVAL remains. No merge, auto-merge, ready-merge, rebase, force-push, release or publication. -Red baseline established at unchanged main source: schema2pass/8fail; real production provider1pass/2fail, both configured casing styles ignore max1 while absent default3 works. Scoped native import map captures real registry provider construction and invokes its real factory. Next implement schema/types then registry forwarding, preserving absent behavior. +Red tests committed before source: schema2pass/8fail; real provider1pass/2fail. Plugin registry ignored configured max1 in both lower/upper appsettings while absent3/10 default worked. Native Deno scoped import-map wrapper observes the real factory called by the registry, invokes the original and sends real production provider Fetch requests. No product test hook, no fake limiter, no external server/database/resources. HTTP400 is endpoint validation; rate429 is counted before it. Initial unscoped map fixture failure excluded. + +Contract/source committed through e1a608511: AuthRateLimitConfig/Rule, data-only customRules with positive integer seconds/window and max plus slash-prefixed paths/patterns; optional section omitted when absent. Registry accepts auth.rateLimit or Auth.RateLimit (lower wins), validates through shared schema and forwards native customRules with existing betterAuthOptions. Production enablement/storage/global settings untouched. Other backend and unified non-interactive endpoint behavior unchanged. Docs in auth/core README/reference and better-auth page describe defaults, scope and units. No edits to auth-service-runtime.ts, owned by separate PR2641. + +Core/service/provider tests69/69 pass, including absent production3/10, configured max1, development not enabled, casing precedence and invalid-config rejection. Structured check/lint/fmt, quality:gate, release:preflight and docs:accuracy pass. JSR audits/dry-runs for core/plugin pass with pre-existing slow-type/cardinality warnings. Full export-map doc lint core3/plugin12 exactly matches base entrypoints, per-file counts and entrypoint exits after repository-relative normalization; no new finding. + +Canonical agent docs/site build is complete; MCP export corpus generated with documented --allow-dirty for sole regenerated prose input, then assets/publish freshness gates run. No lock changes. No full scaffold.runtime applicable because no scaffold/Aspire/executable wiring changes. Initial docs-only skip labels removed with implementation. Next final generated-consumer commit, independent straightforward IMPL-EVAL (glm_5_3_flash/provider_default; fallback deepseek_v4_pro/provider_default), issue/body acceptance and closing keyword, ready transition, required head checks and review-thread gate. All public evidence omits operator paths/hostnames/ports/session IDs. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md index 5c622d76e3..47d339b1c5 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md @@ -19,3 +19,7 @@ Initial unscoped import-map override was shadowed by workspace package mappings Added documented AuthRateLimitRule/AuthRateLimitConfig types, optional data-only customRules in input/parsed config, positive integer window/max and slash-prefixed pattern validation. Missing section stays omitted. Registry accepts lower auth.rateLimit and upper Auth.RateLimit, validates through shared AuthConfigSchema, and passes configured customRules through existing betterAuthOptions; no enabled/storage/global changes and no production test seam. Public auth/core/reference docs describe native paths, first-match semantics, units, production3/10default, per-IP/path or missing-IP shared buckets, per-process memory storage and the provider-owned route boundary. Initial focused suite13/13 pass. Extended core/service/provider suite69/69 pass, including development enablement unchanged, lowercase precedence and invalid-config rejection before construction. Structured check/lint/fmt, quality:gate, release:preflight and docs:accuracy pass. Both JSR audits/dry-runs pass with existing warnings (core slow types; plugin directory cardinality/slow types). Full export-map doc lint reports core3 private references; measured base comparison and plugin report are being completed. Wrapper permission fixture errors are excluded from gate evidence. + +Full doc-lint baseline comparison confirmed: core3 and plugin12 private-type references match base b0eb07957 in summary, entrypoints, per-file diagnostic counts and entrypoint exits after repository-relative path normalization. Changed config entrypoint has no new finding. Initial raw path comparison differed only because the checkouts have different roots. + +Canonical agent-docs/site build, MCP export corpus, CLI assets and publish assets refresh complete. Export and publish freshness checks pass. Export generator allowed dirty only for the regenerated prose carrier, with every handwritten source/docs input already committed. No CLI asset diff and no lock changes. Final implementation is ready for independent straightforward IMPL-EVAL; 69-test and validation evidence remains above. diff --git a/packages/mcp/src/infrastructure/docs/agent-docs-prose.generated.ts b/packages/mcp/src/infrastructure/docs/agent-docs-prose.generated.ts index c1796f10d8..c58b22e2e2 100644 --- a/packages/mcp/src/infrastructure/docs/agent-docs-prose.generated.ts +++ b/packages/mcp/src/infrastructure/docs/agent-docs-prose.generated.ts @@ -291,9 +291,9 @@ export const EMBEDDED_AGENT_DOCS_PAGES: readonly AgentDocsPage[] = [ ["pages/how-to/index.md","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","f6aebff9f977b4231db9599fa0b8041d56c9d17701c8519a77aa9eaeab096a85",8572], - ["pages/identity-access/auth/index.md","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","7a4518f8faa8804901cc6f10976d64b094c455cc7fc2f8dd2667d356372038ec",23889], + ["pages/identity-access/auth/index.md","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","6f950bc04afb18911d113873cabf07da68fdb9ae59c4ec0a6d11cc50429e9adc",25604], - ["pages/identity-access/better-auth-plugins/index.md","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","a837c1387adefe12eef67a186e6b20aa0a4b50e283ef3c45b24c7c9b7531a6f0",8016], + ["pages/identity-access/better-auth-plugins/index.md","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","9ed33bc7a0a3e34fd62e3b73699459b2a639d1a3ca9c267c4336fcf32a0210b6",8526], ["pages/identity-access/how-to/add-authentication/index.md","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","8fe860de1451ff0213345c58aa05fcdbb97e3217bd4235e7530c612f603b1b96",31523], @@ -383,7 +383,7 @@ export const EMBEDDED_AGENT_DOCS_PAGES: readonly AgentDocsPage[] = [ ["pages/reference/plugin-ai/index.md","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","60f565081e34ddf8c3b69c170622ca66443a7be18f8543e28e51be22745af73c",15959], - ["pages/reference/plugin-auth-core/index.md","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","b9b0deb7aa6f10031d2e10e0b0cc9343cff4eeb928c8b4a2f6ccf7365ef1e4f3",7288], + ["pages/reference/plugin-auth-core/index.md","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","139f891521a16a1b785aa39e36a3d87624e651cb8c21bf3fe1e0c474ec7b0472",7504], ["pages/reference/plugin-auth/index.md","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","a3176a24379aeb45cafed315a88694a8b41751a14747fb47b5ca387624a7ec59",4743], diff --git a/packages/mcp/src/infrastructure/export-surfaces/export-surface-corpus.generated.ts b/packages/mcp/src/infrastructure/export-surfaces/export-surface-corpus.generated.ts index 416930b1b3..136d1c77f2 100644 --- a/packages/mcp/src/infrastructure/export-surfaces/export-surface-corpus.generated.ts +++ b/packages/mcp/src/infrastructure/export-surfaces/export-surface-corpus.generated.ts @@ -275,11 +275,11 @@ export const EXPORT_SURFACE_ROWS: readonly (readonly [string, string, string, st ["plugin-auth","./streams/server","pFZNbxs3EP0rA51kQClq9KbYMgzbaXNoY0iKg8IwDHp3VsuKIhfkrBTV6H8vyCXX5H4YjgPosHqcGc4M5z3y/n5y+XX9x+Nqvby5/PPx5u7mr/Xj+u/bm9VkNrmsqVyhMVzJ9N8S92qL+WdZ1ZSurIgRBohvJJefGBcdU4eviGnqLJBGtrvGgktO0aYOvtlx+lJZ2KT4HiX1kVVW4o4N4FxuE/RWq7zOUN8qbcOwdmEgwii0RFOLNIvQkOByXWv2JDDddDKboK2L59mV2lUCCXOPpa0OYNTSBPLd9NhabVEusdBoSgdukPoVT2aTFWrOBP8X87VmGV4pSfjd1uHOsc19sFO+TGsYHdnD7H6isUCNMrODEH/TscJLwZl5BR+z4ZJQF6wX80fjvOU7E8xYv6KWmZ/Dd36OZT2MJ72DcV5GNglDbc0wQlM4h1pupTrIsQCBui9RuvyFc1giy5UUxzMfbNF3iIk94tHZv0/7tj8wKADwDNqHhcpP5cU8so1H9eOLreFym9i1khAZSXW4mMP0BM4XcM0IoyWKSHIxh2H2wH8jFQalGl1r+fbS0TRLOIcp2j+9Gly2e8XzvnfcCziHW55tzwbF6KyrfYsZDB7agEYO1fSGxVY3B006CupoCcOpr6+xAPxOKHMDg8q0AG4FdoeSgkXSmWfIlDSk64yUnqpm0ObD2/kxdLsuTuIBa8wYlXP7zeUmWsyULPim1sw6f+Jyg7rS3B5mMDU25enJPLT9I3Bj+XNMsEwog3kCHRinr5K46FvXlUFNCZSjvWgSqBC1KRPEkKr620aIm/OgddC7xqamOT4/qs2fGTC9OW1DnPTmuBsyVbLBmLHK/Xj8SOOmTG9+bX3fGcqr30/GSi/wn2/l4P1vz/KNQpBI8ojsPXd0smLaKVWPB27VjfpFWO1oZvr6iHYeom1EPkY47xg1oSSrTKno7jRKw1NrDk9KCWQyZqpjWLTiSYSSOB3XxwpD4jPYM1HjHJaYKZ2fBTTo5syyPlwXLrFvmlPo2d3pSQIvMUNeuTQ9R4d23OLx5c87w3cEw8vdRbd7dpVLNMYrnot4q9WOGzyz180iko4OHgSkA7cykuC9ARh7W05m9tc8LliWYUWYw9MRqETwNAHdKAIIXmB2zARCiaJC/curznwjP3AJhdOCQd/XHU3D/LFdw9Mldrc883dG5GYFwPsa79z6M+EeMVAbnwAaMqA0ZEwI1AaoZARMGAUHJsklaN8DcVruBWEDh1P+kKldxYg/CQRTN1QbS3M4uea3Qr1H/cHwHOFgB05DoTQwkGyHOeSN1vhILoH6SXBTApPw5fP1Fdg8BDrFYsaiLCO+bx4c7elWWv2DTtaSEO2pE+odt416zaupHJhvTufwXYfgwKlUNcGuJkZWpGwz3xE0DMY7o7YFkr0UQDe3gm9QXeXMxn4lwO9IbkA0MsL+bv5cwzPaerwIPHz77arR6yA0YA+eG7unrSSdDVtgmAqnzu2Tqxmkzl5+WitfoaO7lQVSmRKQlUxusAn38PA/AAAA//8DAA==","Gh212y8g712zQ2+//ehCm1u/C/tXPgbpPOMiOw81rXo=",4265,27], - ["plugin-auth-core",".","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","ap9vWXLaFDET5wYqlQ4WAqZELLBzh274cINHUThWoXU=",11080,106], + ["plugin-auth-core",".","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","ozJ6TcTBmVlZP9JyGNSis3HwsR4EgOKPz9PePCjIVdE=",11214,108], ["plugin-auth-core","./authenticator","hFVdT9tKEP0rI78kkdyUq6v7Egq0RXmgUgERdF8wIpP1JN6LM+PO7iZNEf/9am0ncSgUyQ/2zveZc9Z3d8mX4Atibw160WtRn6T1Gd/Qj0Cu8+lCuf2akK6soYPYq8pbYZekiVFCT2/5JWlyrZaNrbBM0kQJ86+ESnqulEev+vhm/P3qdvwwGU8mF1eXDzfjb+Pz24ury0m00VI8Tcg5K/wvqZ3HzFZ4rCqa3Kd3idKclNhQXeH1d8uedI71+zywiRleuHSOV6gWZ2U8NSU6d1gGXoPx0NoB9DdDC+2uI3gHZHiCiJtwuQHXuF3ikkbgvFpeHO+t3i5Jgv/uRsBhOSPt2FSCJ42BZ69EVipejJRnIwj8yLLmjhHLUtYX7MgEpVtFdpWoPxvBTKQkZHjuoAd/JkRfmqFG7009GL0Dc5dXu+KvEayvzS5GcG3N46fuelLIkoIwJ82S08Fu9rh2YefhTWKO4KZF51Mbc7rlCvyZsfAEdW4NJsJhJKdd3UEH9APD4aYM5UHpGn0xgixxTaEsOQYv3yZXl/39IPBcMzdJ2+ccy5L0g6yZcsitM7Ii3QByDqtOo1BJac0G5qLgCwKtJwIMvtgycJikST3bBghNAbMadGihBl+ohEVRRzN6uzqMTmFtfSHBg5JHy5YXgFBtNzrMOOMvkBNbyqEdMLoGZQcISv9Rve/jtm1SmKMtg1Jdee12rbfF27o9l7FSjsZTDv8c/Q0Fcl5aXgzhUmCG5pE4bw4pjVCvbE4aKd1yKQUj8mgJJM7qKmFHYNAUBNZBcJQPM/5coeISWqbD+GdVWmP9C8BbsbZYx7BmQLj9re0au1YJzXrUxwD6icuqJJhOp95l3HC24ysKJ+/p8enwTunF8F7avUr+Ono4OjqC58Fxxh8/wnXk+GERL22VtkJ/OBwOhnHFtdj6Ty/8nwfDjKfTaUPKqCQQJgiMy5ldBAluy6c98jvGxClD6SNlml24PeRb+rXyBoOqm+gZqRB7ELW/Ggwb2b+AXSr8Eehg36IQOKe5jZKJrFpa52LK+IrlXHRJOViuwtsr8fJIDCev305PbSsj6A/g5BR6jQe0mXoN8DGRlDRE50h9v814cgK9rV/0ajCd+Pjv6kzxISoJy1jfCbs0MtFbNh7mKsu9hgLjCm2JM1tav4kSn+Cc9vbc4oLFeWvcMSiuwW9/BkDxbnM1sXe6mEluyQEq1dRHzSkfJvf3/wMAAP//AwA=","CFv8XloyQaY5H/9E0CGhKp/y+qNeXv8AdLLVEIKwDUQ=",2185,9], - ["plugin-auth-core","./config","hFFdi8IwEPwrS56LP+DwBPHp4DhEH8WHNNlqaNwN+fDovz/aWm20PaGUZDo7O505HMQ6xfOGqTInUYwuX+RSzJC9OuNF3qCt56vR6LPJHMz4E5cdhmSHFXsMwTBt2RrVTGE3gWNxELFxuLZGBlFk56v0RpYW52GPFXok9XyepA+r4BEBfMIOpWayzTJRTfxLq9s4PEU3Q1VMIY64/W99dEh/Xj4+Ztp5uG/lp7p4WZOTVuNURtQZ+N7f3WJW2FuHE/W+GMw4q66SFgZn08kQqM538jIaJpBKoYuoofJ8gR+Me+WNiyCdg4AxGjqFhSjEN3NAkLM6puvvrlZixR5BYyWTjQGkx1bSGtStWu8WKvbzkgtRiCHrp2XhLB22b9+uaqCUqkbSILV0EX1neLSCaXA+LYcUfdPO9M+GuTYIkjSEPkpwfTs1cRna4ZAu/eZ4zkMJ6K9G4dQ/qv9lF+J4/AMAAP//AwA=","IrBdzFyDr0z7padwR3f4MyJ6ht7q2vaAiAsYOhA4QuI=",1114,9], + ["plugin-auth-core","./config","jVJNb9pAEP0rI196oem9TSNF6aVS1EZwRByG3TGMsGe2+2HKv6/WBsMSUyIha/bx5r35Wi6r5xS3Lyo1b6rZxeOnuBQLZGG21OIRevPasSVfZJZgwZ9jpFduORYJIzpPDR2xIm14zCmk5lTMgkJglTdt2BymsKPAaras4sHRc8MYqlkRd+gZ173lB+DL2FNNnsTQVTwpcyoBzkOE7zAntCrN4THJTnQvT8d0uBr+DapRCfGCO7T7tUeG+PH8Z6Fdrueu/NQ239mUpMLuauX3Oi9u4QZ5nPhFGTfg8WZGg+JI7nY/cVLvmi84T/26MwyuSRsWMH3fyWNkFUBjyEWyUHtt4RfFhfHsIqBzEChGlk14qGbVq2ogwJs63N/GqLamWj2BpRpTEwOgpyzZMNmsNlQLtfrbkpl32uOVWdiio/z12eoAazQ7Egto0UXy4cpC5VT5tBxJ9Iec89vlNzZnIol1yhJBO/KeLYVvoC33AwbnKZDvKJz5p4az2g+M+Dmv8qzyJ2lESIFlA3FLY96nAIKRO4I9i9X9lxb/QqcG16nBobbh96K6YwIUC2FYM7jhcnai65AbC6kdppINLqeba2VDU/M3/5d9qFarfw==","idx3xB2+X9IBED337L9mSY28PHPttbb2E14mN7w08Ys=",1428,11], ["plugin-auth-core","./contracts/v1","xJVNb+IwEIb/ipUzQtor6iIhGmmrapdVQrlQRE0YikVqR7bTFf9+FZI4/pgkHPZD4hDPvH48tvE72220eFl/26dxmj6tfuzT9WIdp9HEiab7JN6snuN9ulz9jKtkqc9LWtADy5lmoKJJRKuQ4FrSTLcKfPgIJ8aZZoJ70zZfPKUJJKLUIJtBmp3hgzqDBFSZt+ukoBQTPAFVCK4AjzqQFwXSk9sho13SPD/Q7PLEi1L740BlEf2Q0X4HS9UNTD6BT3GBpvZ22TCI6y00GjezPD5KDpm9NPbOWQfrRp7CRjkBRydKbaPaoa/xYFbEKDc0Z0da/e9iKYV8pJpGu8k2knACCTyr5n5Syeghrz7t8L/87inhT4f1tYBFzqi6K/wfChwNO3dHcBfLBFea9HvZjLzeLGim6j+zmsnbS3mN7KUI4ndd0nM+b9ZYwnFDHHqzQXw2kjJe6YbNM8DCxj+9ZPDmm/Ps89OZxXxAVPNgCc96O35owAHclrhk36hrLGLXDtPJ48CgVNzZUSxeqtMBaqbfBxxal5w3z5WE/YB8JQnQo+D59aHkFy5+8bnB97UPZ5lQhC/XFnP/igN7Q3XucXmtquaP7MXfRUALbmC81OEinQ7YIP0+6OK6LIYKC0QaJgLsL89qqx3Rba4Br02jNLTEoA1jTLzIvm5dNfhMFEAoJ6IASbWQpJCMZ6ygOeEAR0W0ILWPE8qvpPF2os9SlO9n8lbnmit8m0aTaPhX10tO1UrlIWfZzZ4NVzYbUNNBealADmmzxicI8GMhGNeEVad9j3CA+gE9stooaJZBoeFIDleiz9AdqXdIBjJ18aP6bhPGKiToUvK/uebAeajm0sYOOdANMW+PbRzpyUaIotR3IR2dy9ztfgMAAP//AwA=","isfjOSnGXmN8feHbrWCg7WVHtsvlAEsu/rgFdiIcNtU=",3552,38], diff --git a/packages/mcp/src/publish-assets.generated.ts b/packages/mcp/src/publish-assets.generated.ts index b9067f6d4a..c48066d4db 100644 --- a/packages/mcp/src/publish-assets.generated.ts +++ b/packages/mcp/src/publish-assets.generated.ts @@ -307,7 +307,7 @@ export const MCP_EMBEDDED_DOCS_PROVENANCE: 'pages/web-layer/vite/index.md', 'pages/why/index.md', ], - sourceBytes: 3255674, + sourceBytes: 3258115, documentCount: 286, - sha256: 'fac2e9ae8649238e745dba7653ae153741b6a78ccc5a8ac767e50ff3e8f40467', + sha256: '4f102e05e921644a32a711bb3071f9211d6df2a95eefa4d678f7e68843fd9c94', }; From c65adf52701bbe6f5415e145b8366403410f208b Mon Sep 17 00:00:00 2001 From: Rickylabs Date: Mon, 16 Nov 2026 19:59:56 +0100 Subject: [PATCH 5/5] docs(harness): record independent auth rate-limit evaluation --- .../context-pack.md | 3 + .../evaluate.md | 91 +++++++++++++++++++ .../worklog.md | 7 ++ 3 files changed, 101 insertions(+) create mode 100644 .llm/runs/fix-auth-sign-in-rate-limit--issue-2634/evaluate.md diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md index 5ed4927258..f3149afac1 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/context-pack.md @@ -9,3 +9,6 @@ Contract/source committed through e1a608511: AuthRateLimitConfig/Rule, data-only Core/service/provider tests69/69 pass, including absent production3/10, configured max1, development not enabled, casing precedence and invalid-config rejection. Structured check/lint/fmt, quality:gate, release:preflight and docs:accuracy pass. JSR audits/dry-runs for core/plugin pass with pre-existing slow-type/cardinality warnings. Full export-map doc lint core3/plugin12 exactly matches base entrypoints, per-file counts and entrypoint exits after repository-relative normalization; no new finding. Canonical agent docs/site build is complete; MCP export corpus generated with documented --allow-dirty for sole regenerated prose input, then assets/publish freshness gates run. No lock changes. No full scaffold.runtime applicable because no scaffold/Aspire/executable wiring changes. Initial docs-only skip labels removed with implementation. Next final generated-consumer commit, independent straightforward IMPL-EVAL (glm_5_3_flash/provider_default; fallback deepseek_v4_pro/provider_default), issue/body acceptance and closing keyword, ready transition, required head checks and review-thread gate. All public evidence omits operator paths/hostnames/ports/session IDs. + + +Independent IMPL-EVAL PASS: https://github.com/rickylabs/netscript/pull/2642#issuecomment-6926024823, evaluated86ffff9a61bf784840f3a744404c7cf960c14816. evaluate.md is committed with this documentation-only follow-up. All issue criteria proved, issue checked, body has closing keyword/evidence mapping, review threads0/0, draft checks3SUCCESS/24SKIPPED. Next ready transition then verify required checks at final head; do not merge or mark ready-merge. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/evaluate.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/evaluate.md new file mode 100644 index 0000000000..31c9f4e7d4 --- /dev/null +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/evaluate.md @@ -0,0 +1,91 @@ +# Evaluation: issue #2634 / PR #2642 — fix(auth): configure provider endpoint rate limits + +## Metadata + +| Field | Value | +| -------------- | ----- | +| Run ID | `fix-auth-sign-in-rate-limit--issue-2634` | +| Target | branch `fix/auth-sign-in-rate-limit` head `86ffff9a61bf784840f3a744404c7cf960c14816`, base `origin/main` `b0eb079575968e843b781579673c9fe2ae250e07` | +| Archetype | 2 — Integration (contract schema + plugin backend composition), service/docs overlays | +| Scope overlays | service, docs | +| Evaluator | independent IMPL-EVAL session, 2026-11-16 | +| Verdict | **PASS** | + +## Route identity (protocol) + +- Requested/pinned evaluator: `glm_5_3_flash/provider_default`, options `{}` (no variant override), mapped by `@harness/models` to `opencode-go/glm-5.3-flash` — observed identity matches; no silent substitution. +- Fallback `deepseek_v4_pro/provider_default` not needed; launch succeeded. +- Generator per run `supervisor.md`: Codex `gpt-6.1-sol`/xhigh (OpenAI vendor family). Evaluator vendor family differs (GLM); sessions independent (fresh evaluator session, no shared history). No lane self-certification. +- Read-only shared checkout verified: head equals `86ffff9a61bf784840f3a744404c7cf960c14816` exactly; no other worktree touched. + +## Process Verification + +| Check | Result | Evidence | +| ----- | ------ | -------- | +| PLAN-EVAL disposition recorded before implementation | PASS | `worklog.md` §Design records justified `PLAN-EVAL: N/A` (narrow native JSON passthrough, locked defaults); plan.md §Contract locks the decision set | +| Design checkpoint exists in worklog | PASS | `worklog.md` `## Design` (surface, validation, forwarding, oracle, docs) | +| Commit slices match plan | PASS | S1 red `c70f6e564` (tests committed before source), S2 contract+forwarding+docs `e1a608511`, S3 generated consumers `86ffff9a6` — matches plan S1–S3 | +| Each slice has named gate evidence | PASS | worklog red-baseline/contract sections + PR IMPL comments; gates re-run independently below | +| No speculative seams | PASS | No production factory/test hook added; only an observability wrapper inside the disposable test; diff is 18 files, all serving contract/test/docs/generated refresh | +| Issue read in full | PASS | `gh issue view 2634` (summary, evidence, expected behavior, 4 acceptance boxes, related #883/#882) | + +## Change-scope verification (against plan and PR claims) + +- Contract: optional `AuthConfig`/`AuthConfigInput.rateLimit` with `AuthRateLimitConfig`/`AuthRateLimitRule`; native `customRules` record; `window`/`max` positive integers; slash-prefixed keys; absent stays omitted (`...(raw.rateLimit === undefined ? {} : { rateLimit: raw.rateLimit })` and registry conditional spread). Confirmed in `packages/plugin-auth-core/src/config/mod.ts`. +- Registry: `plugins/auth/services/src/backend-registry.ts` reads lower `auth.rateLimit` with upper `Auth.RateLimit` fallback (`??` — lower wins), validates through shared `AuthConfigSchema`, forwards only `customRules` via the existing `betterAuthOptions` passthrough. No enabled/global/storage override added. +- Provider forwarding verified in source: `packages/auth-better-auth/src/better-auth.ts` spreads `...betterAuthOptions` into the composed options passed to `betterAuth(...)` (spread before explicit NetScript-owned keys, after model-name defaults). Installed provider resolves to `better-auth@1.7.14` per `deno.lock` — matches research claim. +- Exports: new types exported from `src/public/mod.ts` (root) and config module. Reference docs table updated. +- Docs: auth guide section, better-auth plugins page, core README, reference index — state default 3/10 production, seconds/requests units, first-match, slash-prefixed relative patterns, per-process memory storage, missing-IP shared bucket, provider-owned endpoint boundary, and the host-created `betterAuthOptions` path. +- No scaffold/Aspire/executable/lock changes in the diff — full `scaffold.runtime` non-applicability claim **verified**; the focused real-provider test is the correct boundary proof for this fix. + +## Test-oracle validity (independently assessed, not taken on trust) + +- The wrapper in `plugins/auth/tests/services/rate-limit-production_test.ts` maps `@netscript/auth-better-auth` **only within the scope of the real registry module** (`plugins/auth/services/src/backend-registry.ts`, which is confirmed as the import site), re-exports the real provider module, and its intercepted `createNetscriptBetterAuth` always calls the original factory. The captured options and the real constructed provider instance exist only inside the disposable child process. +- Requests are real Fetch POSTs to the real provider handler (`/api/auth/sign-in/email`). No fake limiter, no product injection hook, no external resources. The initial unscoped loader mapping is excluded from the committed test (only the scoped map ships). +- Status semantics verified: configured `max:1` → `[400, 429]` (429 counted before the endpoint's 400 email/password-disabled response — no database/account state needed); absent → `[400, 400, 400, 429]` (built-in production 3/10); development → unthrottled; `both` styles → lower-case section wins (upper `max:5` ignored). The invalid-config case rejects before provider construction. + +## Independent test runs (evaluator's own, pinned Deno 2.9.7 via mise) + +| Suite | Command (repo-relative) | Result | +| ----- | ----------------------- | ------ | +| Schema tests | `.llm/tools/run-deno-test.ts --cwd packages/plugin-auth-core -- --allow-all src/config/config_test.ts` | 10/10 PASS | +| Real-provider rate-limit test | `.llm/tools/run-deno-test.ts --cwd plugins/auth -- --allow-all tests/services/rate-limit-production_test.ts` | 6/6 PASS | +| plugin-auth-core full | same wrapper, package root | 54/54 PASS | +| Adjacent plugin tests (control) | `deno test --allow-all --unstable-kv plugins/auth/tests/services/{documented-cookie-jar,workos-observer,workos-composition}_test.ts` from repo root | 8/8 PASS (a `--cwd plugins/auth` invocation of the full plugin suite produced 5 cwd-relative path failures; all pass from repo root — environmental, not product) | + +## Static/fitness/docs gates (evaluator's own runs) + +| Gate | Result | Evidence | +| ---- | ------ | -------- | +| Targeted typecheck | PASS | `deno check --unstable-kv` over the five changed source/test files | +| Lint wrapper | PASS | `run-deno-lint.ts --root packages/plugin-auth-core --root plugins/auth` → 0 occurrences (110 files) | +| Fmt check wrapper | PASS | `run-deno-fmt.ts` same roots → 0 findings | +| quality:scan | PASS | 0 findings; 7 pre-existing allowances (all issue #1276, unrelated files) | +| Doctrine fitness (arch:check body) | PASS | `check-doctrine.ts --all-roots` exit 0, FAIL=0, pre-existing WARNs only | +| release:preflight | PASS | import-attributes / file-url-import-meta / self-imports all PASS (0 findings) | +| docs:accuracy | PASS | 216 published pages, 287 shipped corpus files, 111/111 commands | +| JSR publish dry-run | PASS | `deno publish --dry-run --allow-dirty --no-check` in `packages/plugin-auth-core` → "Dry run complete" | +| Doc lint (changed entrypoint) | PASS | `run-deno-doc-lint.ts --root packages/plugin-auth-core`: `./src/config/mod.ts` entrypoint 0 findings; package totals 3 private-type refs — consistent with claimed measured base core=3 | +| MCP export corpus freshness | PASS | `deno task check:mcp-export-corpus` exit 0 | +| CLI assets barrel freshness | PASS | `deno task check:assets-barrel` exit 0 (no CLI asset diff) | +| Review-thread gate | PASS | `deno task check:review-threads -- --repo rickylabs/netscript --pr 2642 --pretty` → threads=0 unanswered=0 | + +## Issue acceptance / close-gate pre-check + +- All four #2634 acceptance boxes are checked with a linked evidence comment on the PR. +- PR body carries `Closes #2634` and exactly one `acceptance-evidence` fenced YAML block (4 entries, one per box). +- Milestone `0.0.10`; labels `type:fix`, `area:auth`, `priority:p2`, `status:impl-eval` (exactly one `status:`); no forbidden `status:ready-merge` label present. +- Remaining unchecked PR DoD row is this independent evaluation plus required head checks — expected pre-merge state for `status:impl-eval`; the generator transitions the PR after review and verifies required checks at the current head. Merge/release actions intentionally not performed by the evaluator. + +## Checks / reviews state at evaluated head + +- Draft PR #2642, head `86ffff9a6`. Required draft checks currently policy-skipped; `build` and `classify docs-site changes` SUCCESS; "Utility docs browser and style policy" was in progress at evaluation time. Review threads: 0 open / 0 unanswered. + +## Findings + +- No blocking findings. No unrecorded doctrine violation introduced (AP-25 not triggered: side effects are confined to adapter/composition and disposable test files; defaults remain provider-owned, consistent with composition-root doctrine). +- Non-blocking observation: issue acceptance evidence links to the S2 IMPL phase comment rather than a dedicated evidence comment; the linked comment contains the test summaries and the PR body carries the structured acceptance-evidence block, so the evidence requirement is satisfied. + +## Verdict + +**PASS** — approved scope complete, required static/fitness/docs gates independently green, genuine-oracle runtime evidence independently reproduced, docs and run artifacts sufficient for resume. Straightforward tier IMPL-EVAL loop maximum five (owner-notification after three) applies to any re-steer; none needed. diff --git a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md index 47d339b1c5..be44b5f5c9 100644 --- a/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md +++ b/.llm/runs/fix-auth-sign-in-rate-limit--issue-2634/worklog.md @@ -23,3 +23,10 @@ Initial focused suite13/13 pass. Extended core/service/provider suite69/69 pass, Full doc-lint baseline comparison confirmed: core3 and plugin12 private-type references match base b0eb07957 in summary, entrypoints, per-file diagnostic counts and entrypoint exits after repository-relative path normalization. Changed config entrypoint has no new finding. Initial raw path comparison differed only because the checkouts have different roots. Canonical agent-docs/site build, MCP export corpus, CLI assets and publish assets refresh complete. Export and publish freshness checks pass. Export generator allowed dirty only for the regenerated prose carrier, with every handwritten source/docs input already committed. No CLI asset diff and no lock changes. Final implementation is ready for independent straightforward IMPL-EVAL; 69-test and validation evidence remains above. + + +## Independent evaluation + +IMPL-EVAL PASS at86ffff9a61bf784840f3a744404c7cf960c14816: https://github.com/rickylabs/netscript/pull/2642#issuecomment-6926024823. Requested/observed glm_5_3_flash/provider_default, no variant override, independent session/vendor family; no fallback. Evaluator independently ran schema10/10, provider6/6, core54/54 and adjacent root control8/8, and verified the native scoped import-map oracle, defaults, validation and forwarding. Scoped/static/docs/freshness gates passed, with documented baseline findings. No blocking findings. Its initial full-suite cwd fixture failures were disproved by the root control, not counted as product failures. + +All four issue acceptance boxes are checked with linked evidence. Review-thread gate0/0. Before readiness, draft head checks are3SUCCESS/24SKIPPED by workflow policy. This follow-up commits only evaluator/run evidence; production/tests/docs/generated consumers equal the evaluated tree. Ready transition will schedule required CI; final readiness is reported only after current-head checks and thread gate are verified again. No merge/auto-merge/ready-merge label or publication.