every-plugin 2.10.0 → 3.0.0-rc.0

package/src/runtime/services/plugin.service.ts

@@ -1,23 +1,48 @@
-import { Effect, Exit, Layer, Scope } from "effect";
+import { Context, Effect, Exit, Layer, Scope } from "effect";
 import type {
   AnyPlugin,
   AnyPluginConstructor,
   InitializedPlugin,
+  LoadedPlugin,
+  PluginInstance,
   PluginRegistry,
   SecretsConfig,
 } from "../../types";
-import { ModuleFederationService } from "./module-federation.service";
-import { PluginLifecycleService } from "./plugin-lifecycle.service";
+import type { PluginRuntimeError } from "../errors";
+import { ModuleFederationServiceDefault } from "./module-federation.service";
+import { PluginLifecycleService, PluginLifecycleServiceDefault } from "./plugin-lifecycle.service";
 import {
   PluginLoaderService,
+  PluginLoaderServiceDefault,
   PluginMapTag,
   PluginRegistryTag,
-  RegistryService,
+  RegistryServiceDefault,
 } from "./plugin-loader.service";
-import { SecretsConfigTag, SecretsService } from "./secrets.service";
+import { SecretsConfigTag, SecretsServiceDefault } from "./secrets.service";
 
-export class PluginService extends Effect.Service<PluginService>()("PluginService", {
-  scoped: Effect.gen(function* () {
+export interface PluginServiceShape {
+  loadPlugin: (pluginId: string) => Effect.Effect<LoadedPlugin, PluginRuntimeError>;
+  instantiatePlugin: <T extends AnyPlugin>(
+    pluginId: string,
+    loadedPlugin: LoadedPlugin<T>,
+  ) => Effect.Effect<PluginInstance<T>, PluginRuntimeError>;
+  initializePlugin: <T extends AnyPlugin>(
+    pluginInstance: PluginInstance<T>,
+    config: any,
+    plugins?: Record<string, unknown>,
+  ) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+  registerPlugin: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void>;
+  shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void>;
+  cleanup: Effect.Effect<void>;
+}
+
+export class PluginService extends Context.Service<PluginService, PluginServiceShape>()(
+  "PluginService",
+) {}
+
+export const PluginServiceDefault = Layer.effect(
+  PluginService,
+  Effect.gen(function* () {
     const loader = yield* PluginLoaderService;
     const lifecycle = yield* PluginLifecycleService;
 
@@ -27,44 +52,37 @@ export class PluginService extends Effect.Service<PluginService>()("PluginServic
       initializePlugin: loader.initializePlugin,
       registerPlugin: (plugin: InitializedPlugin<AnyPlugin>) => lifecycle.register(plugin),
       shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) =>
-        Effect.gen(function* () {
-          yield* plugin.plugin
-            .shutdown()
-            .pipe(
-              Effect.catchAll((error) =>
-                Effect.logWarning(`Failed to shutdown plugin ${plugin.plugin.id}`, error),
-              ),
-            );
-
-          yield* Scope.close(plugin.scope, Exit.succeed(undefined));
-
-          yield* lifecycle.unregister(plugin);
-        }),
+        Scope.close(plugin.scope, Exit.succeed(undefined)).pipe(
+          Effect.catchCause((cause) =>
+            Effect.logWarning(`Failed to shutdown plugin ${plugin.plugin.id}`, cause),
+          ),
+          Effect.ensuring(lifecycle.unregister(plugin)),
+        ),
       cleanup: lifecycle.cleanup,
     };
   }),
-}) {
-  static Live = (
-    registry: PluginRegistry,
-    secrets: SecretsConfig,
-    pluginMap: Record<string, AnyPluginConstructor> = {},
-  ) => {
-    const contextLayer = Layer.mergeAll(
-      Layer.succeed(PluginRegistryTag, registry),
-      Layer.succeed(SecretsConfigTag, secrets),
-      Layer.succeed(PluginMapTag, pluginMap),
-    );
+);
 
-    const servicesLayer = Layer.mergeAll(
-      ModuleFederationService.Default,
-      SecretsService.Default,
-      RegistryService.Default,
-      PluginLifecycleService.Default,
-    ).pipe(Layer.provide(contextLayer));
+export const PluginServiceLive = (
+  registry: PluginRegistry,
+  secrets: SecretsConfig,
+  pluginMap: Record<string, AnyPluginConstructor> = {},
+) => {
+  const contextLayer = Layer.mergeAll(
+    Layer.succeed(PluginRegistryTag, registry),
+    Layer.succeed(SecretsConfigTag, secrets),
+    Layer.succeed(PluginMapTag, pluginMap),
+  );
 
-    return PluginService.Default.pipe(
-      Layer.provide(PluginLoaderService.Default),
-      Layer.provide(servicesLayer),
-    );
-  };
-}
+  const servicesLayer = Layer.mergeAll(
+    ModuleFederationServiceDefault,
+    SecretsServiceDefault,
+    RegistryServiceDefault,
+    PluginLifecycleServiceDefault,
+  ).pipe(Layer.provide(contextLayer));
+
+  return PluginServiceDefault.pipe(
+    Layer.provide(PluginLoaderServiceDefault),
+    Layer.provide(servicesLayer),
+  );
+};

package/src/runtime/services/secrets.service.ts

@@ -1,4 +1,4 @@
-import { Context, Effect } from "effect";
+import { Context, Effect, Layer } from "effect";
 import * as z from "zod";
 import type { SecretsConfig } from "../../types";
 import { PluginRuntimeError } from "../errors";
@@ -9,13 +9,21 @@ const configSchema = z
   })
   .passthrough();
 
