@xopcai/xopc 0.0.321 → 0.0.323

package/dist/src/connectors/connection-recovery-service.js

@@ -19,6 +19,7 @@ import { capabilityActions, isToolInputSchema, missingConnectionCapabilities } f
 import { resolveConnectionCandidate } from "./connection-candidates.js";
 import { installConnector } from "./install.js";
 import { persistConfigMutation } from "../config/config-mutation.js";
+import { HostPluginMcpRecovery } from "./plugin-mcp-recovery.js";
 import { randomUUID } from "node:crypto";
 //#region src/connectors/connection-recovery-service.ts
 init_transaction();
@@ -36,6 +37,9 @@ const SCOPE_ORDER = {
 };
 const INTENT_TTL = 30 * 6e4;
 const ATTEMPT_TTL = 10 * 6e4;
+function isConnectorNeed(need) {
+	return need.target.type === "connector";
+}
 /** Authorization lives at click time. Chat history contains only immutable explanations. */
 var ConnectionRecoveryService = class {
 	busy = /* @__PURE__ */ new Set();
@@ -77,6 +81,9 @@ var ConnectionRecoveryService = class {
 	get adapter() {
 		return this.deps.adapter ?? new ComposioSessionsAdapter();
 	}
+	get pluginMcp() {
+		return this.deps.pluginMcp ?? new HostPluginMcpRecovery(this.deps.getConfig);
+	}
 	snapshot(conversationId) {
 		if (!connectorPrincipalForSession(conversationId).isLocalOwner) throw new Error("This connection belongs to another principal.");
 		const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
@@ -90,13 +97,25 @@ var ConnectionRecoveryService = class {
 	}
 	view(wait, verifiedIds) {
 		const needs = wait.needs.map((need) => {
-			const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === need.connectorId);
-			const installation = getConnectorInstallation(`${need.connectorId}-${wait.principalId}`);
+			if (need.target.type === "plugin-mcp") {
+				const availability = this.pluginMcp.availability(need.target);
+				const phase = !availability.available || need.connectionId && need.capabilityError ? "blocked" : need.connectionId === need.target.serverId ? "ready" : need.attempt && need.attempt.expiresAt > Date.now() ? "authorizing" : need.unavailable ? "reconnect" : "connect";
+				return {
+					...need,
+					phase,
+					accounts: [],
+					alternatives: [],
+					...availability.reason || need.capabilityError ? { reason: availability.reason ?? need.capabilityError } : {}
+				};
+			}
+			const id = need.target.connectorId;
+			const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === id);
+			const installation = getConnectorInstallation(`${id}-${wait.principalId}`);
 			const cli = instance?.materialized.type === "cli" ? getCliAdapter(instance.materialized.adapterId) : void 0;
 			const scopeBlocked = Math.max(1, ...need.capabilities.filter((capability) => cli || /^[A-Z]+_/.test(capability)).map((capability) => SCOPE_ORDER[cli ? cli.curatedActions[capability] ?? "read" : scopeForComposioAction(capability).scope])) > SCOPE_ORDER[installation?.maxScope ?? "read"];
 			const all = listConnectorConnections({
 				principalId: wait.principalId,
-				connectorId: need.connectorId
+				connectorId: id
 			});
 			const requested = need.accountId ? all.find((connection) => connection.accountId === need.accountId) : void 0;
 			const blocked = scopeBlocked || instance?.enabled === false || installation?.enabled === false || installation?.selectedAccountIds?.length === 0 || Boolean(installation && requested && !canAccessConnectorAccount(requested, installation, wait.agentId)) || Boolean(installation?.allowedAgentIds.length && !installation.allowedAgentIds.includes(wait.agentId));
@@ -115,9 +134,9 @@ var ConnectionRecoveryService = class {
 				"revoked",
 				"failed"
 			].includes(connection.status)) ? "reconnect" : "connect";
-			const alternatives = ["composio-gmail", "composio-outlook"].includes(need.connectorId) ? ["composio-gmail", "composio-outlook"].filter((id) => id !== need.connectorId).map((id) => ({
-				candidateRef: id,
-				label: getConnectorDefinition(id)?.displayName ?? id
+			const alternatives = ["composio-gmail", "composio-outlook"].includes(id) ? ["composio-gmail", "composio-outlook"].filter((candidate) => candidate !== id).map((candidate) => ({
+				candidateRef: candidate,
+				label: getConnectorDefinition(candidate)?.displayName ?? candidate
 			})) : [];
 			return {
 				...need,
@@ -174,14 +193,16 @@ var ConnectionRecoveryService = class {
 			}))
 		}, verified).needs;
 		return Promise.all(wait.needs.map(async (need) => {
+			if (need.target.type === "plugin-mcp") return need;
 			if (views.find((view) => view.key === need.key)?.phase !== "ready") return {
 				...need,
 				capabilityError: void 0
 			};
 			try {
-				const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === need.connectorId && instance.enabled);
+				const id = need.target.connectorId;
+				const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === id && instance.enabled);
 				if (!instance) throw new Error("Connector setup is unavailable");
-				const definition = getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) ?? getConnectorDefinition(need.connectorId);
+				const definition = getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) ?? getConnectorDefinition(id);
 				if (definition?.runtime.type === "cli") {
 					const selected = views.find((view) => view.key === need.key);
 					const connection = selected?.connectionId ? getConnectorConnection(selected.connectionId) : void 0;
@@ -211,7 +232,7 @@ var ConnectionRecoveryService = class {
 				const missing = missingConnectionCapabilities(need, new Set(Object.entries(schemas && typeof schemas === "object" ? schemas : {}).filter(([action, value]) => value && typeof value === "object" && isToolInputSchema(value.inputSchema) && isComposioActionAllowedByCatalog(action)).map(([action]) => action)));
 				if (missing.length) log.warn({
 					conversationId: wait.conversationId,
-					connectorId: need.connectorId,
+					connectorId: id,
 					missingCapabilities: missing
 				}, "Connected app lacks required tool contracts");
 				return {
@@ -222,7 +243,7 @@ var ConnectionRecoveryService = class {
 				log.warn({
 					err,
 					conversationId: wait.conversationId,
-					connectorId: need.connectorId
+					connectorId: need.target.connectorId
 				}, "Connected app capability check failed");
 				return {
 					...need,
@@ -235,9 +256,10 @@ var ConnectionRecoveryService = class {
 		const config = this.deps.getConfig();
 		const instances = listConnectorInstances(config);
 		const cliIds = new Set(instances.filter((item) => item.materialized.type === "cli").map((item) => item.connectorId));
-		const fresh = wait.needs.some((need) => !cliIds.has(need.connectorId)) ? await this.adapter.syncConnections({ principalId: wait.principalId }) : [];
+		const connectorNeeds = wait.needs.filter(isConnectorNeed);
+		const fresh = connectorNeeds.some((need) => !cliIds.has(need.target.connectorId)) ? await this.adapter.syncConnections({ principalId: wait.principalId }) : [];
 		for (const connection of currentAccountConnections(listConnectorConnections({ principalId: wait.principalId }))) {
-			if (connection.provider !== "cli" || !wait.needs.some((need) => need.connectorId === connection.connectorId)) continue;
+			if (connection.provider !== "cli" || !connectorNeeds.some((need) => need.target.connectorId === connection.connectorId)) continue;
 			const policy = getConnectorInstallation(`${connection.connectorId}-${wait.principalId}`);
 			if (!policy || !canAccessConnectorAccount(connection, policy, wait.agentId)) continue;
 			const instanceId = connection.metadata.runtimeInstanceId;
@@ -247,6 +269,38 @@ var ConnectionRecoveryService = class {
 		}
 		return fresh;
 	}
+	async syncPluginMcpNeeds(wait) {
+		return Promise.all(wait.needs.map(async (need) => {
+			if (need.target.type !== "plugin-mcp") return need;
+			const status = await this.pluginMcp.status(need.target);
+			if (status.status === "connected") {
+				const verified = await this.pluginMcp.verify(need.target);
+				return {
+					...need,
+					connectionId: need.target.serverId,
+					unavailable: false,
+					attempt: void 0,
+					capabilityError: verified.ready ? void 0 : verified.error ?? "The connected MCP tools are unavailable."
+				};
+			}
+			if (status.status === "authorizing") return {
+				...need,
+				connectionId: void 0,
+				unavailable: false,
+				attempt: {
+					id: status.session?.id ?? need.attempt?.id ?? randomUUID(),
+					expiresAt: status.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
+				}
+			};
+			return {
+				...need,
+				connectionId: void 0,
+				unavailable: true,
+				attempt: void 0,
+				capabilityError: status.status === "error" ? status.session?.error : void 0
+			};
+		}));
+	}
 	async preflight(input) {
 		if (input.kind !== "connection_resume") return true;
 		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
@@ -255,12 +309,13 @@ var ConnectionRecoveryService = class {
 		try {
 			const fresh = await this.syncConnections(wait);
 			const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
-			wait.needs = await this.checkCapabilities(wait, verified);
-			const ready = this.view(wait, verified).needs.every((need) => need.phase === "ready");
-			wait.needs = wait.needs.map((need) => ({
+			wait.needs = await this.syncPluginMcpNeeds(wait);
+			wait.needs = wait.needs.map((need) => need.target.type === "plugin-mcp" ? need : {
 				...need,
 				unavailable: !fresh.some((item) => item.id === need.connectionId && item.status === "active")
-			}));
+			});
+			wait.needs = await this.checkCapabilities(wait, verified);
+			const ready = this.view(wait, verified).needs.every((need) => need.phase === "ready");
 			if (getConnectionWait(wait.id)?.version !== wait.version) return false;
 			if (ready && wait.intent && wait.intent.validUntil > Date.now() && wait.intent.objectiveRevision === wait.objectiveRevision) return true;
 		} catch {}
@@ -319,8 +374,51 @@ var ConnectionRecoveryService = class {
 				const need = wait.needs.find((need) => need.key === action.needKey);
 				if (!need) throw new Error("Unknown connection requirement.");
 				if (this.view(wait).needs.find((item) => item.key === need.key)?.phase === "blocked") throw new Error("Connector policy blocks this connection.");
-				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === need.connectorId);
-				const definition = (instance ? getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) : void 0) ?? getConnectorDefinition(need.connectorId);
+				if (need.target.type === "plugin-mcp") {
+					const serverId = need.target.serverId;
+					const attemptId = randomUUID();
+					wait = updateConnectionWait({
+						...wait,
+						intent: {
+							objectiveRevision: wait.objectiveRevision,
+							validUntil: Date.now() + INTENT_TTL
+						},
+						needs: wait.needs.map((item) => item.key === need.key ? {
+							...item,
+							unavailable: false,
+							capabilityError: void 0,
+							attempt: {
+								id: attemptId,
+								expiresAt: Date.now() + ATTEMPT_TTL
+							}
+						} : item)
+					}, wait.version);
+					publishConnectionWait(conversationId);
+					const auth = await this.pluginMcp.start(need.target);
+					const latest = getConnectionWait(wait.id);
+					if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
+					wait = updateConnectionWait({
+						...wait,
+						needs: wait.needs.map((item) => item.key === need.key ? {
+							...item,
+							attempt: auth.status === "authorizing" ? {
+								id: auth.session?.id ?? attemptId,
+								expiresAt: auth.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
+							} : void 0,
+							connectionId: auth.status === "connected" ? serverId : void 0,
+							unavailable: auth.status === "error",
+							capabilityError: auth.status === "error" ? auth.session?.error : void 0
+						} : item)
+					}, wait.version);
+					publishConnectionWait(conversationId);
+					return {
+						snapshot: this.snapshot(conversationId),
+						authorizationUrl: auth.session?.authorizationUrl
+					};
+				}
+				const id = need.target.connectorId;
+				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === id);
+				const definition = (instance ? getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) : void 0) ?? getConnectorDefinition(id);
 				if (definition?.runtime.type === "cli") {
 					updateConnectionWait({
 						...wait,
@@ -332,7 +430,7 @@ var ConnectionRecoveryService = class {
 					publishConnectionWait(conversationId);
 					return {
 						snapshot: this.snapshot(conversationId),
-						authorizationUrl: `/#/connectors?connector=${encodeURIComponent(need.connectorId)}`
+						authorizationUrl: `/#/connectors?connector=${encodeURIComponent(id)}`
 					};
 				}
 				if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error("Unsupported connector.");
@@ -353,8 +451,8 @@ var ConnectionRecoveryService = class {
 				}, wait.version);
 				publishConnectionWait(conversationId);
 				const config = this.deps.getConfig();
-				await this.ensureInstallation(wait, need.connectorId);
-				const installationId = `${need.connectorId}-${wait.principalId}`;
+				await this.ensureInstallation(wait, id);
+				const installationId = `${id}-${wait.principalId}`;
 				const auth = await this.adapter.authorize({
 					principalId: wait.principalId,
 					toolkit: definition.runtime.toolkit,
@@ -388,12 +486,20 @@ var ConnectionRecoveryService = class {
 					authorizationUrl: auth.connectUrl
 				};
 			} else {
+				if (action.action === "submit_callback") {
+					const need = wait.needs.find((need) => need.key === action.needKey);
+					if (!need || need.target.type !== "plugin-mcp") throw new Error("OAuth callback is unavailable.");
+					if (!action.callbackUrl || action.callbackUrl.length > 16384) throw new Error("Expected the complete OAuth callback URL.");
+					await this.pluginMcp.submitCallback(need.target, action.callbackUrl);
+				}
 				const fresh = await this.syncConnections(wait);
 				const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
 				const latest = getConnectionWait(wait.id);
 				if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
 				let needs = wait.needs.map((need) => {
-					const authorized = fresh.find((item) => item.providerConnectionId === need.attempt?.connectionId && item.status === "active" && item.connectorId === need.connectorId && (!need.accountId || item.accountId === need.accountId));
+					if (need.target.type === "plugin-mcp") return need;
+					const id = need.target.connectorId;
+					const authorized = fresh.find((item) => item.providerConnectionId === need.attempt?.connectionId && item.status === "active" && item.connectorId === id && (!need.accountId || item.accountId === need.accountId));
 					return authorized ? {
 						...need,
 						unavailable: false,
@@ -404,13 +510,19 @@ var ConnectionRecoveryService = class {
 						attempt: void 0
 					} : {
 						...need,
-						unavailable: !fresh.some((item) => item.connectorId === need.connectorId && item.status === "active" && (!need.connectionId || item.id === need.connectionId) && (!need.accountId || item.accountId === need.accountId))
+						unavailable: !fresh.some((item) => item.connectorId === id && item.status === "active" && (!need.connectionId || item.id === need.connectionId) && (!need.accountId || item.accountId === need.accountId))
 					};
 				});
+				needs = await this.syncPluginMcpNeeds({
+					...wait,
+					needs
+				});
 				if (action.action === "select_account") {
 					const need = needs.find((item) => item.key === action.needKey);
-					const connection = currentAccountConnections(fresh).find((item) => item.accountId === action.accountId && item.connectorId === need?.connectorId);
-					if (!need || !connection || !this.view(wait, verified).needs.find((item) => item.key === need.key)?.accounts.some((item) => item.id === connection.accountId)) throw new Error("Account is unavailable.");
+					if (!need || need.target.type !== "connector") throw new Error("Account selection is unavailable.");
+					const id = need.target.connectorId;
+					const connection = currentAccountConnections(fresh).find((item) => item.accountId === action.accountId && item.connectorId === id);
+					if (!connection || !this.view(wait, verified).needs.find((item) => item.key === need.key)?.accounts.some((item) => item.id === connection.accountId)) throw new Error("Account is unavailable.");
 					needs = needs.map((item) => item.key === need.key ? {
 						...item,
 						connectionId: connection.id,
@@ -422,7 +534,7 @@ var ConnectionRecoveryService = class {
 				for (const selected of this.view({
 					...wait,
 					needs
-				}, verified).needs) if (selected.phase === "ready" || selected.capabilityError && selected.connectionId) await this.ensureInstallation(wait, selected.connectorId);
+				}, verified).needs) if (selected.target.type === "connector" && (selected.phase === "ready" || selected.capabilityError && selected.connectionId)) await this.ensureInstallation(wait, selected.target.connectorId);
 				needs = await this.checkCapabilities({
 					...wait,
 					needs

package/dist/src/connectors/plugin-mcp-recovery.d.ts

@@ -0,0 +1,28 @@
+import type { PluginMcpConnectionTarget } from '@xopcai/gateway-contract';
+import { type McpOAuthStatus } from '../agent/mcp/oauth/mcp-oauth-manager.js';
+import type { Config } from '../config/schema.js';
+export type PluginMcpAvailability = {
+    available: boolean;
+    reason?: string;
+};
+export type PluginMcpVerification = {
+    ready: boolean;
+    error?: string;
+};
+export interface PluginMcpRecovery {
+    availability(target: PluginMcpConnectionTarget): PluginMcpAvailability;
+    status(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    start(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    verify(target: PluginMcpConnectionTarget): Promise<PluginMcpVerification>;
+    submitCallback(target: PluginMcpConnectionTarget, callbackUrl: string): Promise<McpOAuthStatus>;
+}
+export declare class HostPluginMcpRecovery implements PluginMcpRecovery {
+    private readonly getConfig;
+    constructor(getConfig: () => Config);
+    availability(target: PluginMcpConnectionTarget): PluginMcpAvailability;
+    status(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    start(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    verify(target: PluginMcpConnectionTarget): Promise<PluginMcpVerification>;
+    submitCallback(target: PluginMcpConnectionTarget, callbackUrl: string): Promise<McpOAuthStatus>;
+    private resolveServer;
+}

package/dist/src/connectors/plugin-mcp-recovery.js

@@ -0,0 +1,90 @@
+import { AgentPluginStore } from "../extensions/agent-plugins/store.js";
+import { savePluginAuthBinding } from "../extensions/agent-plugins/auth.js";
+import { loadMergedBundleMcpConfig } from "../agent/mcp/bundle-mcp-config.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
+import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
+import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
+//#region src/connectors/plugin-mcp-recovery.ts
+var HostPluginMcpRecovery = class {
+	constructor(getConfig) {
+		this.getConfig = getConfig;
+	}
+	availability(target) {
+		const plugin = new AgentPluginStore().get(target.pluginId);
+		if (!plugin) return {
+			available: false,
+			reason: "The plugin is no longer installed."
+		};
+		if (!plugin.receipt.enabled) return {
+			available: false,
+			reason: "Enable the plugin before connecting its account."
+		};
+		if (plugin.readiness === "blocked") return {
+			available: false,
+			reason: "Repair the plugin before connecting its account."
+		};
+		if (plugin.servers[target.serverName]?.type !== "streamable-http") return {
+			available: false,
+			reason: "This plugin server does not support OAuth."
+		};
+		return { available: true };
+	}
+	async status(target) {
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).status(target.serverId, server);
+	}
+	async start(target) {
+		const availability = this.availability(target);
+		if (!availability.available) throw new Error(availability.reason);
+		await savePluginAuthBinding(new AgentPluginStore(), target.pluginId, target.serverName, { mode: "oauth" });
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).start({
+			serverId: target.serverId,
+			rawServer: server,
+			cfg: this.getConfig()
+		});
+	}
+	async verify(target) {
+		const availability = this.availability(target);
+		if (!availability.available) return {
+			ready: false,
+			error: availability.reason
+		};
+		const status = await this.status(target);
+		if (status.status !== "connected") return {
+			ready: false,
+			error: status.session?.error
+		};
+		const cfg = this.getConfig();
+		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
+			workspaceDir: getWorkspacePath(cfg) || "./workspace",
+			cfg,
+			serverId: target.serverId
+		});
+		if (capabilities.error) return {
+			ready: false,
+			error: capabilities.error.message
+		};
+		if (capabilities.toolCount === 0) return {
+			ready: false,
+			error: "The connected MCP server did not expose any tools."
+		};
+		return { ready: true };
+	}
+	async submitCallback(target, callbackUrl) {
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).submitCallback(target.serverId, server, callbackUrl);
+	}
+	resolveServer(target) {
+		const cfg = this.getConfig();
+		const server = loadMergedBundleMcpConfig({
+			workspaceDir: getWorkspacePath(cfg) || "./workspace",
+			cfg
+		}).config.mcpServers[target.serverId];
+		const origin = server?.xopcPlugin;
+		if (!server || origin?.id !== target.pluginId || origin.serverName !== target.serverName) throw new Error("Plugin MCP server is unavailable.");
+		return server;
+	}
+};
+//#endregion
+export { HostPluginMcpRecovery };

package/dist/src/extensions/agent-plugins/auth.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { AgentPluginStore } from './store.js';
+import { type PluginServer } from './validation.js';
+declare const bindingSchema: z.ZodObject<{
+    serverName: z.ZodString;
+    mode: z.ZodEnum<{
+        none: "none";
+        auto: "auto";
+        oauth: "oauth";
+        "api-key": "api-key";
+    }>;
+    identityScope: z.ZodLiteral<"owner">;
+    endpointFingerprint: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        target: z.ZodEnum<{
+            headers: "headers";
+            env: "env";
+        }>;
+        key: z.ZodString;
+        provider: z.ZodString;
+        prefix: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PluginAuthBinding = z.infer<typeof bindingSchema>;
+export declare function pluginEndpointFingerprint(server: PluginServer): string;
+export declare function readPluginAuthBinding(store: AgentPluginStore, id: string, name: string, server: PluginServer): PluginAuthBinding | undefined;
+export declare function savePluginAuthBinding(store: AgentPluginStore, id: string, name: string, input: {
+    mode: PluginAuthBinding['mode'];
+    secrets?: Array<{
+        target: 'headers' | 'env';
+        key: string;
+        value: string;
+        prefix?: string;
+    }>;
+}): Promise<void>;
+export declare function applyPluginAuthBinding(raw: Record<string, unknown>, binding: PluginAuthBinding | undefined): Record<string, unknown>;
+export declare function pluginOAuthScope(raw: unknown): string | undefined;
+export declare function removePluginCredentials(store: AgentPluginStore, id: string): Promise<void>;
+export {};

package/dist/src/extensions/agent-plugins/auth.js

@@ -0,0 +1,156 @@
+import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
+import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
+import { pluginName, pluginServerId } from "./validation.js";
+import { clearPluginMcpHealth } from "./health.js";
+import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
+import { McpOAuthStore } from "../../agent/mcp/oauth/mcp-oauth-store.js";
+import { join } from "node:path";
+import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { validateHeaderName } from "node:http";
+//#region src/extensions/agent-plugins/auth.ts
+init_credentials();
+init_write_file_atomic();
+init_paths_state();
+const bindingSchema = z.strictObject({
+	serverName: z.string(),
+	mode: z.enum([
+		"auto",
+		"oauth",
+		"api-key",
+		"none"
+	]),
+	identityScope: z.literal("owner"),
+	endpointFingerprint: z.string(),
+	fields: z.array(z.strictObject({
+		target: z.enum(["headers", "env"]),
+		key: z.string(),
+		provider: z.string(),
+		prefix: z.string()
+	}))
+});
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const providerPrefix = (id) => `plugin-${hash(id).slice(0, 16)}-`;
+function pluginEndpointFingerprint(server) {
+	return hash(server.type === "stdio" ? JSON.stringify(server) : new URL(server.url).toString());
+}
+function bindingPath(store, id, name) {
+	return join(store.stateDir, "plugin-auth", pluginName.parse(id), `${hash(name)}.json`);
+}
+function readPluginAuthBinding(store, id, name, server) {
+	const path = bindingPath(store, id, name);
+	if (!existsSync(path)) return void 0;
+	const binding = bindingSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+	return binding.endpointFingerprint === pluginEndpointFingerprint(server) ? binding : void 0;
+}
+async function savePluginAuthBinding(store, id, name, input) {
+	const plugin = store.get(id);
+	const server = plugin?.servers[name];
+	if (!server || plugin?.readiness === "blocked") throw new Error("Plugin MCP server unavailable");
+	if (input.mode === "oauth" && server.type !== "streamable-http") throw new Error("OAuth requires streamable HTTP");
+	const endpointFingerprint = pluginEndpointFingerprint(server);
+	const fields = [];
+	const resolver = new CredentialResolver(store.stateDir === resolveStateDir() ? {} : { stateDir: store.stateDir });
+	if (input.mode !== "api-key" && input.secrets?.length) throw new Error("Secrets require api-key mode");
+	const seen = /* @__PURE__ */ new Set();
+	for (const field of input.secrets ?? []) {
+		if (!field.value || field.value.length > 16384 || /[\r\n\0]/.test(field.value) || /[\r\n\0]/.test(field.prefix ?? "")) throw new Error("Invalid secret value");
+		if (field.target === "headers") {
+			validateHeaderName(field.key);
+			if (server.type === "stdio") throw new Error("stdio credentials must use env");
+			if ([
+				"host",
+				"content-length",
+				"connection",
+				"transfer-encoding",
+				"cookie"
+			].includes(field.key.toLowerCase())) throw new Error("Unsupported credential header");
+		} else if (server.type !== "stdio" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(field.key) || /^(PLUGIN_ROOT|PLUGIN_DATA|PATH)$/i.test(field.key) || isDangerousHostEnvVarName(field.key)) throw new Error("Unsupported credential environment variable");
+		const normalizedKey = field.target === "headers" || process.platform === "win32" ? field.key.toLowerCase() : field.key;
+		if (seen.has(normalizedKey)) throw new Error("Duplicate credential field");
+		seen.add(normalizedKey);
+		const provider = `${providerPrefix(id)}${hash(JSON.stringify([
+			"owner",
+			id,
+			name,
+			endpointFingerprint,
+			field.target,
+			normalizedKey
+		]))}`;
+		fields.push({
+			target: field.target,
+			key: field.key,
+			provider,
+			prefix: field.prefix ?? ""
+		});
+	}
+	for (let i = 0; i < fields.length; i++) await resolver.saveApiKey(fields[i].provider, input.secrets[i].value);
+	const binding = bindingSchema.parse({
+		serverName: name,
+		mode: input.mode,
+		identityScope: "owner",
+		endpointFingerprint,
+		fields
+	});
+	await writeTextAtomic(bindingPath(store, id, name), JSON.stringify(binding));
+	clearPluginMcpHealth(id, name, store.stateDir);
+}
+function applyPluginAuthBinding(raw, binding) {
+	if (!binding) return raw;
+	const result = { ...raw };
+	if (binding.mode === "none" || binding.mode === "api-key") {
+		delete result.auth;
+		delete result.xopcAutoAuth;
+	}
+	if (binding.mode === "oauth") {
+		result.auth = { type: "oauth" };
+		delete result.xopcAutoAuth;
+		result.headers = Object.fromEntries(Object.entries(result.headers ?? {}).filter(([key]) => key.toLowerCase() !== "authorization"));
+	}
+	for (const field of binding.fields) {
+		const values = { ...result[field.target] };
+		const insensitive = field.target === "headers" || process.platform === "win32";
+		for (const key of Object.keys(values)) if (insensitive ? key.toLowerCase() === field.key.toLowerCase() : key === field.key) delete values[key];
+		values[field.key] = { xopcSecretRef: {
+			provider: field.provider,
+			fieldKey: field.key,
+			prefix: field.prefix
+		} };
+		result[field.target] = values;
+	}
+	result.xopcAuthRevision = hash(JSON.stringify(binding));
+	return result;
+}
+function pluginOAuthScope(raw) {
+	const plugin = raw?.xopcPlugin;
+	return plugin ? `owner:${pluginServerId(plugin.id, plugin.serverName)}` : void 0;
+}
+async function removePluginCredentials(store, id) {
+	pluginName.parse(id);
+	const plugin = store.get(id);
+	const serverNames = new Set(Object.keys(plugin?.servers ?? {}));
+	const dir = join(store.stateDir, "plugin-auth", id);
+	if (existsSync(dir)) for (const file of readdirSync(dir)) {
+		if (!/^[a-f0-9]{64}\.json$/.test(file)) throw new Error("Unexpected plugin auth store entry");
+		const binding = bindingSchema.parse(JSON.parse(readFileSync(join(dir, file), "utf8")));
+		serverNames.add(binding.serverName);
+	}
+	const { getMcpOAuthManager } = await import("../../agent/mcp/oauth/mcp-oauth-manager.js");
+	for (const name of serverNames) {
+		await getMcpOAuthManager({ xopcPlugin: {
+			id,
+			serverName: name
+		} }).cancelPending();
+		await new McpOAuthStore(`owner:${pluginServerId(id, name)}`).deleteScope();
+	}
+	const resolver = new CredentialResolver(store.stateDir === resolveStateDir() ? {} : { stateDir: store.stateDir });
+	for (const profile of await resolver.listProfiles()) if (profile.provider.startsWith(providerPrefix(id))) await resolver.deleteProviderCredential(profile.provider);
+	if (existsSync(dir)) rmSync(dir, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+export { applyPluginAuthBinding, pluginEndpointFingerprint, pluginOAuthScope, readPluginAuthBinding, removePluginCredentials, savePluginAuthBinding };

package/dist/src/extensions/agent-plugins/connection.d.ts

@@ -0,0 +1,8 @@
+import type { ConnectionNeed } from '@xopcai/gateway-contract';
+import { AgentPluginStore } from './store.js';
+export declare function pluginMcpCandidateRef(pluginId: string, serverName: string): string;
+export declare function parsePluginMcpCandidateRef(ref: string): {
+    pluginId: string;
+    serverName: string;
+} | undefined;
+export declare function resolvePluginMcpConnectionCandidate(ref: string, store?: AgentPluginStore): ConnectionNeed | undefined;

package/dist/src/extensions/agent-plugins/connection.js

@@ -0,0 +1,41 @@
+import { pluginServerId } from "./validation.js";
+import { AgentPluginStore } from "./store.js";
+//#region src/extensions/agent-plugins/connection.ts
+const PREFIX = "plugin-mcp:";
+function pluginMcpCandidateRef(pluginId, serverName) {
+	return `${PREFIX}${encodeURIComponent(pluginId)}:${encodeURIComponent(serverName)}`;
+}
+function parsePluginMcpCandidateRef(ref) {
+	if (!ref.startsWith(PREFIX)) return void 0;
+	const parts = ref.slice(11).split(":");
+	if (parts.length !== 2) return void 0;
+	try {
+		return {
+			pluginId: decodeURIComponent(parts[0]),
+			serverName: decodeURIComponent(parts[1])
+		};
+	} catch {
+		return;
+	}
+}
+function resolvePluginMcpConnectionCandidate(ref, store = new AgentPluginStore()) {
+	const parsed = parsePluginMcpCandidateRef(ref);
+	if (!parsed) return void 0;
+	const plugin = store.get(parsed.pluginId);
+	const server = plugin?.servers[parsed.serverName];
+	if (!plugin || !server || !plugin.receipt.enabled || plugin.readiness === "blocked" || server.type !== "streamable-http") return;
+	const serverId = pluginServerId(plugin.id, parsed.serverName);
+	return {
+		key: serverId,
+		target: {
+			type: "plugin-mcp",
+			pluginId: plugin.id,
+			serverId,
+			serverName: parsed.serverName
+		},
+		label: plugin.manifest.name,
+		capabilities: [`mcp.tools:${serverId}`]
+	};
+}
+//#endregion
+export { parsePluginMcpCandidateRef, pluginMcpCandidateRef, resolvePluginMcpConnectionCandidate };