@agentxm/extension-materialization 0.29.1 → 0.29.4

package/dist/src/index.d.ts

@@ -13,7 +13,7 @@
  */
 export { NO_MATERIALIZATION_OBSERVATION, type ExtensionManager, type ManagerRequirements, type MaterializationFacts, type MaterializationObservation, } from "./manager-contract.js";
 export { ExtensionManagers, type ExtensionManagersService } from "./manager-registry.js";
-export { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager, type AcquiredContentFacts, type HookManagerService, type HookMaterializationFacts, type KnowledgeManagerService, type KnowledgeMaterializationFacts, type KnowledgeSyncResult, type McpServerMaterializationFacts, type PackMaterializationFacts, type RuleManagerService, type RuleMaterializationFacts, type SkillMaterializationFacts, type SubagentManagerService, type SubagentMaterializationFacts, } from "./managers.js";
+export { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager, type AcquiredContentFacts, type HookManagerService, type HookMaterializationFacts, type KnowledgeManagerService, type KnowledgeMaterializationFacts, type KnowledgeSyncResult, type McpServerMaterializationFacts, type McpServerManagerService, type PackMaterializationFacts, type RuleManagerService, type RuleMaterializationFacts, type SkillMaterializationFacts, type SubagentManagerService, type SubagentMaterializationFacts, } from "./managers.js";
 export type { ExtensionManagerFailure, ExtensionMaterializationError } from "./errors.js";
 export { ArchiveIntegrityMismatch, CanonicalPackageProbeFailed, CreateDestinationExists, LifecyclePostconditionViolated, PackageCopyFailed, PackageMaterializationFailed, ScaffoldedExtensionUnresolved, StagedPackageInvalid, type MaterializationError, } from "./extensions/errors.js";
 export { HookDefinitionInvalid, HookInstallStateMissing, type HookManagerError, } from "./hooks/errors.js";

package/dist/src/manager-registry.d.ts

