@zackbart/connecta 0.25.0 → 0.26.1

package/dist/routes/activity.js

@@ -1,71 +1,8 @@
 import { Duration, Effect } from "effect";
 import { InvalidActivityCursorError, } from "../activity.js";
+import { ACTOR_LABEL_BUDGET_MS, ACTOR_LABEL_CONCURRENCY, actorKey, cleanActorLabel, labelLookups, } from "./actor-labels.js";
 import { authorized, refuse, serveOperator } from "./operator.js";
-import { activityActorNamespace, privateJson, } from "./shared.js";
-const ACTIVITY_LABEL_CONCURRENCY = 8;
-const ACTIVITY_LABEL_PAGE_BUDGET_MS = 1_500;
-const ACTIVITY_LABEL_MAX_LENGTH = 160;
-function cleanActivityActorLabel(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const compact = value.replace(/\s+/gu, " ").trim();
-    if (!compact)
-        return undefined;
-    return Array.from(compact).slice(0, ACTIVITY_LABEL_MAX_LENGTH).join("");
-}
-function actorKey(actor) {
-    return JSON.stringify([actor.kind, actor.namespace, actor.id]);
-}
-/**
- * One lookup per distinct actor on the page, each against the single provider
- * that owns the actor's directory. An actor no provider can claim unambiguously
- * gets no lookup at all.
- */
-function labelLookups(page, auth) {
-    const identities = new Map();
-    for (const event of page.events) {
-        if (!event.actor.id)
-            continue;
-        identities.set(actorKey(event.actor), {
-            kind: event.actor.kind,
-            id: event.actor.id,
-            ...(event.actor.namespace ? { namespace: event.actor.namespace } : {}),
-        });
-    }
-    const lookups = [];
-    for (const [key, identity] of identities) {
-        const sameKindProviders = auth
-            .map((provider, index) => ({ provider, index }))
-            .filter(({ provider }) => provider.kind === identity.kind);
-        const candidates = sameKindProviders.filter(({ provider }) => Boolean(provider.activityActorLabel));
-        const eligible = identity.namespace
-            ? candidates.filter(({ provider }) => activityActorNamespace(provider) === identity.namespace)
-            : (() => {
-                const directoryKey = ({ provider, index, }) => {
-                    const namespace = activityActorNamespace(provider);
-                    return namespace === undefined
-                        ? `provider:${index}`
-                        : `namespace:${namespace}`;
-                };
-                // Every same-kind provider participates in the ambiguity check,
-                // even if it cannot resolve labels. Otherwise a legacy ID owned
-                // by a provider without a resolver could be disclosed to a
-                // different provider that happens to have one.
-                const directories = new Set(sameKindProviders.map(directoryKey));
-                if (directories.size !== 1)
-                    return [];
-                const [directory] = directories;
-                return candidates.filter((candidate) => directoryKey(candidate) === directory);
-            })();
-        // One namespace is one directory. Use its first configured resolver so
-        // duplicate gate adapters over the same Clerk instance do not multiply
-        // the provider-level concurrency cap.
-        const provider = eligible[0]?.provider;
-        if (provider)
-            lookups.push({ key, id: identity.id, provider });
-    }
-    return lookups;
-}
+import { privateJson } from "./shared.js";
 /**
  * Add display-only actor labels to one authorized activity page. Resolution is
  * best-effort, bounded, and read-time only: stored events retain stable ids and
@@ -78,14 +15,14 @@ function labelLookups(page, auth) {
 function enrichActivityActorLabels(page, auth) {
     return Effect.suspend(() => {
         const labels = new Map();
-        const resolve = ({ key, id, provider }) => Effect.tryPromise(() => Promise.resolve(provider.activityActorLabel(id))).pipe(Effect.map(cleanActivityActorLabel), Effect.orElseSucceed(() => undefined), Effect.map((label) => {
+        const resolve = ({ key, id, provider }) => Effect.tryPromise(() => Promise.resolve(provider.activityActorLabel(id))).pipe(Effect.map(cleanActorLabel), Effect.orElseSucceed(() => undefined), Effect.map((label) => {
             if (label)
                 labels.set(key, label);
         }));
-        return Effect.forEach(labelLookups(page, auth), resolve, {
-            concurrency: ACTIVITY_LABEL_CONCURRENCY,
+        return Effect.forEach(labelLookups(page.events.map((event) => event.actor), auth), resolve, {
+            concurrency: ACTOR_LABEL_CONCURRENCY,
             discard: true,
-        }).pipe(Effect.timeoutOption(Duration.millis(ACTIVITY_LABEL_PAGE_BUDGET_MS)), Effect.map(() => ({
+        }).pipe(Effect.timeoutOption(Duration.millis(ACTOR_LABEL_BUDGET_MS)), Effect.map(() => ({
             ...page,
             events: page.events.map((event) => {
                 const resolved = event.actor.id

package/dist/routes/actor-labels.js

@@ -0,0 +1,114 @@
+// Display labels for stored actors, shared by the activity page and the
+// artifact library. An actor is stored as a stable id; a label is resolved at
+// read time from the one auth provider that owns the actor's directory, and
+// only on an authorized read path. Nothing here is persisted, and a label a
+// store happens to carry is never trusted or echoed.
+import { activityActorNamespace } from "./shared.js";
+export const ACTOR_LABEL_CONCURRENCY = 8;
+export const ACTOR_LABEL_BUDGET_MS = 1_500;
+const ACTOR_LABEL_MAX_LENGTH = 160;
+export function cleanActorLabel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const compact = value.replace(/\s+/gu, " ").trim();
+    if (!compact)
+        return undefined;
+    return Array.from(compact).slice(0, ACTOR_LABEL_MAX_LENGTH).join("");
+}
+export function actorKey(actor) {
+    return JSON.stringify([actor.kind, actor.namespace, actor.id]);
+}
+/**
+ * One lookup per distinct actor, each against the single provider that owns
+ * the actor's directory. An actor no provider can claim unambiguously gets no
+ * lookup at all.
+ */
+export function labelLookups(actors, auth) {
+    const identities = new Map();
+    for (const actor of actors) {
+        if (!actor.id)
+            continue;
+        identities.set(actorKey(actor), {
+            kind: actor.kind,
+            id: actor.id,
+            ...(actor.namespace ? { namespace: actor.namespace } : {}),
+        });
+    }
+    const lookups = [];
+    for (const [key, identity] of identities) {
+        const sameKindProviders = auth
+            .map((provider, index) => ({ provider, index }))
+            .filter(({ provider }) => provider.kind === identity.kind);
+        const candidates = sameKindProviders.filter(({ provider }) => Boolean(provider.activityActorLabel));
+        const eligible = identity.namespace
+            ? candidates.filter(({ provider }) => activityActorNamespace(provider) === identity.namespace)
+            : (() => {
+                const directoryKey = ({ provider, index, }) => {
+                    const namespace = activityActorNamespace(provider);
+                    return namespace === undefined
+                        ? `provider:${index}`
+                        : `namespace:${namespace}`;
+                };
+                // Every same-kind provider participates in the ambiguity check,
+                // even if it cannot resolve labels. Otherwise a legacy ID owned
+                // by a provider without a resolver could be disclosed to a
+                // different provider that happens to have one.
+                const directories = new Set(sameKindProviders.map(directoryKey));
+                if (directories.size !== 1)
+                    return [];
+                const [directory] = directories;
+                return candidates.filter((candidate) => directoryKey(candidate) === directory);
+            })();
+        // One namespace is one directory. Use its first configured resolver so
+        // duplicate gate adapters over the same Clerk instance do not multiply
+        // the provider-level concurrency cap.
+        const provider = eligible[0]?.provider;
+        if (provider)
+            lookups.push({ key, id: identity.id, provider });
+    }
+    return lookups;
+}
+/**
+ * Resolve labels for `actors`, best-effort: at most eight lookups at once,
+ * 1.5 seconds in all, and whatever has resolved by then is the answer. A
+ * provider outage yields no labels, never a failed read.
+ */
+export async function resolveActorLabels(actors, auth) {
+    const labels = new Map();
+    const queue = labelLookups(actors, auth);
+    let cursor = 0;
+    let expired = false;
+    const worker = async () => {
+        while (!expired && cursor < queue.length) {
+            const lookup = queue[cursor++];
+            if (!lookup)
+                return;
+            try {
+                const label = cleanActorLabel(await Promise.resolve(lookup.provider.activityActorLabel?.(lookup.id)));
+                if (label && !expired)
+                    labels.set(lookup.key, label);
+            }
+            catch {
+                // A failed lookup leaves the actor unlabeled.
+            }
+        }
+    };
+    let timer;
+    const budget = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            expired = true;
+            resolve();
+        }, ACTOR_LABEL_BUDGET_MS);
+    });
+    try {
+        await Promise.race([
+            Promise.all(Array.from({ length: Math.min(ACTOR_LABEL_CONCURRENCY, queue.length) }, worker)),
+            budget,
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+    return new Map(labels);
+}

package/dist/routes/credentials.js

@@ -131,31 +131,53 @@ function credentialRequest(context, connectorId, action) {
                     : "this connector does not support credential testing", 400);
             }
             // Whatever goes wrong past this point is the test's result, not the
-            // route's: the page shows it beside the Test button.
+            // route's: the page shows it beside the Test button. Only `ok` leaves
+            // the host. A hook's message, and anything it throws, can quote the
+            // downstream's reply, and that reply can quote the credential it just
+            // rejected — so the text goes to the deployment's log and the page
+            // says a fixed sentence for the outcome instead.
+            const logged = (ok, detail) => {
+                if (!detail)
+                    return;
+                const line = `[connecta] connector "${connectorId}" credential test ${ok ? "passed" : "failed"}: ${detail}`;
+                if (ok)
+                    opts.logger.info(line);
+                else
+                    opts.logger.warn(line);
+            };
             return yield* Effect.tryPromise({
                 try: async () => {
                     const values = await vault.getAll(connectorId, owner);
                     const shape = storedCredentialShape(credential, values);
+                    // Both refusals are the route's own words, and each carries the
+                    // problem kind the page keys its copy and fix prompt off.
                     if (shape.state === "missing") {
                         return privateJson({
                             error: mode === "multiple"
                                 ? "configure the credentials before testing them"
                                 : "configure the credential before testing it",
+                            problem: "credential_required",
                         }, { status: 409 });
                     }
                     if (shape.state === "mismatch") {
-                        return privateJson({ error: shape.message }, { status: 409 });
+                        return privateJson({ error: shape.message, problem: "credential_mismatch" }, { status: 409 });
                     }
                     const storedValues = values;
                     const ctx = registry.contextFor(connectorId, baseUrl);
-                    return privateJson(mode === "multiple"
+                    const result = mode === "multiple"
                         ? await connector.testCredentials(storedValues, ctx)
                         : await connector.testCredential(
                         // The single-value shape check above guarantees this key.
-                        storedValues.value, ctx));
+                        storedValues.value, ctx);
+                    const ok = result?.ok === true;
+                    logged(ok, result?.message);
+                    return privateJson({ ok });
                 },
                 catch: (error) => error,
-            }).pipe(Effect.catch((error) => Effect.succeed(privateJson({ ok: false, message: msg(error) }))));
+            }).pipe(Effect.catch((error) => {
+                logged(false, msg(error));
+                return Effect.succeed(privateJson({ ok: false }));
+            }));
         }
         if (action)
             return yield* refuse("not found", 404);

