@agentxm/extension-lifecycle 0.28.12 → 0.28.13

package/dist/src/mcps/manager.d.ts

@@ -1,16 +0,0 @@
-/**
- * MCP server extension manager service.
- *
- * Implements ExtensionManager<McpServerExtensionRef>. Delegates to existing
- * MCP server materialization functions and workspace service methods.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as Path from "effect/Path";
-import * as Layer from "effect/Layer";
-import { McpServerManager } from "@agentxm/extension-workspace";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-export declare const McpServerManagerLive: Layer.Layer<McpServerManager, never, WorkspaceMutations | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
-//# sourceMappingURL=manager.d.ts.map

package/dist/src/mcps/manager.js

@@ -1,247 +0,0 @@
-/**
- * MCP server extension manager service.
- *
- * Implements ExtensionManager<McpServerExtensionRef>. Delegates to existing
- * MCP server materialization functions and workspace service methods.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as Path from "effect/Path";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-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 { mcpRegistryResolutionKey, WorkspaceMutations } from "@agentxm/workspace-state";
-import { canReuseInstalledPackage } from "@agentxm/extension-workspace";
-import { materializeRegistryPackageWithTreeIntegrity } from "../registry-materialization.js";
-import { computeExtensionPathsForLayout } from "@agentxm/workspace-state";
-import { acceptedRegistryVersionForRef, validateExactResolvedVersion, } from "@agentxm/workspace-state";
-import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
-import { configuredRowsByName } from "@agentxm/workspace-state";
-import { isObservedInstalled } from "@agentxm/workspace-state";
-import { acceptedCanonicalObservation, prepareAcceptedCanonicalTransition, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-import { protectWorkspacePath } from "@agentxm/workspace-state";
-import { computeMaterializedTreeIntegrity } from "@agentxm/workspace-state";
-// Build lock entry from registry ref
-const buildMcpServerLockEntry = (ref, treeIntegrity) => ({
-    type: "registry",
-    sourceType: "registry",
-    packageFormat: "agentxm",
-    endpoint: ref.source.location,
-    extensionType: "mcp-server",
-    workspaceName: ref.server.name,
-    owner: ref.owner,
-    name: ref.name,
-    resolvedVersion: decodeVersionSync(ref.version),
-    integrity: Option.getOrElse(ref.integrity, () => ""),
-    sourceName: ref.source.name,
-    publisherBindingId: ref.publisherBindingId,
-    treeIntegrity,
-});
-// -----------------------------------------------------------------------------
-// Live Layer
-// -----------------------------------------------------------------------------
-export const McpServerManagerLive = Layer.effect(McpServerManager, Effect.gen(function* () {
-    const ws = yield* WorkspaceMutations;
-    const fs = yield* FileSystem.FileSystem;
-    const httpClient = yield* HttpClient.HttpClient;
-    const path = yield* Path.Path;
-    const baseDir = ws.baseDir;
-    // Build a layer to provide FileSystem + Path to inner effects
-    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({
-                serverName: ref.server.name,
-                refType: ref.refType,
-            });
-        }
-        const registryRef = ref;
-        const canonicalPath = computeExtensionPathsForLayout(path.join, ws.layout, registryRef, "mcps", registryRef.name).canonicalPath;
-        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,
-            force: force === true,
-            refVersion: registryRef.version,
-            hasIntegrity: Option.isSome(registryRef.integrity),
-            ...(lockedVersion === undefined ? {} : { lockedVersion }),
-            existsFailureDetail: (target) => `Failed to check if canonical path exists: ${target}`,
-        }));
-        if (useExisting && Option.isSome(lockedEntry)) {
-            const observedTree = yield* provide(computeMaterializedTreeIntegrity(canonicalPath));
-            if (observedTree === lockedEntry.value.treeIntegrity) {
-                lastTreeIntegrities.set(registryRef.server.name, lockedEntry.value.treeIntegrity);
-                return;
-            }
-        }
-        const materialized = yield* provide(materializeRegistryPackageWithTreeIntegrity({
-            baseDir,
-            destinationPath: canonicalPath,
-            sourceLocation: registryRef.source.location,
-            owner: registryRef.owner,
-            type: "mcp-server",
-            name: registryRef.name,
-            version: registryRef.version,
-            integrity: registryRef.integrity,
-            messages: {
-                integrityMismatchDetail: `Integrity mismatch for ${registryRef.name}@${registryRef.version}`,
-            },
-        }));
-        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",
-            // Multiple configured agents may share one native config file.
-            targetFile: `mcp:${target.name}:configured-agents`,
-            contributor: target,
-            adapter: {
-                observe: () => Effect.succeed({
-                    unitId: "mcp-server:native-config-entry",
-                    path: `${agentId}:${target.name}`,
-                    present: true,
-                    current: false,
-                    expectedContributors: [],
-                    observedContributors: [target.name],
-                }),
-                apply: () => provide(removeMcpServerFromManifest(agentId, {
-                    workspaceRoot: baseDir,
-                    scope: ws.scope,
-                    serverName: target.name,
-                })).pipe(Effect.asVoid),
-            },
-        })));
-        if (retainCanonical || retainShared)
-            return;
-        const canonical = yield* provide(acceptedCanonicalObservation({
-            workspace: ws,
-            type: "mcp-server",
-            name: target.name,
-        }));
-        const serverPath = removableAcceptedCanonicalPath(canonical);
-        if (Option.isSome(serverPath)) {
-            yield* protectWorkspacePath(serverPath.value);
-            yield* fs.remove(serverPath.value, { recursive: true, force: true }).pipe(Effect.mapError((cause) => new McpConfigIoFailed({
-                detail: `Failed to remove MCP server package: ${serverPath.value}`,
-                cause,
-            })));
-        }
-    }, Effect.asVoid);
-    const materializeUninstall = makeMaterializeRemoval(false);
-    const materializeDeactivate = makeMaterializeRemoval(true);
-    return {
-        type: "mcp-server",
-        runTransaction: ws.runTransaction,
-        isInstalled: Effect.fn("McpServerManager.isInstalled")(function* ({ target, }) {
-            return yield* isObservedInstalled(ws, "mcp-server", target.name);
-        }),
-        materializeInstall,
-        prepareSourceTransition: ({ ref }) => provide(prepareAcceptedCanonicalTransition({
-            workspace: ws,
-            type: "mcp-server",
-            name: ref.server.name,
-            ref,
-        })),
-        getConfiguredSource: Effect.fn("McpServerManager.getConfiguredSource")(function* ({ target, }) {
-            const configured = yield* ws.getConfiguredMcpServerEntries();
-            return Option.fromUndefinedOr(configured[target.name]?.source);
-        }),
-        isConfigured: Effect.fn("McpServerManager.isConfigured")(function* ({ target }) {
-            const configured = yield* ws.getConfiguredMcpServerEntries();
-            return configured[target.name] !== undefined;
-        }),
-        listMaterializable: Effect.fn("McpServerManager.listMaterializable")(function* () {
-            const configured = yield* ws.records
-                .rows("mcp-server")
-                .pipe(Effect.map(configuredRowsByName));
-            return yield* configuredMcpServersToDiskRefs({ fs, path, baseDir, scope: ws.scope, layout: ws.layout }, configured);
-        }),
-        materializeUninstall,
-        materializeDeactivate,
-        upsertSettingsEntry: ({ ref, versionRange, }) => {
-            if (ref.refType !== "registry")
-                return Effect.void.pipe(Effect.withSpan("McpServerManager.upsertSettingsEntry"));
-            const registryRef = ref;
-            return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
-                const treeIntegrity = lastTreeIntegrities.get(registryRef.server.name);
-                if (treeIntegrity === undefined) {
-                    return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
-                }
-                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,
-                });
-            }), Effect.withSpan("McpServerManager.upsertSettingsEntry"));
-        },
-        removeSettingsEntry: ({ target }) => ws
-            .removeMcpServerSettings(target.name)
-            .pipe(Effect.withSpan("McpServerManager.removeSettingsEntry")),
-        upsertLockfileEntry: ({ ref }) => {
-            if (ref.refType !== "registry")
-                return ws
-                    .removeMcpServerLock(ref.server.name)
-                    .pipe(Effect.withSpan("McpServerManager.upsertLockfileEntry"));
-            const registryRef = ref;
-            return validateExactResolvedVersion(`mcpServers.${ref.server.name}.resolvedVersion`, registryRef.version).pipe(Effect.flatMap(() => {
-                const treeIntegrity = lastTreeIntegrities.get(registryRef.server.name);
-                if (treeIntegrity === undefined) {
-                    return Effect.fail(new McpInstallStateMissing({ name: registryRef.server.name }));
-                }
-                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 }) => {
-            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/artifact.d.ts

@@ -1,24 +0,0 @@
-import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
-import type { McpServerLockEntry } from "@agentxm/workspace-state";
-import type { JobStepArtifact, JobStepArtifactTarget } from "@agentxm/workspace-operations";
-import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
-export declare const mcpConfigSurface: (scope: WorkspaceScope) => string;
-export declare const MCP_AGENT_CONFIG_SURFACE = ".mcp.json";
-export declare const mcpServerVersion: (entry: McpServerLockEntry) => string | undefined;
-export declare const mcpServerSourcePath: (scope: WorkspaceScope, entry: McpServerLockEntry) => string;
-export declare const agentConfigTarget: (change: JobStepArtifactTarget["change"], agentIds: ReadonlyArray<AgentId>) => JobStepArtifactTarget | undefined;
-export interface AgentMcpConfigOutcome {
-    readonly agentId: string;
-    readonly targets?: ReadonlyArray<JobStepArtifactTarget>;
-}
-export declare const agentConfigTargets: (outcomes: ReadonlyArray<AgentMcpConfigOutcome>) => ReadonlyArray<JobStepArtifactTarget>;
-export declare const mcpSettingsTarget: (scope: WorkspaceScope, change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
-export declare const mcpSourceTarget: (scope: WorkspaceScope, entry: McpServerLockEntry, change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
-export declare const mcpServerArtifact: (args: {
-    readonly lockEntry: McpServerLockEntry | undefined;
-    readonly scope: JobStepArtifact["scope"];
-    readonly change: JobStepArtifact["change"];
-    readonly targets: ReadonlyArray<JobStepArtifactTarget>;
-    readonly agents?: ReadonlyArray<string>;
-}) => JobStepArtifact;
-//# sourceMappingURL=artifact.d.ts.map

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

@@ -1,74 +0,0 @@
-import { ACQUIRED_EXTENSIONS_DIR } from "@agentxm/workspace-state";
-import { acquiredExtensionDisplayPathFromLockEntry } from "@agentxm/workspace-state";
-export const mcpConfigSurface = (scope) => scope === "project"
-    ? "axm.json / axm-lock.yaml"
-    : ".axm/workspace/axm.json / .axm/workspace/axm-lock.yaml";
-export const MCP_AGENT_CONFIG_SURFACE = ".mcp.json";
-export const mcpServerVersion = (entry) => entry.type === "registry" ? entry.resolvedVersion : undefined;
-export const mcpServerSourcePath = (scope, entry) => acquiredExtensionDisplayPathFromLockEntry(scope === "project" ? ACQUIRED_EXTENSIONS_DIR : ".axm/workspace/agent_extensions", entry, "mcps", entry.workspaceName);
-export const agentConfigTarget = (change, agentIds) => agentIds.length === 0
-    ? undefined
-    : {
-        path: MCP_AGENT_CONFIG_SURFACE,
-        change,
-        agentIds,
-    };
-const mergeTargetChange = (current, next) => {
-    if (current === "created" || next === "created")
-        return "created";
-    if (current === "updated" || next === "updated")
-        return "updated";
-    if (current === "removed" || next === "removed")
-        return "removed";
-    return "unchanged";
-};
-export const agentConfigTargets = (outcomes) => {
-    const grouped = new Map();
-    for (const outcome of outcomes) {
-        for (const target of outcome.targets ?? []) {
-            const existing = grouped.get(target.path);
-            if (existing === undefined) {
-                grouped.set(target.path, {
-                    path: target.path,
-                    change: target.change,
-                    agentIds: [outcome.agentId],
-                });
-                continue;
-            }
-            existing.change = mergeTargetChange(existing.change, target.change);
-            existing.agentIds.push(outcome.agentId);
-        }
-    }
-    return Array.from(grouped.values()).map((target) => ({
-        path: target.path,
-        change: target.change,
-        agentIds: target.agentIds,
-    }));
-};
-export const mcpSettingsTarget = (scope, change) => ({
-    path: scope === "project" ? "axm.json" : ".axm/workspace/axm.json",
-    change,
-});
-export const mcpSourceTarget = (scope, entry, change) => ({
-    path: mcpServerSourcePath(scope, entry),
-    change,
-});
-export const mcpServerArtifact = (args) => {
-    const version = args.lockEntry === undefined ? undefined : mcpServerVersion(args.lockEntry);
-    return {
-        path: args.lockEntry === undefined
-            ? mcpConfigSurface(args.scope)
-            : mcpServerSourcePath(args.scope, args.lockEntry),
-        scope: args.scope,
-        change: args.change,
-        ...(args.agents === undefined ? {} : { agents: args.agents }),
-        ...(version === undefined ? {} : { version }),
-        ...(args.targets.length === 0
-            ? {}
-            : {
-                fileCount: args.targets.length,
-                targets: args.targets,
-            }),
-    };
-};
-//# sourceMappingURL=artifact.js.map

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

@@ -1,78 +0,0 @@
-/**
- * Install MCP server executor — orchestrates the per-server installation pipeline.
- *
- * Registry-only install: fetch archive, extract to canonical path, update lockfile/settings.
- * Simpler than skills — no agent symlinks.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as FileSystem from "effect/FileSystem";
-import type * as HttpClient from "effect/unstable/http/HttpClient";
-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 { 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;
-    readonly versionRange: Option.Option<string>;
-    /** When true, write to lockfile only (skip settings). Used for pack dependencies. */
-    readonly skipSettings: Option.Option<boolean>;
-    /** Materialize only; the enclosing authored-package transaction owns state writes. */
-    readonly skipStateWrites?: boolean;
-    /** When true, enforce strict policy for MCP sync outcomes. */
-    readonly strictAgentSync?: Option.Option<boolean>;
-    /** Resolved MCP input values from `--env KEY=VALUE` flags. */
-    readonly env?: Option.Option<Readonly<Record<string, string>>>;
-    /**
-     * Whether the invoking surface can prompt for missing required inputs.
-     * The transport boundary resolves flag, CI, and TTY state.
-     */
-    readonly nonInteractive: boolean;
-};
-/**
- * Add an MCP server to the workspace.
- *
- * @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.
- *
- * Registry-only: fetch archive, validate integrity, extract to canonical path,
- * then update lockfile/settings.
- */
-export declare const installMcpServer: (op: InstallMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
-//# sourceMappingURL=install.d.ts.map