@@ -11,11 +11,10 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as ServiceMap from "effect/Context";
-import type { McpServerExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/mcp-server";
 import type { PackRef } from "@agentxm/extension-model/unstable/extensions/refs/pack";
 import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
 import type { ExtensionManager, ManagerRequirements } from "./manager-contract.js";
-import type { HookManagerService, KnowledgeManagerService, McpServerMaterializationFacts, PackMaterializationFacts, RuleManagerService, SkillMaterializationFacts, SubagentManagerService } from "./managers.js";
+import type { HookManagerService, KnowledgeManagerService, McpServerManagerService, PackMaterializationFacts, RuleManagerService, SkillMaterializationFacts, SubagentManagerService } from "./managers.js";
 /** The manager each extension type is materialized through. */
 export interface ExtensionManagersService {
     readonly skill: ExtensionManager<SkillExtensionRef, SkillMaterializationFacts, ManagerRequirements>;
@@ -23,7 +22,7 @@ export interface ExtensionManagersService {
     readonly rule: RuleManagerService;
     readonly hook: HookManagerService;
     readonly knowledge: KnowledgeManagerService;
-    readonly "mcp-server": ExtensionManager<McpServerExtensionRef, McpServerMaterializationFacts, ManagerRequirements>;
+    readonly "mcp-server": McpServerManagerService;
     readonly pack: ExtensionManager<PackRef, PackMaterializationFacts, ManagerRequirements>;
 }
 declare const ExtensionManagers_base: ServiceMap.ServiceClass<ExtensionManagers, "@agentxm/extension-materialization/ExtensionManagers", ExtensionManagersService>;

package/dist/src/managers.d.ts

@@ -17,7 +17,7 @@ import * as ServiceMap from "effect/Context";
 import type { ExtensionManager, ManagerRequirements, MaterializationFacts, MaterializationObservation } from "./manager-contract.js";
 import type { ExtensionManagerFailure } from "./errors.js";
 import type { ProjectionPlan } from "@agentxm/workspace-projection";
-import type { ConfiguredAgentOutcome } from "@agentxm/workspace-state";
+import type { ConfiguredAgentOutcome, McpServerEntry } from "@agentxm/workspace-state";
 import type { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
 import type { SourceHash } from "@agentxm/extension-model/unstable/sources/source-hash";
 import type { TreeIntegrity } from "@agentxm/workspace-state";
@@ -83,7 +83,15 @@ export type PackMaterializationFacts = AcquiredContentFacts;
 declare const SkillManager_base: ServiceMap.ServiceClass<SkillManager, "@agentxm/extension-materialization/managers/SkillManager", ExtensionManager<SkillExtensionRef, SkillMaterializationFacts, ManagerRequirements>>;
 export declare class SkillManager extends SkillManager_base {
 }
-declare const McpServerManager_base: ServiceMap.ServiceClass<McpServerManager, "@agentxm/extension-materialization/managers/McpServerManager", ExtensionManager<McpServerExtensionRef, McpServerMaterializationFacts, ManagerRequirements>>;
+export interface McpServerManagerService extends ExtensionManager<McpServerExtensionRef, McpServerMaterializationFacts, ManagerRequirements> {
+    readonly configuredAgentOutcomes: (state: "projected" | "current") => Effect.Effect<ReadonlyArray<ConfiguredAgentOutcome>, ExtensionManagerFailure, ManagerRequirements>;
+    readonly configuredAgentOutcomesForEntry: (args: {
+        readonly name: string;
+        readonly entry: McpServerEntry;
+        readonly state: "projected" | "current";
+    }) => Effect.Effect<ReadonlyArray<ConfiguredAgentOutcome>, ExtensionManagerFailure, ManagerRequirements>;
+}
+declare const McpServerManager_base: ServiceMap.ServiceClass<McpServerManager, "@agentxm/extension-materialization/managers/McpServerManager", McpServerManagerService>;
 export declare class McpServerManager extends McpServerManager_base {
 }
 export interface SubagentManagerService extends ExtensionManager<SubagentExtensionRef, SubagentMaterializationFacts, ManagerRequirements> {

package/dist/src/mcps/install-operation.js

@@ -18,8 +18,8 @@ import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import { NativeWriteAuthority } from "@agentxm/agent-integration";
-import { CodingAgentRepository, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/workspace-projection";
+import { NativeWriteAuthority, syncManifestMcpServerToAgents } from "@agentxm/agent-integration";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { mcpRegistryResolutionKey } from "@agentxm/workspace-state";
 import { isPathSafe } from "@agentxm/extension-model/unstable/path-types";
 import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
@@ -262,6 +262,7 @@ const syncConfiguredAgentsOnInstall = (args) => Effect.gen(function* () {
         warnings.push(`Skipping unknown configured agents: ${unknownConfiguredAgentIds.join(", ")}`);
     }
     const configuredAgents = yield* agentRepo.getConfiguredAgents();
+    const configuredAgentIds = configuredAgents.map(({ id }) => id);
     let outcomes;
     if (args.nothingRunnable) {
         outcomes = configuredAgents.map((agent) => ({
@@ -273,34 +274,24 @@ const syncConfiguredAgentsOnInstall = (args) => Effect.gen(function* () {
         }));
     }
     else {
-        outcomes = yield* applyProjectionPlansWithResults(configuredAgents.map((agent) => planSingletonProjection({
-            unitId: "mcp-server:native-config-entry",
-            targetFile: "mcp:configured-agents",
-            contributor: args,
-            adapter: {
-                observe: () => Effect.succeed({
-                    unitId: "mcp-server:native-config-entry",
-                    path: `${agent.id}:${args.serverName}`,
-                    present: false,
-                    current: false,
-                    expectedContributors: [args.serverName],
-                    observedContributors: [],
-                }),
-                apply: () => Effect.gen(function* () {
-                    const outcome = yield* agent.addMcpServer({
-                        workspaceRoot: args.wsBaseDir,
-                        scope: args.scope,
-                        serverName: args.serverName,
-                        canonicalPath: args.canonicalPath,
-                        owner: args.owner,
-                        resolvedVersion: args.resolvedVersion,
-                        enabled: args.enabled,
-                        configValues: args.configValues,
-                    });
-                    return { agentId: agent.id, outcome };
-                }),
+        const synced = yield* syncManifestMcpServerToAgents({
+            agentIds: configuredAgentIds,
+            workspaceRoot: args.wsBaseDir,
+            scope: args.scope,
+            serverName: args.serverName,
+            canonicalPath: args.canonicalPath,
+            owner: args.owner,
+            resolvedVersion: args.resolvedVersion,
+            enabled: args.enabled,
+            configValues: args.configValues,
+        });
+        outcomes = configuredAgentIds.map((agentId, index) => ({
+            agentId,
+            outcome: synced[index] ?? {
+                _tag: "failed",
+                reason: "Agent sync returned no outcome",
             },
-        })));
+        }));
     }
     const misconfigured = Array.filter(outcomes, ({ outcome }) => outcome._tag === "misconfigured");
     if (misconfigured.length > 0) {

package/dist/src/mcps/manager.js

@@ -12,10 +12,10 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { McpInstallStateMissing, McpRegistryOnlyInstall } from "./errors.js";
-import { applyProjectionPlans, planSingletonProjection } from "@agentxm/workspace-projection";
+import { applyProjectionPlans, inspectMcpServerAcrossAgents, planSingletonProjection, } from "@agentxm/workspace-projection";
 import { McpConfigIoFailed, removeMcpServerFromManifest } from "@agentxm/agent-integration";
 import { NO_MATERIALIZATION_OBSERVATION } from "../manager-contract.js";
-import { McpServerManager } from "../managers.js";
+import { McpServerManager, } from "../managers.js";
 import { configuredMcpServersToDiskRefs } from "../extensions/materializable-from-disk.js";
 import { mcpRegistryResolutionKey, WorkspaceMutations } from "@agentxm/workspace-state";
 import { canReuseInstalledPackage } from "../extensions/canonical-directory.js";
@@ -159,6 +159,57 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
     });
     const materializeUninstall = makeMaterializeRemoval(false);
     const materializeDeactivate = makeMaterializeRemoval(true);
+    const configuredAgentOutcomesForEntry = Effect.fn("McpServerManager.configuredAgentOutcomesForEntry")(function* ({ name, entry, state, }) {
+        const configuredAgentIds = yield* ws.getConfiguredAgents();
+        const canonical = entry.kind === "inline"
+            ? Option.none()
+            : (yield* acceptedCanonicalObservation({
+                workspace: ws,
+                type: "mcp-server",
+                name,
+            })).pipe(Option.flatMap(({ observation }) => Option.fromUndefinedOr(observation.path)));
+        const inspections = yield* inspectMcpServerAcrossAgents({
+            workspaceRoot: baseDir,
+            scope: ws.scope,
+            agentIds: configuredAgentIds,
+            serverName: name,
+            entry: { ...entry, enabled: true },
+            canonicalPaths: Option.match(canonical, { onNone: () => [], onSome: (value) => [value] }),
+            state,
+        });
+        return inspections.map((inspection) => ({
+            extensionType: "mcp-server",
+            name,
+            agentId: inspection.agentId,
+            outcome: inspection.status === "match"
+                ? state
+                : inspection.status === "unsupported"
+                    ? "unsupported"
+                    : inspection.status === "blocked"
+                        ? "blocked"
+                        : "failed",
+            reasonCode: inspection.status === "match"
+                ? "supported"
+                : inspection.status === "absent"
+                    ? "projection-missing"
+                    : inspection.status === "drift"
+                        ? "stale-projection"
+                        : `mcp-${inspection.status}`,
+            reason: inspection.reason ??
+                (inspection.status === "match"
+                    ? `${inspection.agentId} has a matching MCP projection.`
+                    : inspection.status === "absent"
+                        ? `The expected ${inspection.agentId} projection is missing.`
+                        : inspection.status === "drift"
+                            ? `The expected ${inspection.agentId} projection is stale.`
+                            : `MCP projection status is ${inspection.status}.`),
+            ...(inspection.path.length === 0 ? {} : { path: inspection.path }),
+        }));
+    });
+    const configuredAgentOutcomes = (state) => Effect.gen(function* () {
+        const entries = yield* ws.getConfiguredMcpServerEntries();
+        return (yield* Effect.forEach(Object.entries(entries).filter(([, entry]) => state === "projected" || entry.enabled), ([name, entry]) => configuredAgentOutcomesForEntry({ name, entry, state }), { concurrency: "unbounded" })).flat();
+    });
     return {
         type: "mcp-server",
         isInstalled: Effect.fn("McpServerManager.isInstalled")(function* ({ target, }) {
@@ -187,6 +238,8 @@ export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(fu
         }),
         materializeUninstall,
         materializeDeactivate,
+        configuredAgentOutcomes,
+        configuredAgentOutcomesForEntry,
         upsertSettingsEntry: ({ ref, versionRange, materialization, }) => {
             if (ref.refType !== "registry")
                 return Effect.void.pipe(Effect.withSpan("McpServerManager.upsertSettingsEntry"));

package/package.json

@@ -4,26 +4,27 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.29.1",
-    "@agentxm/extension-content": "^0.29.1",
-    "@agentxm/extension-model": "^0.29.1",
-    "@agentxm/extension-resolution": "^0.29.1",
-    "@agentxm/extension-sources": "^0.29.1",
-    "@agentxm/registry-client": "^0.29.1",
-    "@agentxm/workspace-operations": "^0.29.1",
-    "@agentxm/workspace-projection": "^0.29.1",
-    "@agentxm/workspace-state": "^0.29.1",
-    "@agentxm/workspace-transactions": "^0.29.1",
+    "@agentxm/agent-integration": "^0.29.4",
+    "@agentxm/extension-content": "^0.29.4",
+    "@agentxm/extension-model": "^0.29.4",
+    "@agentxm/extension-resolution": "^0.29.4",
+    "@agentxm/extension-sources": "^0.29.4",
+    "@agentxm/registry-client": "^0.29.4",
+    "@agentxm/workspace-operations": "^0.29.4",
+    "@agentxm/workspace-projection": "^0.29.4",
+    "@agentxm/workspace-state": "^0.29.4",
+    "@agentxm/workspace-transactions": "^0.29.4",
     "@napi-rs/keyring": "^1.3.0",
-    "effect": "4.0.0-rc.112"
+    "effect": "4.0.0-rc.115"
   },
   "description": "AXM extension materialization: the per-extension-type manager contract and implementations, canonical package staging, registry materialization, and the install/uninstall/authored closure recipes for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/vitest": "4.0.0-rc.112",
+    "@effect/platform-node": "4.0.0-rc.115",
+    "@effect/vitest": "4.0.0-rc.115",
+    "@fast-check/vitest": "^0.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.10",
+    "vitest": "^5.0.0",
     "yaml": "^2.9.0"
   },
   "engines": {
@@ -66,5 +67,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.1"
+  "version": "0.29.4"
 }