@agentxm/workspace-configuration 0.28.4-bootstrap.0

package/dist/src/inline-mcp.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Inline MCP capability policy: parsing and validating inline server
+ * definitions from user-supplied command, URL, environment, and header
+ * inputs, and deciding whether a configured entry already matches a desired
+ * inline definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type { ConfigurableAgentId } from "@agentxm/extension-model/unstable/agent-capabilities";
+import type { McpServerEntry } from "@agentxm/workspace-state";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+import type { InlineMcpDefinition } from "./mcp-import-preflight.js";
+export declare const splitCommand: (value: string) => ReadonlyArray<string>;
+export declare const parseInlineMcpEnv: (values: ReadonlyArray<string>) => Effect.Effect<Readonly<Record<string, string>>, WorkspaceConfigurationFailed>;
+export declare const parseInlineMcpHeaders: (values: ReadonlyArray<string>) => Effect.Effect<Readonly<Record<string, string>>, WorkspaceConfigurationFailed>;
+export declare const validateInlineMcpRemoteUrl: (value: string) => Effect.Effect<void, WorkspaceConfigurationFailed>;
+export declare const matchesInlineMcpEntry: (args: {
+    readonly existing: McpServerEntry | undefined;
+    readonly definition: InlineMcpDefinition;
+    readonly env: Readonly<Record<string, string>>;
+    readonly agents: ReadonlyArray<ConfigurableAgentId> | undefined;
+}) => boolean;
+/** Derive the inline definition from the add command's mutually exclusive inputs. */
+export declare const makeInlineMcpDefinition: (args: {
+    readonly command: string | undefined;
+    readonly url: string | undefined;
+}, headers: Readonly<Record<string, string>>) => Effect.Effect<InlineMcpDefinition, WorkspaceConfigurationFailed>;
+//# sourceMappingURL=inline-mcp.d.ts.map

package/dist/src/inline-mcp.js

