@zackbart/connecta 0.34.0 → 0.35.0

package/dist/auth/vercel-agent.js

@@ -0,0 +1,266 @@
+import { runEdge } from "../runtime/run.js";
+import { authCall, authCatch, authFetch, authFlow, authInvoke, authMethod, authProgram, registerAuth, } from "./native.js";
+import { AGENT_NAMESPACE, agentSubjectId, trustAgentProvider } from "../agent-identity.js";
+import { authenticationBusyResponse, withAuthenticationDeadline } from "../auth-admission.js";
+import { authorizationCredential } from "../inbound-credential.js";
+const ISSUER = "https://oidc.vercel.com";
+const JWKS = `${ISSUER}/.well-known/jwks`;
+const CACHE_MS = 300_000;
+const REFRESH_MS = 30_000;
+const SKEW_SECONDS = 30;
+const KEY_FETCH_BUSY = Symbol("key fetch capacity reached");
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+function bytes(value) {
+    if (!/^[A-Za-z0-9_-]+(?![\s\S])/.test(value))
+        throw new Error("Invalid JWT encoding");
+    return Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (char) => char.charCodeAt(0));
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function part(value) {
+    const decoded = JSON.parse(decoder.decode(bytes(value)));
+    if (!record(decoded))
+        throw new Error("Invalid JWT object");
+    return decoded;
+}
+function parsed(request) {
+    const credential = authorizationCredential(request);
+    if (credential.kind !== "bearer" || credential.token.length > 16_384)
+        return undefined;
+    const pieces = credential.token.split(".");
+    if (pieces.length !== 3)
+        return undefined;
+    try {
+        return { header: part(pieces[0]), claims: part(pieces[1]), pieces };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Recognition reserves Vercel's issuer namespace; verification still checks exact values. */
+export function isVercelAgentCredential(request) {
+    const iss = parsed(request)?.claims.iss;
+    return typeof iss === "string" && (iss === ISSUER || iss.startsWith(`${ISSUER}/`));
+}
+function denied() {
+    return {
+        ok: false,
+        response: Response.json({ error: "unauthorized" }, {
+            status: 401,
+            headers: { "WWW-Authenticate": "Bearer", "Cache-Control": "no-store" },
+        }),
+    };
+}
+function readKeys(signal) {
+    return runEdge(authProgram(readKeysNative, [signal]));
+}
+const readKeysNative = /* @__PURE__ */ registerAuth(readKeys, function (signal) {
+    return authFlow(function* () {
+        let response;
+        let reader;
+        const cancel = () => {
+            void reader?.cancel().catch(() => { });
+        };
+        try {
+            signal.throwIfAborted();
+            response = (yield authFetch(JWKS, {
+                signal,
+                redirect: "manual",
+                headers: { Accept: "application/json" },
+            }));
+            signal.throwIfAborted();
+            if (!response.ok || !response.body)
+                throw new Error("JWKS unavailable");
+            reader = response.body.getReader();
+            signal.addEventListener("abort", cancel, { once: true });
+            const chunks = [];
+            let size = 0;
+            for (;;) {
+                signal.throwIfAborted();
+                const { done, value } = (yield authInvoke(reader, "read", []));
+                signal.throwIfAborted();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 65536)
+                    throw new Error("JWKS too large");
+                chunks.push(value);
+            }
+            const body = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                body.set(chunk, offset);
+                offset += chunk.length;
+            }
+            const jwks = JSON.parse(decoder.decode(body));
+            if (!record(jwks) || !Array.isArray(jwks.keys) || jwks.keys.length > 16)
+                throw new Error("Invalid JWKS");
+            const keys = new Map();
+            for (const key of jwks.keys) {
+                if (!record(key) ||
+                    key.kty !== "RSA" ||
+                    (key.alg !== undefined && key.alg !== "RS256") ||
+                    (key.use !== undefined && key.use !== "sig") ||
+                    (key.key_ops !== undefined && (!Array.isArray(key.key_ops) || !key.key_ops.includes("verify"))) ||
+                    typeof key.kid !== "string" ||
+                    key.kid.length === 0 ||
+                    key.kid.length > 256 ||
+                    typeof key.n !== "string" ||
+                    typeof key.e !== "string" ||
+                    "d" in key)
+                    continue;
+                const modulus = bytes(key.n);
+                if (modulus.length < 256 || modulus.length > 512 || bytes(key.e).length > 8 || keys.has(key.kid)) {
+                    throw new Error("Invalid RSA key");
+                }
+                keys.set(key.kid, { kty: "RSA", n: key.n, e: key.e, alg: "RS256", ext: true, key_ops: ["verify"] });
+            }
+            if (keys.size === 0)
+                throw new Error("No signing keys");
+            return keys;
+        }
+        finally {
+            signal.removeEventListener("abort", cancel);
+            (yield authCatch(authInvoke(reader, "cancel", []), () => { }));
+            reader?.releaseLock();
+            (yield authCatch(authInvoke(response?.body, "cancel", []), () => { }));
+        }
+    });
+});
+/** One bounded public-key cache per deployment; never retains request I/O or promises. */
+export function vercelAgentAuth(agents, logger = console) {
+    const bindings = agents.filter((agent) => agent.vercel);
+    if (bindings.length === 0)
+        return undefined;
+    let cache;
+    let refreshAfter = 0;
+    let retryAfter = 0;
+    let fetching = 0;
+    function load(signal) {
+        return runEdge(authProgram(loadNative, [signal]));
+    }
+    const loadNative = /* @__PURE__ */ registerAuth(load, function (signal) {
+        return authFlow(function* () {
+            if (fetching >= 2)
+                throw KEY_FETCH_BUSY;
+            if (Date.now() < retryAfter)
+                throw new Error("JWKS unavailable");
+            fetching++;
+            try {
+                const keys = (yield authCall(readKeys, [signal]));
+                signal.throwIfAborted();
+                cache = { expires: Date.now() + CACHE_MS, keys };
+            }
+            catch {
+                if (!signal.aborted)
+                    retryAfter = Date.now() + REFRESH_MS;
+                throw new Error("JWKS unavailable");
+            }
+            finally {
+                fetching--;
+            }
+        });
+    });
+    return trustAgentProvider({
+        kind: "vercel_oidc",
+        activityActorNamespace: AGENT_NAMESPACE,
+        recognizesCredential: isVercelAgentCredential,
+        authorize: authMethod(function (request) {
+            return authFlow(function* () {
+                try {
+                    return (yield authCall(withAuthenticationDeadline, [
+                        request,
+                        authMethod((signal) => {
+                            return authFlow(function* () {
+                                const jwt = parsed(request);
+                                if (!jwt ||
+                                    jwt.header.alg !== "RS256" ||
+                                    typeof jwt.header.kid !== "string" ||
+                                    jwt.header.kid.length === 0 ||
+                                    jwt.header.kid.length > 256 ||
+                                    jwt.header.crit !== undefined ||
+                                    jwt.header.b64 !== undefined)
+                                    return denied();
+                                const c = jwt.claims;
+                                const segment = (value, project = false) => typeof value === "string" &&
+                                    (project ? /^[A-Za-z0-9._-]{1,128}(?![\s\S])/ : /^[A-Za-z0-9_-]{1,128}(?![\s\S])/).test(value);
+                                if (!segment(c.owner) ||
+                                    !segment(c.project, true) ||
+                                    !segment(c.owner_id) ||
+                                    !segment(c.project_id) ||
+                                    !segment(c.environment) ||
+                                    c.external_sub !== undefined ||
+                                    (c.iss !== ISSUER && c.iss !== `${ISSUER}/${c.owner}`) ||
+                                    c.aud !== `https://vercel.com/${c.owner}` ||
+                                    c.sub !== `owner:${c.owner}:project:${c.project}:environment:${c.environment}`)
+                                    return denied();
+                                const agent = bindings.find(({ vercel: v }) => v &&
+                                    v.team === c.owner_id &&
+                                    v.project === (v.project.startsWith("prj_") ? c.project_id : c.project) &&
+                                    v.environments.some((environment) => environment === c.environment));
+                                if (!agent)
+                                    return denied();
+                                const validTime = () => {
+                                    const now = Date.now() / 1000;
+                                    return (typeof c.exp === "number" &&
+                                        Number.isFinite(c.exp) &&
+                                        typeof c.iat === "number" &&
+                                        Number.isFinite(c.iat) &&
+                                        c.exp > c.iat &&
+                                        c.exp > now - SKEW_SECONDS &&
+                                        c.iat <= now + SKEW_SECONDS &&
+                                        (c.nbf === undefined ||
+                                            (typeof c.nbf === "number" &&
+                                                Number.isFinite(c.nbf) &&
+                                                c.nbf <= now + SKEW_SECONDS &&
+                                                c.nbf < c.exp)));
+                                };
+                                if (!validTime())
+                                    return denied();
+                                const fresh = cache && cache.expires > Date.now();
+                                if (!fresh)
+                                    (yield authCall(load, [signal]));
+                                let key = cache?.keys.get(jwt.header.kid);
+                                if (!key && fresh && Date.now() >= refreshAfter) {
+                                    refreshAfter = Date.now() + REFRESH_MS;
+                                    (yield authCall(load, [signal]));
+                                    key = cache?.keys.get(jwt.header.kid);
+                                }
+                                if (!key)
+                                    return denied();
+                                const imported = (yield authInvoke(crypto.subtle, "importKey", [
+                                    "jwk",
+                                    key,
+                                    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+                                    false,
+                                    ["verify"],
+                                ]));
+                                signal.throwIfAborted();
+                                const valid = (yield authInvoke(crypto.subtle, "verify", [
+                                    "RSASSA-PKCS1-v1_5",
+                                    imported,
+                                    bytes(jwt.pieces[2]),
+                                    encoder.encode(`${jwt.pieces[0]}.${jwt.pieces[1]}`),
+                                ]));
+                                signal.throwIfAborted();
+                                if (!valid || !validTime())
+                                    return denied();
+                                return { ok: true, agent: agent.name, subjectId: agentSubjectId(agent.name) };
+                            });
+                        }),
+                    ]));
+                }
+                catch (error) {
+                    if (error === KEY_FETCH_BUSY)
+                        return {
+                            ok: false,
+                            response: authenticationBusyResponse(logger),
+                        };
+                    return denied();
+                }
+            });
+        }),
+    });
+}

