@sema-agent/client-core 0.111.0 → 0.112.0

package/dist/localConfig/mcp/views.d.ts

@@ -0,0 +1,170 @@
+import { type McpProbeFacade } from '../../mcpProbeWire.js';
+import type { McpProbeReading } from '../../mcpProbeCapability.js';
+import type { McpAuthorizationView } from '../../mcpLiveness.js';
+import type { UiLanguage } from '../../env/uiLanguage.js';
+import { type LocalConfigPreview, type LocalConfigReceipt, type LocalConfigStorePort } from '../kernel.js';
+import { type McpServersReport } from './servers.js';
+import { type McpServerEdit, type McpServerEditContext, type McpServerEditOutcome } from './edit.js';
+export type McpArgView = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'masked';
+};
+export interface McpSecretMemberView {
+    readonly name: string;
+    readonly hasValue: boolean;
+}
+export type McpServerEntryView = {
+    readonly transport: 'stdio';
+    readonly command: string;
+    readonly args: readonly McpArgView[];
+    readonly env: readonly McpSecretMemberView[];
+    readonly allowTools: readonly string[] | 'invalid' | null;
+} | {
+    readonly transport: 'http';
+    readonly url: string;
+    readonly headers: readonly McpSecretMemberView[];
+    readonly headersHelper: readonly McpArgView[] | null;
+    readonly oauth: {
+        readonly clientId: string | null;
+        readonly callbackPort: number | null;
+    } | null;
+    readonly allowTools: readonly string[] | 'invalid' | null;
+} | {
+    readonly transport: 'unsupported';
+    readonly declaredType: string;
+} | {
+    readonly transport: 'unreadable';
+};
+export interface McpServerProblemView {
+    readonly reason: string;
+    readonly path: string | null;
+    readonly sentence: string;
+}
+export interface McpServerRowView {
+    readonly name: string;
+    readonly label: string;
+    readonly scope: string;
+    readonly shadows: readonly string[];
+    readonly state: string;
+    readonly withheldBy: string | null;
+    readonly approvedBy: string | null;
+    readonly writable: boolean;
+    readonly base: string | null;
+    readonly deploymentWins: boolean;
+    readonly missing: readonly string[];
+    readonly entry: McpServerEntryView;
+    readonly problems: readonly McpServerProblemView[];
+    readonly sentence: string | null;
+}
+export interface McpServerReportView {
+    readonly kind: 'mcp_servers';
+    readonly rows: readonly McpServerRowView[];
+    readonly unreadable: readonly string[];
+    readonly locked: 'enterprise_config' | 'plugin_only' | null;
+    readonly purpose: 'report' | 'load';
+    readonly approvalsWithheld: readonly McpApprovalWithheldView[];
+    readonly deployment: {
+        readonly state: 'unknown';
+        readonly names: readonly [];
+    } | {
+        readonly state: 'read';
+        readonly names: readonly {
+            readonly name: string;
+            readonly label: string;
+        }[];
+    };
+    readonly pluginRoster: 'host_supplied' | 'absent';
+    readonly promptsAndResources: 'not_yet';
+}
+export interface McpApprovalWithheldView {
+    readonly layer: string;
+    readonly cause: 'trust_withheld';
+    readonly sentence: string;
+}
+export interface McpImportedView {
+    readonly name: string;
+    readonly label: string;
+    readonly renamedFrom: string | null;
+}
+export interface McpSkippedView {
+    readonly name: string;
+    readonly label: string;
+    readonly reason: string;
+}
+export interface McpProbeServerRowView {
+    readonly name: string;
+    readonly label: string;
+    readonly status: string;
+    readonly errorCode: string | null;
+    readonly toolCount: number | null;
+    readonly authorization: McpAuthorizationView | 'unreadable' | null;
+}
+export interface McpServerRefusalDetailView {
+    readonly refusal: string;
+    readonly path: string | null;
+    readonly nameReason: string | null;
+    readonly by: string | null;
+    readonly scope: string | null;
+    readonly scopes: readonly string[];
+    readonly exhausted: boolean;
+    readonly why: string | null;
+    readonly problems: readonly McpServerProblemView[];
+    readonly env: readonly string[];
+    readonly headers: readonly string[];
+    readonly args: readonly number[];
+}
+export interface McpServerEditPlanView {
+    readonly op: string;
+    readonly name: string;
+    readonly label: string;
+    readonly scope: string | null;
+    readonly renamedFrom: string | null;
+    readonly replaced: boolean;
+    readonly imported: readonly McpImportedView[];
+    readonly skipped: readonly McpSkippedView[];
+}
+export interface McpServerEditNoticeView {
+    readonly kind: string;
+    readonly scope: string | null;
+    readonly names: readonly string[];
+    readonly sentence: string;
+}
+export interface McpServerEditOutcomeView {
+    readonly receipt: LocalConfigReceipt | LocalConfigPreview;
+    readonly refusal: McpServerRefusalDetailView | null;
+    readonly plan: McpServerEditPlanView | null;
+    readonly notices: readonly McpServerEditNoticeView[];
+    readonly probe: 'ready' | 'removed' | 'not_active' | 'env_missing' | 'edit_refused' | null;
+    readonly sentence: string;
+}
+export type McpServerProbeView = {
+    readonly kind: 'face';
+    readonly probedAt: string;
+    readonly servers: readonly McpProbeServerRowView[];
+} | {
+    readonly kind: 'refused';
+    readonly cause: string;
+    readonly sentence: string;
+} | {
+    readonly kind: 'unknown';
+    readonly why: string;
+    readonly sentence: string;
+} | {
+    readonly kind: 'not_probed';
+    readonly why: 'removed' | 'not_active' | 'env_missing' | 'edit_refused' | 'unavailable';
+    readonly sentence: string;
+};
+export declare function mcpServerReportView(report: McpServersReport, lang?: UiLanguage): McpServerReportView;
+export declare function mcpServerEditOutcomeView(outcome: McpServerEditOutcome, lang?: UiLanguage): McpServerEditOutcomeView;
+export declare function mcpServerEditSentence(outcome: McpServerEditOutcome, lang?: UiLanguage): string;
+export declare function probeMcpServerEdit(edit: McpServerEdit, store: LocalConfigStorePort, ctx: McpServerEditContext, facade: McpProbeFacade, capability: McpProbeReading, lang?: UiLanguage): Promise<McpServerProbeView>;
+export type McpViewCheck = true | {
+    readonly reason: string;
+    readonly field?: string;
+};
+export declare const checkMcpServerReportView: (v: unknown) => McpViewCheck;
+export declare const checkMcpServerEditOutcomeView: (v: unknown) => McpViewCheck;
+export declare const checkMcpServerProbeView: (v: unknown) => McpViewCheck;
+export declare function checkMcpServerEditRequest(v: {} | null | undefined): McpViewCheck;

