@zackbart/connecta 0.24.4 → 0.26.0

package/dist/routes/oauth.js

@@ -1,5 +1,7 @@
+import { Effect } from "effect";
 import { oauthValueStorageKey } from "../auth/downstream-oauth.js";
 import { resolveBranding } from "../branding.js";
+import { oauthCallbackOutcome, providerErrorReason, } from "../oauth-callback-outcome.js";
 import { authorizeUiIdentity, mayManageConnector, validateAuthPermissions, loggableValue, msg, } from "./shared.js";
 function escapeHtml(value) {
     return value
@@ -8,8 +10,14 @@ function escapeHtml(value) {
         .replaceAll(">", ">")
         .replaceAll('"', """);
 }
-/** `body` is escaped — callback params and error messages are attacker-influenced. */
-function html(body, status = 200, branding, hasUi = false) {
+/**
+ * The callback's one page. It renders a reason from a closed set and that
+ * reason's fixed copy, so nothing the request carried — the provider's `error`
+ * parameter, an exchange failure's message — can reach the body. Escaping
+ * stays anyway: branding and the configured connector id are still strings.
+ */
+function html(reason, branding, hasUi = false, connectorId) {
+    const outcome = oauthCallbackOutcome(reason, connectorId);
     const brand = resolveBranding(branding);
     const title = brand.pageTitle;
     const owner = brand.ownerName
@@ -52,7 +60,10 @@ function html(body, status = 200, branding, hasUi = false) {
   a { color: inherit; text-decoration: underline; text-decoration-thickness: 1.5px;
     text-underline-offset: .22em; }
   a:hover { text-decoration-color: transparent; }
-  a:focus-visible { outline: 1px solid #000; outline-offset: 2px; }
+  a:focus-visible, summary:focus-visible { outline: 1px solid #000; outline-offset: 2px; }
+  summary { cursor: pointer; }
+  pre { font: 13px/1.5 ui-monospace, Menlo, Consolas, monospace; margin: .75rem 0 0;
+    padding: .75rem; white-space: pre-wrap; border: 1px solid #000; user-select: all; }
   @media (max-width: 36.99rem) {
     .grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
     .product { grid-column: 2; }
@@ -66,15 +77,16 @@ function html(body, status = 200, branding, hasUi = false) {
     ${owner}
     ${product}
   </header>
-  <main class="shell grid">
+  <main class="shell grid" data-oauth-callback="${outcome.reason}">
     <h1>Connection status</h1>
     <div class="copy">
-      <p>${escapeHtml(body)}</p>
+      <p>${escapeHtml(outcome.message)}</p>
+      ${outcome.fixPrompt ? `<details><summary>Fix prompt for a coding agent</summary><pre>${escapeHtml(outcome.fixPrompt)}</pre></details>` : ""}
       ${hasUi ? `<p><a href="/">Return to ${escapeHtml(brand.productName)}</a></p>` : ""}
     </div>
   </main>
 </body>
-</html>`, { status, headers: { "Content-Type": "text/html; charset=utf-8" } });
+</html>`, { status: outcome.status, headers: { "Content-Type": "text/html; charset=utf-8" } });
 }
 /**
  * Pay the storage read a real downstream-OAuth refusal pays, on the refusal
@@ -107,16 +119,29 @@ async function equalizeRefusalCost(context) {
         // Deliberately ignored — see above.
     }
 }
-export async function routeOAuthCallback(context) {
+/**
+ * The callback route as a step of the request's fiber, and the one step that
+ * the request's signal does not interrupt.
+ *
+ * An authorization code is single-use. Once a browser has delivered one, the
+ * handoff it consumes, the exchange, and the catalog invalidation after it are
+ * one commitment: abandoned halfway, a connector could hold fresh tokens
+ * behind a catalog still cached as unauthorized, or a consumed handoff with no
+ * exchange behind it. A caller that hangs up mid-exchange loses only the page.
+ */
+export function routeOAuthCallback(context) {
+    if (!context.path.startsWith("/oauth/callback/"))
+        return Effect.succeed(null);
+    return Effect.uninterruptible(Effect.promise(() => finishOAuthCallback(context)));
+}
+async function finishOAuthCallback(context) {
     const { path, url, baseUrl, opts } = context;
-    if (!path.startsWith("/oauth/callback/"))
-        return null;
     const error = url.searchParams.get("error");
     if (error)
-        return html(`Authorization denied: ${error}`, 400, opts.branding, Boolean(opts.ui));
+        return html(providerErrorReason(error), opts.branding, Boolean(opts.ui));
     const code = url.searchParams.get("code");
     if (!code)
-        return html("Missing authorization code.", 400, opts.branding, Boolean(opts.ui));
+        return html("invalid_callback", opts.branding, Boolean(opts.ui));
     const id = path.slice("/oauth/callback/".length);
     const state = url.searchParams.get("state");
     const callbackTarget = await opts.registry.oauthCallbackView(id, state);
@@ -130,8 +155,7 @@ export async function routeOAuthCallback(context) {
     const connectorContext = callbackRegistry
         ? callbackRegistry.contextFor(id, baseUrl)
         : opts.registry.contextFor(id, baseUrl);
-    const refused = () => html("Authorization could not be completed. Re-run authorization from " +
-        "connecta and try again.", 400, opts.branding, Boolean(opts.ui));
+    const refused = () => html("invalid_callback", opts.branding, Boolean(opts.ui));
     if (!connector || !connector.finishAuth) {
         await equalizeRefusalCost(connectorContext);
         return refused();
@@ -196,15 +220,19 @@ export async function routeOAuthCallback(context) {
             opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
                 `${loggableValue(id)} with 500: its principal handoff could not be ` +
                 `consumed (${loggableValue(msg(err))}). No authorization code was exchanged.`);
-            return html("Authorization could not be completed.", 500, opts.branding, Boolean(opts.ui));
+            return html("handoff_failed", opts.branding, Boolean(opts.ui), id);
         }
     }
     try {
         await connector.finishAuth(code, connectorContext, url.searchParams);
         await callbackRegistry.invalidateStored(id);
-        return html(`Connected "${id}". You can close this window.`, 200, opts.branding, Boolean(opts.ui));
+        return html("connected", opts.branding, Boolean(opts.ui), id);
     }
     catch (err) {
-        return html(`Authorization failed: ${msg(err)}`, 500, opts.branding, Boolean(opts.ui));
+        // The page names the reason and nothing else; what the exchange threw can
+        // quote a token endpoint's body, so it goes only to the operator log.
+        opts.logger.warn(`[connecta] OAuth callback for connector ${loggableValue(id)} failed ` +
+            `with 500: the authorization code exchange threw ${loggableValue(msg(err))}.`);
+        return html("exchange_failed", opts.branding, Boolean(opts.ui), id);
     }
 }

package/dist/routes/operator.js

@@ -0,0 +1,83 @@
+// The Effect plumbing the operator and activity data routes share.
+//
+// Each JSON route under /ui/* is one Effect program, run at its Promise edge
+// by serveOperator. A route that settles its answer early — a refusal, or an
+// auth provider's own challenge — fails with an Answer carrying that exact
+// Response, and the edge serves it. That is the whole error model: every
+// status, body, and header is still built by privateJson or by the provider,
+// so the wire format cannot drift from what these routes have always sent.
+// Anything else that goes wrong is a defect and rejects the edge, as a throw
+// from the async handlers did.
+//
+// Effect's HttpApi was measured for this and not used (P1-S18). Declaring
+// these seven endpoints added about 101 KB gzip to ./ui and 131 KB to
+// ./activity, most of it Schema, and matching the wire format would have
+// meant opting out of nearly everything it does: unowned paths fall through
+// to the next module rather than 404, a wrong method is a JSON 405, the
+// Content-Type and size checks run before a body is read, and a credential
+// field error names the field in words the page already shows. Plain routing
+// over one error channel keeps the behavior and costs nothing, because ./ui
+// already carries Effect through its deadlines.
+//
+// Imported by the /ui and /activity graphs only; never from the root entry.
+import { Effect } from "effect";
+import { runEdge } from "../runtime/run.js";
+import { authorize, authorizeUiIdentity, msg, privateJson, validateAuthPermissions, } from "./shared.js";
+/** A response the route has already decided on. */
+export class Answer {
+    response;
+    _tag = "Answer";
+    constructor(response) {
+        this.response = response;
+    }
+}
+/** End the route with a private JSON error, as every route here does. */
+export function refuse(error, status) {
+    return Effect.fail(new Answer(privateJson({ error }, { status })));
+}
+function admitted(result) {
+    return Effect.flatMap(Effect.promise(() => result), (authz) => authz.ok ? Effect.succeed(authz) : Effect.fail(new Answer(authz.response)));
+}
+/** Any configured caller. The gate's refusal, challenge headers and all, is the answer. */
+export function authorized({ request, baseUrl, opts, runtimeContext }, partitionIdentity = true) {
+    return Effect.suspend(() => admitted(authorize(request, baseUrl, opts.auth, runtimeContext, opts.identity, partitionIdentity)));
+}
+/** A signed-in person, for a route that changes how a connector authenticates. */
+export function authorizedPerson({ request, baseUrl, opts, runtimeContext }, purpose) {
+    return Effect.suspend(() => admitted(authorizeUiIdentity(request, baseUrl, opts.auth, purpose, runtimeContext, opts.identity)));
+}
+/** The partition and tool grants an identity carries into a registry view. */
+export function scopeFor(authz, connectorIds = authz.connectorIds) {
+    return {
+        connectorIds,
+        ...(authz.toolAccess ? { toolAccess: authz.toolAccess } : {}),
+        ...(authz.guardedToolAccess ? { guardedToolAccess: authz.guardedToolAccess } : {}),
+        ...(authz.subjectKey ? { subjectKey: authz.subjectKey } : {}),
+        ...(authz.principalKey ? { principalKey: authz.principalKey } : {}),
+    };
+}
+/**
+ * The registry as this identity may see it. A configured permission naming a
+ * connector that does not exist refuses the whole view, management rights
+ * included, rather than quietly granting what remains.
+ */
+export function visibleRegistry({ opts }, authz) {
+    return Effect.try({
+        try: () => {
+            validateAuthPermissions(authz, opts.registry);
+            return opts.registry.scoped(scopeFor(authz));
+        },
+        catch: (error) => new Answer(privateJson({ error: msg(error) }, { status: 403 })),
+    });
+}
+/**
+ * Run one route program to its Response.
+ *
+ * A read passes the request's signal, so a caller who leaves stops whatever
+ * the read was waiting on. A mutation passes none: once a vault write or an
+ * OAuth disconnect has started, the cache invalidation that follows it must
+ * run too, whether or not anyone is still waiting for the answer.
+ */
+export function serveOperator(program, signal) {
+    return runEdge(Effect.catch(program, (answer) => Effect.succeed(answer.response)), signal ? { signal } : undefined);
+}

package/dist/routes/shared.d.ts

@@ -1,5 +1,5 @@
 import type { Implementation } from "@modelcontextprotocol/server";
-import type { ActivityModule, OperatorSurface } from "../module-contracts.js";
+import type { ActivityModule, ArtifactsModule, OperatorSurface } from "../module-contracts.js";
 import type { ActivityActor, ActivityReadGate, ActivityStore } from "../activity.js";
 import type { CredentialVault } from "../credential-contract.js";
 import type { DeferredWork } from "../connector-scope.js";
@@ -7,6 +7,7 @@ import type { AdmissionController } from "../executor-admission.js";
 import type { Registry, ToolAccess } from "../registry.js";
 import type { ResolvedPool } from "../connector-access.js";
 import type { AuthenticatedIdentity, ConnectaBranding, Executor, InboundAuth, InboundAuthRuntimeContext, Logger } from "../types.js";
+import type { ApprovalPolicy } from "../tool-safety.js";
 import type { ConnectorPermission, ConnectaIdentityConfig } from "../index.js";
 export { msg } from "../errors.js";
 export interface ServerOptions {
@@ -16,6 +17,7 @@ export interface ServerOptions {
     /** Validated named pools served at `/mcp/<name>`; empty when none declared. */
     pools?: ReadonlyMap<string, ResolvedPool> | undefined;
     publicUrl?: string | undefined;
+    artifactOrigin?: string | undefined;
     allowedOrigins?: readonly string[] | "*" | undefined;
     serverInfo: Implementation;
     logger: Logger;
@@ -37,6 +39,17 @@ export interface ServerOptions {
     maxHostCalls?: number | undefined;
     /** Deadline per execute_code host call. Default 15_000. */
     hostCallTimeoutMs?: number | undefined;
+    /** Hard ceiling on one execute_code run, outside the sandbox. Default 120_000. */
+    watchdogMs?: number | undefined;
+    /** Resumable writes' settings; absent when they are off. */
+    resumable?: {
+        maxWrites: number;
+        ttlSeconds: number;
+    } | undefined;
+    /** Config approval exemptions (`execute.approval`), resolved at construction. */
+    approval?: ApprovalPolicy | undefined;
+    /** Writes one program may send (`execute.maxWrites`), exempt ones included. */
+    maxWrites?: number | undefined;
     /** Required sandbox backing the execute_code meta-tool. */
     executor: Executor;
     /** Sanitized identity of the configured sandbox, when it has one. */
@@ -48,6 +61,8 @@ export interface ServerOptions {
     /** Optional browser routes, with no implementation import in core. */
     ui?: OperatorSurface | undefined;
     activityModule?: ActivityModule | undefined;
+    /** Optional team pages; their routes mount only beside `ui`. */
+    artifactsModule?: ArtifactsModule | undefined;
     /** Optional browser UI and OAuth result-page labels. */
     branding?: ConnectaBranding | undefined;
 }
@@ -84,6 +99,8 @@ export declare function authorize(request: Request, baseUrl: string, auth: Inbou
     connectorIds: "all" | readonly string[];
     /** Per-connector tool allowlist for connectors granted by address only. */
     toolAccess?: ToolAccess;
+    /** Granted addresses that still require the catalog's read-only hint. */
+    guardedToolAccess?: ToolAccess;
     operator: boolean;
     credentialAdministration: ConnectorPermission;
     personalConnection: ConnectorPermission;
@@ -106,6 +123,13 @@ type AuthorizedIdentity = Extract<Awaited<ReturnType<typeof authorize>>, {
 }>;
 /** Unknown configured ids refuse the complete view, including management rights. */
 export declare function validateAuthPermissions(authz: AuthorizedIdentity, registry: Registry): void;
+/**
+ * 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 declare function mayViewArtifacts(authz: AuthorizedIdentity, registry: Registry): boolean;
 export declare function mayManageConnector(authz: AuthorizedIdentity, connector: {
     id: string;
     authScope?: "shared" | "personal";

package/dist/routes/shared.js

@@ -1,5 +1,6 @@
 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);
@@ -36,7 +37,7 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
         const identity = { actor, interactive: false };
         let access;
         try {
-            access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all");
+            access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all", { allowReadOnly: true });
         }
         catch {
             return {
@@ -83,7 +84,7 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                         ? await identityConfig.activityAccess(principal)
                         : false;
                 }
-                access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all");
+                access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all", { allowReadOnly: true });
                 if (interactive) {
                     credentialAdministration = identityConfig?.credentialAdministration ? await identityConfig.credentialAdministration(identity) : "none";
                     personalConnection = principal && identityConfig?.personalConnection ? await identityConfig.personalConnection(identity) : "none";
@@ -194,6 +195,23 @@ export function validateAuthPermissions(authz, registry) {
         }
     }
 }
+/**
+ * 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;

package/dist/routes/ui-data.js

@@ -0,0 +1,211 @@
+// The Effect core of the operator payload: `buildUiData` in src/ui.ts is its
+// Promise face, and the `/ui/connectors/<id>` route yields it directly.
+//
+// Every visible connector is one slot of a bounded fan-out: its probe runs
+// under a deadline, any failure becomes that connector's error row rather
+// than the payload's, and its connector scope closes as the slot ends,
+// however it ends.
+import { Effect } from "effect";
+import { resolveDiscoveryConcurrency } from "../concurrency.js";
+import { credentialTestRule, describeUndeclaredCredentialFields, storedCredentialShape, } from "../credential-rules.js";
+import { closeScope } from "../runtime/connector-scope.js";
+import { withDeadlineEffect } from "../runtime/run.js";
+import { isApprovalExempt, NO_EXEMPTIONS, } from "../tool-safety.js";
+import { uiProblemFor, uiToolSafety } from "../ui.js";
+import { CONNECTA_VERSION } from "../version.js";
+const DETAIL_TIMEOUT_MS = 30_000;
+const DETAIL_TIMED_OUT = "Connection details timed out. Retry this connection.";
+function attempt(operation) {
+    return Effect.tryPromise({ try: operation, catch: (error) => error });
+}
+export function uiData(registry, baseUrl, options) {
+    return Effect.suspend(() => {
+        const requestScope = {};
+        const vault = options.credentialVault;
+        const owner = options.personalCredentialOwner;
+        /**
+         * A connector's status message stops here. It can quote a downstream error
+         * body — and a downstream error body can quote the secret it just rejected —
+         * so the payload carries only the classified `problem` and the raw text goes
+         * to the deployment's log, where an operator debugging the failure already
+         * looks. An `ok` status's message is informational and simply dropped.
+         */
+        const logStatus = (id, state, message) => {
+            if (!message || state === "ok")
+                return;
+            const logger = registry.contextFor(id, baseUrl, requestScope).logger;
+            const line = `[connecta] connector "${id}" operator status ${state}: ${message}`;
+            if (state === "auth_required")
+                logger.info(line);
+            else
+                logger.warn(line);
+        };
+        // Status first, then the catalog only when status is ok. A failed status
+        // read is an error status, not a failed row: the row still reports the
+        // connector's credential.
+        const observe = (c, drift, signal) => {
+            if (drift) {
+                return Effect.succeed({
+                    status: { state: "auth_required", message: drift },
+                    tools: [],
+                    catalogFailed: false,
+                });
+            }
+            return Effect.gen(function* () {
+                const status = yield* attempt(() => registry.statusFor(c.id, baseUrl, requestScope, { signal }));
+                if (status.state !== "ok" || signal.aborted) {
+                    return { status, tools: [], catalogFailed: false };
+                }
+                return yield* attempt(async () => (await registry.getTools(c.id, baseUrl, requestScope, { signal })).map((t) => ({
+                    name: t.name,
+                    address: `${c.id}.${t.name}`,
+                    ...(t.description ? { description: t.description } : {}),
+                    safety: uiToolSafety(t, isApprovalExempt(options.approval ?? NO_EXEMPTIONS, c, t.name, t)),
+                }))).pipe(Effect.map((tools) => ({ status, tools, catalogFailed: false })), 
+                // The registry owns the failed catalog observation; the page only
+                // needs to know there was one.
+                Effect.catch(() => Effect.succeed({ status, tools: [], catalogFailed: !signal.aborted })));
+            }).pipe(Effect.catch((error) => Effect.succeed({
+                status: {
+                    state: "error",
+                    message: error instanceof Error
+                        ? error.message
+                        : "Connection details unavailable",
+                },
+                tools: [],
+                catalogFailed: false,
+            })));
+        };
+        // The credential card, for someone who may manage this connector's auth.
+        // Never fails: a vault that cannot be read is the card's own error.
+        const credentialFor = (c) => {
+            const mayManageAuth = options.mayManage?.(c.id) ??
+                (c.authScope === "personal" ? Boolean(owner) : options.oauthManagement);
+            const declared = c.credential;
+            if (!declared || !vault || !mayManageAuth)
+                return Effect.succeed(undefined);
+            // One rule, shared with the test route: only the hook matching the
+            // declared credential shape can run, so the button is offered only
+            // where a click can succeed (src/credentials.ts).
+            const testRule = credentialTestRule(c);
+            const credentialFields = (metadata) => declared.fields?.map((field) => {
+                const fieldMetadata = metadata?.fields?.[field.name];
+                return {
+                    name: field.name,
+                    label: field.label,
+                    ...(field.description ? { description: field.description } : {}),
+                    ...(field.placeholder ? { placeholder: field.placeholder } : {}),
+                    inputType: field.inputType ?? "password",
+                    configured: Boolean(fieldMetadata),
+                    ...(fieldMetadata
+                        ? {
+                            lastFour: fieldMetadata.lastFour,
+                            updatedAt: fieldMetadata.updatedAt,
+                        }
+                        : {}),
+                };
+            });
+            const card = {
+                label: declared.label,
+                ...(declared.description ? { description: declared.description } : {}),
+                ...(declared.placeholder ? { placeholder: declared.placeholder } : {}),
+            };
+            return attempt(async () => {
+                const metadata = await vault.metadata(c.id, c.authScope === "personal" ? owner : undefined);
+                const fields = credentialFields(metadata);
+                const shape = storedCredentialShape(declared, metadata?.fields ?? null);
+                return {
+                    ...card,
+                    ...(fields?.length ? { fields } : {}),
+                    configured: shape.state === "valid",
+                    removable: Boolean(metadata),
+                    ...(metadata
+                        ? { lastFour: metadata.lastFour, updatedAt: metadata.updatedAt }
+                        : {}),
+                    testable: testRule.mode !== null && shape.state !== "mismatch",
+                    ...(shape.state === "mismatch"
+                        ? { error: shape.message, problem: "credential_mismatch" }
+                        : {}),
+                    // A dropped field leaves its secret in the vault, and the field
+                    // list below only renders fields the connector still declares —
+                    // so without this line there is nowhere an operator could see it.
+                    ...(shape.state === "valid" && shape.undeclared.length
+                        ? { notice: describeUndeclaredCredentialFields(shape.undeclared) }
+                        : {}),
+                };
+            }).pipe(Effect.catch(() => {
+                const fields = credentialFields();
+                return Effect.succeed({
+                    ...card,
+                    ...(fields?.length ? { fields } : {}),
+                    configured: false,
+                    removable: true,
+                    testable: testRule.mode !== null,
+                    error: "Stored credential could not be read.",
+                    problem: "credential_unreadable",
+                });
+            }));
+        };
+        const detail = (c, signal) => Effect.gen(function* () {
+            const drift = yield* attempt(() => registry.credentialDriftFor(c.id));
+            // One deadline covers the whole row. The status and catalog reads once
+            // had a second one of the same length inside it, which could only fire
+            // after this one had already ended the row.
+            const { status, tools, catalogFailed } = yield* observe(c, drift, signal);
+            const credential = yield* credentialFor(c);
+            logStatus(c.id, status.state, status.message);
+            const problem = uiProblemFor(c, status.state, {
+                credentialDrift: Boolean(drift),
+                catalogFailed,
+            });
+            return {
+                id: c.id,
+                authScope: c.authScope ?? "shared",
+                ...(c.title ? { title: c.title } : {}),
+                ...(c.description !== undefined ? { description: c.description } : {}),
+                status: status.state,
+                ...(problem ? { problem } : {}),
+                toolCount: tools.length,
+                tools,
+                // Counts only, and only when a refresh in this runtime produced them.
+                // `Registry.statusFor` already rebuilt the report through
+                // `boundedCatalogDrift`, so what lands here cannot carry a name or a
+                // schema even if the plugin seam returned one.
+                ...(status.catalogDrift ? { catalogDrift: status.catalogDrift } : {}),
+                ...(status.catalogAccess ? { catalogAccess: status.catalogAccess } : {}),
+                oauth: Boolean(c.startAuth && c.disconnectAuth),
+                ...(credential ? { credential } : {}),
+            };
+        });
+        const unavailable = (c, error) => Effect.sync(() => {
+            logStatus(c.id, "failed", error instanceof Error ? error.message : String(error));
+            return {
+                id: c.id,
+                ...(c.title ? { title: c.title } : {}),
+                authScope: c.authScope ?? "shared",
+                status: "error",
+                problem: "connector_unavailable",
+                oauth: Boolean(c.startAuth && c.disconnectAuth),
+                toolCount: 0,
+                tools: [],
+            };
+        });
+        const row = (c) => withDeadlineEffect((signal) => detail(c, signal), {
+            timeoutMs: options.timeoutMs ?? DETAIL_TIMEOUT_MS,
+            ...(options.signal ? { signal: options.signal } : {}),
+            timeoutError: new Error(DETAIL_TIMED_OUT),
+        }).pipe(
+        // A hook that throws where it should reject fails its own row too.
+        Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => unavailable(c, error)), Effect.ensuring(Effect.suspend(() => closeScope(c, registry.contextFor(c.id, baseUrl, requestScope), options.defer))));
+        return Effect.forEach(registry.listConnectors(), row, {
+            concurrency: resolveDiscoveryConcurrency(options.discoveryConcurrency),
+        }).pipe(Effect.map((connectors) => ({
+            serverInfo: options.serverInfo,
+            connectaVersion: CONNECTA_VERSION,
+            connectors,
+            activityEnabled: options.activityEnabled,
+            credentialManagement: options.credentialManagement,
+            oauthManagement: options.oauthManagement || Boolean(owner),
+        })));
+    });
+}