@zackbart/connecta 0.26.0 → 0.26.2

package/dist/routes/access-tokens.js

@@ -0,0 +1,110 @@
+import { authorizeUiIdentity, isSameOrigin, privateJson, } from "./shared.js";
+async function readName(request) {
+    if (!request.headers
+        .get("content-type")
+        ?.toLowerCase()
+        .startsWith("application/json")) {
+        return {
+            ok: false,
+            response: privateJson({ error: "Content-Type must be application/json" }, { status: 415 }),
+        };
+    }
+    const reader = request.body?.getReader();
+    const chunks = [];
+    let size = 0;
+    if (reader) {
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 1_000) {
+                    reader.cancel().catch(() => { });
+                    return { ok: false, response: privateJson({ error: "request body is too large" }, { status: 413 }) };
+                }
+                chunks.push(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    const raw = new TextDecoder().decode(bytes);
+    if (raw.length > 1_000) {
+        return {
+            ok: false,
+            response: privateJson({ error: "request body is too large" }, { status: 413 }),
+        };
+    }
+    try {
+        const body = JSON.parse(raw);
+        return { ok: true, name: body.name };
+    }
+    catch {
+        return {
+            ok: false,
+            response: privateJson({ error: "invalid JSON body" }, { status: 400 }),
+        };
+    }
+}
+/**
+ * Interactive-operator lifecycle for deployment access tokens. The token itself
+ * is deliberately never an administrator credential and cannot reach here.
+ */
+export async function routeAccessTokens(context, manager) {
+    const match = /^\/ui\/access-tokens(?:\/([0-9a-f-]{36}))?$/.exec(context.path);
+    if (!match)
+        return null;
+    const { request, baseUrl, opts } = context;
+    if (request.method === "OPTIONS") {
+        return privateJson({ error: "CORS is not allowed" }, { status: 403 });
+    }
+    const mutating = request.method !== "GET";
+    if (mutating && !isSameOrigin(request, baseUrl)) {
+        return privateJson({ error: "same-origin request required" }, { status: 403 });
+    }
+    const admin = await authorizeUiIdentity(request, baseUrl, opts.auth, "access token management", context.runtimeContext, opts.identity);
+    if (!admin.ok)
+        return admin.response;
+    if (!admin.accessTokenManagement || !admin.identity.principal) {
+        return privateJson({ error: "access token management permission required" }, { status: 403 });
+    }
+    const id = match[1];
+    try {
+        if (!id && request.method === "GET") {
+            return privateJson({ accessTokens: await manager.list() });
+        }
+        if (!id && request.method === "POST") {
+            const input = await readName(request);
+            if (!input.ok)
+                return input.response;
+            return privateJson(await manager.create(input.name, admin.identity.principal), { status: 201 });
+        }
+        if (id && request.method === "PUT") {
+            const input = await readName(request);
+            if (!input.ok)
+                return input.response;
+            const accessToken = await manager.rename(id, input.name);
+            return accessToken
+                ? privateJson({ accessToken })
+                : privateJson({ error: "unknown access token" }, { status: 404 });
+        }
+        if (id && request.method === "DELETE") {
+            const accessToken = await manager.revoke(id, `${admin.identity.principal.namespace}:${admin.identity.principal.id}`);
+            return accessToken
+                ? privateJson({ accessToken })
+                : privateJson({ error: "unknown access token" }, { status: 404 });
+        }
+        return privateJson({ error: "method not allowed" }, { status: 405 });
+    }
+    catch {
+        return privateJson({ error: "Access token operation failed; check the name, capacity, and storage" }, { status: 400 });
+    }
+}

package/dist/routes/mcp.js

@@ -1,5 +1,6 @@
 import { createMcpHandler, isLegacyRequest, McpServer, WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/server";
 import { Duration, Effect, Exit, Option, Result, Scope } from "effect";
+import { notFoundResponse } from "../branding.js";
 import { registerExecuteTool } from "../execute.js";
 import { ExecutorAdmissionError, } from "../executor-admission.js";
 import { registerMetaTools } from "../meta-tools.js";
@@ -495,7 +496,10 @@ export function createMcpRoute(opts) {
                     if (!pool || reason !== "granted") {
                         opts.logger.warn(`[connecta] refused /mcp/${poolName} with 404: pool ${reason}` +
                             (authz.actor.id ? ` for ${loggableValue(authz.actor.id)}` : ""));
-                        return cors(new Response("Not Found", { status: 404 }));
+                        // The server's own 404, so a browser sees the page every unserved
+                        // path shows and an MCP client (which never asks for text/html)
+                        // still reads a plain "Not Found".
+                        return cors(notFoundResponse(request, opts));
                     }
                     access = intersectAccess(authz, pool.access);
                 }

package/dist/routes/oauth-management.js

@@ -1,8 +1,29 @@
 import { Effect, Result } from "effect";
+import { drainOAuthStartResets } from "../auth/oauth-start-reset.js";
 import { closeScope } from "../runtime/connector-scope.js";
+import { withDeadlineEffect } from "../runtime/run.js";
 import { isSafeHttpUrl } from "../ui.js";
 import { authorizedPerson, refuse, serveOperator, visibleRegistry, } from "./operator.js";
 import { mayManageConnector, isSameOrigin, msg, privateJson, } from "./shared.js";
+/** Bounds the start and its handoff; invalidation and scope close finish after it. */
+const OAUTH_START_TIMEOUT_MS = 30_000;
+/**
+ * How a POST starts authorization, from its `mode` query parameter:
+ * `restart` (the default) resets the connector to a fresh epoch — wiping the
+ * grant, the client registration, and discovery — before starting over;
+ * `continue` hands back a recent pending authorization URL when one exists
+ * and otherwise starts a flow in the current epoch, keeping the stored
+ * registration. `null` is a malformed request.
+ */
+function startMode(url) {
+    const modes = url.searchParams.getAll("mode");
+    if (modes.length === 0)
+        return "restart";
+    const [mode] = modes;
+    return modes.length === 1 && (mode === "continue" || mode === "restart")
+        ? mode
+        : null;
+}
 function oauthManagementRequest(context, connectorId) {
     const { request, baseUrl, defer, opts } = context;
     return Effect.gen(function* () {
@@ -27,35 +48,65 @@ function oauthManagementRequest(context, connectorId) {
         if (!disconnecting && request.method !== "POST") {
             return yield* refuse("method not allowed", 405);
         }
-        const ctx = registry.contextFor(connectorId, baseUrl, {});
+        const mode = disconnecting ? undefined : startMode(context.url);
+        if (mode === null) {
+            return yield* refuse('mode must be "continue" or "restart"', 400);
+        }
+        let ctx;
         // The connector scope this request opened ends with it, however it ends.
-        yield* Effect.addFinalizer(() => closeScope(connector, ctx, defer));
-        const operation = yield* Effect.result(Effect.tryPromise({
+        yield* Effect.addFinalizer(() => ctx ? closeScope(connector, ctx, defer) : Effect.void);
+        const timeoutError = new Error("OAuth authorization start timed out");
+        const operation = yield* Effect.result(withDeadlineEffect((signal) => Effect.tryPromise({
             try: async () => {
+                ctx = registry.contextFor(connectorId, baseUrl, {}, { signal });
                 if (disconnecting) {
                     await disconnectAuth(ctx);
                     return undefined;
                 }
-                const started = await startAuth(ctx, { force: true });
+                const started = await startAuth(ctx, { force: mode === "restart" });
+                if (signal.aborted)
+                    throw signal.reason;
                 if (started.authorizationUrl) {
                     await registry.bindOAuthHandoff(connectorId, started.authorizationUrl);
                 }
                 return started;
             },
             catch: (error) => error,
+        }), {
+            // A disconnect deliberately ignores both browser cancellation and
+            // this start deadline so its reset reaches invalidation.
+            ...(disconnecting ? {} : { timeoutMs: OAUTH_START_TIMEOUT_MS }),
+            ...(disconnecting ? {} : { signal: request.signal }),
+            timeoutError,
         }));
-        // The old grant and its cached catalog are invalid after either operation,
-        // including a partially failed physical cleanup whose epoch fence succeeded.
-        const invalidated = yield* Effect.result(Effect.tryPromise({
-            try: () => registry.invalidateStored(connectorId),
-            catch: (error) => error,
-        }));
+        const opened = ctx;
+        if (Result.isFailure(operation) && opened) {
+            // Storage has no abort contract. If a reset's generation write is still
+            // pending, answering now would let it publish over a newer flow.
+            yield* Effect.promise(() => drainOAuthStartResets(opened.requestScope ?? opened));
+        }
+        // A disconnect or a restart invalidates the old grant and its cached
+        // catalog, even when a partially failed physical cleanup left its epoch
+        // fence standing. So does a continued start that had to begin a new flow:
+        // the grant it found was missing or refused. A continued start that
+        // reused a pending URL or found the connection healthy changed nothing,
+        // so the catalog stays. (A continue does reset a disconnected connector,
+        // but the disconnect already invalidated that catalog.)
+        const started = Result.isSuccess(operation) ? operation.success : undefined;
+        const reused = mode === "continue" && started?.authorizationReused === true;
+        const unchanged = mode === "continue" && (reused || started?.state === "ok");
+        const invalidated = unchanged
+            ? Result.succeed(undefined)
+            : yield* Effect.result(Effect.tryPromise({
+                try: () => registry.invalidateStored(connectorId),
+                catch: (error) => error,
+            }));
         // Every failure below answers in the route's own fixed words. A hook's
         // rejection and a status message can quote a token endpoint's error body
         // or a provider's refusal, either of which can quote the secret it was
         // sent, so that text goes to the deployment's log and nowhere else.
         const failed = (detail, fixed, status) => {
-            opts.logger.warn(`[connecta] connector "${connectorId}" OAuth ${disconnecting ? "disconnect" : "restart"} failed: ${detail}`);
+            opts.logger.warn(`[connecta] connector "${connectorId}" OAuth ${disconnecting ? "disconnect" : mode} failed: ${detail}`);
             return refuse(fixed, status);
         };
         const couldNot = disconnecting
@@ -64,6 +115,9 @@ function oauthManagementRequest(context, connectorId) {
         // A Result, not a caught value, decides whether it failed: a hook that
         // rejects with no reason at all still failed.
         if (Result.isFailure(operation)) {
+            if (operation.failure === timeoutError) {
+                return yield* failed(`start exceeded ${OAUTH_START_TIMEOUT_MS} ms`, "OAuth authorization start timed out", 504);
+            }
             return yield* failed(msg(operation.failure), couldNot, 400);
         }
         if (Result.isFailure(invalidated)) {
@@ -92,7 +146,7 @@ function oauthManagementRequest(context, connectorId) {
         // stopped shipping, and the state and the link are the whole answer.
         return privateJson({
             state: result.state,
-            ...(authorizationUrl ? { authorizationUrl } : {}),
+            ...(authorizationUrl ? { authorizationUrl, reused } : {}),
         });
     }).pipe(Effect.scoped);
 }

package/dist/routes/oauth.js

@@ -1,92 +1,59 @@
 import { Effect } from "effect";
 import { oauthValueStorageKey } from "../auth/downstream-oauth.js";
-import { resolveBranding } from "../branding.js";
+import { escapeHtml, renderPage, resolveBranding, STATUS_ICONS } 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
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;");
-}
+const TONE_MARKS = {
+    ok: { className: " ok", icon: STATUS_ICONS.ok, label: "Connected" },
+    declined: { className: "", icon: STATUS_ICONS.declined, label: "Not connected" },
+    problem: { className: " danger", icon: STATUS_ICONS.problem, label: "Not connected" },
+};
 /**
- * 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.
+ * The callback's one page, in the shared layout. 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. The connector's title appears only when `connector` is passed,
+ * which the route does only after the state check, and `oauthCallbackOutcome`
+ * gates it by reason again; every refusal before that point is the same bytes
+ * for every connector id and path. Escaping stays anyway: branding and a
+ * configured title are still strings.
+ *
+ * The fix prompt is for whoever runs the deployment, and the person reading
+ * this page is often a teammate finishing personal auth, so it sits folded
+ * under a quiet disclosure rather than in the message.
  */
-function html(reason, branding, hasUi = false, connectorId) {
-    const outcome = oauthCallbackOutcome(reason, connectorId);
-    const brand = resolveBranding(branding);
-    const title = brand.pageTitle;
-    const owner = brand.ownerName
-        ? brand.ownerUrl
-            ? `<a class="brand" href="${escapeHtml(brand.ownerUrl)}">${escapeHtml(brand.ownerName)}</a>`
-            : `<span class="brand">${escapeHtml(brand.ownerName)}</span>`
-        : brand.productUrl
-            ? `<a class="brand" href="${escapeHtml(brand.productUrl)}">${escapeHtml(brand.productName)}</a>`
-            : `<span class="brand">${escapeHtml(brand.productName)}</span>`;
-    const product = brand.ownerName
-        ? brand.productUrl
-            ? `<a class="product" href="${escapeHtml(brand.productUrl)}">${escapeHtml(brand.productName)}</a>`
-            : `<span class="product">${escapeHtml(brand.productName)}</span>`
+function html(reason, opts, connector) {
+    const brand = resolveBranding(opts.branding);
+    const outcome = oauthCallbackOutcome(reason, connector, brand.productName);
+    const mark = TONE_MARKS[outcome.tone];
+    const uiMounted = Boolean(opts.ui);
+    const home = uiMounted
+        ? `<div class="status-actions"><a class="btn${outcome.tone === "ok" ? "" : " primary"}" href="/">Return to ${escapeHtml(brand.productName)}</a></div>`
+        : "";
+    const details = outcome.fixPrompt
+        ? `<details class="status-details">
+      <summary>Details for the operator</summary>
+      <p>If this keeps happening, send this to whoever runs ${escapeHtml(brand.productName)}. It is written for a coding agent working on the deployment and carries nothing from the provider's response.</p>
+      <pre>${escapeHtml(outcome.fixPrompt)}</pre>
+    </details>`
         : "";
-    return new Response(`<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<meta name="theme-color" content="${escapeHtml(brand.themeColor)}">
-<link rel="icon" href="${escapeHtml(brand.faviconHref)}" type="image/svg+xml">
-<link rel="shortcut icon" href="/favicon.ico">
-<title>${escapeHtml(title)}</title>
-<style>
-  * { border-radius: 0; box-sizing: border-box; }
-  html { color: #000; background: #fff; font: 16px/1.5 "Helvetica Neue",
-    Helvetica, Arial, sans-serif; -webkit-font-smoothing: antialiased; }
-  body { margin: 0; min-height: 100vh; }
-  ::selection { color: #fff; background: #000; }
-  .shell { margin: 0 auto; max-width: 70rem; padding: 1rem; }
-  .grid { display: grid; gap: 1rem 1.5rem;
-    grid-template-columns: repeat(3, minmax(0, 1fr)); }
-  .brand { font-weight: 500; grid-column: 1; text-decoration: none; }
-  .product { grid-column: 2 / -1; }
-  main { margin-top: 5rem; }
-  h1, p { font: inherit; margin: 0; }
-  h1 { grid-column: 1; }
-  .copy { grid-column: 2 / -1; max-width: 34em; }
-  .copy > * + * { margin-top: 1.5rem; }
-  a { color: inherit; text-decoration: underline; text-decoration-thickness: 1.5px;
-    text-underline-offset: .22em; }
-  a:hover { text-decoration-color: transparent; }
-  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; }
-    main { margin-top: 3rem; }
-    h1, .copy { grid-column: 1 / -1; }
-  }
-</style>
-</head>
-<body>
-  <header class="shell grid">
-    ${owner}
-    ${product}
-  </header>
-  <main class="shell grid" data-oauth-callback="${outcome.reason}">
-    <h1>Connection status</h1>
-    <div class="copy">
-      <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>` : ""}
+    const body = `<main class="page shell" data-oauth-callback="${outcome.reason}">
+  <section class="status-page">
+    <div class="status-head">
+      <span class="status-mark${mark.className}" aria-hidden="true">${mark.icon}</span>
+      <p class="status-label${mark.className}">${mark.label}</p>
     </div>
-  </main>
-</body>
-</html>`, { status: outcome.status, headers: { "Content-Type": "text/html; charset=utf-8" } });
+    <h1>${escapeHtml(outcome.heading)}</h1>
+    <p class="status-copy">${escapeHtml(outcome.message)}</p>
+    ${home}
+    ${details}
+  </section>
+</main>`;
+    return new Response(renderPage(opts.branding, {
+        title: `${outcome.heading} — ${brand.pageTitle}`,
+        uiMounted,
+        body,
+    }), { status: outcome.status, headers: { "Content-Type": "text/html; charset=utf-8" } });
 }
 /**
  * Pay the storage read a real downstream-OAuth refusal pays, on the refusal
@@ -138,10 +105,10 @@ async function finishOAuthCallback(context) {
     const { path, url, baseUrl, opts } = context;
     const error = url.searchParams.get("error");
     if (error)
-        return html(providerErrorReason(error), opts.branding, Boolean(opts.ui));
+        return html(providerErrorReason(error), opts);
     const code = url.searchParams.get("code");
     if (!code)
-        return html("invalid_callback", opts.branding, Boolean(opts.ui));
+        return html("invalid_callback", opts);
     const id = path.slice("/oauth/callback/".length);
     const state = url.searchParams.get("state");
     const callbackTarget = await opts.registry.oauthCallbackView(id, state);
@@ -155,7 +122,7 @@ async function finishOAuthCallback(context) {
     const connectorContext = callbackRegistry
         ? callbackRegistry.contextFor(id, baseUrl)
         : opts.registry.contextFor(id, baseUrl);
-    const refused = () => html("invalid_callback", opts.branding, Boolean(opts.ui));
+    const refused = () => html("invalid_callback", opts);
     if (!connector || !connector.finishAuth) {
         await equalizeRefusalCost(connectorContext);
         return refused();
@@ -220,19 +187,19 @@ async function finishOAuthCallback(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("handoff_failed", opts.branding, Boolean(opts.ui), id);
+            return html("handoff_failed", opts, connector);
         }
     }
     try {
         await connector.finishAuth(code, connectorContext, url.searchParams);
         await callbackRegistry.invalidateStored(id);
-        return html("connected", opts.branding, Boolean(opts.ui), id);
+        return html("connected", opts, connector);
     }
     catch (err) {
         // 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);
+        return html("exchange_failed", opts, connector);
     }
 }

package/dist/routes/shared.d.ts

@@ -1,5 +1,5 @@
 import type { Implementation } from "@modelcontextprotocol/server";
-import type { ActivityModule, ArtifactsModule, OperatorSurface } from "../module-contracts.js";
+import type { AccessTokensModule, 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";
@@ -63,6 +63,7 @@ export interface ServerOptions {
     activityModule?: ActivityModule | undefined;
     /** Optional team pages; their routes mount only beside `ui`. */
     artifactsModule?: ArtifactsModule | undefined;
+    accessTokens?: AccessTokensModule | undefined;
     /** Optional browser UI and OAuth result-page labels. */
     branding?: ConnectaBranding | undefined;
 }
@@ -102,6 +103,7 @@ export declare function authorize(request: Request, baseUrl: string, auth: Inbou
     /** Granted addresses that still require the catalog's read-only hint. */
     guardedToolAccess?: ToolAccess;
     operator: boolean;
+    accessTokenManagement: boolean;
     credentialAdministration: ConnectorPermission;
     personalConnection: ConnectorPermission;
     /** Backward-compatible name used by operator views. */

package/dist/routes/shared.js

@@ -45,7 +45,7 @@ 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, credentialAdministration: "none", personalConnection: "none" };
+        return { ok: true, actor, identity, ...access, operator: false, accessTokenManagement: false, credentialAdministration: "none", personalConnection: "none" };
     }
     let lastResponse = null;
     for (const provider of auth) {
@@ -75,6 +75,7 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                 interactive,
             };
             let operator = interactive;
+            let accessTokenManagement = false;
             let credentialAdministration = "none";
             let personalConnection = "none";
             let access;
@@ -86,6 +87,9 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                 }
                 access = parseConnectorAccess(identityConfig?.connectorAccess ? await identityConfig.connectorAccess(identity) : "all", { allowReadOnly: true });
                 if (interactive) {
+                    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";
                 }
@@ -113,6 +117,7 @@ export async function authorize(request, baseUrl, auth, runtimeContext, identity
                     ? { principalKey: await identityStorageKey(principal) }
                     : {}),
                 ...access,
+                accessTokenManagement,
                 credentialAdministration,
                 personalConnection,
                 operator,

package/dist/routes/ui.js

@@ -74,6 +74,7 @@ export async function routeUi(context) {
     const artifactPage = operatorPage === "artifacts" || operatorPage === "artifact";
     if (operatorPage &&
         (operatorPage !== "activity" || opts.activity?.list) &&
+        (operatorPage !== "tokens" || opts.accessTokens) &&
         (!artifactPage || opts.artifactsModule)) {
         if (request.method !== "GET" && request.method !== "HEAD") {
             return privateJson({ error: "method not allowed" }, { status: 405 });
@@ -95,9 +96,15 @@ export async function routeUi(context) {
         // An artifact shell frames the sandboxed page from its own origin and
         // nothing else; Connections stays on the deployment's public origin.
         const homeUrl = opts.publicUrl ? new URL("/", opts.publicUrl).toString() : "/";
+        // The artifact host serves no favicon, so a shell there takes its icons
+        // from the public origin, as the 404 does; on the main host they stay
+        // root-relative.
+        const onArtifactHost = Boolean(opts.artifactOrigin) &&
+            url.origin === new URL(opts.artifactOrigin).origin;
+        const iconOrigin = onArtifactHost ? opts.publicUrl : undefined;
         return new Response(request.method === "HEAD"
             ? null
-            : renderUiHtml(uiAuth, mcpUrl, opts.branding, nonce, operatorPage, { homeUrl }), {
+            : renderUiHtml(uiAuth, mcpUrl, opts.branding, nonce, operatorPage, { homeUrl, iconOrigin }), {
             status: 200,
             headers: {
                 "Content-Type": "text/html; charset=utf-8",
@@ -181,6 +188,7 @@ function summary(context) {
             serverInfo: opts.serverInfo,
             connectaVersion: CONNECTA_VERSION,
             activityEnabled,
+            ...(opts.accessTokens ? { accessTokenManagement: authz.accessTokenManagement && authz.identity.principal ? "available" : "requires_operator" } : {}),
             ...(opts.artifactsModule && mayViewArtifacts(authz, opts.registry) ? { artifactsEnabled: true } : {}),
             credentialManagement,
             oauthManagement: visible.some(c => mayManage(c.id)),

package/dist/server.js

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { notFoundResponse } from "./branding.js";
 import { aggregateCallAdmissionSnapshots } from "./call-admission.js";
 import { isAdmittingExecutor } from "./executor-admission.js";
 import { createMcpRoute, MCP_CORS_HEADERS } from "./routes/mcp.js";
@@ -76,6 +77,7 @@ export function createFetchHandler(opts) {
                     "/health",
                     ...(opts.ui?.reservedPaths ?? []),
                     ...(opts.ui && opts.activity?.list ? ["/activity"] : []),
+                    ...(opts.ui && opts.accessTokens ? ["/tokens"] : []),
                     ...(opts.ui && opts.artifactsModule ? ["/artifacts", "/artifacts/*"] : []),
                 ],
             },
@@ -107,7 +109,7 @@ export function createFetchHandler(opts) {
             const response = yield* metadata(request, baseUrl);
             if (response)
                 return response;
-            return new Response("Not Found", { status: 404 });
+            return notFoundResponse(request, opts);
         }
         if (path === "/health")
             return yield* Effect.promise(health);
@@ -117,7 +119,7 @@ export function createFetchHandler(opts) {
         const mcp = yield* routeMcp.handle(context);
         if (mcp)
             return mcp;
-        return new Response("Not Found", { status: 404 });
+        return notFoundResponse(request, opts);
     });
     const serve = (request, runtimeContext) => Effect.suspend(() => {
         const url = new URL(request.url);
@@ -127,15 +129,16 @@ export function createFetchHandler(opts) {
             ? runtimeContext.waitUntil.bind(runtimeContext)
             : undefined;
         // The artifact hostname has no MCP, health, OAuth, or operator routes.
-        // Dispatch before MCP origin checks so even a hostile /mcp is a plain 404.
+        // Dispatch before MCP origin checks so even a hostile /mcp gets the same
+        // 404 as any other unserved path.
         if (opts.artifactOrigin && url.origin === new URL(opts.artifactOrigin).origin) {
             if (!isArtifactPath(path) || !opts.ui || !opts.artifactsModule) {
-                return Effect.succeed(withSecurityHeaders(new Response("Not Found", { status: 404 }), url, path));
+                return Effect.succeed(withSecurityHeaders(notFoundResponse(request, opts), url, path));
             }
             const context = {
                 request, url, path, baseUrl: opts.artifactOrigin, opts, defer, runtimeContext,
             };
-            return Effect.map(Effect.promise(() => opts.ui.handle(context)), response => withSecurityHeaders(response ?? new Response("Not Found", { status: 404 }), url, path));
+            return Effect.map(Effect.promise(() => opts.ui.handle(context)), response => withSecurityHeaders(response ?? notFoundResponse(request, opts), url, path));
         }
         if (opts.artifactOrigin && isArtifactPath(path) && opts.ui && opts.artifactsModule) {
             const target = new URL(opts.artifactOrigin);