-export class SecretsConfigTag extends Context.Tag("SecretsConfig")<
-  SecretsConfigTag,
-  SecretsConfig
->() {}
+export class SecretsConfigTag extends Context.Service<SecretsConfigTag, SecretsConfig>()(
+  "SecretsConfig",
+) {}
 
-export class SecretsService extends Effect.Service<SecretsService>()("SecretsService", {
-  effect: Effect.gen(function* () {
+export interface SecretsServiceShape {
+  hydrateSecrets: <T>(config: T) => Effect.Effect<T, PluginRuntimeError>;
+}
+
+export class SecretsService extends Context.Service<SecretsService, SecretsServiceShape>()(
+  "SecretsService",
+) {}
+
+export const SecretsServiceDefault = Layer.effect(
+  SecretsService,
+  Effect.gen(function* () {
     const secrets = yield* SecretsConfigTag;
 
     const hydrateValue = (value: unknown): unknown => {
@@ -57,18 +65,15 @@ export class SecretsService extends Effect.Service<SecretsService>()("SecretsSer
       hydrateSecrets: <T>(config: T) =>
         Effect.gen(function* () {
           const parseResult = configSchema.parse(config);
-          try {
-            return hydrateValue(parseResult) as T;
-          } catch (error) {
-            return yield* Effect.fail(
+          return yield* Effect.try({
+            try: () => hydrateValue(parseResult) as T,
+            catch: (error) =>
               new PluginRuntimeError({
                 operation: "hydrate-secrets",
                 cause: error instanceof Error ? error : new Error(String(error)),
-                retryable: false,
               }),
-            );
-          }
+          });
         }),
     };
   }),
-}) {}
+);

package/src/runtime/services/shared-identity.ts

@@ -0,0 +1,68 @@
+import { isEffectCriticalSharedDep } from "../../shared-deps-spec";
+
+interface IdentityManifest {
+  metaData?: { pluginVersion?: string; name?: string };
+  shared?: Array<{ name: string; version?: string }>;
+}
+
+export interface SharedIdentityMismatch {
+  name: string;
+  expected: string;
+  actual: string | null;
+}
+
+const MANIFEST_TIMEOUT_MS = 15_000;
+
+function manifestUrl(remoteUrl: string): string {
+  return remoteUrl.endsWith("/") ? `${remoteUrl}mf-manifest.json` : `${remoteUrl}/mf-manifest.json`;
+}
+
+function normalizeBaseUrl(remoteUrl: string): string {
+  const withoutHash = remoteUrl.split("#")[0] ?? remoteUrl;
+  return withoutHash.replace(/\/(mf-manifest\.json|remoteEntry\.js)$/i, "");
+}
+
+export function compareSharedIdentity(
+  remoteShared: Array<{ name: string; version?: string }> | undefined,
+  expectedVersions: Map<string, string>,
+): SharedIdentityMismatch[] {
+  const mismatches: SharedIdentityMismatch[] = [];
+  const remoteByName = new Map((remoteShared ?? []).map((s) => [s.name, s]));
+
+  for (const [name, expected] of expectedVersions.entries()) {
+    if (!isEffectCriticalSharedDep(name)) continue;
+    const remoteEntry = remoteByName.get(name);
+    if (!remoteEntry) continue;
+    if (remoteEntry.version && remoteEntry.version !== expected) {
+      mismatches.push({ name, expected, actual: remoteEntry.version });
+    }
+  }
+
+  return mismatches;
+}
+
+export function describeSharedIdentityMismatch(
+  pluginId: string,
+  mismatches: SharedIdentityMismatch[],
+  hostExpectation: string,
+): string {
+  const lines = mismatches.map(
+    (m) =>
+      `  ${m.name}: expected ${m.expected} (from ${hostExpectation}), got ${m.actual ?? "missing"}`,
+  );
+  return (
+    `[SharedIdentity] Refusing to load plugin "${pluginId}": shared dependency version skew.\n` +
+    `${lines.join("\n")}\n` +
+    `Run "bos mf check" for the full report. Fix: rebuild and redeploy the host and this plugin together (single release train, e.g. "bos publish --deploy --packages local").`
+  );
+}
+
+export async function fetchRemoteIdentityManifest(
+  remoteUrl: string,
+): Promise<IdentityManifest | null> {
+  const base = normalizeBaseUrl(remoteUrl);
+  const url = manifestUrl(base);
+  const res = await fetch(url, { signal: AbortSignal.timeout(MANIFEST_TIMEOUT_MS) });
+  if (!res.ok) return null;
+  return (await res.json()) as IdentityManifest;
+}

package/src/runtime/validation.ts

@@ -13,11 +13,9 @@ export const validate = <T>(
     if (result.success) {
       return result.data;
     }
-    return yield* Effect.fail(
-      new ValidationError({
-        pluginId,
-        stage,
-        zodError: result.error,
-      }),
-    );
+    return yield* new ValidationError({
+      pluginId,
+      stage,
+      zodError: result.error,
+    });
   });