@@ -0,0 +1,132 @@
+/**
+ * Inline MCP capability policy: parsing and validating inline server
+ * definitions from user-supplied command, URL, environment, and header
+ * inputs, and deciding whether a configured entry already matches a desired
+ * inline definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+export const splitCommand = (value) => value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => {
+    if ((part.startsWith('"') && part.endsWith('"')) ||
+        (part.startsWith("'") && part.endsWith("'"))) {
+        return part.slice(1, -1);
+    }
+    return part;
+}) ?? [];
+const isSensitiveName = (name) => /(?:authorization|cookie|credential|password|secret|token|api[-_]?key)/iu.test(name);
+const hasEnvironmentReference = (value) => /\$\{[A-Za-z_][A-Za-z0-9_]*\}/u.test(value);
+export const parseInlineMcpEnv = (values) => Effect.forEach(values, (value) => Effect.gen(function* () {
+    const separator = value.indexOf("=");
+    if (separator > 0) {
+        const name = value.slice(0, separator);
+        const configured = value.slice(separator + 1);
+        if (isSensitiveName(name) && !hasEnvironmentReference(configured)) {
+            return yield* new WorkspaceConfigurationFailed({
+                category: "usage",
+                detail: `Sensitive MCP input ${name} must use an environment reference; pass --env ${name}`,
+            });
+        }
+        return [name, configured];
+    }
+    return [value, `\${${value}}`];
+})).pipe(Effect.map((entries) => Object.fromEntries(entries)));
+const parseInlineMcpHeader = (value) => Effect.gen(function* () {
+    const separator = value.indexOf(":");
+    if (separator <= 0) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: `Invalid header "${value}". Use Name:Value.`,
+        });
+    }
+    const name = value.slice(0, separator).trim();
+    const configured = value.slice(separator + 1).trim();
+    if (isSensitiveName(name) && !hasEnvironmentReference(configured)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: `Sensitive MCP header ${name} must use an environment reference`,
+        });
+    }
+    return [name, configured];
+});
+export const parseInlineMcpHeaders = (values) => Effect.map(Effect.forEach(values, parseInlineMcpHeader), (entries) => Object.fromEntries(entries));
+export const validateInlineMcpRemoteUrl = (value) => Effect.gen(function* () {
+    const protocol = yield* Effect.try({
+        try: () => new URL(value).protocol,
+        catch: (cause) => new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: `Invalid MCP server URL "${value}". Use an http(s):// streamable URL.`,
+            cause,
+        }),
+    });
+    if (protocol === "ws:" || protocol === "wss:") {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: "WebSocket MCP transport is not supported; use an http(s):// streamable URL.",
+        });
+    }
+    if (protocol !== "http:" && protocol !== "https:") {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "usage",
+            detail: `Unsupported MCP server URL scheme "${protocol}". Use an http(s):// streamable URL.`,
+        });
+    }
+});
+const arraysEqual = (left, right) => {
+    const normalizedLeft = left ?? [];
+    const normalizedRight = right ?? [];
+    return (normalizedLeft.length === normalizedRight.length &&
+        normalizedLeft.every((value, index) => value === normalizedRight[index]));
+};
+const recordsEqual = (left, right) => {
+    const normalizedLeft = left ?? {};
+    const normalizedRight = right ?? {};
+    const leftEntries = Object.entries(normalizedLeft).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+    const rightEntries = Object.entries(normalizedRight).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+    return (leftEntries.length === rightEntries.length &&
+        leftEntries.every(([key, value], index) => {
+            const rightEntry = rightEntries[index];
+            return rightEntry !== undefined && key === rightEntry[0] && value === rightEntry[1];
+        }));
+};
+export const matchesInlineMcpEntry = (args) => args.existing !== undefined &&
+    args.existing.kind === "inline" &&
+    args.existing.enabled &&
+    args.existing.command ===
+        (args.definition.type === "stdio" ? args.definition.command : undefined) &&
+    arraysEqual(args.existing.args, args.definition.type === "stdio" ? args.definition.args : undefined) &&
+    args.existing.url === (args.definition.type === "http" ? args.definition.url : undefined) &&
+    recordsEqual(args.existing.headers, args.definition.type === "http" ? args.definition.headers : undefined) &&
+    recordsEqual(args.existing.env, args.env) &&
+    arraysEqual(args.existing.agents, args.agents);
+/** Derive the inline definition from the add command's mutually exclusive inputs. */
+export const makeInlineMcpDefinition = (args, headers) => Effect.gen(function* () {
+    if (args.command !== undefined) {
+        const commandParts = splitCommand(args.command);
+        const command = commandParts[0];
+        if (command === undefined) {
+            return yield* new WorkspaceConfigurationFailed({
+                category: "usage",
+                detail: "Inline MCP command cannot be empty.",
+            });
+        }
+        return {
+            type: "stdio",
+            command,
+            args: commandParts.slice(1),
+        };
+    }
+    if (args.url !== undefined) {
+        return {
+            type: "http",
+            url: args.url,
+            headers,
+        };
+    }
+    return yield* new WorkspaceConfigurationFailed({
+        category: "usage",
+        detail: "Provide --command or --url for inline MCP servers.",
+    });
+});
+//# sourceMappingURL=inline-mcp.js.map

