@zackbart/connecta 0.15.0 → 0.16.0

package/dist/operator-ui/view.js

@@ -0,0 +1,270 @@
+export const OPERATOR_PAGES = [
+    "connections",
+    "credentials",
+    "tokens",
+    "activity",
+];
+export const PAGE_META = {
+    connections: { path: "/", label: "Connections" },
+    credentials: { path: "/credentials", label: "Credentials" },
+    tokens: { path: "/tokens", label: "Access tokens" },
+    activity: { path: "/activity", label: "Activity" },
+};
+export function pageForPath(path) {
+    const match = OPERATOR_PAGES.find((page) => PAGE_META[page].path === path);
+    return match ?? "connections";
+}
+export function info(message) {
+    return { message, tone: "info" };
+}
+export function failure(message) {
+    return { message, tone: "error" };
+}
+export function initialState(page) {
+    return {
+        page,
+        generation: 0,
+        session: "loading",
+        gate: null,
+        refreshing: false,
+        pendingFocus: null,
+        ...identityScopedState(),
+    };
+}
+/**
+ * Every field that belongs to one operator identity. Split out because the only
+ * safe way to change identity is to replace all of them at once: a field left
+ * behind here is one identity's data on another identity's screen.
+ */
+function identityScopedState() {
+    return {
+        data: null,
+        connectorFilter: "",
+        oauthNotice: null,
+        oauthBusy: null,
+        credentialNotice: null,
+        credentialEditing: null,
+        credentialBusy: null,
+        tokenPhase: "idle",
+        tokenNotice: null,
+        tokens: [],
+        createdToken: null,
+        tokenRenaming: null,
+        tokenBusy: false,
+        activityPhase: "idle",
+        activityNotice: null,
+        activityEvents: [],
+        activityCursor: null,
+        activitySearch: "",
+    };
+}
+/**
+ * Drop to the gate and forget the previous operator. Bumping the generation is
+ * what makes the drop stick: work already in flight for the old identity
+ * resolves into a state that no longer accepts it.
+ */
+export function resetIdentity(state, gate = null) {
+    return {
+        ...state,
+        generation: state.generation + 1,
+        session: "gated",
+        gate,
+        refreshing: false,
+        pendingFocus: null,
+        ...identityScopedState(),
+    };
+}
+/**
+ * Leaving a page closes what should not survive it: a one-time secret, a half
+ * typed credential, and the notices that answered the page just left.
+ */
+export function withPage(state, page) {
+    return {
+        ...state,
+        page,
+        createdToken: null,
+        tokenRenaming: null,
+        tokenNotice: null,
+        credentialEditing: null,
+        credentialNotice: null,
+    };
+}
+export function credentialUnavailableCopy(capability) {
+    if (capability === "no_slots") {
+        return "No connectors declare operator-managed credential slots. Connector credentials remain configuration-as-code until a slot is declared.";
+    }
+    if (capability === "vault_not_configured") {
+        return "Credential storage is not configured. Set credentials.encryptionKey before managing connector credentials here.";
+    }
+    return "Credential management requires an eligible Clerk operator. Bearer-authenticated sessions can inspect connections but cannot manage stored credentials.";
+}
+export function accessTokenUnavailableCopy(capability) {
+    if (capability === "not_configured") {
+        return "Access tokens are not configured for this deployment. Add accessTokens to the deployment configuration to enable them.";
+    }
+    return "Access token management requires an eligible Clerk operator. A Bearer token can connect to MCP, but it cannot create or revoke other tokens.";
+}
+export function connectorStatusLabel(status) {
+    if (status === "ok")
+        return "Connected";
+    if (status === "auth_required")
+        return "Authorization needed";
+    return "Unavailable";
+}
+export function toolCountLabel(count) {
+    return `${count} ${count === 1 ? "tool" : "tools"}`;
+}
+/**
+ * The four categories, in the order an operator should read them: what the
+ * deployment refuses to call, what it can no longer call, what contradicts a
+ * vetted verdict, and what changed shape underneath a reviewed schema. Counts
+ * only — a name or a schema on this path would be the payload leak the whole
+ * drift model exists to avoid.
+ */
+const DRIFT_CATEGORIES = [
+    { key: "unclassifiedTools", label: "Unclassified" },
+    { key: "unservedTools", label: "Unserved" },
+    { key: "annotationConflicts", label: "Annotation conflicts" },
+    { key: "schemaChanges", label: "Schema changes" },
+];
+export function driftTotal(drift) {
+    if (!drift)
+        return 0;
+    return DRIFT_CATEGORIES.reduce((sum, { key }) => sum + (drift[key] || 0), 0);
+}
+export function driftState(drift) {
+    if (!drift)
+        return "unavailable";
+    return driftTotal(drift) > 0 ? "warning" : "clean";
+}
+/** Every category with its count, so a clean report still shows its zeros. */
+export function driftCounts(drift) {
+    if (!drift)
+        return [];
+    return DRIFT_CATEGORIES.map(({ key, label }) => ({
+        key,
+        label,
+        count: drift[key] || 0,
+    }));
+}
+/** One line naming the state and when it was observed. Never what drifted. */
+export function driftSummary(drift) {
+    const state = driftState(drift);
+    if (state === "unavailable") {
+        return "No catalog refresh observed yet in this runtime.";
+    }
+    const observed = formatDate(drift?.observedAt);
+    const when = observed ? ` · observed ${observed}` : "";
+    if (state === "clean")
+        return `Matches the reviewed manifest${when}`;
+    const total = driftTotal(drift);
+    return `${total} difference${total === 1 ? "" : "s"} from the reviewed manifest${when}`;
+}
+/**
+ * Only http/https may become a clickable href — the browser half of the gate
+ * `src/ui.ts` applies before an authorizationUrl is ever serialized. A hostile
+ * downstream that gets a `javascript:` URL past one of them still meets the
+ * other, and the caller renders inert text instead of a link.
+ */
+export function safeHttpHref(url) {
+    if (!url)
+        return null;
+    try {
+        const protocol = new URL(url).protocol;
+        return protocol === "http:" || protocol === "https:" ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Locale timestamp, or "" for anything that is not a readable date. */
+export function formatDate(value) {
+    if (!value)
+        return "";
+    const date = new Date(value);
+    return Number.isNaN(date.valueOf()) ? "" : date.toLocaleString();
+}
+export function actorLabel(actor) {
+    if (!actor?.kind)
+        return "unknown";
+    if (actor.label)
+        return `${actor.kind} · ${actor.label}`;
+    return actor.id ? `${actor.kind} · ${actor.id}` : actor.kind;
+}
+/**
+ * The stable id behind a friendly label, shown only when a label or namespace
+ * could otherwise make two different people look like one.
+ */
+export function actorStableId(actor) {
+    if (!actor?.id)
+        return null;
+    if (!actor.label && !actor.namespace)
+        return null;
+    return actor.namespace ? `${actor.namespace} · ${actor.id}` : actor.id;
+}
+function activityMatches(event, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return true;
+    return [
+        event.address,
+        event.connectorId,
+        event.toolName,
+        event.source,
+        event.outcome,
+        event.errorCode,
+        event.friction,
+        event.actor?.kind,
+        event.actor?.id,
+        event.actor?.namespace,
+        event.actor?.label,
+    ].some((value) => String(value ?? "").toLowerCase().includes(q));
+}
+export function filterActivity(events, query) {
+    return events.filter((event) => activityMatches(event, query));
+}
+/** Counts only. What the deployment ran, never what it sent or received. */
+export function activitySummary(events) {
+    if (events.length === 0)
+        return "Arguments and results are never stored.";
+    const tools = new Set(events.map((event) => event.address)).size;
+    return `${events.length} loaded call${events.length === 1 ? "" : "s"} · ${tools} tool${tools === 1 ? "" : "s"} · no arguments or results stored`;
+}
+const ACTIVITY_OUTCOMES = ["success", "error", "timeout", "cancelled"];
+export function activityOutcomeClass(outcome) {
+    return ACTIVITY_OUTCOMES.includes(outcome) ? outcome : "error";
+}
+/** The one-line detail under an address: source, retries, and friction. */
+export function activityDetail(event) {
+    const parts = [event.source];
+    if (event.attempts > 1)
+        parts.push(`${event.attempts} attempts`);
+    if (event.friction)
+        parts.push(event.friction);
+    // The friction class and the code coincide for auth_required and
+    // result_too_large. Printing "· auth_required · auth_required" says nothing
+    // twice, so the coarse class stands in for both when they agree.
+    if (event.errorCode && event.errorCode !== event.friction) {
+        parts.push(event.errorCode);
+    }
+    return parts.join(" · ");
+}
+export function credentialStateLabel(credential) {
+    if (!credential.configured)
+        return "not configured";
+    const masked = credential.fields?.length
+        ? "configured"
+        : `configured · ••••${credential.lastFour ?? ""}`;
+    return credential.updatedAt
+        ? `${masked} · updated ${formatDate(credential.updatedAt)}`
+        : masked;
+}
+/** Gate copy for the two inbound-auth shapes, so the sign-in state is never a blank page. */
+export function gateCopy(kind, signedIn) {
+    if (kind !== "clerk") {
+        return "Paste an operator bearer token to open this page. Nothing is requested until you do.";
+    }
+    return signedIn
+        ? "Signed in with Clerk, but this account cannot open deployment-wide operator pages."
+        : "Sign in with Clerk to open this operator page.";
+}

package/dist/providers/cloudflare.d.ts

@@ -1,6 +1,8 @@
 import type { Connector, ConnectorCredentialConfig } from "../types.js";
 /** Cloudflare's v4 REST base. Override only for a proxy or a test double. */
 export declare const CLOUDFLARE_API_BASE = "https://api.cloudflare.com/client/v4";
+/** Authentication schemes accepted by Cloudflare's v4 API. */
+export type CloudflareAuthentication = "apiToken" | "globalApiKey";
 /**
  * Every DNS record type the records API accepts, for filtering a list.
  * Enumerated in the schema so an agent picks a legal type without reading
@@ -40,7 +42,9 @@ export interface CloudflareOptions {
     zoneId?: string;
     /** API base override for a proxy or a test double. Defaults to the v4 API. */
     baseUrl?: string;
-    /** Credential presentation override; the token is always operator-managed. */
+    /** Authentication scheme. Defaults to the recommended scoped API token. */
+    authentication?: CloudflareAuthentication;
+    /** Credential presentation override; credentials are always operator-managed. */
     credential?: ConnectorCredentialConfig;
     /** Account-specific conventions appended to the maintained provider guide. */
     instructions?: string;
@@ -51,4 +55,3 @@ export interface CloudflareOptions {
 }
 /** A maintained Cloudflare REST API connection. */
 export declare function cloudflare(id: string, options: CloudflareOptions): Connector;
-//# sourceMappingURL=cloudflare.d.ts.map