package/dist/auth-admission.js

@@ -0,0 +1,204 @@
+import { Effect } from "effect";
+import { authCall, AuthenticationWork, authProgram, authValue, hasAuthProgram, registerAuth } from "./auth/native.js";
+import { failureRecord, logFailure } from "./operator-record.js";
+import { runEdge, withDeadlineEffect } from "./runtime/run.js";
+// Shared by human and agent routes, even across deployments constructed in the
+// same loaded core. Isolate-wide state is counters and plain charge records:
+// no queue, requests, promises, signals, or I/O.
+const AUTHENTICATION_CONCURRENCY = 16;
+// Work still unsettled after its hard deadline plus grace leaves the active
+// pool for this allowance. Equal to the active limit: a partial wave of stalls
+// recovers while normal authentication continues, yet total outstanding work
+// never exceeds twice the limit, and a full wave, or a binding that never
+// settles, fills it and fails closed instead of accumulating I/O.
+const ABANDONED_ALLOWANCE = 16;
+const SETTLEMENT_GRACE_MS = 1_000;
+// Clerk owns a ten-second deadline; custom adapters share that threshold.
+const DEFAULT_DEADLINE_MS = 10_000;
+// Native Access lookups and agent-token storage reads.
+const NATIVE_DEADLINE_MS = 5_000;
+let active = 0;
+let abandoned = 0;
+// Charges released by the collector and not yet logged: a plain number.
+let unreachable = 0;
+// Overdue active charges waiting for abandoned room; at most the active limit.
+const overdue = new Set();
+// The one release that is not a settlement. Each charge's token is reachable
+// only through the continuations attached to its adapter promise and native
+// operations, plus its deadline timer and its request's lifetime entry. While
+// any of that work can still settle, whatever would settle it reaches the
+// token. Once the collector frees the token, nothing can ever settle the
+// charge, so it is released. Collection is eventual, never timed. A runtime
+// without FinalizationRegistry (workerd without `enable_weak_ref` before the
+// 2025-05-05 compatibility date) releases on settlement alone.
+const collector = typeof FinalizationRegistry === "function"
+    ? new FinalizationRegistry((charge) => {
+        if (release(charge))
+            unreachable++;
+    })
+    : undefined;
+/** Health counters: plain numbers and one runtime fact, no request facts. */
+export function authenticationSnapshot() {
+    return {
+        active,
+        limit: AUTHENTICATION_CONCURRENCY,
+        abandoned,
+        abandonedLimit: ABANDONED_ALLOWANCE,
+        abandonedSaturated: abandoned >= ABANDONED_ALLOWANCE,
+        unreachableRelease: collector !== undefined,
+    };
+}
+function abandon(charge) {
+    if (charge.state !== "active")
+        return;
+    // A full allowance cannot overflow: the charge keeps its active slot.
+    if (abandoned >= ABANDONED_ALLOWANCE) {
+        overdue.add(charge);
+        return;
+    }
+    charge.state = "abandoned";
+    active--;
+    abandoned++;
+}
+/**
+ * Exactly once per charge: when its underlying work has settled, or when the
+ * collector proves it never can. The flag lives in the record, so a second
+ * attempt from either path changes nothing.
+ */
+function release(charge) {
+    if (charge.state === "released")
+        return false;
+    overdue.delete(charge);
+    if (charge.state === "active")
+        active--;
+    else
+        abandoned--;
+    charge.state = "released";
+    for (const waiting of overdue) {
+        if (abandoned >= ABANDONED_ALLOWANCE)
+            break;
+        overdue.delete(waiting);
+        abandon(waiting);
+    }
+    return true;
+}
+// Lets built-in adapters register work that has no cancellation API with
+// their own invocation, without changing the published adapter contract.
+// Keyed by the exact request `authenticate` hands its adapter; no request
+// ever reads another request's work or settlement. The entry refers to its
+// lifetime weakly: workerd keeps a Request, and whatever a WeakMap keys on it,
+// alive after its invocation ends, so a strong entry would pin every token.
+// While the adapter can still reach withAuthenticationDeadline, its pending
+// promise holds the lifetime through `authenticate`.
+const lifetimes = new WeakMap();
+const weakly = (lifetime) => typeof WeakRef === "function" ? new WeakRef(lifetime) : { deref: () => lifetime };
+/**
+ * Race the caller and a five-second deadline for a native operation that
+ * cannot be cancelled. The caller gets a prompt answer; the operation itself
+ * stays charged to this invocation until it actually settles.
+ */
+export function withAuthenticationDeadline(request, operation) {
+    return runEdge(authProgram(withAuthenticationDeadlineNative, [request, operation]));
+}
+const withAuthenticationDeadlineNative = /* @__PURE__ */ registerAuth(withAuthenticationDeadline, function (request, operation) {
+    return Effect.suspend(() => {
+        const lifetime = lifetimes.get(request)?.deref();
+        lifetime?.deadline(NATIVE_DEADLINE_MS);
+        const bounded = withDeadlineEffect((signal) => {
+            signal.throwIfAborted();
+            return authCall(operation, [signal]);
+        }, { timeoutMs: NATIVE_DEADLINE_MS, signal: request.signal, timeoutError: new Error("Authentication timed out") });
+        // A custom decorator may call the saved Promise shell. Reuse this exact
+        // request's charge even when native consumer dispatch cannot select it.
+        return lifetime ? bounded.pipe(Effect.provideService(AuthenticationWork, lifetime)) : bounded;
+    });
+});
+/** Shared capacity refusal: one checked log and retryable HTTP contract. */
+export function authenticationBusyResponse(logger, reason = "authentication_busy") {
+    logFailure(logger, "Authentication admission refused", failureRecord({ reason }));
+    return Response.json({ error: { code: "authentication_busy", message: "Authentication capacity reached.", retryable: true } }, { status: 503, headers: { "Cache-Control": "no-store", "Retry-After": "1" } });
+}
+/** The sole route boundary for invoking an inbound adapter, including its SDK. */
+export function authenticate(provider, request, baseUrl, runtimeContext, logger, settle) {
+    return runEdge(authProgram(authenticateNative, [provider, request, baseUrl, runtimeContext, logger, settle]));
+}
+const authenticateNative = /* @__PURE__ */ registerAuth(authenticate, function (provider, request, baseUrl, runtimeContext, logger, settle) {
+    return Effect.suspend(() => {
+        request.signal.throwIfAborted();
+        if (unreachable > 0) {
+            unreachable = 0;
+            logFailure(logger, "Authentication released after its pending work became unreachable", failureRecord({ reason: "authentication_unreachable" }));
+        }
+        if (active >= AUTHENTICATION_CONCURRENCY || abandoned >= ABANDONED_ALLOWANCE) {
+            // Callers see one retryable contract; the log and health tell an
+            // operator whether stalled bindings, not load, are refusing.
+            const reason = abandoned >= ABANDONED_ALLOWANCE ? "authentication_abandoned_saturated" : "authentication_busy";
+            return Effect.succeed({
+                admitted: false,
+                response: authenticationBusyResponse(logger, reason),
+            });
+        }
+        active++;
+        const charge = { state: "active" };
+        // Held only by this scope's closures (see `collector`); the registry keeps
+        // the record, and the token, as its own unregister key, only weakly.
+        const token = {};
+        collector?.register(token, charge, token);
+        // The adapter's own program or Promise plus each tracked native operation.
+        let remaining = 1;
+        let timer;
+        let complete;
+        const done = new Promise((resolve) => {
+            complete = resolve;
+        });
+        const finish = () => {
+            if (--remaining !== 0)
+                return;
+            clearTimeout(timer);
+            collector?.unregister(token);
+            if (lifetimes.get(request)?.deref() === lifetime)
+                lifetimes.delete(request);
+            release(charge);
+            complete();
+        };
+        const lifetime = {
+            deadline(ms) {
+                clearTimeout(timer);
+                timer = setTimeout(() => abandon(charge), ms + SETTLEMENT_GRACE_MS);
+            },
+            track(pending) {
+                remaining++;
+                void pending.then(finish, finish);
+            },
+        };
+        lifetime.deadline(DEFAULT_DEADLINE_MS);
+        lifetimes.set(request, weakly(lifetime));
+        // Native verification composes in this request and accounts for the
+        // real settlement of every uncancellable SDK/platform leaf.
+        if (hasAuthProgram(provider.authorize)) {
+            settle?.(done);
+            return authCall(provider.authorize, [request, baseUrl, runtimeContext], provider).pipe(Effect.provideService(AuthenticationWork, lifetime), Effect.ensuring(Effect.sync(finish)), Effect.map((result) => ({ admitted: true, result })));
+        }
+        let asynchronous = false;
+        try {
+            const result = provider.authorize(request, baseUrl, runtimeContext);
+            // A synchronous local/cached verdict owns no pending authentication.
+            // Release before yielding, rather than holding a slot for a microtask.
+            if ("ok" in result)
+                return Effect.succeed({ admitted: true, result });
+            asynchronous = true;
+            const pending = result.finally(finish);
+            // Keep just this request's settlement continuation runnable when workerd
+            // drops the disconnected caller, including native work that outlived the
+            // caller-facing deadline. It neither detaches nor starts work.
+            settle?.(done);
+            return authValue(() => pending).pipe(Effect.map((result) => ({ admitted: true, result })));
+        }
+        finally {
+            // A caller leaving is not proof that its adapter or SDK has stopped.
+            // Keep capacity charged until the underlying authorization settles.
+            if (!asynchronous)
+                finish();
+        }
+    });
+});