package/dist/routes/mcp.js

@@ -1,8 +1,10 @@
 import { createMcpHandler, isLegacyRequest, McpServer, WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/server";
-import { Effect, Exit, Result, Scope } from "effect";
+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";
+import { registerResumeTool } from "../resumable.js";
 import { intersectAccess } from "../connector-access.js";
 import { instructionsFor } from "../skills.js";
 import { msg } from "../errors.js";
@@ -101,9 +103,9 @@ function closeWithBody(response, signal, close) {
     const reader = response.body.getReader();
     onAbort = () => {
         // `cancel()` belongs to an operator/auth/SDK-provided stream and may
-        // reject. Consume both outcomes: `.finally(release)` would release the
-        // permit but preserve the rejection as an unhandled promise.
-        void reader.cancel(signal.reason).then(release, release);
+        // reject or never settle. Release now; consume either outcome separately.
+        release();
+        void reader.cancel(signal.reason).catch(() => { });
     };
     signal.addEventListener("abort", onAbort, { once: true });
     if (signal.aborted)
@@ -126,12 +128,8 @@ function closeWithBody(response, signal, close) {
             }
         },
         async cancel(reason) {
-            try {
-                await reader.cancel(reason);
-            }
-            finally {
-                release();
-            }
+            release();
+            await reader.cancel(reason);
         },
     });
     return new Response(body, {
@@ -220,14 +218,19 @@ function toolkitRetired(logger) {
         },
     });
 }
