@agentxm/extension-lifecycle 0.28.11 → 0.28.13

package/dist/src/mcps/install/plan.js

@@ -0,0 +1,301 @@
+/**
+ * Installing an MCP connection from the registry.
+ *
+ * An MCP server is acquired once and referenced by a local connection name, so
+ * this decides who owns that name, which version constraint every origin
+ * referencing the same server agrees on, and whether the selected workspace
+ * scope can hold an MCP configuration at all.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { installMcpServer } from "@agentxm/extension-materialization";
+import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
+import { ExtensionNameSchema, } from "@agentxm/extension-model/unstable/extensions";
+import { intersectVersionConstraints } from "@agentxm/extension-model/unstable/version-constraints";
+import { SourceHostProviders, resolveSource } from "@agentxm/extension-sources";
+import { operationPresentation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, mcpRegistryResolutionKey } from "@agentxm/workspace-state";
+import { lifecycleStepFailure } from "../../step-failure.js";
+import { registryLoginSuggestions } from "../../install/registry-login-suggestion.js";
+import { parseRegistryInstallTarget } from "../../install/registry-install-target.js";
+import { installRefused, } from "../../install/vocabulary.js";
+const LOCAL_NAME_RULE = "Local MCP names must be max 64 chars, use lowercase letters, numbers, and hyphens, and cannot start or end with a hyphen.";
+const REGISTRY_ONLY = "Use @owner/mcps/server-name or just server-name.";
+/**
+ * Decode repeated `--env KEY=VALUE` inputs into a record. Later occurrences of
+ * the same key win. Registry installs resolve declared inputs by name, so a
+ * bare `KEY` (passthrough from the ambient environment, as `axm mcps add`
+ * allows) is refused here rather than silently resolving to nothing.
+ */
+export const parseMcpEnvInputs = (env) => Effect.gen(function* () {
+    const parsed = {};
+    for (const value of env) {
+        const separator = value.indexOf("=");
+        if (separator <= 0) {
+            return yield* installRefused({
+                category: "usage",
+                detail: "--env must use KEY=VALUE format",
+            });
+        }
+        parsed[value.slice(0, separator)] = value.slice(separator + 1);
+    }
+    return parsed;
+});
+const isConfigurableAgentId = (agentId) => agentId in CONFIGURABLE_AGENTS_BY_ID;
+const decodeLocalName = (value) => Schema.decodeUnknownEffect(ExtensionNameSchema)(value).pipe(Effect.mapError((cause) => installRefused({ category: "validation", detail: LOCAL_NAME_RULE, cause })));
+/** Read the MCP source grammar and settle the local connection name. */
+export const parseMcpServerInstallRequest = Effect.fn("InstallExtensions.parseMcpRequest")(function* (args) {
+    const ws = yield* WorkspaceMutations;
+    const trimmed = args.source.trim();
+    const env = yield* parseMcpEnvInputs(args.env);
+    const parsed = parseRegistryInstallTarget(trimmed, {
+        expectedType: "mcp-server",
+        allowBareName: true,
+    });
+    if (Result.isFailure(parsed)) {
+        switch (parsed.failure.kind) {
+            case "wrong-type":
+                return yield* installRefused({
+                    category: "validation",
+                    detail: "MCP server source must include /mcps/ segment",
+                    suggestions: [{ description: "Use @owner/mcps/server-name format." }],
+                });
+            case "missing-name":
+                return yield* installRefused({
+                    category: "not_found",
+                    detail: "MCP server source must include a server name",
+                    suggestions: [{ description: "Use @owner/mcps/server-name format." }],
+                });
+            default:
+                return yield* installRefused({
+                    category: "usage",
+                    detail: "MCP servers can only be installed from a registry",
+                    suggestions: [{ description: REGISTRY_ONLY }],
+                });
+        }
+    }
+    const requestedLocalName = Option.getOrElse(args.localName, () => parsed.success.name);
+    if (parsed.success.kind === "registry") {
+        return {
+            owner: parsed.success.owner,
+            serverName: parsed.success.name,
+            localName: yield* decodeLocalName(requestedLocalName),
+            versionRange: Option.fromUndefinedOr(parsed.success.versionRange),
+            resolvedInput: trimmed,
+            force: args.force,
+            nonInteractive: args.nonInteractive,
+            env,
+        };
+    }
+    const owner = yield* ws.getConfiguredOwner().pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: "Configured workspace owner could not be read",
+        cause,
+    })), Effect.flatMap(Option.match({
+        onNone: () => Effect.fail(installRefused({
+            category: "validation",
+            detail: `Cannot resolve bare MCP server name "${parsed.success.name}" without a configured owner`,
+            suggestions: [
+                {
+                    description: "Use the fully-qualified `@owner/mcps/name` form, set `owner` in settings, or sign in.",
+                    cmd: "axm login",
+                },
+            ],
+        })),
+        onSome: Effect.succeed,
+    })));
+    return {
+        owner,
+        serverName: parsed.success.name,
+        localName: yield* decodeLocalName(requestedLocalName),
+        versionRange: Option.none(),
+        resolvedInput: `${owner}/mcps/${parsed.success.name}`,
+        force: args.force,
+        nonInteractive: args.nonInteractive,
+        env,
+    };
+});
+/**
+ * Decide which local name may own the connection and which version constraint
+ * every origin referencing the same registry server can agree on.
+ */
+export const resolveMcpServerSourceRequest = Effect.fn("InstallExtensions.resolveMcpSource")(function* (request) {
+    const ws = yield* WorkspaceMutations;
+    const source = yield* resolveSource(request.resolvedInput).pipe(Effect.mapError((cause) => installRefused({
+        category: "validation",
+        detail: `Invalid source: ${cause.message}`,
+        suggestions: [{ description: REGISTRY_ONLY }],
+        cause,
+    })));
+    if (source.type !== "registry") {
+        return yield* installRefused({
+            category: "usage",
+            detail: "MCP servers can only be installed from a registry",
+            suggestions: [{ description: "Use a registry source: @owner/mcps/server-name" }],
+        });
+    }
+    const identity = mcpRegistryResolutionKey({
+        authority: source.location,
+        owner: request.owner,
+        name: request.serverName,
+    });
+    const graph = yield* ws.getDesiredStateGraph().pipe(Effect.mapError((cause) => installRefused({
+        category: "internal",
+        detail: "Desired MCP state could not be read",
+        cause,
+    })));
+    const existingLocalNode = graph.nodes.find((node) => node.type === "mcp-server" && node.name === request.localName);
+    if (existingLocalNode !== undefined &&
+        (existingLocalNode.authority === "inline" || existingLocalNode.identity !== identity)) {
+        return yield* installRefused({
+            category: "conflict",
+            detail: `Local MCP name "${request.localName}" is already owned by a different source`,
+        });
+    }
+    const closure = graph.mcpSourceClosures.find((candidate) => candidate.identity === identity);
+    const retainedConstraints = (closure?.origins ?? []).flatMap((origin) => {
+        if (origin.constraint === undefined)
+            return [];
+        if (origin.type === "settings" && origin.localName === request.localName)
+            return [];
+        return [origin.constraint];
+    });
+    const requestedConstraints = Option.match(request.versionRange, {
+        onNone: () => retainedConstraints,
+        onSome: (range) => [...retainedConstraints, range],
+    });
+    const combinedConstraint = intersectVersionConstraints(requestedConstraints);
+    if (requestedConstraints.length > 0 && combinedConstraint === undefined) {
+        const contributors = (closure?.origins ?? [])
+            .filter((origin) => origin.constraint !== undefined)
+            .map((origin) => origin.type === "settings"
+            ? `${origin.localName ?? "settings"}:${origin.constraint}`
+            : `${origin.pack}:${origin.constraint}`);
+        return yield* installRefused({
+            category: "conflict",
+            detail: `MCP source constraints do not intersect for ${request.owner}/mcps/${request.serverName}: ${[
+                ...contributors,
+                `${request.localName}:${Option.getOrElse(request.versionRange, () => "*")}`,
+            ].join(", ")}`,
+        });
+    }
+    return {
+        source,
+        owner: request.owner,
+        serverName: request.serverName,
+        versionRange: combinedConstraint === undefined ? Option.none() : Option.some(combinedConstraint),
+    };
+});
+/** Discover the MCP server the resolved request names. */
+export const discoverMcpServerRefs = Effect.fn("InstallExtensions.discoverMcpServers")(function* (request) {
+    const sources = yield* SourceHostProviders;
+    const refs = yield* sources
+        .find(request.source, {
+        names: [request.serverName],
+        type: "mcp-server",
+        owner: Option.some(request.owner),
+        versionRange: request.versionRange,
+    })
+        .pipe(Effect.mapError((cause) => installRefused({
+        category: "network",
+        detail: "MCP server could not be fetched from registry",
+        suggestions: [{ description: "Verify the server name and registry configuration." }],
+        cause,
+    })));
+    return refs.filter((ref) => ref.type === "mcp-server");
+});
+/** Settle the connection this request installs, or refuse when nothing matched. */
+export const finalizeMcpServerInstallIntent = Effect.fn("InstallExtensions.finalizeMcpIntent")(function* (request, refs) {
+    const ws = yield* WorkspaceMutations;
+    const [ref] = refs;
+    if (ref === undefined) {
+        const hosts = yield* ws.getRegistrySourceHosts().pipe(Effect.mapError((cause) => installRefused({
+            category: "internal",
+            detail: "Configured registry hosts could not be read",
+            cause,
+        })));
+        const loginSuggestions = yield* registryLoginSuggestions(hosts.map((host) => host.location.href));
+        return yield* installRefused({
+            category: "not_found",
+            detail: `MCP server "${request.serverName}" not found in registry`,
+            suggestions: [
+                { description: "Verify the server name and check available MCP servers." },
+                ...loginSuggestions,
+            ],
+        });
+    }
+    return {
+        ref,
+        localName: request.localName,
+        versionRange: request.versionRange,
+        force: request.force,
+        nonInteractive: request.nonInteractive,
+        env: request.env,
+    };
+});
+/** The closure a settled MCP intent becomes. */
+export const planMcpServerInstall = Effect.fn("InstallExtensions.planMcpServer")(function* (intent) {
+    const ws = yield* WorkspaceMutations;
+    // A user-scope workspace can only hold an MCP configuration when every
+    // configured agent has a user-scope MCP config target to write into.
+    if (ws.scope === "user") {
+        const configuredAgents = yield* ws.getConfiguredAgents().pipe(Effect.mapError((cause) => installRefused({
+            category: "internal",
+            detail: "Configured agents could not be read",
+            cause,
+        })));
+        const refused = configuredAgents.flatMap((agentId) => {
+            if (!isConfigurableAgentId(agentId)) {
+                return [`${agentId}: no MCP capability catalog entry`];
+            }
+            const capability = CONFIGURABLE_AGENTS_BY_ID[agentId].capabilities["mcp-server"];
+            if (capability.axm.writer === null || !("transports" in capability.native)) {
+                return [`${agentId}: no MCP config support`];
+            }
+            return capability.axm.writer.config.targets.some((target) => target.scope === ws.scope)
+                ? []
+                : [`${agentId}: no ${ws.scope} MCP config target`];
+        });
+        if (refused.length > 0) {
+            return yield* installRefused({
+                category: "validation",
+                detail: `Cannot install MCP servers in user scope for the configured agent placement: ${refused.join("; ")}`,
+            });
+        }
+    }
+    return {
+        _tag: "Plan",
+        name: "Install MCP server",
+        description: Option.some(`Install MCP server ${intent.localName}`),
+        presentation: operationPresentation({ imperative: "install", past: "Installed", gerund: "Installing" }, "mcp-server"),
+        jobs: [
+            {
+                concurrency: 1,
+                steps: [
+                    {
+                        key: `mcp-server:${intent.localName}`,
+                        label: intent.localName,
+                        readiness: "ready",
+                        run: installMcpServer({
+                            name: "install-mcp-server",
+                            args: {
+                                ref: intent.ref,
+                                localName: intent.localName,
+                                nonInteractive: intent.nonInteractive,
+                                force: intent.force,
+                                versionRange: intent.versionRange,
+                                skipSettings: Option.none(),
+                                env: Option.some(intent.env ?? {}),
+                            },
+                        }).pipe(Effect.mapError(lifecycleStepFailure)),
+                    },
+                ],
+            },
+        ],
+    };
+});
+//# sourceMappingURL=plan.js.map

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