package/dist/src/instruction-reconciliation.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Instruction-management policy over the kernel's instruction semantics:
+ * observation, readiness preflight, reconciliation transitions, and disabling
+ * instruction-file management. Failures stay typed through this feature; the
+ * application boundary owns their rendering.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { WorkspaceMutationsService } from "@agentxm/workspace-state";
+import { assertInstructionTargetsSafe, assertInstructionsGitignoreSafe } from "@agentxm/extension-workspace";
+import type { InstructionProjectionSnapshot, ResolvedInstructionsConfig } from "@agentxm/extension-workspace";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+/** The one observation a command's planning derives its views from. */
+export declare const observeInstructions: (args: {
+    readonly ws: WorkspaceMutationsService;
+    readonly config: ResolvedInstructionsConfig;
+}) => Effect.Effect<InstructionProjectionSnapshot, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+export declare const activeInstructionsConfig: (ws: WorkspaceMutationsService) => Effect.Effect<Option.Option<ResolvedInstructionsConfig>, import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, never>;
+export declare const instructionStateIsCurrent: (snapshot: InstructionProjectionSnapshot) => boolean;
+/** The typed failure a readiness preflight can surface. */
+export type InstructionReadinessFailure = Effect.Error<ReturnType<typeof assertInstructionTargetsSafe>> | Effect.Error<ReturnType<typeof assertInstructionsGitignoreSafe>>;
+export declare const instructionReconciliationReadiness: (args: {
+    readonly ws: WorkspaceMutationsService;
+    readonly snapshot: InstructionProjectionSnapshot;
+}) => Effect.Effect<Option.None<InstructionReadinessFailure> | Option.Some<InstructionReadinessFailure>, never, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+/**
+ * Remove every alias the given configuration owns, observing fresh so the
+ * decision reflects the workspace at the moment of removal. Used before a new
+ * configuration is reconciled, so a changed source filename or alias policy
+ * never leaves the old arrangement behind. Refuses on an unowned target like
+ * every other path.
+ */
+export declare const removeInstructionTargetsFor: (args: {
+    readonly ws: WorkspaceMutationsService;
+    readonly config: ResolvedInstructionsConfig;
+}) => Effect.Effect<string[], import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/extension-workspace").InstructionMaintenanceFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+/**
+ * Runs inside the workspace transaction: preflight against a fresh
+ * observation (the plan's readiness check ran before the transaction opened),
+ * apply the transition, reconcile, and verify from the sync's own readback.
+ */
+export declare const reconcileInstructionTransition: <A, E>(args: {
+    readonly ws: WorkspaceMutationsService;
+    readonly config: ResolvedInstructionsConfig;
+    readonly preflightConfig?: ResolvedInstructionsConfig;
+    readonly transition: Effect.Effect<A, E>;
+}) => Effect.Effect<A, WorkspaceConfigurationFailed | import("@agentxm/extension-workspace").InstructionMaintenanceFailure | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure | E, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+export declare const disableInstructionManagement: (args: {
+    readonly ws: WorkspaceMutationsService;
+    readonly config: ResolvedInstructionsConfig;
+}) => Effect.Effect<{
+    removed: string[];
+    gitignore: string | undefined;
+}, import("@agentxm/workspace-state").WorkspaceSnapshotError | import("@agentxm/workspace-state").SettingsWriteError | import("@agentxm/extension-workspace").InstructionMaintenanceFailed | import("@agentxm/workspace-state").PathTraversalDetected | import("@agentxm/workspace-state").SymlinkCreationError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError, import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+//# sourceMappingURL=instruction-reconciliation.d.ts.map

package/dist/src/instruction-reconciliation.js

@@ -0,0 +1,93 @@
+/**
+ * Instruction-management policy over the kernel's instruction semantics:
+ * observation, readiness preflight, reconciliation transitions, and disabling
+ * instruction-file management. Failures stay typed through this feature; the
+ * application boundary owns their rendering.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { assertInstructionTargetsSafe, assertInstructionsGitignoreSafe, instructionProjectionIsCurrent, observeInstructionProjection, removeManagedInstructionTargets, removeInstructionsGitignore, resolveInstructionsConfig, syncInstructions, } from "@agentxm/extension-workspace";
+import { WorkspaceConfigurationFailed } from "./errors.js";
+const configuredAgents = (ws) => ws.getConfiguredAgents();
+/** The one observation a command's planning derives its views from. */
+export const observeInstructions = Effect.fn("Instructions.observe")(function* (args) {
+    const agents = yield* configuredAgents(args.ws);
+    return yield* observeInstructionProjection({
+        workspaceRoot: args.ws.baseDir,
+        scope: args.ws.scope,
+        configuredAgents: agents,
+        config: args.config,
+    });
+});
+export const activeInstructionsConfig = Effect.fn("Instructions.activeConfig")(function* (ws) {
+    const value = yield* ws.getInstructionsConfig();
+    if (Option.isNone(value) || value.value === false) {
+        return Option.none();
+    }
+    return Option.some(resolveInstructionsConfig(value.value));
+});
+export const instructionStateIsCurrent = (snapshot) => snapshot.status.missingSources.length === 0 && instructionProjectionIsCurrent(snapshot);
+export const instructionReconciliationReadiness = Effect.fn("Instructions.reconciliationReadiness")(function* (args) {
+    return yield* Effect.result(Effect.all([
+        assertInstructionTargetsSafe(args.snapshot.status),
+        assertInstructionsGitignoreSafe(args.ws.baseDir),
+    ], { concurrency: 1, discard: true })).pipe(Effect.map((result) => result._tag === "Success"
+        ? Option.none()
+        : Option.some(result.failure)));
+});
+/**
+ * Remove every alias the given configuration owns, observing fresh so the
+ * decision reflects the workspace at the moment of removal. Used before a new
+ * configuration is reconciled, so a changed source filename or alias policy
+ * never leaves the old arrangement behind. Refuses on an unowned target like
+ * every other path.
+ */
+export const removeInstructionTargetsFor = (args) => Effect.gen(function* () {
+    const snapshot = yield* observeInstructions(args);
+    return yield* removeManagedInstructionTargets({ snapshot, dryRun: false });
+});
+/**
+ * Runs inside the workspace transaction: preflight against a fresh
+ * observation (the plan's readiness check ran before the transaction opened),
+ * apply the transition, reconcile, and verify from the sync's own readback.
+ */
+export const reconcileInstructionTransition = (args) => Effect.gen(function* () {
+    const agents = yield* configuredAgents(args.ws);
+    const preflight = yield* observeInstructions({
+        ws: args.ws,
+        config: args.preflightConfig ?? args.config,
+    });
+    yield* assertInstructionTargetsSafe(preflight.status);
+    yield* assertInstructionsGitignoreSafe(args.ws.baseDir);
+    const transitionResult = yield* args.transition;
+    const syncResult = yield* syncInstructions({
+        workspaceRoot: args.ws.baseDir,
+        scope: args.ws.scope,
+        configuredAgents: agents,
+        config: args.config,
+        dryRun: false,
+    });
+    if (!instructionProjectionIsCurrent(syncResult.snapshot)) {
+        return yield* new WorkspaceConfigurationFailed({
+            category: "internal",
+            detail: "Instruction reconciliation did not reach the desired state",
+        });
+    }
+    return transitionResult;
+}).pipe(Effect.withSpan("Instructions.reconcileTransition"));
+export const disableInstructionManagement = Effect.fn("Instructions.disableManagement")(function* (args) {
+    yield* assertInstructionsGitignoreSafe(args.ws.baseDir);
+    const removed = yield* removeInstructionTargetsFor(args);
+    const gitignore = yield* removeInstructionsGitignore({
+        workspaceRoot: args.ws.baseDir,
+        dryRun: false,
+    });
+    yield* args.ws.setInstructionsConfig(false);
+    return {
+        removed,
+        gitignore: Option.getOrUndefined(gitignore),
+    };
+});
+//# sourceMappingURL=instruction-reconciliation.js.map

package/dist/src/mcp-import-preflight.d.ts

@@ -0,0 +1,44 @@
+import * as DateTime from "effect/DateTime";
+import type { ConfigurableAgentId } from "@agentxm/extension-model/unstable/agent-capabilities";
+export type InlineMcpDefinition = {
+    readonly type: "stdio";
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+} | {
+    readonly type: "http";
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+};
+export interface McpImportSource {
+    readonly filePath: string;
+    readonly serversKey: string;
+    readonly config: Readonly<Record<string, unknown>>;
+    readonly agents?: ReadonlyArray<ConfigurableAgentId>;
+}
+export interface McpImportAdoption {
+    readonly filePath: string;
+    readonly serversKey: string;
+    readonly name: string;
+}
+export interface McpImportCandidate {
+    readonly name: string;
+    readonly definition: InlineMcpDefinition;
+    readonly env: Readonly<Record<string, string>>;
+    readonly adoptions: ReadonlyArray<McpImportAdoption>;
+    readonly agents?: ReadonlyArray<ConfigurableAgentId>;
+}
+export interface McpImportFinding {
+    readonly name: string;
+    readonly reason: string;
+}
+export interface McpImportPreflight {
+    readonly candidates: ReadonlyArray<McpImportCandidate>;
+    readonly skipped: ReadonlyArray<McpImportFinding>;
+    readonly conflicts: ReadonlyArray<McpImportFinding>;
+}
+export declare const preflightMcpImports: (args: {
+    readonly configuredNames: ReadonlySet<string>;
+    readonly now: DateTime.Utc;
+    readonly sources: ReadonlyArray<McpImportSource>;
+}) => McpImportPreflight;
+//# sourceMappingURL=mcp-import-preflight.d.ts.map

package/dist/src/mcp-import-preflight.js

@@ -0,0 +1,277 @@
+import * as DateTime from "effect/DateTime";
+import { isAxmManagedMcpEntry } from "@agentxm/workspace-state";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
+const stringRecord = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value);
+    if (entries.some(([, item]) => typeof item !== "string"))
+        return undefined;
+    return Object.fromEntries(entries.map(([key, item]) => [key, String(item)]));
+};
+const sortedRecord = (value) => Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+const envRefs = (value) => {
+    const env = value === undefined ? {} : stringRecord(value);
+    if (env === undefined)
+        return undefined;
+    return Object.fromEntries(Object.keys(env)
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => [name, `\${${name}}`]));
+};
+const isSensitiveName = (name) => /(?:authorization|cookie|credential|password|secret|token|api[-_]?key)/iu.test(name);
+const hasEnvironmentReference = (value) => /\$\{[A-Za-z_][A-Za-z0-9_]*\}/u.test(value);
+const literalSensitiveField = (config) => {
+    const entry = Object.entries(config).find(([name, value]) => isSensitiveName(name) && typeof value === "string" && !hasEnvironmentReference(value));
+    return entry === undefined
+        ? undefined
+        : {
+            name: entry[0],
+            reason: `Sensitive field ${entry[0]} must use an environment reference`,
+        };
+};
+const sensitiveArgumentConflict = (args) => {
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index] ?? "";
+        const assignment = /^(?:--)?([^=]+)=(.*)$/u.exec(argument);
+        const assignedName = assignment?.[1];
+        const assignedValue = assignment?.[2];
+        if (assignedName !== undefined &&
+            assignedValue !== undefined &&
+            isSensitiveName(assignedName) &&
+            !hasEnvironmentReference(assignedValue)) {
+            return {
+                name: assignedName,
+                reason: `Sensitive argument ${assignedName} must use an environment reference`,
+            };
+        }
+        const flagName = argument.replace(/^-+/u, "");
+        if (assignment === null && argument.startsWith("-") && isSensitiveName(flagName)) {
+            const value = args[index + 1];
+            if (value === undefined || !hasEnvironmentReference(value)) {
+                return {
+                    name: flagName,
+                    reason: `Sensitive argument ${flagName} must use an environment reference`,
+                };
+            }
+            index += 1;
+        }
+    }
+    return undefined;
+};
+const sensitiveHeaderConflict = (headers) => {
+    const entry = Object.entries(headers).find(([name, value]) => isSensitiveName(name) && !hasEnvironmentReference(value));
+    return entry === undefined
+        ? undefined
+        : {
+            name: entry[0],
+            reason: `Sensitive header ${entry[0]} must use an environment reference`,
+        };
+};
+const sensitiveUrlConflict = (value) => {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return "Unsupported MCP server URL scheme; use an http(s) URL";
+        }
+        const username = decodeURIComponent(url.username);
+        const password = decodeURIComponent(url.password);
+        if ((username.length > 0 && !hasEnvironmentReference(username)) ||
+            (password.length > 0 && !hasEnvironmentReference(password))) {
+            return "MCP server URL credentials must use an environment reference";
+        }
+        const sensitiveParameter = Array.from(url.searchParams.keys()).find(isSensitiveName);
+        if (sensitiveParameter !== undefined &&
+            !hasEnvironmentReference(url.searchParams.get(sensitiveParameter) ?? "")) {
+            return `Sensitive URL parameter ${sensitiveParameter} must use an environment reference`;
+        }
+        return undefined;
+    }
+    catch {
+        return "Unsupported MCP server URL";
+    }
+};
+const normalizeServer = (args) => {
+    if (isAxmManagedMcpEntry(args.config)) {
+        return { _tag: "skip", finding: { name: args.name, reason: "Already managed by AXM" } };
+    }
+    const sensitiveField = literalSensitiveField(args.config);
+    if (sensitiveField !== undefined) {
+        return {
+            _tag: "conflict",
+            finding: { name: args.name, reason: sensitiveField.reason },
+        };
+    }
+    const env = envRefs(args.config["env"] ?? args.config["environment"]);
+    if (env === undefined) {
+        return {
+            _tag: "skip",
+            finding: { name: args.name, reason: "Unsupported MCP server environment" },
+        };
+    }
+    const url = args.config["url"];
+    if (typeof url === "string") {
+        const rawHeaders = args.config["headers"] ?? args.config["http_headers"];
+        const headers = rawHeaders === undefined ? {} : stringRecord(rawHeaders);
+        if (headers === undefined) {
+            return {
+                _tag: "skip",
+                finding: { name: args.name, reason: "Unsupported MCP server headers" },
+            };
+        }
+        const headerConflict = sensitiveHeaderConflict(headers);
+        if (headerConflict !== undefined) {
+            return {
+                _tag: "conflict",
+                finding: { name: args.name, reason: headerConflict.reason },
+            };
+        }
+        const urlConflict = sensitiveUrlConflict(url);
+        if (urlConflict !== undefined) {
+            return { _tag: "conflict", finding: { name: args.name, reason: urlConflict } };
+        }
+        return {
+            _tag: "candidate",
+            candidate: {
+                name: args.name,
+                definition: {
+                    type: "http",
+                    url,
+                    headers: sortedRecord(headers),
+                },
+                env,
+                adoptions: [args.adoption],
+                ...(args.agents === undefined ? {} : { agents: args.agents }),
+            },
+        };
+    }
+    const commandValue = args.config["command"];
+    const separateArgs = args.config["args"] === undefined ? [] : stringArray(args.config["args"]);
+    if (separateArgs === undefined) {
+        return {
+            _tag: "skip",
+            finding: { name: args.name, reason: "Unsupported MCP server arguments" },
+        };
+    }
+    const command = typeof commandValue === "string"
+        ? { executable: commandValue, args: separateArgs }
+        : (() => {
+            const parts = stringArray(commandValue);
+            if (parts === undefined)
+                return undefined;
+            const executable = parts[0];
+            return executable === undefined ? undefined : { executable, args: parts.slice(1) };
+        })();
+    if (command === undefined || command.executable.length === 0) {
+        return {
+            _tag: "skip",
+            finding: { name: args.name, reason: "Unsupported MCP server configuration" },
+        };
+    }
+    const argumentConflict = sensitiveArgumentConflict(command.args);
+    if (argumentConflict !== undefined) {
+        return {
+            _tag: "conflict",
+            finding: { name: args.name, reason: argumentConflict.reason },
+        };
+    }
+    return {
+        _tag: "candidate",
+        candidate: {
+            name: args.name,
+            definition: {
+                type: "stdio",
+                command: command.executable,
+                args: command.args,
+            },
+            env,
+            adoptions: [args.adoption],
+            ...(args.agents === undefined ? {} : { agents: args.agents }),
+        },
+    };
+};
+const candidateIdentity = (candidate) => {
+    const entry = candidate.definition;
+    return JSON.stringify({
+        type: entry.type,
+        command: entry.type === "stdio" ? entry.command : undefined,
+        args: entry.type === "stdio" ? entry.args : undefined,
+        url: entry.type === "http" ? entry.url : undefined,
+        headers: entry.type === "http" ? entry.headers : undefined,
+        env: sortedRecord(candidate.env),
+    });
+};
+const sortFindings = (findings) => [...findings].sort((left, right) => left.name.localeCompare(right.name) || left.reason.localeCompare(right.reason));
+export const preflightMcpImports = (args) => {
+    const candidates = new Map();
+    const conflictNames = new Set();
+    const skipped = [];
+    const conflicts = [];
+    const sources = [...args.sources].sort((left, right) => left.filePath.localeCompare(right.filePath));
+    for (const source of sources) {
+        const servers = source.config[source.serversKey];
+        if (!isRecord(servers))
+            continue;
+        for (const [name, value] of Object.entries(servers).sort(([left], [right]) => left.localeCompare(right))) {
+            if (args.configuredNames.has(name)) {
+                skipped.push({ name, reason: "Already configured" });
+                continue;
+            }
+            if (!isRecord(value)) {
+                skipped.push({ name, reason: "Unsupported MCP server configuration" });
+                continue;
+            }
+            const normalized = normalizeServer({
+                name,
+                config: value,
+                adoption: { filePath: source.filePath, serversKey: source.serversKey, name },
+                now: args.now,
+                ...(source.agents === undefined ? {} : { agents: source.agents }),
+            });
+            if (normalized._tag === "skip") {
+                skipped.push(normalized.finding);
+                continue;
+            }
+            if (normalized._tag === "conflict") {
+                conflictNames.add(name);
+                conflicts.push(normalized.finding);
+                continue;
+            }
+            const existing = candidates.get(name);
+            if (existing === undefined) {
+                candidates.set(name, normalized.candidate);
+                continue;
+            }
+            if (candidateIdentity(existing) !== candidateIdentity(normalized.candidate)) {
+                conflictNames.add(name);
+                conflicts.push({
+                    name,
+                    reason: `Conflicting unmanaged configurations were found for ${name}`,
+                });
+                continue;
+            }
+            candidates.set(name, {
+                ...existing,
+                adoptions: Array.from(new Map([...existing.adoptions, ...normalized.candidate.adoptions].map((adoption) => [
+                    `${adoption.filePath}\0${adoption.serversKey}\0${adoption.name}`,
+                    adoption,
+                ])).values()),
+                ...(existing.agents === undefined && normalized.candidate.agents === undefined
+                    ? {}
+                    : {
+                        agents: Array.from(new Set([...(existing.agents ?? []), ...(normalized.candidate.agents ?? [])])).sort((left, right) => left.localeCompare(right)),
+                    }),
+            });
+        }
+    }
+    const uniqueConflicts = Array.from(new Map(sortFindings(conflicts).map((finding) => [`${finding.name}\0${finding.reason}`, finding])).values());
+    const uniqueSkipped = Array.from(new Map(sortFindings(skipped).map((finding) => [`${finding.name}\0${finding.reason}`, finding])).values());
+    return {
+        candidates: Array.from(candidates.values())
+            .filter((candidate) => !conflictNames.has(candidate.name))
+            .sort((left, right) => left.name.localeCompare(right.name)),
+        skipped: uniqueSkipped,
+        conflicts: uniqueConflicts,
+    };
+};
+//# sourceMappingURL=mcp-import-preflight.js.map