@zackbart/connecta 0.28.1 → 0.30.0

package/dist/routes/shared.js

@@ -1,6 +1,7 @@
+import { authorizationCredential, authorizationRequest, isMachineCredential } from "../inbound-credential.js";
+import { htmlSecurityHeaders } from "../html-security.js";
 import { parseConnectorAccess } from "../connector-access.js";
 import { identityStorageKey, validIdentityReference } from "../identity.js";
-import { isExplicitlyReadOnly } from "../tool-safety.js";
 export { msg } from "../errors.js";
 export function privateJson(body, init = {}) {
     const headers = new Headers(init.headers);
@@ -31,8 +32,75 @@ export function activityActorNamespace(provider) {
         ? provider.activityActorNamespace
         : undefined;
 }
-export async function authorize(request, baseUrl, auth, runtimeContext, identityConfig, partitionIdentity = true) {
-    if (auth.length === 0) {
+/** Metadata routing and challenge selection use the same first actual answer. */
+export async function authMetadata(request, baseUrl, auth) {
+    for (const provider of auth) {
+        const response = await provider.handleMetadata?.(request, baseUrl);
+        if (response)
+            return { provider, response };
+    }
+    return null;
+}
+async function providerChallenge(response, request, baseUrl, auth, refusingProvider) {
+    if (response.status !== 401)
+        return response;
+    if (!response.headers.has("WWW-Authenticate")) {
+        const headers = new Headers(response.headers);
+        headers.set("WWW-Authenticate", refusingProvider?.challenge?.(request, baseUrl) ?? "Bearer");
+        response = new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+    }
+    const path = new URL(request.url).pathname;
+    const pool = /^\/mcp\/([a-z0-9_-]+)$/.exec(path)?.[1];
+    const metadataRequest = new Request(new URL(`/.well-known/oauth-protected-resource${pool ? `/mcp/${pool}` : ""}`, baseUrl), { signal: request.signal });
+    const owner = await authMetadata(metadataRequest, baseUrl, auth);
+    if (!owner)
+        return response;
+    // Metadata is an ordinary bounded response, never retained across requests.
+    await owner.response.body?.cancel();
+    const challenge = owner.provider.challenge?.(request, baseUrl);
+    if (!challenge)
+        return response;
+    const headers = new Headers(response.headers);
+    headers.set("WWW-Authenticate", challenge);
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
+function recognizedProvider(request, auth, runtimeContext) {
+    for (const provider of auth) {
+        if (!provider.recognizesCredential)
+            continue;
+        const recognized = provider.recognizesCredential(request, runtimeContext);
+        if (typeof recognized !== "boolean") {
+            // A misimplemented hook may return a rejected Promise. Refuse without
+            // letting its arbitrary rejection reach an unhandled-rejection sink.
+            void Promise.resolve(recognized).catch(() => { });
+            throw new Error("invalid credential recognition verdict");
+        }
+        if (recognized)
+            return provider;
+    }
+    return undefined;
+}
+export async function authorize(request, baseUrl, auth, runtimeContext, identityConfig, partitionIdentity = true, interactiveOnly = false) {
+    const credential = authorizationCredential(request);
+    const explicit = credential.kind !== "absent";
+    if (credential.kind === "invalid") {
+        const challenge = auth.find((provider) => provider.kind !== "access_token")?.challenge?.(request, baseUrl) ?? "Bearer";
+        return {
+            ok: false,
+            response: await providerChallenge(privateJson({ error: "unauthorized" }, {
+                status: 401,
+                headers: { "WWW-Authenticate": challenge },
+            }), request, baseUrl, auth),
+        };
+    }
+    request = authorizationRequest(request);
+    if (explicit && runtimeContext)
+        runtimeContext = { waitUntil: runtimeContext.waitUntil.bind(runtimeContext) };
+    const machineCredential = isMachineCredential(request);
+    if (interactiveOnly && machineCredential) {
+        return { ok: false, response: privateJson({ error: "authenticated user required" }, { status: 403 }) };
+    }
+    if (auth.length === 0 && !interactiveOnly && !explicit) {
         const actor = { kind: "anonymous" };
         const identity = { actor, interactive: false };
         let access;
@@ -45,28 +113,63 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                 response: privateJson({ error: "identity access resolution failed" }, { status: 403 }),
             };
         }
-        return { ok: true, actor, identity, ...access, operator: false, accessTokenManagement: false, credentialAdministration: "none", personalConnection: "none" };
+        return {
+            ok: true,
+            actor,
+            identity,
+            ...access,
+            operator: false,
+            accessTokenManagement: false,
+            credentialAdministration: "none",
+            personalConnection: "none",
+        };
+    }
+    let recognized;
+    try {
+        recognized = recognizedProvider(request, machineCredential ? auth.filter((provider) => provider.kind === "access_token") : auth, runtimeContext);
+    }
+    catch {
+        return { ok: false, response: privateJson({ error: "credential recognition failed" }, { status: 403 }) };
+    }
+    if (machineCredential && !recognized) {
+        return {
+            ok: false,
+            response: await providerChallenge(privateJson({ error: "unauthorized" }, {
+                status: 401,
+                headers: { "WWW-Authenticate": "Bearer" },
+            }), request, baseUrl, auth),
+        };
+    }
+    if (interactiveOnly && recognized && !recognized.interactiveOperator) {
+        return { ok: false, response: privateJson({ error: "authenticated user required" }, { status: 403 }) };
     }
     let lastResponse = null;
-    for (const provider of auth) {
+    const eligible = auth.filter((provider) => (!interactiveOnly || provider.interactiveOperator) &&
+        (!explicit || machineCredential || provider.kind !== "access_token" || !provider.recognizesCredential));
+    // A header owns one verdict even for adapters without a recognition hook.
+    const candidates = recognized ? [recognized] : explicit ? eligible.slice(0, 1) : eligible;
+    for (const provider of candidates) {
         const result = await provider.authorize(request, baseUrl, runtimeContext);
         if (result.ok) {
+            if (interactiveOnly && !result.userId) {
+                return { ok: false, response: privateJson({ error: "authenticated user required" }, { status: 403 }) };
+            }
             const subjectId = result.subjectId ?? result.userId;
             const actorNamespace = activityActorNamespace(provider);
-            const derivedPrincipal = result.userId && actorNamespace
-                ? { namespace: actorNamespace, id: result.userId }
-                : undefined;
-            const principal = validIdentityReference(result.principal)
-                ? result.principal
-                : derivedPrincipal;
+            const derivedPrincipal = result.userId && actorNamespace ? { namespace: actorNamespace, id: result.userId } : undefined;
+            const principal = validIdentityReference(result.principal) ? result.principal : derivedPrincipal;
             const subject = subjectId
                 ? { namespace: actorNamespace ?? `connecta:auth:${provider.kind}`, id: subjectId }
                 : principal;
             const interactive = Boolean(result.userId && provider.interactiveOperator);
+            // Principal-only API callers still need a stable typed actor for history
+            // ownership. Never collapse distinct personal partitions into { kind }.
+            const actorId = subjectId ?? principal?.id;
+            const recordNamespace = actorNamespace ?? (subjectId === undefined ? principal?.namespace : undefined);
             const actor = {
                 kind: provider.kind,
-                ...(subjectId ? { id: subjectId } : {}),
-                ...(subjectId && actorNamespace ? { namespace: actorNamespace } : {}),
+                ...(actorId ? { id: actorId } : {}),
+                ...(actorId && recordNamespace ? { namespace: recordNamespace } : {}),
             };
             const identity = {
                 actor,
@@ -81,22 +184,30 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
             let access;
             try {
                 if (identityConfig?.activityAccess) {
-                    operator = interactive && principal
-                        ? await identityConfig.activityAccess(principal)
-                        : false;
+                    operator = principal ? await identityConfig.activityAccess(principal) : false;
                 }
                 access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all", { allowReadOnly: true });
                 if (interactive) {
-                    accessTokenManagement = identityConfig?.accessTokenManagement ? await identityConfig.accessTokenManagement(identity) : false;
+                    accessTokenManagement = identityConfig?.accessTokenManagement
+                        ? await identityConfig.accessTokenManagement(identity)
+                        : false;
                     if (typeof accessTokenManagement !== "boolean")
                         throw new Error("invalid token management permission");
-                    credentialAdministration = identityConfig?.credentialAdministration ? await identityConfig.credentialAdministration(identity) : "none";
-                    personalConnection = principal && identityConfig?.personalConnection ? await identityConfig.personalConnection(identity) : "none";
+                    credentialAdministration = identityConfig?.credentialAdministration
+                        ? await identityConfig.credentialAdministration(identity)
+                        : "none";
+                    personalConnection =
+                        principal && identityConfig?.personalConnection
+                            ? await identityConfig.personalConnection(identity)
+                            : "none";
                 }
                 if (typeof operator !== "boolean")
                     throw new Error("invalid activity permission");
                 for (const permission of [credentialAdministration, personalConnection]) {
-                    if (permission !== "all" && permission !== "none" && (!Array.isArray(permission) || !permission.every(id => typeof id === "string" && /^[a-z0-9_-]+$/.test(id))))
+                    if (permission !== "all" &&
+                        permission !== "none" &&
+                        (!Array.isArray(permission) ||
+                            !permission.every((id) => typeof id === "string" && /^[a-z0-9_-]+$/.test(id))))
                         throw new Error("invalid identity permission");
                 }
             }
@@ -110,57 +221,39 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                 ok: true,
                 actor,
                 identity,
-                ...(subject && partitionIdentity
-                    ? { subjectKey: await identityStorageKey(subject) }
-                    : {}),
-                ...(principal && partitionIdentity
-                    ? { principalKey: await identityStorageKey(principal) }
-                    : {}),
+                ...(result.sessionCookies?.length ? { sessionCookies: result.sessionCookies } : {}),
+                ...(subject && partitionIdentity ? { subjectKey: await identityStorageKey(subject) } : {}),
+                ...(principal && partitionIdentity ? { principalKey: await identityStorageKey(principal) } : {}),
                 ...access,
                 accessTokenManagement,
                 credentialAdministration,
                 personalConnection,
                 operator,
-                ...(operator ? { uiAdminEligible: true } : {}),
+                ...(interactive && operator ? { uiAdminEligible: true } : {}),
             };
         }
         lastResponse = result.response;
+        if (recognized || result.response.status !== 401)
+            break;
     }
     return {
         ok: false,
-        response: lastResponse ??
-            new Response(JSON.stringify({ error: "unauthorized" }), {
+        response: await providerChallenge(lastResponse ??
+            privateJson({ error: "unauthorized" }, {
                 status: 401,
-                headers: {
-                    "Content-Type": "application/json",
-                    "WWW-Authenticate": "Bearer",
-                },
-            }),
+                headers: { "WWW-Authenticate": "Bearer" },
+            }), request, baseUrl, auth, explicit ? candidates[0] : undefined),
     };
 }
+/** Human routes reject machine credentials before any verification or storage I/O. */
 export async function authorizeUiIdentity(request, baseUrl, auth, purpose, runtimeContext, identityConfig) {
-    const providers = auth.filter((candidate) => candidate.interactiveOperator);
-    if (providers.length === 0) {
+    if (!auth.some((provider) => provider.interactiveOperator)) {
         return {
             ok: false,
             response: privateJson({ error: `${purpose} requires interactive user authentication` }, { status: 403 }),
         };
     }
-    let lastResponse;
-    for (const provider of providers) {
-        const authz = await authorize(request, baseUrl, [provider], runtimeContext, identityConfig);
-        if (!authz.ok) {
-            lastResponse = authz.response;
-            continue;
-        }
-        if (authz.identity.interactive)
-            return authz;
-        lastResponse = privateJson({ error: "authenticated user required" }, { status: 403 });
-    }
-    return {
-        ok: false,
-        response: lastResponse ?? privateJson({ error: `${purpose} requires interactive user authentication` }, { status: 403 }),
-    };
+    return authorize(request, baseUrl, auth, runtimeContext, identityConfig, true, true);
 }
 export function isSameOrigin(request, baseUrl) {
     const origin = request.headers.get("origin");
@@ -174,7 +267,9 @@ export function isSameOrigin(request, baseUrl) {
     }
 }
 export function withSecurityHeaders(response, requestUrl, _path) {
-    const headers = new Headers(response.headers);
+    const headers = response.headers.get("Content-Type")?.toLowerCase().startsWith("text/html")
+        ? htmlSecurityHeaders(response.headers)
+        : new Headers(response.headers);
     headers.set("X-Content-Type-Options", "nosniff");
     headers.set("Referrer-Policy", "no-referrer");
     if (requestUrl.protocol === "https:") {
@@ -188,44 +283,29 @@ export function withSecurityHeaders(response, requestUrl, _path) {
 }
 /** Unknown configured ids refuse the complete view, including management rights. */
 export function validateAuthPermissions(authz, registry) {
-    for (const value of [
-        authz.connectorIds,
-        authz.credentialAdministration,
-        authz.personalConnection,
-    ]) {
+    for (const value of [authz.connectorIds, authz.credentialAdministration, authz.personalConnection]) {
         if (value === "all" || value === "none")
             continue;
-        if (!Array.isArray(value) || value.some(id => !registry.getConnector(id))) {
+        if (!Array.isArray(value) || value.some((id) => !registry.getConnector(id))) {
             throw new Error("invalid identity permission connector ids");
         }
     }
 }
-/**
- * Whether this identity may open artifact pages: exactly whoever may read the
- * `artifacts` connector — it is visible to them and `get_artifact` is among
- * its tools they were granted. Viewing grants nothing a program could not
- * already read (ethos, "Human routes manage auth, never capability").
- */
-export function mayViewArtifacts(authz, registry) {
-    if (authz.connectorIds !== "all" && !authz.connectorIds.includes("artifacts")) {
-        return false;
-    }
-    const tools = authz.toolAccess?.get("artifacts");
-    if (tools && !tools.has("get_artifact"))
-        return false;
-    if (!authz.guardedToolAccess?.get("artifacts")?.has("get_artifact"))
-        return true;
-    return registry.getConnector("artifacts")?.staticTools?.some((tool) => tool.name === "get_artifact" && isExplicitlyReadOnly(tool)) === true;
-}
 export function mayManageConnector(authz, connector) {
     if (!authz.identity.interactive)
         return false;
     if (authz.connectorIds !== "all" && !authz.connectorIds.includes(connector.id)) {
         return false;
     }
-    const permission = connector.authScope === "personal"
-        ? authz.personalConnection
-        : authz.credentialAdministration;
-    return permission === "all" ||
-        (permission !== "none" && permission.includes(connector.id));
+    const permission = connector.authScope === "personal" ? authz.personalConnection : authz.credentialAdministration;
+    return permission === "all" || (permission !== "none" && permission.includes(connector.id));
+}
+/** Preserve refreshed browser cookies on the redirect or completion page. */
+export function withSessionCookies(response, cookies) {
+    if (!cookies?.length)
+        return response;
+    const headers = new Headers(response.headers);
+    for (const cookie of cookies)
+        headers.append("Set-Cookie", cookie);
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
 }

package/dist/routes/skills.js

@@ -0,0 +1,30 @@
+import { ProtocolError } from "@modelcontextprotocol/server";
+import { z } from "zod";
+import { ConnectorCallError } from "../errors.js";
+import { SkillsRegistry } from "../skills.js";
+/** Native Skills methods use the same request-view registry as both text readers. */
+export function registerSkills(server, view, baseUrl, options) {
+    // McpServer's resource constructor installs its static registry and turns
+    // listChanged on. Declare the capability on the low-level server instead.
+    server.server.registerCapabilities({ resources: {} });
+    const registry = new SkillsRegistry(view, baseUrl, options);
+    const listParams = z.object({ cursor: z.string().max(128).optional() });
+    const getParams = z.object({ uri: z.string().min(1).max(32_768).startsWith("skill://") });
+    const result = z.record(z.string(), z.unknown());
+    const safely = async (read) => {
+        try {
+            return await read();
+        }
+        catch (error) {
+            if (error instanceof ConnectorCallError && (error.code === "not_found" || error.code === "invalid_args")) {
+                throw new ProtocolError(-32602, "Unknown skill/file or invalid skills cursor.");
+            }
+            // No raw downstream cause can become an SDK/operator diagnostic.
+            throw new ProtocolError(-32603, "Skills are unavailable.");
+        }
+    };
+    server.server.setRequestHandler("skills/list", { params: listParams, result }, (params) => safely(() => registry.list(params.cursor)));
+    server.server.setRequestHandler("skills/get", { params: getParams, result }, (params) => safely(() => registry.get(params.uri)));
+    server.server.setRequestHandler("resources/list", { params: listParams, result }, (params) => safely(() => registry.resources(params.cursor)));
+    server.server.setRequestHandler("resources/read", { params: getParams, result }, (params) => safely(() => registry.read(params.uri)));
+}

package/dist/routes/ui-config.js

@@ -0,0 +1,225 @@
+import { activityEventVisible } from "./activity-disclosure.js";
+import { operatorActivityContext } from "./activity-context.js";
+import { bindActivityRequest } from "../activity-request.js";
+import { configValuePaths } from "../config-value-sources.js";
+import { Effect } from "effect";
+import { intersectAccess } from "../connector-access.js";
+import { describedTools } from "../described.js";
+import { resolveDiscoveryConcurrency } from "../concurrency.js";
+import { recordedToolName } from "../operator-record.js";
+import { closeScope } from "../runtime/connector-scope.js";
+import { withDeadlineEffect } from "../runtime/run.js";
+import { uiProblemFor } from "../ui.js";
+import { authorized, serveOperator, visibleRegistry } from "./operator.js";
+import { mayManageConnector, privateJson } from "./shared.js";
+const attempt = (operation) => Effect.tryPromise({ try: operation, catch: (error) => error });
+const validName = (name) => recordedToolName({ name }) === name;
+function grants(access, ids) {
+    return ids
+        .filter((id) => access.connectorIds === "all" || access.connectorIds.includes(id))
+        .map((connectorId) => {
+        const tools = access.toolAccess?.get(connectorId);
+        return {
+            connectorId,
+            tools: tools
+                ? [...tools].filter(validName).map((name) => ({
+                    name,
+                    requireReadOnly: access.guardedToolAccess?.get(connectorId)?.has(name) === true,
+                }))
+                : "all",
+        };
+    });
+}
+function toolVisible(authz, id, name, classification) {
+    return (validName(name) &&
+        (!authz.toolAccess?.get(id) || authz.toolAccess.get(id).has(name)) &&
+        (!authz.guardedToolAccess?.get(id)?.has(name) || classification === "read"));
+}
+function observe(context, registry, connector, activity) {
+    const { opts, baseUrl, request, defer } = context;
+    const scope = {};
+    if (activity)
+        bindActivityRequest(scope, activity);
+    const id = connector.id;
+    return withDeadlineEffect((signal) => Effect.gen(function* () {
+        const drift = yield* attempt(() => registry.credentialDriftFor(id));
+        const status = drift
+            ? { state: "auth_required" }
+            : yield* attempt(() => registry.statusFor(id, baseUrl, scope, { signal, ...(defer ? { defer } : {}) }));
+        let catalogFailed = false;
+        const tools = status.state === "ok"
+            ? yield* attempt(() => registry.getTools(id, baseUrl, scope, { signal, ...(defer ? { defer } : {}) })).pipe(Effect.catch(() => {
+                catalogFailed = true;
+                return Effect.succeed([]);
+            }))
+            : [];
+        const problem = uiProblemFor(connector, status.state, { credentialDrift: Boolean(drift), catalogFailed });
+        return {
+            id,
+            status: status.state,
+            ...(status.registrationPath ? { auth: { registrationPath: status.registrationPath } } : {}),
+            ...(problem ? { problem } : {}),
+            // Catalog metadata is allowed for authenticated operators. Only the name
+            // and its derived address are withheld when they fail the record grammar.
+            tools: describedTools(tools).map((tool) => {
+                const name = recordedToolName(tool);
+                return {
+                    ...tool,
+                    name,
+                    address: `${id}.${name}`,
+                    classification: tool.classification === "read" ? "read" : "write",
+                };
+            }),
+            catalogAgeMs: registry.catalogAgeMs(id),
+            lastCall: null,
+        };
+    }), {
+        timeoutMs: opts.config.discovery.probeTimeoutMs,
+        signal: request.signal,
+        timeoutError: new Error("Operator config observation timed out."),
+    }).pipe(Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch(() => Effect.succeed({
+        id,
+        status: "error",
+        problem: "connector_unavailable",
+        tools: [],
+        catalogAgeMs: registry.catalogAgeMs(id),
+        lastCall: null,
+    })), Effect.ensuring(Effect.suspend(() => closeScope(connector, registry.contextFor(id, baseUrl, scope), defer))));
+}
+const OUTCOMES = new Set([
+    "success",
+    "error",
+    "timeout",
+    "cancelled",
+    "paused",
+    "approved",
+]);
+const isTimestamp = (value) => /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value));
+function lastCalls(context, authz, registry, rows, admittedPools) {
+    const activity = context.opts.config.activity;
+    if (!activity?.store.list)
+        return Effect.succeed("unconfigured");
+    if (!authz.operator)
+        return Effect.succeed("forbidden");
+    return Effect.gen(function* () {
+        const permitted = activity.readGate
+            ? yield* attempt(async () => (await activity.readGate(authz.actor)) === true).pipe(Effect.orElseSucceed(() => false))
+            : true;
+        if (!permitted)
+            return "forbidden";
+        return yield* Effect.gen(function* () {
+            const byId = new Map(rows.map((row) => [row.id, row]));
+            let cursor;
+            const seen = new Set();
+            // Bound the read even when a custom reader repeats a cursor or ignores
+            // its requested page size. Each page belongs to the request fiber, so
+            // cancellation cannot start the next page.
+            for (let pageIndex = 0; pageIndex < 10; pageIndex++) {
+                const page = yield* attempt(() => activity.store.list({ limit: 100, ...(cursor ? { cursor } : {}) }));
+                for (const event of page.events.slice(0, 100)) {
+                    if (event.kind === "catalog_drift")
+                        continue;
+                    const row = byId.get(event.connectorId);
+                    if (!row || !isTimestamp(event.occurredAt) || !OUTCOMES.has(event.outcome))
+                        continue;
+                    if (!activityEventVisible(context, authz, registry, admittedPools, event))
+                        continue;
+                    if (!row.lastCall || event.occurredAt > row.lastCall.at)
+                        row.lastCall = { at: event.occurredAt, outcome: event.outcome };
+                }
+                cursor = page.nextCursor;
+                if (!cursor || seen.has(cursor))
+                    break;
+                seen.add(cursor);
+            }
+            return "available";
+        }).pipe(Effect.catchDefect((defect) => Effect.fail(defect)), Effect.orElseSucceed(() => {
+            for (const row of rows)
+                row.lastCall = null;
+            return "unavailable";
+        }));
+    });
+}
+function configRead(context) {
+    const { opts } = context;
+    return Effect.gen(function* () {
+        const authz = yield* authorized(context);
+        const registry = yield* visibleRegistry(context, authz);
+        const visible = registry.listConnectors();
+        const ids = visible.map((c) => c.id);
+        const pools = [];
+        for (const [name, pool] of opts.pools) {
+            const admitted = yield* attempt(async () => (await pool.grant(authz.identity)) === true).pipe(Effect.orElseSucceed(() => false));
+            if (admitted)
+                pools.push({
+                    name,
+                    path: `/mcp/${name}`,
+                    trust: pool.trust,
+                    grants: grants(intersectAccess(authz, pool.access), ids),
+                });
+        }
+        const config = structuredClone(opts.configDescription);
+        config.connectors = config.connectors
+            .filter((c) => ids.includes(c.id))
+            .map((c) => ({
+            ...c,
+            ...(c.tools
+                ? { tools: c.tools.filter((tool) => toolVisible(authz, c.id, tool.name, tool.classification)) }
+                : {}),
+        }));
+        config.classification = Object.fromEntries(Object.entries(config.classification)
+            .filter(([id]) => ids.includes(id))
+            .map(([id, tools]) => [
+            id,
+            Object.fromEntries(Object.entries(tools).filter(([name, classification]) => toolVisible(authz, id, name, classification))),
+        ]));
+        config.pools = config.pools.flatMap((pool) => {
+            const admitted = pools.find((p) => p.name === pool.name);
+            if (!admitted)
+                return [];
+            return [
+                {
+                    ...pool,
+                    tools: admitted.grants.flatMap((grant) => grant.tools === "all"
+                        ? [grant.connectorId]
+                        : grant.tools.map((tool) => `${grant.connectorId}.${tool.name}`)),
+                },
+            ];
+        });
+        const requestActivity = operatorActivityContext(context, authz);
+        const rows = yield* Effect.forEach(visible, (c) => observe(context, registry, c, requestActivity), {
+            concurrency: resolveDiscoveryConcurrency(opts.config.discovery.concurrency),
+        });
+        const activity = yield* lastCalls(context, authz, registry, rows, new Set(pools.map((pool) => pool.name)));
+        const contract = {
+            schemaVersion: 1,
+            config,
+            configSources: Object.fromEntries(configValuePaths(config).map((path) => [path, opts.configValueSources?.[path] ?? "config"])),
+            live: { connectors: rows, activity },
+            you: {
+                interactive: authz.identity.interactive,
+                grants: grants(authz, ids),
+                trust: opts.config.trust,
+                pools,
+                permissions: {
+                    activity: activity === "available" || activity === "unavailable",
+                    accessTokenManagement: Boolean(opts.config.accessTokens && authz.accessTokenManagement && authz.identity.principal),
+                    connectors: visible.map((c) => ({
+                        id: c.id,
+                        use: true,
+                        manageSharedAuth: c.authScope !== "personal" && mayManageConnector(authz, c),
+                        connectPersonal: c.authScope === "personal" && mayManageConnector(authz, c),
+                    })),
+                },
+            },
+        };
+        return privateJson(contract);
+    });
+}
+export async function routeUiConfig(context) {
+    if (context.path !== "/ui/api/config")
+        return null;
+    if (context.request.method !== "GET")
+        return privateJson({ error: "method not allowed" }, { status: 405 });
+    return serveOperator(configRead(context), context.request.signal);
+}