-function serveMcp(request, opts, baseUrl, actor, registry, canManageAuth, runtimeContext) {
+function serveMcp(request, requestSignal, opts, baseUrl, actor, registry, canManageAuth, poolName, runtimeContext) {
+    // A paused run belongs to the endpoint it started on: resuming it through
+    // another pool's endpoint finds nothing, as another subject would.
+    const resumable = opts.resumable
+        ? { ...opts.resumable, pool: poolName ?? null, approval: opts.approval }
+        : undefined;
     // Every McpServer the request builds is fresh and closes with its scope.
     // The modern handler tears its own down after the exchange; the legacy
     // transport never does, and neither may stay wired to an ended request.
     const servers = [];
     const createServer = () => {
         const server = new McpServer(opts.serverInfo, {
-            instructions: instructionsFor(),
+            instructions: instructionsFor(resumable !== undefined),
             cacheHints: {
                 "tools/list": {
                     ttlMs: 3_600_000,
@@ -265,17 +268,18 @@ function serveMcp(request, opts, baseUrl, actor, registry, canManageAuth, runtim
             ...(opts.discoveryConcurrency !== undefined
                 ? { discoveryConcurrency: opts.discoveryConcurrency }
                 : {}),
-            requestSignal: request.signal,
+            requestSignal,
             ...(runtimeContext?.waitUntil
                 ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
                 : {}),
+            approval: opts.approval,
         });
-        registerExecuteTool(server, registry, {
+        const runner = registerExecuteTool(server, registry, {
             baseUrl,
             executor: opts.executor,
             logger: opts.logger,
             ...(activity ? { activity } : {}),
-            requestSignal: request.signal,
+            requestSignal,
             ...(runtimeContext?.waitUntil
                 ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
                 : {}),
@@ -300,6 +304,18 @@ function serveMcp(request, opts, baseUrl, actor, registry, canManageAuth, runtim
             ...(opts.watchdogMs !== undefined
                 ? { watchdogMs: opts.watchdogMs }
                 : {}),
+            resumable,
+            approval: opts.approval,
+            maxWrites: opts.maxWrites,
+        });
+        // Always registered, so the surface is the same eight tools on every
+        // deployment; without resumable writes it answers that there is nothing
+        // to resume.
+        registerResumeTool(server, registry, {
+            runner,
+            settings: resumable,
+            ...(activity ? { activity } : {}),
+            requestSignal,
         });
         servers.push(server);
         return server;
@@ -405,7 +421,23 @@ export function createMcpRoute(opts) {
         if (request.method === "OPTIONS") {
             return Effect.succeed(cors(new Response(null, { status: 204 })));
         }
+        // This controller belongs to this request. Its signal reaches auth and
+        // every registered tool; a controller sweep never touches it.
+        const localAbort = new AbortController();
+        const onCallerAbort = () => localAbort.abort(request.signal.reason);
+        request.signal.addEventListener("abort", onCallerAbort, { once: true });
+        if (request.signal.aborted)
+            onCallerAbort();
+        let deadlineTimer;
         return scopedToBody(Effect.gen(function* () {
+            yield* Effect.addFinalizer(() => Effect.sync(() => {
+                if (!localAbort.signal.aborted) {
+                    localAbort.abort(request.signal.reason ?? new Error("MCP request ended."));
+                }
+                request.signal.removeEventListener("abort", onCallerAbort);
+                if (deadlineTimer !== undefined)
+                    clearTimeout(deadlineTimer);
+            }));
             const admission = yield* Effect.result(admitted(opts.requestAdmission, request.signal));
             if (Result.isFailure(admission)) {
                 const error = admission.failure;
@@ -420,6 +452,17 @@ export function createMcpRoute(opts) {
                 }
                 return cors(requestAdmissionFailure(error));
             }
+            const remainingMs = admission.success.remainingMs();
+            if (remainingMs !== undefined && remainingMs <= 0) {
+                admission.success.release();
+                return cors(new Response("MCP request lifetime exceeded.", { status: 504 }));
+            }
+            if (remainingMs !== undefined) {
+                deadlineTimer = setTimeout(() => {
+                    localAbort.abort(new Error("MCP request lifetime exceeded."));
+                }, remainingMs);
+            }
+            const localRequest = new Request(request, { signal: localAbort.signal });
             if (admission.success.waitMs > 0) {
                 opts.logger.debug("[connecta] MCP request admitted after queue wait", {
                     waitMs: admission.success.waitMs,
@@ -431,52 +474,70 @@ export function createMcpRoute(opts) {
             // Effect `authorize` would put Effect in the /activity bundle, which
             // shares it, to save only the lookups an abandoned authorization
             // finishes on its own.
-            const authz = yield* Effect.promise(() => authorize(request, baseUrl, opts.auth, runtimeContext, opts.identity));
-            if (!authz.ok)
-                return cors(authz.response);
-            // A pool endpoint narrows the identity's own view and nothing else. An
-            // undeclared name, a grant that refuses, and a grant that throws are
-            // one identical 404 so a credential never enumerates the other pools;
-            // the operator log is where the reason lives.
-            let access = authz;
-            if (poolName !== undefined) {
-                const pool = opts.pools?.get(poolName);
-                const reason = !pool ? "undeclared" : yield* Effect.promise(async () => {
-                    try {
-                        return (await pool.grant(authz.identity)) === true ? "granted" : "refused";
-                    }
-                    catch {
-                        return "grant threw";
+            const handled = Effect.gen(function* () {
+                const authz = yield* Effect.promise(() => authorize(localRequest, baseUrl, opts.auth, runtimeContext, opts.identity));
+                if (!authz.ok)
+                    return cors(authz.response);
+                // A pool endpoint narrows the identity's own view and nothing else. An
+                // undeclared name, a grant that refuses, and a grant that throws are
+                // one identical 404 so a credential never enumerates the other pools;
+                // the operator log is where the reason lives.
+                let access = authz;
+                if (poolName !== undefined) {
+                    const pool = opts.pools?.get(poolName);
+                    const reason = !pool ? "undeclared" : yield* Effect.promise(async () => {
+                        try {
+                            return (await pool.grant(authz.identity)) === true ? "granted" : "refused";
+                        }
+                        catch {
+                            return "grant threw";
+                        }
+                    });
+                    if (!pool || reason !== "granted") {
+                        opts.logger.warn(`[connecta] refused /mcp/${poolName} with 404: pool ${reason}` +
+                            (authz.actor.id ? ` for ${loggableValue(authz.actor.id)}` : ""));
+                        // 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));
                     }
-                });
-                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 }));
+                    access = intersectAccess(authz, pool.access);
                 }
-                access = intersectAccess(authz, pool.access);
-            }
-            let scopedRegistry;
-            try {
-                validateAuthPermissions(authz, opts.registry);
-                scopedRegistry = opts.registry.scoped({
-                    connectorIds: access.connectorIds,
-                    ...(access.toolAccess ? { toolAccess: access.toolAccess } : {}),
-                    ...(authz.subjectKey ? { subjectKey: authz.subjectKey } : {}),
-                    ...(authz.principalKey ? { principalKey: authz.principalKey } : {}),
-                });
-            }
-            catch (error) {
-                return cors(new Response(JSON.stringify({ error: msg(error) }), {
-                    status: 403,
-                    headers: { "Content-Type": "application/json" },
-                }));
-            }
-            if (new URL(request.url).searchParams.has("toolkit")) {
-                return cors(toolkitRetired(opts.logger));
-            }
-            return cors(yield* serveMcp(request, opts, baseUrl, authz.actor, scopedRegistry, id => { const connector = scopedRegistry.getConnector(id); return Boolean(connector && mayManageConnector(authz, connector)); }, runtimeContext));
-        }), request.signal);
+                let scopedRegistry;
+                try {
+                    validateAuthPermissions(authz, opts.registry);
+                    scopedRegistry = opts.registry.scoped({
+                        connectorIds: access.connectorIds,
+                        ...(access.toolAccess ? { toolAccess: access.toolAccess } : {}),
+                        ...(access.guardedToolAccess ? { guardedToolAccess: access.guardedToolAccess } : {}),
+                        ...(authz.subjectKey ? { subjectKey: authz.subjectKey } : {}),
+                        ...(authz.principalKey ? { principalKey: authz.principalKey } : {}),
+                        caller: {
+                            identity: authz.identity,
+                            ...(poolName !== undefined ? { pool: poolName } : {}),
+                        },
+                    });
+                }
+                catch (error) {
+                    return cors(new Response(JSON.stringify({ error: msg(error) }), {
+                        status: 403,
+                        headers: { "Content-Type": "application/json" },
+                    }));
+                }
+                if (new URL(request.url).searchParams.has("toolkit")) {
+                    return cors(toolkitRetired(opts.logger));
+                }
+                return cors(yield* serveMcp(localRequest, localAbort.signal, opts, baseUrl, authz.actor, scopedRegistry, id => { const connector = scopedRegistry.getConnector(id); return Boolean(connector && mayManageConnector(authz, connector)); }, poolName, runtimeContext));
+            });
+            if (remainingMs === undefined)
+                return yield* handled;
+            const bounded = yield* handled.pipe(Effect.timeoutOption(Duration.millis(remainingMs)));
+            if (Option.isNone(bounded))
+                localAbort.abort(new Error("MCP request lifetime exceeded."));
+            return Option.isSome(bounded)
+                ? bounded.value
+                : cors(new Response("MCP request lifetime exceeded.", { status: 504 }));
+        }), localAbort.signal);
     }
     return { handle: routeMcp, rejectOrigin };
 }