@zackbart/connecta 0.33.0 → 0.34.1

package/dist/operator-ui/health.js

@@ -0,0 +1,52 @@
+/**
+ * The next steady evidence. A settled connector takes its current row; one
+ * being read again keeps its previous evidence when this identity has any.
+ * Returns `previous` itself when nothing changed, so it can live in React
+ * state. A new identity starts empty.
+ */
+export function steadyHealth(state, previous) {
+    const same = previous?.generation === state.generation ? previous : null;
+    const contract = state.contract?.role === "maintainer" && state.data ? state.contract : null;
+    // No contract on screen: keep what was shown until the next one arrives.
+    if (!contract || !state.data)
+        return same ?? { generation: state.generation, rows: Object.create(null) };
+    const reading = new Set(state.data.connectors.filter((c) => c.status === "loading").map((c) => c.id));
+    const held = same?.rows ?? Object.create(null);
+    const rows = Object.create(null);
+    let changed = !same || Object.keys(held).length !== contract.live.connectors.length;
+    for (const live of contract.live.connectors) {
+        const before = Object.hasOwn(held, live.id) ? held[live.id] : undefined;
+        if (before && reading.has(live.id)) {
+            rows[live.id] = before;
+            continue;
+        }
+        const failed = Object.hasOwn(state.connectorFailures, live.id) && Boolean(state.connectorFailures[live.id]);
+        if (before?.live === live && before.failed === failed)
+            rows[live.id] = before;
+        else {
+            rows[live.id] = { live, failed };
+            changed = true;
+        }
+    }
+    return changed ? { generation: state.generation, rows } : same;
+}
+/** The contract each view renders health from, with every live row replaced by its steady evidence. */
+export function shownHealth(contract, health) {
+    const signals = Object.create(null);
+    if (!contract)
+        return { contract, signals };
+    let replaced = false;
+    const connectors = contract.live.connectors.map((live) => {
+        const row = Object.hasOwn(health.rows, live.id) ? health.rows[live.id] : undefined;
+        if (row?.failed)
+            signals[live.id] = { failed: true };
+        if (!row || row.live === live)
+            return live;
+        replaced = true;
+        return row.live;
+    });
+    return {
+        contract: replaced ? { ...contract, live: { ...contract.live, connectors } } : contract,
+        signals,
+    };
+}

package/dist/operator-ui/member-page.js

@@ -35,23 +35,17 @@ function controlsFor(manage, connection) {
     }
     return [];
 }
