@xopcai/xopc 0.0.369 → 0.0.370

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

@@ -1,90 +0,0 @@
-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/connection.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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 };

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

@@ -1,4 +0,0 @@
-export type PluginMcpHealth = 'ready' | 'authorization_required' | 'error' | 'not_tested';
-export declare function readPluginMcpHealth(id: string, name: string, revision: string, stateDir?: string): PluginMcpHealth;
-export declare function clearPluginMcpHealth(id: string, name: string, stateDir?: string): void;
-export declare function recordPluginMcpHealth(raw: unknown, status: Exclude<PluginMcpHealth, 'not_tested'>): void;

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

@@ -1,48 +0,0 @@
-import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
-import { pluginName } from "./validation.js";
-import { join } from "node:path";
-import { readFileSync, rmSync } from "node:fs";
-import { createHash } from "node:crypto";
-//#region src/extensions/agent-plugins/health.ts
-init_paths_state();
-init_write_file_atomic();
-init_logger();
-const log = createLogger("PluginMcpHealth");
-function pathFor(id, name, stateDir) {
-	return join(stateDir, "plugin-health", pluginName.parse(id), `${createHash("sha256").update(name).digest("hex")}.json`);
-}
-function readPluginMcpHealth(id, name, revision, stateDir = resolveStateDir()) {
-	try {
-		const value = JSON.parse(readFileSync(pathFor(id, name, stateDir), "utf8"));
-		return value.revision === revision && [
-			"ready",
-			"authorization_required",
-			"error"
-		].includes(value.status) ? value.status : "not_tested";
-	} catch {
-		return "not_tested";
-	}
-}
-function clearPluginMcpHealth(id, name, stateDir = resolveStateDir()) {
-	rmSync(pathFor(id, name, stateDir), { force: true });
-}
-function recordPluginMcpHealth(raw, status) {
-	const plugin = raw?.xopcPlugin;
-	if (!plugin) return;
-	try {
-		writeTextAtomicSync(pathFor(plugin.id, plugin.serverName, resolveStateDir()), JSON.stringify({
-			revision: plugin.revision,
-			status
-		}));
-	} catch (error) {
-		log.warn({
-			err: error,
-			pluginId: plugin.id
-		}, "Could not persist MCP connection status");
-	}
-}
-//#endregion
-export { clearPluginMcpHealth, readPluginMcpHealth, recordPluginMcpHealth };

package/dist/src/extensions/agent-plugins/plugin-oauth-scope.d.ts

@@ -1 +0,0 @@
-export declare function pluginOAuthScope(raw: unknown): string | undefined;

package/dist/src/extensions/agent-plugins/plugin-oauth-scope.js

@@ -1,8 +0,0 @@
-import { pluginServerId } from "./validation.js";
-//#region src/extensions/agent-plugins/plugin-oauth-scope.ts
-function pluginOAuthScope(raw) {
-	const plugin = raw?.xopcPlugin;
-	return plugin ? `owner:${pluginServerId(plugin.id, plugin.serverName)}` : void 0;
-}
-//#endregion
-export { pluginOAuthScope };