package/dist/localConfig/mcp/views.js

@@ -0,0 +1,429 @@
+import { displayUntrusted, displayConfiguredUrl } from '../../displayUntrusted.js';
+import { capForDisplay } from '../../fleetTaskDesc.js';
+import { settingsCredentialKeyPaths } from '../../settingsCredentialKeyPaths.js';
+import { probeMcpServers, MCP_PROBE_REFUSAL_CAUSES, MCP_PROBE_UNKNOWN_WHYS } from '../../mcpProbeWire.js';
+import { msg, renderMessage } from '../../i18n/translate.js';
+import { localConfigReceiptSentence } from '../kernel.js';
+import { localConfigReceiptShapeOf } from '../receiptShape.js';
+import { MCP_SERVER_SCOPES, MCP_SERVER_ROW_STATES, MCP_SERVER_WITHHELD_CAUSES, ownData, stringListOf } from './servers.js';
+import { mcpRowBaseOf, mcpServerProbeTargetOf, MCP_SERVER_EDIT_OPS, refusalReasonOf, shapeMcpServerEdit } from './edit.js';
+const LABEL_MAX = 140;
+const TEXT_MAX = 400;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const own = (v, k) => {
+    const r = ownData(v, k);
+    return r.ok ? r.value : undefined;
+};
+const label = (s) => displayUntrusted(s, { max: LABEL_MAX });
+const text = (s) => displayUntrusted(s, { max: TEXT_MAX });
+const keysOf = (v) => {
+    try {
+        return isRecord(v) ? Object.keys(v) : [];
+    }
+    catch {
+        return undefined;
+    }
+};
+const membersOf = (v) => {
+    const keys = keysOf(v);
+    return keys === undefined ? undefined : keys.map((k) => Object.freeze({ name: label(k), hasValue: typeof own(v, k) === 'string' && own(v, k) !== '' }));
+};
+function maskedArgsOf(list) {
+    try {
+        const masked = new Set();
+        for (const f of settingsCredentialKeyPaths({ args: [...list] })) {
+            const m = /^args\[(\d+)\]$/.exec(f.path);
+            if (m !== null)
+                masked.add(Number(m[1]));
+        }
+        return masked;
+    }
+    catch {
+        return 'all';
+    }
+}
+function argsView(v) {
+    const list = stringListOf(v) ?? [];
+    const masked = maskedArgsOf(list);
+    return list.map((a, i) => (masked === 'all' || masked.has(i) ? Object.freeze({ kind: 'masked' }) : Object.freeze({ kind: 'text', text: text(a) })));
+}
+function allowToolsView(entry) {
+    const r = ownData(entry, 'allowTools');
+    if (!r.ok)
+        return 'invalid';
+    if (r.value === undefined)
+        return null;
+    const list = stringListOf(r.value);
+    return list === undefined ? 'invalid' : Object.freeze(list.map(label));
+}
+const REMOTE_TYPES = new Set(['http', 'sse', 'ws', 'streamable-http', 'sse-ide', 'ws-ide', 'sdk', 'claudeai-proxy']);
+function entryView(entry) {
+    try {
+        if (!isRecord(entry))
+            return Object.freeze({ transport: 'unreadable' });
+        const t = own(entry, 'type');
+        if (t !== undefined && t !== 'stdio' && t !== 'http')
+            return Object.freeze({ transport: 'unsupported', declaredType: typeof t === 'string' ? label(t) : 'unknown' });
+        if (t === 'http' || (t === undefined && typeof own(entry, 'url') === 'string' && own(entry, 'command') === undefined)) {
+            const url = own(entry, 'url');
+            const helper = own(entry, 'headersHelper');
+            const oauth = own(entry, 'oauth');
+            const cid = isRecord(oauth) ? own(oauth, 'clientId') : undefined;
+            const port = isRecord(oauth) ? own(oauth, 'callbackPort') : undefined;
+            const headers = membersOf(own(entry, 'headers'));
+            if (headers === undefined)
+                return Object.freeze({ transport: 'unreadable' });
+            return Object.freeze({
+                transport: 'http',
+                url: typeof url === 'string' ? capForDisplay(displayConfiguredUrl(url), TEXT_MAX) : '',
+                headers: Object.freeze(headers),
+                headersHelper: typeof helper === 'string' ? Object.freeze(argsView([helper])) : null,
+                oauth: isRecord(oauth) ? Object.freeze({ clientId: typeof cid === 'string' ? label(cid) : null, callbackPort: typeof port === 'number' && Number.isInteger(port) ? port : null }) : null,
+                allowTools: allowToolsView(entry),
+            });
+        }
+        if (typeof t === 'string' && REMOTE_TYPES.has(t))
+            return Object.freeze({ transport: 'unsupported', declaredType: label(t) });
+        const cmd = own(entry, 'command');
+        const env = membersOf(own(entry, 'env'));
+        if (env === undefined)
+            return Object.freeze({ transport: 'unreadable' });
+        return Object.freeze({ transport: 'stdio', command: typeof cmd === 'string' ? text(cmd) : '', args: Object.freeze(argsView(own(entry, 'args'))), env: Object.freeze(env), allowTools: allowToolsView(entry) });
+    }
+    catch {
+        return Object.freeze({ transport: 'unreadable' });
+    }
+}
+const problemView = (p) => Object.freeze({ reason: String(p.reason), path: typeof p.path === 'string' ? text(p.path) : null, sentence: text(String(p.notice)) });
+const WITHHELD_KEYS = Object.freeze({
+    narrowing_conflict: 'config.mcpServers.withheld.narrowingConflict',
+    narrowing_invalid: 'config.mcpServers.withheld.narrowingInvalid',
+    layer_unreadable: 'config.mcpServers.withheld.layerUnreadable',
+    policy_locked: 'config.mcpServers.withheld.policyLocked',
+});
+function rowView(row, deployment, lang) {
+    const withheldBy = typeof row.withheldBy === 'string' ? row.withheldBy : null;
+    return Object.freeze({
+        name: String(row.name),
+        label: label(String(row.name)),
+        scope: String(row.scope),
+        shadows: Object.freeze([...row.shadows].map(String)),
+        state: String(row.state),
+        withheldBy,
+        approvedBy: typeof row.approvedBy === 'string' ? row.approvedBy : null,
+        writable: row.writable === true,
+        base: row.writable === true ? mcpRowBaseOf(row.origin.revision) : null,
+        deploymentWins: deployment.has(row.name),
+        missing: Object.freeze([...row.missing].map(label)),
+        entry: entryView(row.entry),
+        problems: Object.freeze(row.state === 'unusable' ? (row.problems ?? []).map(problemView) : []),
+        sentence: withheldBy !== null && Object.hasOwn(WITHHELD_KEYS, withheldBy) ? renderMessage(msg(WITHHELD_KEYS[withheldBy]), lang) : null,
+    });
+}
+function rowViewOrUndefined(row, deployment, lang) {
+    try {
+        return rowView(row, deployment, lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function mcpServerReportView(report, lang) {
+    const deployment = report.deployment.state === 'read' ? new Set(report.deployment.names) : new Set();
+    const rows = [];
+    for (const r of report.rows) {
+        const v = rowViewOrUndefined(r, deployment, lang);
+        if (v !== undefined)
+            rows.push(v);
+    }
+    return Object.freeze({
+        kind: 'mcp_servers',
+        rows: Object.freeze(rows),
+        unreadable: Object.freeze([...report.unreadable]),
+        locked: report.locked ?? null,
+        purpose: report.purpose,
+        approvalsWithheld: Object.freeze(report.approvalsWithheld.map((a) => Object.freeze({ layer: a.layer, cause: a.cause, sentence: renderMessage(msg('config.mcpServers.approvalsWithheld', { layer: a.layer }), lang) }))),
+        deployment: report.deployment.state === 'read' ? Object.freeze({ state: 'read', names: Object.freeze(report.deployment.names.map((n) => Object.freeze({ name: n, label: label(n) }))) }) : Object.freeze({ state: 'unknown', names: Object.freeze([]) }),
+        pluginRoster: report.pluginRoster,
+        promptsAndResources: 'not_yet',
+    });
+}
+const NOTICE_KEYS = Object.freeze({
+    shadowed_by: 'config.mcpServers.notice.shadowed',
+    endpoint_differs: 'config.mcpServers.notice.endpointDiffers',
+    deployment_wins: 'config.mcpServers.notice.deploymentWins',
+    env_missing: 'config.mcpServers.notice.envMissing',
+});
+export function mcpServerEditOutcomeView(outcome, lang) {
+    const r = outcome.receipt;
+    const refusal = outcome.refusal;
+    const d = refusal;
+    const strOrNull = (k) => (d !== undefined && typeof d[k] === 'string' ? d[k] : null);
+    const plan = outcome.plan;
+    const probe = outcome.probe === undefined ? null : outcome.probe.kind === 'spec' ? 'ready' : outcome.probe.why;
+    return Object.freeze({
+        receipt: r,
+        refusal: refusal === undefined
+            ? null
+            : Object.freeze({
+                refusal: refusal.refusal,
+                path: refusal.refusal === 'edit_malformed' && refusal.path !== null ? text(refusal.path) : null,
+                nameReason: strOrNull('nameReason'),
+                by: strOrNull('by'),
+                scope: strOrNull('scope'),
+                scopes: Object.freeze(refusal.refusal === 'ambiguous_scope' ? [...refusal.scopes] : []),
+                exhausted: refusal.refusal === 'name_taken' && refusal.exhausted,
+                why: strOrNull('why'),
+                problems: Object.freeze(refusal.refusal === 'mcp_entry_invalid' ? refusal.problems.map(problemView) : []),
+                env: Object.freeze(refusal.refusal === 'credentials_need_reentry' ? refusal.env.map(label) : []),
+                headers: Object.freeze(refusal.refusal === 'credentials_need_reentry' ? refusal.headers.map(label) : []),
+                args: Object.freeze(refusal.refusal === 'credentials_need_reentry' ? [...refusal.args] : []),
+            }),
+        plan: plan === undefined
+            ? null
+            : Object.freeze({
+                op: plan.op,
+                name: plan.name,
+                label: label(plan.name),
+                scope: plan.scope ?? null,
+                renamedFrom: plan.renamedFrom ?? null,
+                replaced: plan.replaced === true,
+                imported: Object.freeze((plan.imported ?? []).map((x) => Object.freeze({ name: x.name, label: label(x.name), renamedFrom: x.renamedFrom ?? null }))),
+                skipped: Object.freeze((plan.skipped ?? []).map((x) => Object.freeze({ name: x.name, label: label(x.name), reason: x.reason }))),
+            }),
+        notices: Object.freeze(outcome.notices.map((n) => {
+            const scope = n.kind === 'shadowed_by' || n.kind === 'endpoint_differs' ? n.scope : null;
+            const names = n.kind === 'env_missing' ? n.names.map(label) : [];
+            return Object.freeze({ kind: n.kind, scope, names: Object.freeze(names), sentence: renderMessage(msg(NOTICE_KEYS[n.kind], { scope: scope ?? '', names: names.join(', ') }), lang) });
+        })),
+        probe,
+        sentence: localConfigReceiptSentence(r, lang),
+    });
+}
+export function mcpServerEditSentence(outcome, lang) {
+    try {
+        return localConfigReceiptSentence(outcome.receipt, lang);
+    }
+    catch {
+        return localConfigReceiptSentence({ kind: 'refused', reason: 'not_written' }, lang);
+    }
+}
+const authorizationCopy = (a) => Object.freeze({ reason: a.reason, ...(a.authorizeUrl === undefined ? {} : { authorizeUrl: a.authorizeUrl }), ...(a.resourceMetadataUrl === undefined ? {} : { resourceMetadataUrl: a.resourceMetadataUrl }) });
+const PROBE_NONE_KEYS = Object.freeze({
+    removed: 'config.mcpServers.probe.removed',
+    not_active: 'config.mcpServers.probe.notActive',
+    env_missing: 'config.mcpServers.probe.envMissing',
+    edit_refused: 'config.mcpServers.probe.editRefusal',
+});
+export async function probeMcpServerEdit(edit, store, ctx, facade, capability, lang) {
+    try {
+        const target = await mcpServerProbeTargetOf(edit, store, ctx);
+        if (target.kind === 'unavailable')
+            return Object.freeze({ kind: 'not_probed', why: 'unavailable', sentence: localConfigReceiptSentence(target, lang) });
+        if (target.kind === 'refused')
+            return Object.freeze({ kind: 'not_probed', why: 'edit_refused', sentence: renderMessage(msg('config.mcpServers.probe.editRefusal'), lang) });
+        if (target.kind === 'none')
+            return Object.freeze({ kind: 'not_probed', why: target.why, sentence: renderMessage(msg(PROBE_NONE_KEYS[target.why]), lang) });
+        const spec = target.spec;
+        const out = await probeMcpServers(facade, { specs: [spec], capability });
+        if (out.status === 'face')
+            return Object.freeze({
+                kind: 'face',
+                probedAt: String(out.face.probedAt),
+                servers: Object.freeze(out.face.servers.map((s) => Object.freeze({
+                    name: String(s.name),
+                    label: label(String(s.name)),
+                    status: String(s.status),
+                    errorCode: typeof s.errorCode === 'string' ? s.errorCode : null,
+                    toolCount: typeof s.toolCount === 'number' && Number.isFinite(s.toolCount) ? s.toolCount : null,
+                    authorization: s.authorizationUnreadable === true ? 'unreadable' : s.authorization === undefined ? null : authorizationCopy(s.authorization),
+                }))),
+            });
+        if (out.status === 'refused')
+            return Object.freeze({ kind: 'refused', cause: out.cause, sentence: text(out.message) });
+        return Object.freeze({ kind: 'unknown', why: out.why, sentence: text(out.message) });
+    }
+    catch {
+        return Object.freeze({ kind: 'not_probed', why: 'edit_refused', sentence: renderMessage(msg('config.mcpServers.probe.editRefusal'), lang) });
+    }
+}
+const fail = (reason, field) => (field === undefined ? { reason } : { reason, field });
+const str = (v, at) => (typeof v === 'string' ? true : fail('must be a string', at));
+const bool = (v, at) => (typeof v === 'boolean' ? true : fail('must be a boolean', at));
+const nullable = (r) => (v, at) => v === null ? true : r(v, at);
+const oneOf = (words) => (v, at) => typeof v === 'string' && words.includes(v) ? true : fail(`must be one of ${words.join('|')}`, at);
+const int = (v, at) => (typeof v === 'number' && Number.isInteger(v) && v >= 0 ? true : fail('must be a non-negative integer', at));
+const list = (r) => (v, at) => {
+    if (!Array.isArray(v))
+        return fail('must be an array', at);
+    for (let i = 0; i < v.length; i++) {
+        const d = Object.getOwnPropertyDescriptor(v, String(i));
+        if (d === undefined || !Object.hasOwn(d, 'value'))
+            return fail('sparse or accessor element', `${at}[${i}]`);
+        const x = r(d.value, `${at}[${i}]`);
+        if (x !== true)
+            return x;
+    }
+    return true;
+};
+const shape = (spec) => (v, at) => {
+    if (!isRecord(v))
+        return fail('must be a plain object', at);
+    const keys = Object.keys(v);
+    for (const k of keys)
+        if (!Object.hasOwn(spec, k))
+            return fail(`unknown key ${k}`, at === '' ? k : `${at}.${k}`);
+    for (const k of Object.keys(spec)) {
+        const d = Object.getOwnPropertyDescriptor(v, k);
+        const p = at === '' ? k : `${at}.${k}`;
+        if (d === undefined)
+            return fail('missing key', p);
+        if (!Object.hasOwn(d, 'value'))
+            return fail('accessor', p);
+        const x = spec[k](d.value, p);
+        if (x !== true)
+            return x;
+    }
+    return true;
+};
+const arms = (key, table) => (v, at) => {
+    const w = own(v, key);
+    if (typeof w !== 'string' || !Object.hasOwn(table, w))
+        return fail(`${key} must be one of ${Object.keys(table).join('|')}`, at === '' ? key : `${at}.${key}`);
+    return table[w](v, at);
+};
+const ARG = arms('kind', { text: shape({ kind: str, text: str }), masked: shape({ kind: str }) });
+const MEMBER = shape({ name: str, hasValue: bool });
+const AUTHORIZATION = (v, at) => {
+    if (!isRecord(v))
+        return fail('must be a plain object', at);
+    for (const k of Object.keys(v))
+        if (k !== 'reason' && k !== 'authorizeUrl' && k !== 'resourceMetadataUrl')
+            return fail(`unknown key ${k}`, `${at}.${k}`);
+    for (const k of ['reason', 'authorizeUrl', 'resourceMetadataUrl']) {
+        const d = Object.getOwnPropertyDescriptor(v, k);
+        if (d === undefined) {
+            if (k === 'reason')
+                return fail('missing key', `${at}.${k}`);
+            continue;
+        }
+        if (!Object.hasOwn(d, 'value'))
+            return fail('accessor', `${at}.${k}`);
+        if (typeof d.value !== 'string' || d.value === '')
+            return fail('must be a non-empty string', `${at}.${k}`);
+    }
+    return true;
+};
+const ALLOW = (v, at) => (v === null || v === 'invalid' ? true : list(str)(v, at));
+const ENTRY = arms('transport', {
+    stdio: shape({ transport: str, command: str, args: list(ARG), env: list(MEMBER), allowTools: ALLOW }),
+    http: shape({ transport: str, url: str, headers: list(MEMBER), headersHelper: nullable(list(ARG)), oauth: nullable(shape({ clientId: nullable(str), callbackPort: nullable(int) })), allowTools: ALLOW }),
+    unsupported: shape({ transport: str, declaredType: str }),
+    unreadable: shape({ transport: str }),
+});
+const PROBLEM = shape({ reason: str, path: nullable(str), sentence: str });
+const SCOPE_WORDS = Object.freeze([...MCP_SERVER_SCOPES, 'managed', 'enterprise', 'claudeai', 'plugin', 'agent', 'dynamic']);
+const ROW = shape({
+    name: str,
+    label: str,
+    scope: oneOf(SCOPE_WORDS),
+    shadows: list(oneOf(SCOPE_WORDS)),
+    state: oneOf(MCP_SERVER_ROW_STATES),
+    withheldBy: nullable(oneOf(MCP_SERVER_WITHHELD_CAUSES)),
+    approvedBy: nullable(oneOf(['settings', 'session', 'bypass', 'non_interactive'])),
+    writable: bool,
+    base: nullable(str),
+    deploymentWins: bool,
+    missing: list(str),
+    entry: ENTRY,
+    problems: list(PROBLEM),
+    sentence: nullable(str),
+});
+const REPORT = shape({
+    kind: oneOf(['mcp_servers']),
+    rows: list(ROW),
+    unreadable: list(oneOf(['global', 'project', 'enterprise', 'managed', 'supplementary'])),
+    locked: nullable(oneOf(['enterprise_config', 'plugin_only'])),
+    purpose: oneOf(['report', 'load']),
+    approvalsWithheld: list(shape({ layer: oneOf(['projectSettings', 'localSettings']), cause: oneOf(['trust_withheld']), sentence: str })),
+    deployment: arms('state', { unknown: shape({ state: str, names: (v, at) => (Array.isArray(v) && v.length === 0 ? true : fail('must be empty', at)) }), read: shape({ state: str, names: list(shape({ name: str, label: str })) }) }),
+    pluginRoster: oneOf(['host_supplied', 'absent']),
+    promptsAndResources: oneOf(['not_yet']),
+});
+const RECEIPT = (v, at) => localConfigReceiptShapeOf(v, at);
+const OUTCOME_SHAPE = shape({
+    receipt: RECEIPT,
+    refusal: nullable(shape({ refusal: str, path: nullable(str), nameReason: nullable(str), by: nullable(str), scope: nullable(str), scopes: list(oneOf(MCP_SERVER_SCOPES)), exhausted: bool, why: nullable(str), problems: list(PROBLEM), env: list(str), headers: list(str), args: list(int) })),
+    plan: nullable(shape({
+        op: oneOf(MCP_SERVER_EDIT_OPS),
+        name: str,
+        label: str,
+        scope: nullable(oneOf(MCP_SERVER_SCOPES)),
+        renamedFrom: nullable(str),
+        replaced: bool,
+        imported: list(shape({ name: str, label: str, renamedFrom: nullable(str) })),
+        skipped: list(shape({ name: str, label: str, reason: str })),
+    })),
+    notices: list(shape({ kind: oneOf(['shadowed_by', 'endpoint_differs', 'deployment_wins', 'env_missing']), scope: nullable(str), names: list(str), sentence: str })),
+    probe: nullable(oneOf(['ready', 'removed', 'not_active', 'env_missing', 'edit_refused'])),
+    sentence: str,
+});
+const OUTCOME = (v, at) => {
+    const verdict = OUTCOME_SHAPE(v, at);
+    if (verdict !== true)
+        return verdict;
+    const refusal = own(v, 'refusal');
+    if (refusal === null)
+        return true;
+    const receipt = own(v, 'receipt');
+    const word = own(refusal, 'refusal');
+    return own(receipt, 'kind') === 'refused' && typeof word === 'string' && refusalReasonOf(word) === own(receipt, 'reason') ? true : fail('refusal mismatch', at === '' ? 'refusal' : `${at}.refusal`);
+};
+const PROBE = arms('kind', {
+    face: shape({
+        kind: str,
+        probedAt: str,
+        servers: list(shape({
+            name: str,
+            label: str,
+            status: str,
+            errorCode: nullable(str),
+            toolCount: nullable((v, at) => (typeof v === 'number' && Number.isFinite(v) ? true : fail('must be a finite number', at))),
+            authorization: (v, at) => (v === null || v === 'unreadable' ? true : AUTHORIZATION(v, at)),
+        })),
+    }),
+    refused: shape({ kind: str, cause: oneOf(MCP_PROBE_REFUSAL_CAUSES), sentence: str }),
+    unknown: shape({ kind: str, why: oneOf(MCP_PROBE_UNKNOWN_WHYS), sentence: str }),
+    not_probed: shape({ kind: str, why: oneOf(['removed', 'not_active', 'env_missing', 'edit_refused', 'unavailable']), sentence: str }),
+});
+const guarded = (r) => (v) => {
+    try {
+        return r(v, '');
+    }
+    catch {
+        return fail('payload could not be read');
+    }
+};
+export const checkMcpServerReportView = guarded(REPORT);
+export const checkMcpServerEditOutcomeView = guarded(OUTCOME);
+export const checkMcpServerProbeView = guarded(PROBE);
+export function checkMcpServerEditRequest(v) {
+    try {
+        if (!isRecord(v))
+            return fail('request must be a plain object');
+        for (const k of Object.keys(v))
+            if (k !== 'sessionId' && k !== 'edit' && k !== 'dryRun')
+                return fail(`unknown key ${k}`, k);
+        const sid = own(v, 'sessionId');
+        if (sid !== undefined && (typeof sid !== 'string' || sid === ''))
+            return fail('sessionId must be a non-empty string', 'sessionId');
+        const dry = own(v, 'dryRun');
+        if (dry !== undefined && dry !== true)
+            return fail('dryRun must be true when present', 'dryRun');
+        const s = shapeMcpServerEdit(own(v, 'edit'));
+        return s.ok ? true : fail('edit is not a valid MCP server edit', s.path === null ? 'edit' : `edit.${s.path}`);
+    }
+    catch {
+        return fail('request could not be read');
+    }
+}