+/**
+ * A few words under the account's name, only where the badge alone would
+ * leave something out: a saved credential that no longer fits, or one saved
+ * but not working.
+ */
 function summaryFor(manage, connection) {
-    if (manage.kind === "credential") {
-        if (!credentialStored(manage)) {
-            return manage.actions.includes("save") ? "Add your credential to use its tools." : "No credential saved.";
-        }
-        if (connection.problem === "credential_mismatch")
-            return "Your saved credential no longer fits. Replace it.";
-        return connection.state === "ok" ? "Your credential is saved." : "Your credential is saved, but it isn't working.";
-    }
-    if (connection.state === "ok")
-        return "Connected with your account.";
-    if (connection.state === "auth_required") {
-        return manage.kind === "oauth" && manage.actions.includes("connect")
-            ? "Not connected. Its tools won't work for you until you connect."
-            : "Not connected.";
-    }
-    return "Unavailable right now.";
+    if (manage.kind !== "credential" || !credentialStored(manage))
+        return null;
+    if (connection.problem === "credential_mismatch")
+        return "Saved credential no longer fits";
+    return connection.state === "ok" ? null : "Saved, but not working";
 }
 const toolCount = (connector) => connector.tools.length;
 export function memberPage(contract) {
@@ -94,19 +88,10 @@ export function toolCountLabel(count) {
 /** The in-page question before a member's action that takes something away. */
 export function memberConfirmCopy(action, name) {
     if (action === "oauth_restart") {
-        return {
-            question: `Reconnect ${name}? Your current connection stops working until you finish authorizing in the new tab.`,
-            confirm: "Reconnect",
-        };
+        return { question: `Reconnect ${name}? It stops working until you finish in the new tab.`, confirm: "Reconnect" };
     }
     if (action === "oauth_disconnect") {
-        return {
-            question: `Disconnect your ${name} account? Its tools stop working for you until you connect again.`,
-            confirm: "Disconnect",
-        };
+        return { question: `Disconnect your ${name} account? Its tools stop working for you.`, confirm: "Disconnect" };
     }
-    return {
-        question: `Clear your ${name} credential? Its tools stop working for you until you add one again.`,
-        confirm: "Clear",
-    };
+    return { question: `Clear your ${name} credential? Its tools stop working for you.`, confirm: "Clear" };
 }

package/dist/operator-ui/overview.js

@@ -0,0 +1,123 @@
+import { endpointRows } from "./endpoints.js";
+import { joinList } from "./connection-map.js";
+import { connectorVerdict } from "./view.js";
+const PROBLEM_TITLE = {
+    connector_unavailable: "is unavailable",
+    oauth_required: "needs authorization",
+    credential_required: "needs a credential",
+    auth_required: "needs a secret in the deployment",
+    credential_mismatch: "can't use its saved credential",
+    catalog_failed: "couldn't load its tools",
+};
+function affects(paths) {
+    return paths.length ? `Affects ${joinList(paths)}` : "No endpoint serves it";
+}
+/**
+ * One row per connector that is not healthy, in config order, then one per
+ * agent that sits in an endpoint without a working token. Each row carries
+ * the fix the rest of the UI already offers for it.
+ */
+export function attentionItems(contract, options = {}) {
+    if (contract.role !== "maintainer")
+        return [];
+    const rows = endpointRows(contract);
+    const connectors = [];
+    for (const config of contract.config?.connectors ?? []) {
+        const live = contract.live.connectors.find((c) => c.id === config.id);
+        if (!live)
+            continue;
+        const signals = options.signals && Object.hasOwn(options.signals, config.id) ? options.signals[config.id] : {};
+        const verdict = connectorVerdict(live, signals);
+        if ((verdict.tone !== "warn" && verdict.tone !== "danger") || !verdict.action)
+            continue;
+        const title = config.title ?? config.id;
+        const id = encodeURIComponent(config.id);
+        const paths = rows.filter((row) => row.groups.some((group) => group.config.id === config.id)).map((r) => r.path);
+        const connection = `/connectors/${id}#connection`;
+        const base = {
+            key: `connector:${config.id}`,
+            kind: "connector",
+            tone: verdict.tone,
+            subject: title,
+            action: { label: verdict.action, href: connection, ariaLabel: `${verdict.action} ${title}` },
+            href: connection,
+        };
+        // The server's problem code outranks a failed read on this page: the row
+        // keeps its fix prompt and says the details didn't load. "Unavailable"
+        // beside a failed read is the page's own (see connectorVerdict).
+        const reported = live.problem ?? (live.status === "error" ? "connector_unavailable" : undefined);
+        const problem = signals.failed && reported === "connector_unavailable" ? undefined : reported;
+        if (problem) {
+            connectors.push({
+                ...base,
+                problem: PROBLEM_TITLE[problem],
+                body: signals.failed ? `Details didn't load · ${affects(paths)}` : affects(paths),
+                fix: { kind: problem, connectorId: config.id },
+            });
+        }
+        else if (signals.failed) {
+            connectors.push({
+                ...base,
+                problem: "didn't load on this page",
+                body: affects(paths),
+                fix: null,
+            });
+        }
+        else if (live.status !== "ok") {
+            connectors.push({
+                ...base,
+                problem: verdict.label === "Authorization needed" ? "needs authorization" : "isn't connected",
+                body: affects(paths),
+                fix: null,
+            });
+        }
+    }
+    const agents = contract.agents
+        .filter((agent) => agent.pools.length && agent.token.state !== "issued")
+        .map((agent) => {
+        // An agent connects only at a pool's agent URL.
+        const paths = agent.pools.map((name) => contract.pools.find((pool) => pool.name === name)?.agentPath ?? `/agent/${name}`);
+        const revoked = agent.token.state === "revoked";
+        return {
+            key: `agent:${agent.name}`,
+            kind: "agent",
+            tone: "warn",
+            subject: agent.name,
+            problem: revoked ? "has a revoked token" : "has no token",
+            body: `Can't connect at ${joinList(paths)}`,
+            action: options.tokensPage
+                ? { label: "Issue token", href: "/tokens", ariaLabel: `Issue a token for ${agent.name}` }
+                : null,
+            href: options.tokensPage ? "/tokens" : null,
+            fix: null,
+        };
+    });
+    // Severity changes as individual details settle. Config order keeps surviving
+    // rows in place without waiting for the slowest connector's read.
+    return [...connectors, ...agents];
+}
+/** The numbers above the list, counted from the same map the page draws. */
+export function overviewHeadline(contract, map, items, signals = {}) {
+    const bar = (contract.config?.connectors ?? []).flatMap((config) => {
+        const live = contract.live.connectors.find((c) => c.id === config.id);
+        if (!live)
+            return [];
+        const health = connectorVerdict(live, Object.hasOwn(signals, config.id) ? signals[config.id] : undefined);
+        return [{ id: config.id, title: config.title ?? config.id, tone: health.tone, label: health.label }];
+    });
+    const healthy = bar.filter((entry) => entry.tone === "ok").length;
+    const warn = bar.filter((entry) => entry.tone === "warn").length;
+    const danger = bar.filter((entry) => entry.tone === "danger").length;
+    const count = (kind) => map.nodes.filter((node) => node.kind === kind).length;
+    return {
+        connectors: bar.length,
+        healthy,
+        warn,
+        danger,
+        bar,
+        endpoints: count("endpoint"),
+        readOnlyEndpoints: map.nodes.filter((node) => node.kind === "endpoint" && node.readOnly).length,
+        people: count("person"),
+        agents: contract.agents.length,
+    };
+}

package/dist/operator-ui/view.d.ts

@@ -4,16 +4,7 @@ import type { CredentialManagementCapability, UiConnector, UiData, UiProblem } f
 import type { FixPromptKind } from "./fix-prompts.js";
 import type { AgentSlot } from "./agents.js";
 export declare function registrationPathLabel(path: NonNullable<UiConnector["registrationPath"]>): string;
-/**
- * A connector's source column: the maintained provider with the
- * implementation it uses, since a dual provider's `auth` selects either the
- * vendor's hosted MCP server or Connecta's REST connector.
- */
-export declare function connectorSourceLabel(source: {
-    kind: string;
-    provider?: string;
-}): string;
-export type OperatorPage = "endpoints" | "settings" | "connector" | "tokens" | "connections" | "activity";
+export type OperatorPage = "overview" | "endpoints" | "settings" | "connector" | "tokens" | "connections" | "activity";
 /** Pages the nav lists, in dashboard order. */
 export declare const OPERATOR_PAGES: readonly OperatorPage[];
 export declare const PAGE_META: Readonly<Record<OperatorPage, {
@@ -134,7 +125,7 @@ export declare function credentialTestNotice(connectorId: string, answer: {
  */
 export declare function refusedNotice(action: DownstreamAction, connectorId: string, problem?: unknown): Notice;
 /** An action whose permission or target changed before it was sent. */
-export declare const STALE_COPY = "This changed before the request was sent, so nothing was sent. Check it and try again.";
+export declare const STALE_COPY = "This changed before sending, so nothing was sent. Try again.";
 /**
  * Every row action's failure, in one voice. The page's own failures — a
  * lapsed session, a denied identity, a dropped connection — read the same for
@@ -327,12 +318,30 @@ export declare function problemCopy(problem: UiProblem | undefined): string | nu
  * error. The two used to share the red box, so the row contradicted itself.
  */
 export declare function problemTone(problem: UiProblem): "warn" | "danger";
+/** What the page knows about a connector beyond its live status: a failed detail read. */
+export interface ConnectorSignals {
+    failed?: boolean;
+}
+/** One connector's health everywhere it is shown: badge tone, status word, and the one action beside it. */
+export interface ConnectorVerdict {
+    tone: "ok" | "warn" | "danger" | "neutral";
+    label: string;
+    /** The link to the Connection tab, or null when the connector is fine. */
+    action: "Connect" | "Replace key" | "Inspect" | null;
+}
 /**
- * What this identity may do with a connector, in one line. Being able to use it
- * is implied by seeing it at all, so the sentence covers authentication, which
- * is the part that differs between operators.
+ * The verdict the Connectors list, the Overview, Endpoints and a connector's
+ * page all show. The server's problem code comes first, then a failed detail
+ * read on this page, then a non-ok status. Catalog drift is informational. A problem
+ * outranks the status, so a connector whose catalog failed is never
+ * "Connected". A failed read marks its connector `connector_unavailable` in
+ * the store, so that one code beside a failed read is the page's own and
+ * reads "Couldn't load" instead of blaming the downstream.
  */
-export declare function permissionLabel(connector: UiConnector): string;
+export declare function connectorVerdict(live: {
+    status: string;
+    problem?: UiProblem;
+}, signals?: ConnectorSignals): ConnectorVerdict;
 /**
  * Hosted-provider catalog drift, as an operator reads it
  * ([#343](https://github.com/zackbart/connecta/issues/343)).
@@ -378,6 +387,8 @@ export declare function activityOutcomeBadge(outcome: string): {
     label: string;
     tone: Tone;
 };
+/** Why a call stalled or failed, in words; "" when nothing was recorded. */
+export declare function activityReason(event: UiActivityEvent): string;
 /** The one-line detail under an address: where it ran, retries, and why it stalled. */
 export declare function activityDetail(event: UiActivityEvent): string;
 /**
@@ -385,13 +396,6 @@ export declare function activityDetail(event: UiActivityEvent): string;
  * beside it is not shown: it can carry a vault's own words.
  */
 export declare function credentialProblemCopy(problem: string | undefined): string;
-export declare function credentialStateLabel(credential: {
-    configured: boolean | null;
-    problem?: string;
-    fields?: unknown[];
-    lastFour?: string;
-    updatedAt?: string;
-}): string;
 /** Gate copy for each browser-auth shape, so the sign-in state is never a blank page. */
 export declare function gateCopy(kind: string, signedIn: boolean): string;
 export {};