@agentxm/extension-lifecycle 0.28.4 → 0.28.6

package/dist/src/configured-entry-resolution.js

@@ -122,7 +122,9 @@ export const resolveConfiguredRegistryEntry = (name, source, expectedType, relea
             detail: `Configured ${expectedType} "${name}" uses a ${pluralType} Registry source`,
         });
     }
-    if (parsedPattern?.name !== undefined && parsedPattern.name !== name) {
+    if (expectedType !== "mcp-server" &&
+        parsedPattern?.name !== undefined &&
+        parsedPattern.name !== name) {
         return yield* new ExtensionLifecycleFailed({
             category: "validation",
             detail: `Configured ${expectedType} "${name}" points to Registry extension "${parsedPattern.name}"`,
@@ -136,13 +138,14 @@ export const resolveConfiguredRegistryEntry = (name, source, expectedType, relea
         });
     }
     const versionRange = Option.fromUndefinedOr(parsedPattern?.versionRange);
+    const registryName = expectedType === "mcp-server" ? (parsedPattern?.name ?? name) : name;
     const workspace = yield* WorkspaceMutations;
     const acceptedRef = yield* acceptedResolutionRef({
         workspace,
         type: expectedType,
         name,
     });
-    const accepted = Option.flatMap(acceptedRef, (ref) => ref.refType === "registry" && ref.owner === owner && ref.name === name
+    const accepted = Option.flatMap(acceptedRef, (ref) => ref.refType === "registry" && ref.owner === owner && ref.name === registryName
         ? Option.some({
             version: ref.version,
             publisherBindingId: ref.publisherBindingId,
@@ -150,7 +153,7 @@ export const resolveConfiguredRegistryEntry = (name, source, expectedType, relea
         : Option.none());
     const providers = yield* SourceHostProviders;
     const resolution = yield* providers.resolveNamedRegistry(resolvedSource, {
-        name,
+        name: registryName,
         type: expectedType,
         owner,
         versionRange,

package/dist/src/hooks/manager.js

@@ -11,7 +11,7 @@ import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
-import { HookConfigInvalid, HookDefinitionInvalid, HookInstallStateMissing, HookIoFailed, activeContributors, applyProjectionPlans, planAggregateProjection, runWithTransientFileBackup, reconcileManagedRegionFile, managedHookCommands, readManagedHookCommands, updateHooksJson, evaluateHookAgentOutcome, WriteBackupRetained, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
+import { HookConfigInvalid, HookDefinitionInvalid, HookInstallStateMissing, HookIoFailed, activeContributors, applyProjectionPlans, planAggregateProjection, runWithTransientFileBackup, reconcileManagedRegionFile, projectionGeneration, managedHookCommands, readManagedHookCommands, updateHooksJson, evaluateHookAgentOutcome, WriteBackupRetained, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
 import { AGENTS as CAPABILITY_AGENTS, installable, } from "@agentxm/extension-model/unstable/agent-capabilities";
 import { computePackageContentHash } from "@agentxm/workspace-state";
 import { computeMaterializedTreeIntegrity } from "@agentxm/workspace-state";
@@ -437,12 +437,25 @@ export const HookManagerLive = Layer.effect(HookManager, Effect.gen(function* ()
         const rendered = input.contributors
             .map((hook) => `### ${hook.manifest.title ?? hook.name}\n\nFor agents without a usable native hook mapping (${hook.fallbackAgentIds.join(", ")}), treat this as a managed advisory rule. After the matching lifecycle event (${hook.manifest.bindings.map((binding) => binding.on).join(", ")}), run \`${hook.command}\` and address any findings before continuing.`)
             .join("\n\n");
+        const generation = projectionGeneration([
+            "hook-fallback-region-v1",
+            target.workspaceRelative,
+            HOOK_FALLBACKS_REGION_OWNER,
+            ...input.contributors.flatMap((contributor) => [
+                contributor.name,
+                contributor.marker,
+                contributor.command,
+                JSON.stringify(contributor.fallbackAgentIds),
+                JSON.stringify(contributor.manifest),
+            ]),
+        ]);
         const { changed, observedRegion } = yield* provide(reconcileManagedRegionFile({
             targetPath: target.targetPath,
             displayPath: target.workspaceRelative,
             region: HOOK_FALLBACKS_REGION,
             owner: HOOK_FALLBACKS_REGION_OWNER,
             rendered,
+            generation,
             ...(options?.dryRun === undefined ? {} : { dryRun: options.dryRun }),
             unsupportedTargetDetail: `Hook fallback target does not support managed regions: ${target.workspaceRelative}`,
         }));
@@ -464,12 +477,6 @@ export const HookManagerLive = Layer.effect(HookManager, Effect.gen(function* ()
                 present: Option.isSome(observedRegion),
                 current: !changed,
                 expectedContributors: input.contributors.map(({ marker }) => marker),
-                observedContributors: Option.match(observedRegion, {
-                    onNone: () => [],
-                    onSome: (region) => input.contributors
-                        .filter(({ command }) => region.includes(command))
-                        .map(({ marker }) => marker),
-                }),
             },
         };
     });
@@ -532,11 +539,16 @@ export const HookManagerLive = Layer.effect(HookManager, Effect.gen(function* ()
                 .map(({ agentId }) => agentId);
             return fallbackAgentIds.length === 0 ? [] : [{ ...contributor, fallbackAgentIds }];
         });
-        const selectNative = (agentId) => () => Effect.succeed(contributors.filter((contributor) => outcomes.some((outcome) => outcome.name === contributor.name &&
-            outcome.agentId === agentId &&
-            outcome.mechanism === "native" &&
-            (outcome.outcome === "projected" || outcome.outcome === "current"))));
-        const selectFallback = () => Effect.succeed(fallbackContributors);
+        // Every reachable Hook contributor is decided from desired state
+        // alone, so hook units never exclude one.
+        const selectNative = (agentId) => () => Effect.succeed({
+            contributors: contributors.filter((contributor) => outcomes.some((outcome) => outcome.name === contributor.name &&
+                outcome.agentId === agentId &&
+                outcome.mechanism === "native" &&
+                (outcome.outcome === "projected" || outcome.outcome === "current"))),
+            exclusions: [],
+        });
+        const selectFallback = () => Effect.succeed({ contributors: fallbackContributors, exclusions: [] });
         const fallbackAgentIds = Array.from(new Set(fallbackContributors.flatMap(({ fallbackAgentIds }) => fallbackAgentIds)));
         const materialization = {
             agents: configuredAgents,

package/dist/src/index.d.ts

@@ -10,7 +10,6 @@
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, type LifecycleFailureAdapterService, } from "./failure-adapter.js";
-export { LifecycleResolutionProgress, type LifecycleResolutionProgressService, } from "./resolution-progress.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, type InstallExtensionCommandWorkflowActions, } from "./workflows/install-command/workflow.js";
@@ -20,10 +19,9 @@ export { ensureSkillAgentArtifact, removeSkillAgentArtifact } from "./skills/mat
 export { getSkillDisplayName } from "./skills/utils.js";
 export { computeSkillSourceHash, gitHostedSkillArtifactSource, installSkill, type InstallSkillOperation, type InstallSkillOperationArgs, } from "./skills/operations/install.js";
 export type { InstallResult } from "./skills/operations/install-result.js";
-export { uninstallSkill, type UninstallSkillOperation, type UninstallSkillOperationArgs, } from "./skills/operations/uninstall.js";
 export { enableSkill, type EnableSkillOperation } from "./skills/operations/enable.js";
 export { disableSkill, type DisableSkillOperation } from "./skills/operations/disable.js";
-export { installMcpServer, type InstallMcpServerOperation, type InstallMcpServerOperationArgs, } from "./mcps/operations/install.js";
+export { collectSecretInputNames, deleteMcpSecrets, installMcpServer, mcpSecretAccount, readMcpServerManifest, type InstallMcpServerOperation, type InstallMcpServerOperationArgs, } from "./mcps/operations/install.js";
 export { uninstallMcpServer, type UninstallMcpServerOperation, type UninstallMcpServerOperationArgs, } from "./mcps/operations/uninstall.js";
 export { enableMcpServer, type EnableMcpServerOperation } from "./mcps/operations/enable.js";
 export { disableMcpServer, type DisableMcpServerOperation } from "./mcps/operations/disable.js";

package/dist/src/index.js

@@ -10,7 +10,6 @@
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, } from "./failure-adapter.js";
-export { LifecycleResolutionProgress, } from "./resolution-progress.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, } from "./workflows/install-command/workflow.js";
@@ -20,11 +19,10 @@ export { materializeRegistryPackage, materializeRegistryPackageWithTreeIntegrity
 export { ensureSkillAgentArtifact, removeSkillAgentArtifact } from "./skills/materialization.js";
 export { getSkillDisplayName } from "./skills/utils.js";
 export { computeSkillSourceHash, gitHostedSkillArtifactSource, installSkill, } from "./skills/operations/install.js";
-export { uninstallSkill, } from "./skills/operations/uninstall.js";
 export { enableSkill } from "./skills/operations/enable.js";
 export { disableSkill } from "./skills/operations/disable.js";
 // MCP server lifecycle operations
-export { installMcpServer, } from "./mcps/operations/install.js";
+export { collectSecretInputNames, deleteMcpSecrets, installMcpServer, mcpSecretAccount, readMcpServerManifest, } from "./mcps/operations/install.js";
 export { uninstallMcpServer, } from "./mcps/operations/uninstall.js";
 export { enableMcpServer } from "./mcps/operations/enable.js";
 export { disableMcpServer } from "./mcps/operations/disable.js";

package/dist/src/knowledge/manager.js

@@ -11,7 +11,7 @@ import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Result from "effect/Result";
 import { PlatformError } from "effect/PlatformError";
-import { KnowledgeDefinitionInvalid, KnowledgeDesiredStateUnreconcilable, KnowledgeInstallStateMissing, KnowledgeIoFailed, KnowledgeObservableContractViolated, KnowledgeResolutionMissing, KnowledgeUnavailable, applyProjectionPlans, planAggregateProjection, requireCompleteGraph, KNOWLEDGE_REGION_OWNER, reconcileKnowledgeDiscovery, observedKnowledgeContributors, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
+import { KnowledgeDefinitionInvalid, KnowledgeDesiredStateUnreconcilable, KnowledgeInstallStateMissing, KnowledgeIoFailed, KnowledgeObservableContractViolated, KnowledgeResolutionMissing, KnowledgeUnavailable, applyProjectionPlans, formatProjectionExclusions, planAggregateProjection, requireCompleteGraph, KNOWLEDGE_REGION_OWNER, reconcileKnowledgeDiscovery, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
 import { canReuseInstalledPackage, materializeExternalPackage } from "@agentxm/extension-workspace";
 import { materializeRegistryPackage } from "../registry-materialization.js";
 import { computeExtensionPathsForLayout, extensionPathSourceFromLockEntry, } from "@agentxm/workspace-state";
@@ -299,21 +299,64 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
             .filter(isSourcedDesiredExtension)
             .filter((node) => node.type === "knowledge" && node.enabled))
         : new KnowledgeDesiredStateUnreconcilable()));
+    /**
+     * Classify a bundle whose package could not be inspected. Only the
+     * bundle's own content is in question here: resolution facts have already
+     * succeeded, so the two truthful answers are that the package is gone or
+     * that its content is invalid.
+     */
+    const excludedContributor = (name, root, failure) => Effect.gen(function* () {
+        const probe = yield* Effect.result(fs.exists(path.join(root, KNOWLEDGE_MANIFEST_FILENAME)));
+        const manifestPresent = Result.isSuccess(probe) && probe.success;
+        if (!manifestPresent)
+            return { contributor: name, reason: "package-missing" };
+        return {
+            contributor: name,
+            reason: "package-invalid",
+            detail: failure._tag === "KnowledgeDefinitionInvalid"
+                ? failure.detail
+                : adapter.describeFailure(failure),
+        };
+    });
+    /**
+     * Resolve the contributor set for the discovery region. A bundle that
+     * fails inspection cannot supply a row, so it is excluded and reported
+     * rather than failing every other bundle's command with it. Resolution
+     * failures — a missing lock entry, an unsupported workspace-authored
+     * bundle — remain fail-closed: they are AXM state problems, not bundle
+     * content problems.
+     */
     const selectKnowledgeBundles = (graph, locked, configured, config, instructionFilesEnabled) => Effect.forEach(graph.nodes.filter((node) => node.type === "knowledge" && node.enabled), (node) => Effect.gen(function* () {
         const root = yield* desiredCanonicalRoot(node, locked[node.name]);
-        const inspected = yield* inspectPackage(root);
         const workspaceInstructionEntry = configured[node.name]?.instructionEntry;
-        const resolution = resolveKnowledgeInstructionEntry({
+        const resolveInclusion = (manifestInstructionEntry) => resolveKnowledgeInstructionEntry({
             bundleEnabled: node.enabled,
             instructionFilesEnabled,
             knowledgeInstructionsEnabled: config.instructions,
             ...(workspaceInstructionEntry === undefined ? {} : { workspaceInstructionEntry }),
-            ...(inspected.manifest.instructionEntry === undefined
-                ? {}
-                : { manifestInstructionEntry: inspected.manifest.instructionEntry }),
+            ...(manifestInstructionEntry === undefined ? {} : { manifestInstructionEntry }),
         });
-        return resolution.included ? [toProjectionBundle(root, inspected)] : [];
-    })).pipe(Effect.map((bundles) => bundles.flat()));
+        const inspection = yield* Effect.result(inspectPackage(root));
+        if (Result.isFailure(inspection)) {
+            // A bundle the workspace would not publish anyway is simply
+            // absent from the region; reporting it would be noise.
+            return resolveInclusion().included
+                ? {
+                    contributors: [],
+                    exclusions: [yield* excludedContributor(node.name, root, inspection.failure)],
+                }
+                : { contributors: [], exclusions: [] };
+        }
+        const inspected = inspection.success;
+        const resolution = resolveInclusion(inspected.manifest.instructionEntry);
+        return {
+            contributors: resolution.included ? [toProjectionBundle(root, inspected)] : [],
+            exclusions: [],
+        };
+    })).pipe(Effect.map((selections) => ({
+        contributors: selections.flatMap(({ contributors }) => contributors),
+        exclusions: selections.flatMap(({ exclusions }) => exclusions),
+    })));
     const resolveKnowledgeProjection = () => Effect.gen(function* () {
         const graph = yield* ws.getDesiredStateGraph();
         const locked = yield* getKnowledgeLockEntries(ws);
@@ -351,10 +394,6 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
                     present: Option.isSome(result.observedRegion),
                     current: !result.changed,
                     expectedContributors: input.contributors.map(({ owner, name }) => `${owner}/knowledge/${name}`),
-                    observedContributors: Option.match(result.observedRegion, {
-                        onNone: () => [],
-                        onSome: observedKnowledgeContributors,
-                    }),
                 }))),
                 apply: (input) => runKnowledgeProjectionAdapter({
                     bundles: input.contributors,
@@ -366,12 +405,18 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
     });
     const projectionPlans = () => makeKnowledgeProjectionPlan().pipe(Effect.map((plan) => [plan]));
     const applyKnowledgeProjection = projectionPlans().pipe(Effect.flatMap(applyProjectionPlans));
-    const reconcileDiscovery = (options) => resolveKnowledgeProjection().pipe(Effect.flatMap(({ graph, locked, configured, config, instructionsTarget }) => requireCompleteGraph(graph).pipe(Effect.flatMap((completeGraph) => selectKnowledgeBundles(completeGraph, locked, configured, config, instructionsTarget.enabled)), Effect.flatMap((bundles) => runKnowledgeProjectionAdapter({
-        bundles,
+    const reconcileDiscovery = (options) => resolveKnowledgeProjection().pipe(Effect.flatMap(({ graph, locked, configured, config, instructionsTarget }) => requireCompleteGraph(graph).pipe(Effect.flatMap((completeGraph) => selectKnowledgeBundles(completeGraph, locked, configured, config, instructionsTarget.enabled)), Effect.flatMap(({ contributors, exclusions }) => runKnowledgeProjectionAdapter({
+        bundles: contributors,
         config,
         instructionsTarget,
         ...(options?.dryRun === undefined ? {} : { dryRun: options.dryRun }),
-    })))));
+    }).pipe(Effect.map((result) => ({
+        ...result,
+        warnings: formatProjectionExclusions({
+            exclusions,
+            targetFile: instructionsTarget.path,
+        }),
+    })))))));
     const buildLockEntry = (ref) => Effect.gen(function* () {
         const state = lastInstallState.get(ref.knowledge.name);
         switch (ref.refType) {
@@ -491,7 +536,7 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
         const discovery = discovered.success;
         return {
             changed: prepared.length > 0 || discovery.changed,
-            warnings: [],
+            warnings: discovery.warnings,
             artifacts: discovery.artifacts,
         };
     });

package/dist/src/mcps/manager.js

@@ -15,7 +15,7 @@ import * as Option from "effect/Option";
 import { McpConfigIoFailed, McpInstallStateMissing, McpRegistryOnlyInstall, removeMcpServerFromManifest, applyProjectionPlans, planSingletonProjection, } from "@agentxm/extension-workspace";
 import { McpServerManager } from "@agentxm/extension-workspace";
 import { configuredMcpServersToDiskRefs } from "@agentxm/extension-workspace";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { mcpRegistryResolutionKey, WorkspaceMutations } from "@agentxm/workspace-state";
 import { canReuseInstalledPackage } from "@agentxm/extension-workspace";
 import { materializeRegistryPackageWithTreeIntegrity } from "../registry-materialization.js";
 import { computeExtensionPathsForLayout } from "@agentxm/workspace-state";
@@ -55,6 +55,7 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
     const fsPathLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path), Layer.succeed(HttpClient.HttpClient, httpClient));
     const provide = (effect) => Effect.provide(effect, fsPathLayer);
     const lastTreeIntegrities = new Map();
+    const pendingRemoval = new Map();
     const materializeInstall = Effect.fn("McpServerManager.materializeInstall")(function* ({ ref, force }) {
         if (ref.refType !== "registry") {
             return yield* new McpRegistryOnlyInstall({
@@ -64,7 +65,11 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
         }
         const registryRef = ref;
         const canonicalPath = computeExtensionPathsForLayout(path.join, ws.layout, registryRef, "mcps", registryRef.name).canonicalPath;
-        const lockedEntry = yield* ws.getLockedMcpServer(registryRef.server.name);
+        const lockedEntry = yield* ws.getLockedMcpServer(mcpRegistryResolutionKey({
+            authority: registryRef.source.location,
+            owner: registryRef.owner,
+            name: registryRef.server.name,
+        }));
         const lockedVersion = acceptedRegistryVersionForRef(lockedEntry, registryRef);
         const useExisting = yield* provide(canReuseInstalledPackage({
             installedPath: canonicalPath,
@@ -97,6 +102,18 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
         lastTreeIntegrities.set(registryRef.server.name, materialized.treeIntegrity);
     }, Effect.asVoid);
     const makeMaterializeRemoval = (retainCanonical) => Effect.fn("McpServerManager.materializeRemoval")(function* ({ target }) {
+        const graph = yield* ws.getDesiredStateGraph();
+        const desiredNode = graph.nodes.find((node) => node.type === "mcp-server" && node.name === target.name);
+        const closure = desiredNode === undefined || desiredNode.authority === "inline"
+            ? undefined
+            : graph.mcpSourceClosures.find((candidate) => candidate.identity === desiredNode.identity);
+        const retainShared = closure !== undefined && closure.localNames.some((name) => name !== target.name);
+        pendingRemoval.set(target.name, {
+            ...(desiredNode === undefined || desiredNode.authority === "inline"
+                ? {}
+                : { resolutionKey: desiredNode.identity }),
+            retainShared,
+        });
         const configuredAgents = yield* ws.getConfiguredAgents();
         yield* applyProjectionPlans(configuredAgents.map((agentId) => planSingletonProjection({
             unitId: "mcp-server:native-config-entry",
@@ -119,7 +136,7 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
                 })).pipe(Effect.asVoid),
             },
         })));
-        if (retainCanonical)
+        if (retainCanonical || retainShared)
             return;
         const canonical = yield* provide(acceptedCanonicalObservation({
             workspace: ws,
@@ -178,6 +195,11 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
                 const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity);
                 return ws.setMcpServer({
                     name: ref.server.name,
+                    resolutionKey: mcpRegistryResolutionKey({
+                        authority: registryRef.source.location,
+                        owner: registryRef.owner,
+                        name: registryRef.server.name,
+                    }),
                     lockEntry,
                     versionRange,
                 });
@@ -200,14 +222,26 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
                 const lockEntry = buildMcpServerLockEntry(registryRef, treeIntegrity);
                 return ws.setMcpServerLock({
                     name: ref.server.name,
+                    resolutionKey: mcpRegistryResolutionKey({
+                        authority: registryRef.source.location,
+                        owner: registryRef.owner,
+                        name: registryRef.server.name,
+                    }),
                     lockEntry,
                     versionRange: Option.none(),
                 });
             }), Effect.withSpan("McpServerManager.upsertLockfileEntry"));
         },
-        removeLockfileEntry: ({ target }) => ws
-            .removeMcpServerLock(target.name)
-            .pipe(Effect.withSpan("McpServerManager.removeLockfileEntry")),
+        removeLockfileEntry: ({ target }) => {
+            const removal = pendingRemoval.get(target.name);
+            pendingRemoval.delete(target.name);
+            if (removal?.retainShared === true || removal?.resolutionKey === undefined) {
+                return Effect.void.pipe(Effect.withSpan("McpServerManager.removeLockfileEntry"));
+            }
+            return ws
+                .removeMcpServerLock(removal.resolutionKey)
+                .pipe(Effect.withSpan("McpServerManager.removeLockfileEntry"));
+        },
     };
 }));
 //# sourceMappingURL=manager.js.map

package/dist/src/mcps/operations/disable.js

@@ -6,12 +6,11 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { CodingAgentRepository, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository } from "@agentxm/extension-workspace";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
 import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 export const disableMcpServer = (op) => Effect.gen(function* () {
@@ -28,48 +27,13 @@ export const disableMcpServer = (op) => Effect.gen(function* () {
         });
     }
     const agents = yield* agentRepo.getConfiguredAgents();
-    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
-        entry,
-        agentIds: agents.map((agent) => agent.id),
-        scope: ws.scope,
-    });
-    if (sharedTargetConflict !== undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: sharedTargetConflict,
-        });
-    }
     const outcomes = yield* ws.runTransaction({
         transition: Effect.gen(function* () {
-            const synced = yield* Effect.forEach(agents, (agent) => Effect.gen(function* () {
-                if (isMcpServerApplicableToAgent(entry, agent.id)) {
-                    return yield* agent.removeMcpServer({
-                        workspaceRoot: ws.baseDir,
-                        scope: ws.scope,
-                        serverName: op.args.serverName,
-                        disableOnly: true,
-                    });
-                }
-                const inspection = yield* inspectAgentMcpServer({
-                    workspaceRoot: ws.baseDir,
-                    scope: ws.scope,
-                    agentId: agent.id,
-                    serverName: op.args.serverName,
-                    entry,
-                });
-                if (inspection.status === "unmanaged") {
-                    return yield* new ExtensionLifecycleFailed({
-                        category: "conflict",
-                        detail: `${agent.id} has an unmanaged MCP server named ${op.args.serverName}; AXM will not remove it while applying the target policy`,
-                    });
-                }
-                return inspection.status === "drift"
-                    ? yield* agent.removeMcpServer({
-                        workspaceRoot: ws.baseDir,
-                        scope: ws.scope,
-                        serverName: op.args.serverName,
-                    })
-                    : { _tag: "success", targets: [] };
+            const synced = yield* Effect.forEach(agents, (agent) => agent.removeMcpServer({
+                workspaceRoot: ws.baseDir,
+                scope: ws.scope,
+                serverName: op.args.serverName,
+                disableOnly: true,
             }), { concurrency: "unbounded" });
             yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({
                 agentId: agent.id,

package/dist/src/mcps/operations/enable.js

@@ -7,14 +7,13 @@ import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { CodingAgentRepository, syncInlineMcpServerToAgents, McpSharedTargetConflict, applyProjectionPlansWithResults, planSingletonProjection, inspectAgentMcpServer, sharedMcpTargetPolicyConflict, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository, syncInlineMcpServerToAgents, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/extension-workspace";
 import { normalizeHandle, parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
 import { usableAcceptedCanonicalObservation } from "@agentxm/workspace-state";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { isMcpServerApplicableToAgent } from "@agentxm/workspace-state";
 import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 const enableArtifact = (args) => {
@@ -116,17 +115,6 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
     const owner = trustedIdentity?.type === "mcp-server" ? trustedIdentity.owner : normalizeHandle("@local");
     const resolvedVersion = accepted?.type === "registry" ? accepted.resolvedVersion : "0.0.0";
     const agents = yield* agentRepo.getConfiguredAgents();
-    const sharedTargetConflict = sharedMcpTargetPolicyConflict({
-        entry,
-        agentIds: agents.map((agent) => agent.id),
-        scope: ws.scope,
-    });
-    if (sharedTargetConflict !== undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            detail: sharedTargetConflict,
-        });
-    }
     const outcomes = yield* ws.runTransaction({
         transition: Effect.gen(function* () {
             const synced = yield* applyProjectionPlansWithResults(agents.map((agent) => planSingletonProjection({
@@ -143,27 +131,6 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
                         observedContributors: [],
                     }),
                     apply: () => Effect.gen(function* () {
-                        if (!isMcpServerApplicableToAgent(entry, agent.id)) {
-                            const inspection = yield* inspectAgentMcpServer({
-                                workspaceRoot: ws.baseDir,
-                                scope: ws.scope,
-                                agentId: agent.id,
-                                serverName: op.args.serverName,
-                                entry,
-                            });
-                            if (inspection.status === "unmanaged") {
-                                return yield* new McpSharedTargetConflict({
-                                    reason: `${agent.id} has an unmanaged MCP server named ${op.args.serverName}; AXM will not remove it while applying the target policy`,
-                                });
-                            }
-                            return inspection.status === "drift"
-                                ? yield* agent.removeMcpServer({
-                                    workspaceRoot: ws.baseDir,
-                                    scope: ws.scope,
-                                    serverName: op.args.serverName,
-                                })
-                                : { _tag: "success", targets: [] };
-                        }
                         return yield* agent.addMcpServer({
                             workspaceRoot: ws.baseDir,
                             scope: ws.scope,

package/dist/src/mcps/operations/install.d.ts

@@ -12,17 +12,19 @@ import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { CodingAgentRepository } from "@agentxm/extension-workspace";
-import type { ConfigurableAgentId } from "@agentxm/extension-model/unstable/agent-capabilities";
 import type { StepFailure } from "@agentxm/workspace-operations";
 import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import type { McpServerExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/mcp-server";
+import { type McpServerManifest } from "@agentxm/extension-model/unstable/mcps/manifest-schema";
 import { LifecycleFailureAdapter } from "../../failure-adapter.js";
 /**
  * Args for the install-mcp-server operation.
  */
 export type InstallMcpServerOperationArgs = {
     readonly ref: McpServerExtensionRef;
+    /** Local connection identity and exact agent-native MCP key. */
+    readonly localName?: string;
     readonly force: boolean;
     /** Explicitly permit a workspace-authored relocation during reconciliation. */
     readonly allowWorkspaceSourceTransition?: boolean;
@@ -40,8 +42,6 @@ export type InstallMcpServerOperationArgs = {
      * The transport boundary resolves flag, CI, and TTY state.
      */
     readonly nonInteractive: boolean;
-    /** Restrict this server to a reviewed subset of configured agents. */
-    readonly agents?: ReadonlyArray<ConfigurableAgentId>;
 };
 /**
  * Add an MCP server to the workspace.
@@ -49,6 +49,25 @@ export type InstallMcpServerOperationArgs = {
  * @experimental This API is unstable and may change without notice.
  */
 export type InstallMcpServerOperation = Operation<"install-mcp-server", InstallMcpServerOperationArgs>;
+export declare const mcpSecretAccount: (args: {
+    readonly scopeRoot: string;
+    readonly localName: string;
+    readonly sourceIdentity: string;
+    readonly inputName: string;
+}) => string;
+export type McpSecretDeletionOutcome = {
+    readonly _tag: "deleted";
+    readonly inputName: string;
+} | {
+    readonly _tag: "absent";
+    readonly inputName: string;
+} | {
+    readonly _tag: "failed";
+    readonly inputName: string;
+};
+export declare const collectSecretInputNames: (manifest: McpServerManifest) => ReadonlySet<string>;
+export declare const readMcpServerManifest: (canonicalPath: string) => Effect.Effect<Option.Option<McpServerManifest>, never, FileSystem.FileSystem | Path.Path>;
+export declare const deleteMcpSecrets: (identity: Omit<Parameters<typeof mcpSecretAccount>[0], "inputName">, secretNames: ReadonlySet<string>) => Effect.Effect<ReadonlyArray<McpSecretDeletionOutcome>>;
 /**
  * Install-mcp-server operation handler.
  *