@@ -3,16 +3,18 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import type { StepFailure } from "@agentxm/workspace-operations";
 import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 export type DisableMcpServerOperation = Operation<"disable-mcp-server", {
     readonly serverName: string;
 }>;
-export declare const disableMcpServer: (op: DisableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+export declare const disableMcpServer: (op: DisableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceTransactionScope | CodingAgentRepository | NativeWriteAuthority | StepFailureConversion>;
 //# sourceMappingURL=disable.d.ts.map

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

@@ -3,15 +3,17 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
+import { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
+import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget, } from "@agentxm/extension-materialization";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 export const disableMcpServer = (op) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
@@ -27,7 +29,7 @@ export const disableMcpServer = (op) => Effect.gen(function* () {
         });
     }
     const agents = yield* agentRepo.getConfiguredAgents();
-    const outcomes = yield* ws.runTransaction({
+    const outcomes = yield* runWorkspaceTransaction({
         transition: Effect.gen(function* () {
             const synced = yield* Effect.forEach(agents, (agent) => agent.removeMcpServer({
                 workspaceRoot: ws.baseDir,

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

@@ -6,13 +6,15 @@
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Effect from "effect/Effect";
-import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
 import type { StepFailure } from "@agentxm/workspace-operations";
 import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { WorkspaceTransactionScope } from "@agentxm/workspace-transactions";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 export type EnableMcpServerOperation = Operation<"enable-mcp-server", {
     readonly serverName: string;
 }>;
-export declare const enableMcpServer: (op: EnableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+export declare const enableMcpServer: (op: EnableMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceTransactionScope | CodingAgentRepository | NativeWriteAuthority | StepFailureConversion>;
 //# sourceMappingURL=enable.d.ts.map

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

@@ -7,14 +7,16 @@ 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, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/extension-workspace";
+import { CodingAgentRepository, applyProjectionPlansWithResults, planSingletonProjection, } from "@agentxm/workspace-projection";
+import { NativeWriteAuthority, syncInlineMcpServerToAgents } from "@agentxm/agent-integration";
 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 { WorkspaceTransactionScope, runWorkspaceTransaction, } from "@agentxm/workspace-transactions";
+import { agentConfigTargets, mcpServerArtifact, mcpSettingsTarget, } from "@agentxm/extension-materialization";
 import { usableAcceptedCanonicalObservation } from "@agentxm/workspace-state";
 import { mcpSyncWarnings, requireSuccessfulMcpSync } from "./sync-outcome.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 const enableArtifact = (args) => {
     return mcpServerArtifact({
@@ -39,7 +41,7 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
     }
     if (entry.kind === "inline") {
         const agentIds = yield* ws.getConfiguredAgents();
-        const outcomes = yield* ws.runTransaction({
+        const outcomes = yield* runWorkspaceTransaction({
             transition: Effect.gen(function* () {
                 const synced = yield* syncInlineMcpServerToAgents(agentIds, {
                     workspaceRoot: ws.baseDir,
@@ -115,7 +117,7 @@ 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 outcomes = yield* ws.runTransaction({
+    const outcomes = yield* runWorkspaceTransaction({
         transition: Effect.gen(function* () {
             const synced = yield* applyProjectionPlansWithResults(agents.map((agent) => planSingletonProjection({
                 unitId: "mcp-server:native-config-entry",
@@ -141,7 +143,7 @@ export const enableMcpServer = (op) => Effect.gen(function* () {
                             enabled: true,
                             configValues: entry.env,
                         });
-                    }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)),
+                    }),
                 },
             })));
             yield* requireSuccessfulMcpSync(op.args.serverName, agents.map((agent, index) => ({

package/dist/src/mcps/operations/sync-outcome.d.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import type { McpServerSyncOutcome } from "@agentxm/extension-workspace";
+import type { McpServerSyncOutcome } from "@agentxm/agent-integration";
 import { ExtensionLifecycleFailed } from "../../errors.js";
 export interface AgentMcpSyncOutcome {
     readonly agentId: string;

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

@@ -11,11 +11,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 } from "@agentxm/extension-workspace";
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import type { StepFailure } from "@agentxm/workspace-operations";
 import type { JobStepResult, Operation } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { LifecycleFailureAdapter } from "../../failure-adapter.js";
+import { McpSecretStore } from "@agentxm/extension-materialization";
+import { StepFailureConversion } from "../../step-failure-conversion.js";
 /**
  * Args for the uninstall-mcp-server operation.
  */
@@ -37,5 +39,5 @@ export type UninstallMcpServerOperation = Operation<"uninstall-mcp-server", Unin
  * 2. Remove canonical directory from disk (if exists)
  * 3. Remove settings and accepted resolution
  */
-export declare const uninstallMcpServer: (op: UninstallMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | LifecycleFailureAdapter>;
+export declare const uninstallMcpServer: (op: UninstallMcpServerOperation) => Effect.Effect<JobStepResult, StepFailure, FileSystem.FileSystem | Path.Path | WorkspaceMutations | CodingAgentRepository | NativeWriteAuthority | McpSecretStore | StepFailureConversion>;
 //# sourceMappingURL=uninstall.d.ts.map

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

@@ -12,15 +12,15 @@ import * as Path from "effect/Path";
 import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { CodingAgentRepository } from "@agentxm/extension-workspace";
+import { NativeWriteAuthority } from "@agentxm/agent-integration";
+import { CodingAgentRepository } from "@agentxm/workspace-projection";
 import { appendWarningsToMessage } from "@agentxm/workspace-operations";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { removeIfExists } from "@agentxm/workspace-state";
 import { acceptedCanonicalObservation, acceptedLockedCanonicalPath, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
-import { agentConfigTarget, mcpServerArtifact, mcpSettingsTarget } from "./artifact.js";
-import { LifecycleFailureAdapter, withAdaptedStepFailures } from "../../failure-adapter.js";
+import { agentConfigTarget, collectSecretInputNames, deleteMcpSecrets, mcpServerArtifact, mcpSettingsTarget, readMcpServerManifest, McpSecretStore, } from "@agentxm/extension-materialization";
+import { StepFailureConversion, withAdaptedStepFailures } from "../../step-failure-conversion.js";
 import { ExtensionLifecycleFailed } from "../../errors.js";
-import { collectSecretInputNames, deleteMcpSecrets, readMcpServerManifest } from "./install.js";
 const REQUIRED_AGENT_IDS = new Set([
     "claude-code",
     "opencode",

package/dist/src/mcps/uninstall/plan.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Uninstalling an MCP connection.
+ *
+ * Removing a connection also removes the secrets it stored in the operating
+ * system keychain, because those inputs exist only for that connection. A
+ * keychain that refuses the deletion does not fail the removal — AXM state is
+ * already applied — but it is reported, because a credential left behind is
+ * something the operator has to finish by hand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { McpServerManager } from "@agentxm/extension-materialization";
+import { type Plan } from "@agentxm/workspace-operations";
+import type { ExtensionLifecycleFailed } from "../../errors.js";
+import type { InstallStepRequirements } from "../../install/vocabulary.js";
+import type { McpServerUninstallIntent } from "../../uninstall/vocabulary.js";
+/** One local connection name is removed at a time. */
+export declare const parseMcpServerUninstallRequest: (selector: string) => McpServerUninstallIntent;
+/** The closure a settled MCP removal becomes. */
+export declare const planMcpServerUninstall: (intent: McpServerUninstallIntent) => Effect.Effect<Plan<InstallStepRequirements>, ExtensionLifecycleFailed, InstallStepRequirements | McpServerManager | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/mcps/uninstall/plan.js

@@ -0,0 +1,109 @@
+/**
+ * Uninstalling an MCP connection.
+ *
+ * Removing a connection also removes the secrets it stored in the operating
+ * system keychain, because those inputs exist only for that connection. A
+ * keychain that refuses the deletion does not fail the removal — AXM state is
+ * already applied — but it is reported, because a credential left behind is
+ * something the operator has to finish by hand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { McpServerManager, buildUninstallOperation, collectSecretInputNames, deleteMcpSecrets, mcpServerArtifact, mcpSourceTarget, readMcpServerManifest, } from "@agentxm/extension-materialization";
+import { appendWarningsToMessage, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, acceptedLockedCanonicalPath, } from "@agentxm/workspace-state";
+import { lifecycleStepFailure } from "../../step-failure.js";
+import { makeWorkspaceRetentionPolicy } from "../../uninstall/retention-policy.js";
+import { workspaceLockfilePath, workspaceSettingsPath } from "../../workspace-paths.js";
+/** One local connection name is removed at a time. */
+export const parseMcpServerUninstallRequest = (selector) => ({
+    targets: [{ type: "mcp-server", name: selector.trim() }],
+});
+/** The closure a settled MCP removal becomes. */
+export const planMcpServerUninstall = Effect.fn("UninstallExtensions.planMcpServers")(function* (intent) {
+    const ws = yield* WorkspaceMutations;
+    const mcpServerManager = yield* McpServerManager;
+    const path = yield* Path.Path;
+    const retentionPolicy = makeWorkspaceRetentionPolicy(ws);
+    const steps = intent.targets.map((target) => {
+        const step = buildUninstallOperation(mcpServerManager, retentionPolicy, {
+            toStepFailure: lifecycleStepFailure,
+            target,
+        });
+        if (step.readiness !== "ready")
+            return step;
+        return {
+            ...step,
+            run: Effect.gen(function* () {
+                const graph = yield* ws
+                    .getDesiredStateGraph()
+                    .pipe(Effect.catch(() => Effect.succeed(undefined)));
+                const desiredNode = graph?.nodes.find((node) => node.type === "mcp-server" && node.name === target.name);
+                const lockEntry = Option.getOrUndefined(yield* ws
+                    .getLockedMcpServerForConnection(target.name)
+                    .pipe(Effect.catch(() => Effect.succeed(Option.none()))));
+                const canonicalPath = yield* acceptedLockedCanonicalPath({
+                    workspace: ws,
+                    type: "mcp-server",
+                    name: target.name,
+                }).pipe(Effect.catch(() => Effect.succeed(Option.none())));
+                const manifest = yield* Option.match(canonicalPath, {
+                    onNone: () => Effect.succeed(Option.none()),
+                    onSome: (root) => readMcpServerManifest(root),
+                });
+                const result = yield* step.run;
+                if (result.result !== "success")
+                    return result;
+                const unchanged = result.disposition === "unchanged";
+                const secretNames = Option.match(manifest, {
+                    onNone: () => new Set(),
+                    onSome: collectSecretInputNames,
+                });
+                const secretDeletionWarnings = unchanged || desiredNode === undefined || desiredNode.authority === "inline"
+                    ? []
+                    : (yield* deleteMcpSecrets({
+                        scopeRoot: path.resolve(ws.baseDir),
+                        localName: target.name,
+                        sourceIdentity: desiredNode.identity,
+                    }, secretNames)).flatMap((outcome) => outcome._tag === "failed"
+                        ? [
+                            `${outcome.inputName} could not be deleted from the system keychain; AXM state was applied and credential cleanup is required`,
+                        ]
+                        : []);
+                const sourceTarget = lockEntry?.type === "registry"
+                    ? mcpSourceTarget(ws.scope, lockEntry, "removed")
+                    : undefined;
+                return {
+                    ...result,
+                    message: appendWarningsToMessage(result.message, secretDeletionWarnings),
+                    ...(secretDeletionWarnings.length === 0
+                        ? {}
+                        : { warnings: [...(result.warnings ?? []), ...secretDeletionWarnings] }),
+                    artifact: mcpServerArtifact({
+                        lockEntry,
+                        scope: ws.scope,
+                        change: unchanged ? "unchanged" : "removed",
+                        targets: unchanged
+                            ? []
+                            : [
+                                { path: workspaceLockfilePath(ws.scope), change: "updated" },
+                                { path: workspaceSettingsPath(ws.scope), change: "updated" },
+                                ...(sourceTarget === undefined ? [] : [sourceTarget]),
+                            ],
+                    }),
+                };
+            }),
+        };
+    });
+    return {
+        _tag: "Plan",
+        name: "Uninstall MCP server",
+        description: Option.some(`Uninstall MCP server ${intent.targets.map((target) => target.name).join(", ")}`),
+        jobs: [{ concurrency: 1, steps }],
+    };
+});
+//# sourceMappingURL=plan.js.map

package/dist/src/packs/artifact.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Where a pack member's acquired package sits, and what an install changed
+ * about it. Both the member step and the pack planner report the same
+ * artifact for the same ref, so a preview and its apply name one path.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import { type ExtensionType, type ExtensionTypePlural } from "@agentxm/extension-model/unstable/extensions";
+import type { JobStepArtifact } from "@agentxm/workspace-operations";
+/** The registry directory segment a type's acquired packages live under. */
+export declare const registryPluralSegment: (type: ExtensionType) => ExtensionTypePlural;
+/** Workspace-relative path of a ref's acquired (or authored) package. */
+export declare const registrySourcePath: (ref: ExtensionRef, scope: JobStepArtifact["scope"]) => string;
+/** The artifact one acquired pack member reports. */
+export declare const registrySourceArtifact: (args: {
+    readonly ref: ExtensionRef;
+    readonly scope: JobStepArtifact["scope"];
+    readonly installedBefore: boolean;
+}) => JobStepArtifact;
+//# sourceMappingURL=artifact.d.ts.map