praxis-agent 0.7.0 → 0.9.0

package/dist/mcp/claude-mcp-management.js

@@ -1,31 +1,92 @@
-import { readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { mkdir, open, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
 import { writeFileAtomically } from '../platform/atomic-write.js';
+import { ExclusiveFileLease, } from '../platform/exclusive-file-lease.js';
 import { loadClaudeSharedResources, resolveClaudeProjectIdentity, } from '../compatibility/claude/shared-resources.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-async function readJson(path) {
-    let source;
+export function filterDisabledMcpResources(resources, disabledNames) {
+    if (disabledNames.length === 0)
+        return resources;
+    const disabled = new Set(disabledNames);
+    return resources.map((resource) => {
+        if (!isRecord(resource.value) || !isRecord(resource.value.mcpServers)) {
+            return resource;
+        }
+        return {
+            ...resource,
+            value: {
+                ...resource.value,
+                mcpServers: Object.fromEntries(Object.entries(resource.value.mcpServers).filter(([name]) => !disabled.has(name))),
+            },
+        };
+    });
+}
+async function readJsonSource(path, rejectSymlinks = true) {
+    let handle;
     try {
-        source = await readFile(path, 'utf8');
+        handle = await open(path, constants.O_RDONLY | (rejectSymlinks ? constants.O_NOFOLLOW : 0));
+        const before = await handle.stat();
+        const source = await handle.readFile('utf8');
+        const after = await handle.stat();
+        if (before.dev !== after.dev ||
+            before.ino !== after.ino ||
+            before.size !== after.size ||
+            before.mtimeMs !== after.mtimeMs) {
+            throw new Error(`MCP config changed while reading: ${path}`);
+        }
+        let value;
+        try {
+            value = JSON.parse(source);
+        }
+        catch (error) {
+            throw new Error(`Invalid MCP config JSON: ${path}`, { cause: error });
+        }
+        if (!isRecord(value))
+            throw new Error(`MCP config must be an object: ${path}`);
+        return {
+            value,
+            fingerprint: {
+                source,
+                device: after.dev,
+                inode: after.ino,
+                size: after.size,
+                modifiedMs: after.mtimeMs,
+            },
+        };
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            return {};
+            return { value: {} };
+        if (error.code === 'ELOOP') {
+            throw new Error(`MCP config must not be a symbolic link: ${path}`, {
+                cause: error,
+            });
+        }
         throw error;
     }
-    let value;
-    try {
-        value = JSON.parse(source);
+    finally {
+        await handle?.close();
     }
-    catch (error) {
-        throw new Error(`Invalid MCP config JSON: ${path}`, { cause: error });
+}
+async function sourceUnchanged(path, fingerprint) {
+    const current = await readJsonSource(path, true);
+    if (!fingerprint || !current.fingerprint) {
+        return fingerprint === current.fingerprint;
     }
-    if (!isRecord(value))
-        throw new Error(`MCP config must be an object: ${path}`);
-    return value;
+    return (current.fingerprint.source === fingerprint.source &&
+        current.fingerprint.device === fingerprint.device &&
+        current.fingerprint.inode === fingerprint.inode &&
+        current.fingerprint.size === fingerprint.size &&
+        current.fingerprint.modifiedMs === fingerprint.modifiedMs);
+}
+async function canonicalTarget(path) {
+    await mkdir(dirname(path), { recursive: true });
+    return join(await realpath(dirname(path)), basename(path));
 }
 function serverMap(value, path) {
     const servers = value.mcpServers;
@@ -58,19 +119,66 @@ function setScopedValue(root, target, value) {
     projects[target.projectIdentity] = value;
     root.projects = projects;
 }
-async function writeJson(path, value) {
-    const committed = await writeFileAtomically(path, `${JSON.stringify(value, null, 2)}\n`);
-    if (!committed)
-        throw new Error(`MCP config write was interrupted: ${path}`);
+async function mutateJson(path, mutate, beforeCommit) {
+    path = await canonicalTarget(path);
+    const lease = new ExclusiveFileLease(`${path}.praxis.lock`);
+    let handle = null;
+    for (let attempt = 0; attempt < 400; attempt += 1) {
+        handle = await lease.tryAcquire();
+        if (handle)
+            break;
+        await setTimeout(5);
+    }
+    if (!handle)
+        throw new Error(`MCP config write lock timed out: ${path}`);
+    try {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const { value, fingerprint } = await readJsonSource(path, true);
+            const next = mutate(value);
+            if (!next)
+                return;
+            await beforeCommit?.(path, attempt);
+            const committed = await writeFileAtomically(path, `${JSON.stringify(next, null, 2)}\n`, { beforeCommit: () => sourceUnchanged(path, fingerprint) });
+            if (committed)
+                return;
+        }
+        throw new Error(`MCP config changed concurrently: ${path}`);
+    }
+    finally {
+        await handle.release();
+    }
+}
+function projectState(root, identity, path) {
+    if (root.projects !== undefined && !isRecord(root.projects)) {
+        throw new Error(`MCP config projects must be an object: ${path}`);
+    }
+    const projects = root.projects;
+    const project = projects?.[identity];
+    if (project !== undefined && !isRecord(project)) {
+        throw new Error(`MCP project state must be an object: ${path}`);
+    }
+    return project ? { ...project } : {};
+}
+function disabledServerNames(project, path) {
+    const disabled = project.disabledMcpServers;
+    if (disabled === undefined)
+        return [];
+    if (!Array.isArray(disabled) ||
+        disabled.some((name) => typeof name !== 'string')) {
+        throw new Error(`disabledMcpServers must be a string array: ${path}`);
+    }
+    return [...disabled];
 }
 export class ClaudeMcpManagement {
     configRoot;
     cwd;
+    beforeCommit;
     constructor(options) {
         this.configRoot = resolve(options.configRoot ??
             process.env.CLAUDE_CONFIG_DIR ??
             join(homedir(), '.claude'));
         this.cwd = resolve(options.cwd);
+        this.beforeCommit = options.beforeCommit;
     }
     async list(scope) {
         const resources = await loadClaudeSharedResources({
@@ -104,13 +212,16 @@ export class ClaudeMcpManagement {
         if (!isRecord(config))
             throw new Error('MCP server config must be an object');
         const target = await this.target(scope);
-        const root = await readJson(target.path);
-        const scoped = scopedValue(root, target);
-        const servers = serverMap(scoped, target.path);
-        servers[name] = config;
-        setServerMap(scoped, servers);
-        setScopedValue(root, target, scoped);
-        await writeJson(target.path, root);
+        await mutateJson(target.path, (root) => {
+            const scoped = { ...scopedValue(root, target) };
+            const servers = { ...serverMap(scoped, target.path), [name]: config };
+            setServerMap(scoped, servers);
+            if (!target.projectIdentity)
+                return scoped;
+            const next = { ...root };
+            setScopedValue(next, target, scoped);
+            return next;
+        }, this.beforeCommit);
         return { name, scope, path: target.path, config };
     }
     async remove(name, scope) {
@@ -118,31 +229,67 @@ export class ClaudeMcpManagement {
         const scopes = scope ? [scope] : ['local', 'project', 'user'];
         for (const candidate of scopes) {
             const target = await this.target(candidate);
-            const root = await readJson(target.path);
-            const scoped = scopedValue(root, target);
-            const servers = serverMap(scoped, target.path);
-            const config = servers[name];
-            if (!config)
-                continue;
-            delete servers[name];
-            setServerMap(scoped, servers);
-            setScopedValue(root, target, scoped);
-            await writeJson(target.path, root);
-            return { name, scope: candidate, path: target.path, config };
+            let removed;
+            await mutateJson(target.path, (root) => {
+                const scoped = { ...scopedValue(root, target) };
+                const servers = { ...serverMap(scoped, target.path) };
+                removed = servers[name];
+                if (!removed)
+                    return undefined;
+                delete servers[name];
+                setServerMap(scoped, servers);
+                if (!target.projectIdentity)
+                    return scoped;
+                const next = { ...root };
+                setScopedValue(next, target, scoped);
+                return next;
+            }, this.beforeCommit);
+            if (removed)
+                return { name, scope: candidate, path: target.path, config: removed };
         }
         throw new Error(`MCP server not found: ${name}`);
     }
     async resetProjectChoices() {
         const path = join(this.configRoot, '.claude.json');
-        const root = await readJson(path);
         const identity = await resolveClaudeProjectIdentity({ cwd: this.cwd });
-        const projects = isRecord(root.projects) ? root.projects : {};
-        const project = isRecord(projects[identity]) ? projects[identity] : {};
-        project.enabledMcpjsonServers = [];
-        project.disabledMcpjsonServers = [];
-        projects[identity] = project;
-        root.projects = projects;
-        await writeJson(path, root);
+        await mutateJson(path, (root) => {
+            const projects = isRecord(root.projects) ? { ...root.projects } : {};
+            const project = isRecord(projects[identity]) ? projects[identity] : {};
+            projects[identity] = {
+                ...project,
+                enabledMcpjsonServers: [],
+                disabledMcpjsonServers: [],
+            };
+            return { ...root, projects };
+        }, this.beforeCommit);
+    }
+    async disabled() {
+        const path = join(this.configRoot, '.claude.json');
+        const identity = await resolveClaudeProjectIdentity({ cwd: this.cwd });
+        const root = (await readJsonSource(path, true)).value;
+        return disabledServerNames(projectState(root, identity, path), path);
+    }
+    async setEnabled(name, scope, enabled) {
+        this.validateName(name);
+        await this.get(name, scope);
+        const path = join(this.configRoot, '.claude.json');
+        const identity = await resolveClaudeProjectIdentity({ cwd: this.cwd });
+        await mutateJson(path, (root) => {
+            const project = projectState(root, identity, path);
+            const disabled = disabledServerNames(project, path);
+            const next = enabled
+                ? disabled.filter((candidate) => candidate !== name)
+                : disabled.includes(name)
+                    ? disabled
+                    : [...disabled, name];
+            if (next.length === disabled.length &&
+                next.every((candidate, index) => candidate === disabled[index])) {
+                return undefined;
+            }
+            const projects = isRecord(root.projects) ? { ...root.projects } : {};
+            projects[identity] = { ...project, disabledMcpServers: next };
+            return { ...root, projects };
+        }, this.beforeCommit);
     }
     async target(scope) {
         if (scope === 'project')

package/dist/mcp/claude-mcp-oauth.js

@@ -74,6 +74,7 @@ function stableServerConfig(server) {
 }
 export function mcpOAuthRecordKey(server) {
     const digest = createHash('sha256')
+        // codeql[js/insufficient-password-hash] deterministic key derivation, not password storage
         .update(stableServerConfig(server))
         .digest('hex')
         .slice(0, 16);
@@ -85,6 +86,7 @@ export function mcpOAuthCredentialService(configRoot) {
     if (canonical === defaultRoot)
         return CREDENTIAL_SERVICE;
     const digest = createHash('sha256')
+        // codeql[js/insufficient-password-hash] keychain service name from config path, not secret hashing
         .update(canonical)
         .digest('hex')
         .slice(0, 8);

package/dist/mcp/claude-mcp-tools.d.ts

@@ -18,7 +18,25 @@ export interface ClaudeMcpPromptDefinition {
 }
 export interface ClaudeMcpServerStatus {
     name: string;
-    status: 'connected' | 'failed';
+    status: 'connected' | 'failed' | 'needs-authentication';
+    statusDetail?: string;
+    authDetail?: string;
+    capabilities?: readonly ('tools' | 'resources' | 'prompts')[];
+    toolCount?: number;
+}
+export interface ClaudeMcpToolInspection {
+    name: string;
+    fullName: string;
+    description?: string;
+}
+export interface ClaudeMcpRuntime {
+    inspect(): Promise<readonly ClaudeMcpServerStatus[]>;
+    reconnect(name: string): Promise<void>;
+    authenticate(name: string): Promise<void>;
+    reload(): Promise<void>;
+    tools(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
+    /** Release MCP transports and child processes owned by this runtime. */
+    close?(): Promise<void>;
 }
 export interface ClaudeMcpConfigurationStatus {
     name: string;
@@ -40,6 +58,8 @@ export interface ClaudeMcpToolRegistryOptions {
     signal?: AbortSignal;
     eventSink?: RuntimeEventSink;
     onPromptsChanged?: (prompts: readonly ClaudeMcpPromptDefinition[]) => void;
+    authenticateServer?: (name: string) => Promise<void>;
+    reloadResources?: () => Promise<readonly ClaudeJsonResource[]>;
     onElicitation?: (request: {
         serverName: string;
         message: ElicitRequest['params']['message'];
@@ -53,9 +73,9 @@ export interface ClaudeMcpToolRegistryOptions {
     }>;
 }
 export declare function validateClaudeMcpConfiguration(resources: readonly ClaudeJsonResource[]): ClaudeMcpConfigurationReport;
-export declare class ClaudeMcpToolRegistry implements ToolRegistry {
+export declare class ClaudeMcpToolRegistry implements ToolRegistry, ClaudeMcpRuntime {
     private readonly options;
-    private readonly tools;
+    private readonly connectedTools;
     private readonly reservedTools;
     private readonly resourceServers;
     private readonly promptServers;
@@ -63,6 +83,7 @@ export declare class ClaudeMcpToolRegistry implements ToolRegistry {
     private readonly clients;
     private readonly serverClients;
     private readonly reconnectableServers;
+    private readonly serverCapabilities;
     private readonly reconnectingServers;
     private readonly promptOperations;
     private promptResultDirectoryPromise;
@@ -73,6 +94,13 @@ export declare class ClaudeMcpToolRegistry implements ToolRegistry {
     static connect(options: ClaudeMcpToolRegistryOptions): Promise<ClaudeMcpToolRegistry>;
     definitions(): readonly ModelToolDefinition[];
     serverStatuses(): readonly ClaudeMcpServerStatus[];
+    inspect(): Promise<readonly ClaudeMcpServerStatus[]>;
+    reconnect(name: string): Promise<void>;
+    authenticate(name: string): Promise<void>;
+    reload(): Promise<void>;
+    tools(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
+    private runtimeStatuses;
+    private configure;
     prompts(): readonly ClaudeMcpPromptDefinition[];
     permissionPrompt(name: string): (call: ModelToolCall, originalCall?: ModelToolCall) => Promise<PermissionApproval>;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;

package/dist/mcp/claude-mcp-tools.js

@@ -641,7 +641,7 @@ async function resourceContent(server, result, context, sensitiveValues) {
 }
 export class ClaudeMcpToolRegistry {
     options;
-    tools = new Map();
+    connectedTools = new Map();
     reservedTools = new Set();
     resourceServers = new Map();
     promptServers = new Map();
@@ -649,6 +649,7 @@ export class ClaudeMcpToolRegistry {
     clients = new Set();
     serverClients = new Map();
     reconnectableServers = new Map();
+    serverCapabilities = new Map();
     reconnectingServers = new Map();
     promptOperations = new Set();
     promptResultDirectoryPromise;
@@ -663,26 +664,7 @@ export class ClaudeMcpToolRegistry {
         const ambientSensitiveValues = sensitiveEnvironmentValues(process.env);
         const warn = (message) => options.onWarning?.(redactSensitiveText(message, ambientSensitiveValues));
         try {
-            for (const server of configuredServers(options.resources, warn)) {
-                registry.statuses.set(server.name, {
-                    name: server.name,
-                    status: 'failed',
-                });
-                let config;
-                try {
-                    config = parseServerConfig(server.name, server.value, server.path);
-                }
-                catch (error) {
-                    warn(`MCP server ${server.name} unavailable: ${error instanceof Error ? error.message : String(error)}`);
-                    continue;
-                }
-                registry.reconnectableServers.set(server.name, {
-                    config,
-                    sensitiveValues: server.sensitiveValues ?? [],
-                });
-                await registry.connectServer(server.name, config, server.sensitiveValues);
-            }
-            registry.publishPrompts();
+            await registry.configure(options.resources, warn);
         }
         catch (error) {
             await registry.close();
@@ -693,14 +675,94 @@ export class ClaudeMcpToolRegistry {
     definitions() {
         return [
             ...this.options.base.definitions(),
-            ...[...this.tools.entries()]
+            ...[...this.connectedTools.entries()]
                 .filter(([name]) => !this.reservedTools.has(name))
                 .map(([, tool]) => tool.definition),
             ...(this.resourceServers.size > 0 ? MCP_RESOURCE_TOOL_DEFINITIONS : []),
         ];
     }
     serverStatuses() {
-        return [...this.statuses.values()];
+        return [...this.statuses.values()].map(({ name, status }) => ({
+            name,
+            status,
+        }));
+    }
+    async inspect() {
+        return this.runtimeStatuses();
+    }
+    async reconnect(name) {
+        await this.reconnectServer(name);
+    }
+    async authenticate(name) {
+        if (!this.statuses.has(name))
+            throw new Error(`Unknown MCP server ${name}`);
+        if (!this.options.authenticateServer) {
+            throw new Error('MCP authentication is not available in this runtime');
+        }
+        await this.options.authenticateServer(name);
+        await this.reconnectServer(name);
+    }
+    async reload() {
+        if (this.closed)
+            throw new Error('MCP registry is closed');
+        this.generation += 1;
+        const clients = [...this.serverClients.values()];
+        this.serverClients.clear();
+        await Promise.allSettled(clients.map((client) => client.close()));
+        for (const client of clients)
+            this.clients.delete(client);
+        this.connectedTools.clear();
+        this.reservedTools.clear();
+        this.resourceServers.clear();
+        this.promptServers.clear();
+        this.statuses.clear();
+        this.reconnectableServers.clear();
+        this.serverCapabilities.clear();
+        const ambientSensitiveValues = sensitiveEnvironmentValues(process.env);
+        const warn = (message) => this.options.onWarning?.(redactSensitiveText(message, ambientSensitiveValues));
+        await this.configure(this.options.reloadResources
+            ? await this.options.reloadResources()
+            : this.options.resources, warn);
+    }
+    async tools(name) {
+        if (!this.statuses.has(name))
+            throw new Error(`Unknown MCP server ${name}`);
+        return [...this.connectedTools.entries()]
+            .filter(([, tool]) => tool.serverName === name)
+            .map(([fullName, tool]) => ({
+            name: tool.toolName,
+            fullName,
+            ...(tool.definition.description
+                ? { description: tool.definition.description }
+                : {}),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    runtimeStatuses() {
+        return [...this.statuses.values()].map((status) => {
+            const capabilities = this.serverCapabilities.get(status.name) ?? [];
+            const toolCount = [...this.connectedTools.values()].filter((tool) => tool.serverName === status.name).length;
+            return { ...status, capabilities, toolCount };
+        });
+    }
+    async configure(resources, warn) {
+        for (const server of configuredServers(resources, warn)) {
+            this.statuses.set(server.name, { name: server.name, status: 'failed' });
+            let config;
+            try {
+                config = parseServerConfig(server.name, server.value, server.path);
+            }
+            catch (error) {
+                warn(`MCP server ${server.name} unavailable: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            this.reconnectableServers.set(server.name, {
+                config,
+                sensitiveValues: server.sensitiveValues ?? [],
+            });
+            await this.connectServer(server.name, config, server.sensitiveValues);
+        }
+        this.publishPrompts();
     }
     prompts() {
         const prompts = [];
@@ -722,13 +784,13 @@ export class ClaudeMcpToolRegistry {
         return prompts;
     }
     permissionPrompt(name) {
-        if (!this.tools.has(name)) {
-            const available = [...this.tools.keys()].join(', ') || 'none';
+        if (!this.connectedTools.has(name)) {
+            const available = [...this.connectedTools.keys()].join(', ') || 'none';
             throw new Error(`MCP tool ${name} (from --permission-prompt-tool) not found. Available MCP tools: ${available}`);
         }
         this.reservedTools.add(name);
         return async (call, originalCall = call) => {
-            const tool = this.tools.get(name);
+            const tool = this.connectedTools.get(name);
             if (!tool)
                 return invalidPermissionResult();
             let result;
@@ -758,7 +820,7 @@ export class ClaudeMcpToolRegistry {
         };
     }
     async prepare(call, context) {
-        return this.tools.has(call.name) ||
+        return this.connectedTools.has(call.name) ||
             MCP_RESOURCE_TOOL_DEFINITIONS.some((definition) => definition.name === call.name)
             ? call
             : this.options.base.prepare(call, context);
@@ -778,7 +840,7 @@ export class ClaudeMcpToolRegistry {
         if (call.name === 'ReadMcpResourceTool') {
             return this.readResource(call.input, context);
         }
-        const tool = this.tools.get(call.name);
+        const tool = this.connectedTools.get(call.name);
         if (!tool)
             return this.options.base.execute(call, context);
         let result;
@@ -898,6 +960,7 @@ export class ClaudeMcpToolRegistry {
             this.clients.delete(client);
             if (this.closed || this.serverClients.get(serverName) !== client)
                 return;
+            this.serverCapabilities.delete(serverName);
             this.statuses.set(serverName, { name: serverName, status: 'failed' });
         };
         client.setRequestHandler(ElicitRequestSchema, async (request) => {
@@ -952,7 +1015,7 @@ export class ClaudeMcpToolRegistry {
                 if (redactSensitiveText(name, sensitiveValues) !== name) {
                     throw new Error('MCP tool name contains sensitive data');
                 }
-                if (this.tools.has(name) || connectedTools.has(name)) {
+                if (this.connectedTools.has(name) || connectedTools.has(name)) {
                     throw new Error(`Duplicate MCP tool ${name}`);
                 }
                 connectedTools.set(name, {
@@ -969,8 +1032,13 @@ export class ClaudeMcpToolRegistry {
             }
             this.assertOpenGeneration(expectedGeneration);
             this.serverClients.set(serverName, client);
+            this.serverCapabilities.set(serverName, [
+                ...(capabilities?.tools ? ['tools'] : []),
+                ...(capabilities?.resources ? ['resources'] : []),
+                ...(capabilities?.prompts ? ['prompts'] : []),
+            ]);
             for (const [name, tool] of connectedTools)
-                this.tools.set(name, tool);
+                this.connectedTools.set(name, tool);
             if (capabilities?.resources) {
                 this.resourceServers.set(serverName, {
                     client,
@@ -990,7 +1058,11 @@ export class ClaudeMcpToolRegistry {
                     });
                 }
             }
-            this.statuses.set(serverName, { name: serverName, status: 'connected' });
+            this.statuses.set(serverName, {
+                name: serverName,
+                status: 'connected',
+                statusDetail: 'connected',
+            });
         }
         catch (error) {
             await client.close().catch(() => undefined);
@@ -999,7 +1071,15 @@ export class ClaudeMcpToolRegistry {
                 this.closed ||
                 expectedGeneration !== this.generation)
                 throw error;
-            this.options.onWarning?.(redactSensitiveText(`MCP server ${serverName} unavailable: ${error instanceof Error ? error.message : String(error)}`, sensitiveValues));
+            const detail = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues);
+            const needsAuthentication = /(?:401|unauthori[sz]ed|not authenticated|oauth|authentication required)/iu.test(detail);
+            this.statuses.set(serverName, {
+                name: serverName,
+                status: needsAuthentication ? 'needs-authentication' : 'failed',
+                statusDetail: detail,
+                ...(needsAuthentication ? { authDetail: `failed: ${detail}` } : {}),
+            });
+            this.options.onWarning?.(`MCP server ${serverName} unavailable: ${detail}`);
         }
     }
     async discoverTools(client, serverName, sensitiveValues) {
@@ -1202,11 +1282,13 @@ export class ClaudeMcpToolRegistry {
         if (previous)
             this.clients.delete(previous);
         this.assertOpenGeneration(expectedGeneration);
-        for (const [name, tool] of this.tools) {
+        for (const [name, tool] of this.connectedTools) {
             if (tool.serverName === serverName)
-                this.tools.delete(name);
+                this.connectedTools.delete(name);
         }
         this.resourceServers.delete(serverName);
+        this.promptServers.delete(serverName);
+        this.serverCapabilities.delete(serverName);
         await this.connectServer(serverName, reconnectable.config, reconnectable.sensitiveValues, expectedGeneration);
         if (this.statuses.get(serverName)?.status !== 'connected') {
             throw new Error(`MCP server ${serverName} could not reconnect`);

package/dist/permissions/claude-permission-resolver.d.ts

@@ -11,8 +11,10 @@ export interface ClaudePermissionResolverOptions {
     permissionMode?: ClaudePermissionMode;
     autoClassifier?: ClaudeAutoClassifier;
     autoModeConfig?: ClaudeAutoModeConfig;
+    isSessionActionApproved?: (call: ModelToolCall) => boolean;
 }
 export type ClaudePermissionMode = 'acceptEdits' | 'auto' | 'bypassPermissions' | 'manual' | 'dontAsk' | 'plan' | 'default';
+export declare function claudePermissionActionKey(call: ModelToolCall): string;
 export declare function validateClaudePermissionSettings(settings: readonly ClaudeJsonResource[]): void;
 export declare class ClaudePermissionResolver implements PermissionResolver {
     private readonly rules;
@@ -22,6 +24,7 @@ export declare class ClaudePermissionResolver implements PermissionResolver {
     private readonly permissionMode;
     private readonly autoClassifier;
     private readonly autoModeConfig;
+    private readonly isSessionActionApproved;
     constructor(options: ClaudePermissionResolverOptions);
     resolve(call: ModelToolCall, context?: PermissionResolutionContext): Promise<PermissionDecision>;
     private askDecision;