mcp-creatio 0.3.6

package/src/creatio/auth/providers/legacy-provider.ts

@@ -0,0 +1,70 @@
+import log from '../../../log';
+import { JSON_ACCEPT } from '../../../types';
+import { parseSetCookie } from '../../../utils';
+import { LegacyAuthConfig } from '../../client-config';
+import { buildHeaders } from '../auth';
+
+import { BaseProvider } from './base-provider';
+
+export class LegacyProvider extends BaseProvider<LegacyAuthConfig> {
+	private _bpmCsrf: string | undefined;
+
+	private _cookieHeader: string | undefined;
+
+	private async _ensureSession() {
+		if (this._cookieHeader) {
+			return;
+		}
+		const url = `${this.config.baseUrl.replace(/\/$/, '')}/ServiceModel/AuthService.svc/Login`;
+		const body = JSON.stringify({
+			UserName: this.authConfig.login,
+			UserPassword: this.authConfig.password,
+		});
+		log.creatioAuthStart(this.config.baseUrl, 'legacy');
+		const res = await fetch(url, {
+			method: 'POST',
+			headers: buildHeaders(JSON_ACCEPT, true),
+			body,
+			redirect: 'manual',
+		});
+		if (!res.ok) {
+			const responseText = await res.text().catch(() => '');
+			log.creatioAuthFailed(this.config.baseUrl, `${res.status} ${responseText}`, 'legacy');
+			throw new Error(`auth_failed:${res.status} ${responseText}`);
+		}
+		log.creatioAuthOk(this.config.baseUrl, 'legacy');
+		let setCookie: string[] = [];
+		if (typeof (res.headers as any).getSetCookie === 'function') {
+			setCookie = (res.headers as any).getSetCookie();
+		} else if ((res.headers as any).raw && (res.headers as any).raw()['set-cookie']) {
+			setCookie = (res.headers as any).raw()['set-cookie'];
+		} else {
+			setCookie = [];
+		}
+		const pairs = parseSetCookie(setCookie);
+		if (!pairs.length) {
+			throw new Error('auth_failed:no_set_cookie');
+		}
+		this._cookieHeader = pairs.map((c) => `${c.name}=${c.value}`).join('; ');
+		const csrf = pairs.find((c) => c.name.toUpperCase() === 'BPMCSRF')?.value;
+		if (csrf) {
+			this._bpmCsrf = csrf;
+		}
+	}
+
+	public async getHeaders(accept: string, isJson?: boolean): Promise<Record<string, string>> {
+		await this._ensureSession();
+		const h = buildHeaders(accept, Boolean(isJson));
+		h['ForceUseSession'] = 'true';
+		h['Cookie'] = this._cookieHeader!;
+		if (this._bpmCsrf) {
+			h['BPMCSRF'] = this._bpmCsrf;
+		}
+		return h;
+	}
+
+	public async refresh(): Promise<void> {
+		this._cookieHeader = undefined;
+		await this._ensureSession();
+	}
+}

package/src/creatio/auth/providers/oauth2-code-provider.ts

@@ -0,0 +1,252 @@
+import { HTTP_MCP_PORT } from '../../../consts';
+import log from '../../../log';
+import { SessionContext, TokenRefreshScheduler, type UserTokens } from '../../../services';
+import { getEffectiveUserKey, getUserKey } from '../../../utils';
+import { CreatioClientConfig, OAuth2CodeAuthConfig } from '../../client-config';
+import { AUTHORIZE_ENDPOINT, REVOCATION_ENDPOINT, TOKEN_ENDPOINT } from '../auth';
+
+import { BaseOAuth2Provider } from './base-oauth2-provider';
+
+export class OAuth2CodeProvider extends BaseOAuth2Provider<OAuth2CodeAuthConfig> {
+	private readonly _sessionContext = SessionContext.instance;
+	private readonly _tokenRefreshScheduler = new TokenRefreshScheduler();
+
+	protected readonly authErrorCode = 'oauth2_code_need_consent';
+
+	private get _scope() {
+		return this.authConfig.scope || 'offline_access';
+	}
+
+	constructor(config: CreatioClientConfig) {
+		super(config);
+		this._tokenRefreshScheduler.setRefreshCallback(this.refreshUserTokens.bind(this));
+	}
+
+	private async _exchangeCodeForTokens(code: string): Promise<UserTokens> {
+		const idBase = this.getIdentityBase();
+		const url = idBase + TOKEN_ENDPOINT;
+		const body = new URLSearchParams();
+		body.set('grant_type', 'authorization_code');
+		body.set('client_id', this.authConfig.clientId);
+		if (this.authConfig.clientSecret) {
+			body.set('client_secret', this.authConfig.clientSecret);
+		}
+		body.set('code', code);
+		body.set('redirect_uri', this.authConfig.redirectUri);
+		body.set('scope', this._scope);
+		log.creatioAuthStart(this.config.baseUrl, 'oauth2_code');
+		const res = await fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+			body: body.toString(),
+		});
+		const txt = await res.text().catch(() => '');
+		if (!res.ok || !txt) {
+			log.creatioAuthFailed(this.config.baseUrl, `token:${res.status} ${txt}`, 'oauth2_code');
+			throw new Error(`oauth2_code_token_error:${res.status}`);
+		}
+		let j: any;
+		try {
+			j = JSON.parse(txt);
+		} catch {
+			log.creatioAuthFailed(this.config.baseUrl, 'token_parse_failed', 'oauth2_code');
+			throw new Error('oauth2_code_token_parse_failed');
+		}
+		if (!j.access_token) {
+			throw new Error('oauth2_code_no_access_token');
+		}
+		const expiresIn = Number(j.expires_in) || 180;
+		const accessTokenExpiryMs = this.computeExpiryMs(expiresIn, 1);
+		log.creatioAuthOk(this.config.baseUrl, 'oauth2_code');
+		return {
+			accessToken: String(j.access_token),
+			accessTokenExpiryMs,
+			refreshToken: j.refresh_token ? String(j.refresh_token) : undefined,
+		};
+	}
+
+	private async _refreshTokens(refreshToken: string): Promise<UserTokens> {
+		const idBase = this.getIdentityBase();
+		const url = idBase + TOKEN_ENDPOINT;
+		log.info('oauth2_code.refresh_attempt', { url, refreshTokenLength: refreshToken.length });
+		const body = new URLSearchParams();
+		body.set('grant_type', 'refresh_token');
+		body.set('client_id', this.authConfig.clientId);
+		if (this.authConfig.clientSecret) {
+			body.set('client_secret', this.authConfig.clientSecret);
+		}
+		body.set('refresh_token', refreshToken);
+		body.set('redirect_uri', this.authConfig.redirectUri);
+		body.set('scope', this._scope);
+		const res = await fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+			body: body.toString(),
+		});
+		const txt = await res.text().catch(() => '');
+		log.info('oauth2_code.refresh_response', {
+			status: res.status,
+			hasBody: !!txt,
+			bodyLength: txt.length,
+		});
+		if (!res.ok || !txt) {
+			log.error('oauth2_code.refresh_failed', {
+				status: res.status,
+				body: txt.substring(0, 200),
+			});
+			throw new Error(`oauth2_code_refresh_error:${res.status}`);
+		}
+		let j: any;
+		try {
+			j = JSON.parse(txt);
+		} catch {
+			throw new Error('oauth2_code_refresh_parse_failed');
+		}
+		if (!j.access_token) {
+			throw new Error('oauth2_code_refresh_no_access_token');
+		}
+		const expiresIn = Number(j.expires_in) || 180;
+		const accessTokenExpiryMs = this.computeExpiryMs(expiresIn, 1);
+		const newTokens = {
+			accessToken: String(j.access_token),
+			accessTokenExpiryMs,
+			refreshToken: j.refresh_token ? String(j.refresh_token) : refreshToken,
+		};
+		log.info('oauth2_code.refresh_success', {
+			hasNewRefreshToken: !!j.refresh_token,
+			expiresIn,
+			accessTokenLength: newTokens.accessToken.length,
+		});
+		return newTokens;
+	}
+
+	protected throwNoTokenError(): void {
+		const userKey = getEffectiveUserKey();
+		const errorMessage = userKey
+			? `${this.authErrorCode}:http://localhost:${HTTP_MCP_PORT}/oauth/start?userKey=${encodeURIComponent(userKey)}`
+			: this.authErrorCode;
+		throw new Error(errorMessage);
+	}
+
+	protected async ensureAccessToken(force = false): Promise<string | undefined> {
+		log.info('oauth2_code.ensure_access_token.start', { force });
+		const now = Date.now();
+		if (
+			!force &&
+			this.accessToken &&
+			this.accessTokenExpiryMs &&
+			now < this.accessTokenExpiryMs
+		) {
+			return this.accessToken;
+		}
+		const userKey = getEffectiveUserKey();
+		if (!userKey) {
+			log.warn('oauth2_code.no_user_key');
+			return undefined;
+		}
+		const saved = await this._sessionContext.getTokensForUser(userKey);
+		if (!saved) {
+			log.warn('oauth2_code.no_saved_tokens', { userKey });
+			return undefined;
+		}
+		if (
+			!force &&
+			saved.accessToken &&
+			saved.accessTokenExpiryMs &&
+			now < saved.accessTokenExpiryMs
+		) {
+			this.accessToken = saved.accessToken;
+			this.accessTokenExpiryMs = saved.accessTokenExpiryMs;
+			return this.accessToken;
+		}
+		if (saved.refreshToken) {
+			const updated = await this._refreshTokens(saved.refreshToken);
+			await this._sessionContext.setTokensForUser(userKey, updated);
+			this.accessToken = updated.accessToken;
+			this.accessTokenExpiryMs = updated.accessTokenExpiryMs;
+			return this.accessToken;
+		}
+		await this._sessionContext.deleteTokensForUser(userKey);
+		return undefined;
+	}
+
+	public async finishAuthorization(code: string): Promise<void> {
+		const userKey = getEffectiveUserKey();
+		log.info('oauth2_code.finish_authorization', { userKey, hasCode: !!code });
+		if (!userKey) {
+			throw new Error('oauth2_code_missing_user');
+		}
+		const tokens = await this._exchangeCodeForTokens(code);
+		await this._sessionContext.setTokensForUser(userKey, tokens);
+		this.accessToken = tokens.accessToken;
+		this.accessTokenExpiryMs = tokens.accessTokenExpiryMs;
+		this._tokenRefreshScheduler.scheduleRefresh(userKey);
+		log.info('oauth2_code.authorization_complete', { userKey });
+	}
+
+	public async getAuthorizeUrl(state: string): Promise<string> {
+		const idBase = this.getIdentityBase();
+		const u = new URL(idBase + AUTHORIZE_ENDPOINT);
+		u.searchParams.set('client_id', this.authConfig.clientId);
+		u.searchParams.set('redirect_uri', this.authConfig.redirectUri);
+		u.searchParams.set('response_type', 'code');
+		u.searchParams.set('state', state);
+		const scopeParam = encodeURIComponent(this._scope);
+		u.search += '&scope=' + scopeParam;
+		log.info('oauth2_code.authorize_url', {
+			idBase,
+			url: u.toString(),
+		});
+		return u.toString();
+	}
+
+	public async revoke(): Promise<void> {
+		try {
+			const userKey = getUserKey();
+			if (!userKey) {
+				return;
+			}
+			const saved = await this._sessionContext.getTokensForUser(userKey);
+			if (!saved?.refreshToken) {
+				await this._sessionContext.deleteTokensForUser(userKey);
+				return;
+			}
+			const idBase = this.getIdentityBase();
+			const url = idBase + REVOCATION_ENDPOINT;
+			const body = new URLSearchParams();
+			body.set('client_id', this.authConfig.clientId);
+			if (this.authConfig.clientSecret) {
+				body.set('client_secret', this.authConfig.clientSecret);
+			}
+			body.set('token', saved.refreshToken);
+			body.set('token_type_hint', 'refresh_token');
+			const res = await fetch(url, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+				body: body.toString(),
+			});
+			if (!res.ok) {
+				const t = await res.text().catch(() => '');
+				log.error('oauth2_code.revoke_failed', { status: res.status, t });
+			}
+		} finally {
+			const userKey = getUserKey();
+			if (userKey) {
+				await this._sessionContext.deleteTokensForUser(userKey);
+				this._tokenRefreshScheduler.cancelRefresh(userKey);
+			}
+			this.accessToken = undefined;
+			this.accessTokenExpiryMs = undefined;
+		}
+	}
+
+	public async refreshUserTokens(userKey: string): Promise<void> {
+		const saved = await this._sessionContext.getTokensForUser(userKey);
+		if (!saved?.refreshToken) {
+			throw new Error('oauth2_no_refresh_token');
+		}
+		const updated = await this._refreshTokens(saved.refreshToken);
+		await this._sessionContext.setTokensForUser(userKey, updated);
+		log.info('oauth2_code.background_refresh_success', { userKey });
+	}
+}

package/src/creatio/auth/providers/oauth2-provider.ts

@@ -0,0 +1,91 @@
+import log from '../../../log';
+import { CreatioClientConfig, OAuth2AuthConfig } from '../../client-config';
+import { TOKEN_BODY_SNIPPET_MAX, TOKEN_ENDPOINT } from '../auth';
+
+import { BaseOAuth2Provider } from './base-oauth2-provider';
+
+export class OAuth2Provider extends BaseOAuth2Provider<OAuth2AuthConfig> {
+	private readonly _config: CreatioClientConfig;
+
+	protected readonly authErrorCode = 'oauth2_auth_failed';
+
+	constructor(config: CreatioClientConfig) {
+		super(config);
+		this._config = config;
+	}
+
+	protected async ensureAccessToken(): Promise<string | undefined> {
+		const now = Date.now();
+		if (this.accessToken && this.accessTokenExpiryMs && now < this.accessTokenExpiryMs) {
+			return this.accessToken;
+		}
+		const url = `${this.getIdentityBase()}${TOKEN_ENDPOINT}`;
+		const body = new URLSearchParams();
+		body.set('grant_type', 'client_credentials');
+		body.set('client_id', this.authConfig.clientId);
+		body.set('client_secret', this.authConfig.clientSecret);
+		try {
+			log.creatioAuthStart(this._config.baseUrl, 'oauth2');
+			const response = await fetch(url, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+				body: body.toString(),
+			});
+			const responseText = await response.text().catch(() => '');
+			const contentType = (response.headers as any)?.get?.('content-type') ?? '';
+			const bodySnippet =
+				responseText && responseText.length > TOKEN_BODY_SNIPPET_MAX
+					? responseText.slice(0, TOKEN_BODY_SNIPPET_MAX) + '\n... [truncated]'
+					: responseText;
+			if (!response.ok) {
+				log.error('oauth.token.error', {
+					url,
+					status: response.status,
+					contentType,
+					bodySnippet,
+				});
+				log.creatioAuthFailed(
+					this._config.baseUrl,
+					`token_error:${response.status}`,
+					'oauth2',
+				);
+				throw new Error(`oauth2_token_error:${response.status}`);
+			}
+			if (!responseText) {
+				log.error('oauth.token.empty_body', { url, status: response.status, contentType });
+				log.creatioAuthFailed(this._config.baseUrl, 'empty_response_body', 'oauth2');
+				throw new Error('oauth2_empty_token_response');
+			}
+			let tokenResponse: any = null;
+			try {
+				tokenResponse = JSON.parse(responseText);
+			} catch (err) {
+				log.error('oauth.token.parse_failed', {
+					url,
+					status: response.status,
+					contentType,
+					bodySnippet,
+				});
+				log.creatioAuthFailed(this._config.baseUrl, 'token_parse_failed', 'oauth2');
+				throw new Error('oauth2_token_parse_failed');
+			}
+			if (!tokenResponse || !tokenResponse.access_token) {
+				log.creatioAuthFailed(
+					this._config.baseUrl,
+					'no_access_token_in_response',
+					'oauth2',
+				);
+				throw new Error('oauth2_no_access_token');
+			}
+			this.accessToken = String(tokenResponse.access_token);
+			const expiresIn = Number(tokenResponse.expires_in) || 3600;
+			this.accessTokenExpiryMs = this.computeExpiryMs(expiresIn, 1);
+			log.creatioAuthOk(this._config.baseUrl, 'oauth2');
+			return this.accessToken;
+		} catch (e: any) {
+			log.error('oauth.token.exception', { error: String(e?.message ?? e) });
+			log.creatioAuthFailed(this._config.baseUrl, String(e?.message ?? e), 'oauth2');
+			return undefined;
+		}
+	}
+}

package/src/creatio/auth/providers/type.ts

@@ -0,0 +1,5 @@
+export enum AuthProviderType {
+	Legacy = 'legacy',
+	OAuth2 = 'oauth2',
+	OAuth2Code = 'oauth2_code',
+}

package/src/creatio/client-config.ts

@@ -0,0 +1,34 @@
+import { AuthProviderType } from './auth/providers';
+
+interface ICreatioAuthConfig {
+	kind: AuthProviderType;
+}
+
+export interface LegacyAuthConfig extends ICreatioAuthConfig {
+	kind: AuthProviderType.Legacy;
+	login: string;
+	password: string;
+}
+
+interface BaseOAuthConfig extends ICreatioAuthConfig {
+	clientId: string;
+	clientSecret: string;
+	scope?: string;
+	idBaseUrl?: string;
+}
+
+export interface OAuth2AuthConfig extends BaseOAuthConfig {
+	kind: AuthProviderType.OAuth2;
+}
+
+export interface OAuth2CodeAuthConfig extends BaseOAuthConfig {
+	kind: AuthProviderType.OAuth2Code;
+	redirectUri: string;
+}
+
+export type CreatioClientAuthConfig = LegacyAuthConfig | OAuth2AuthConfig | OAuth2CodeAuthConfig;
+
+export interface CreatioClientConfig {
+	baseUrl: string;
+	auth: CreatioClientAuthConfig;
+}

package/src/creatio/engines/crud/crud-engine.ts

@@ -0,0 +1,47 @@
+import {
+	CrudDeleteParams,
+	CrudProvider,
+	CrudReadParams,
+	CrudUpdateParams,
+	CrudWriteParams,
+	EntitySchemaDescription,
+} from '../../providers';
+import { CreatioEngine } from '../engine';
+
+export class CrudEngine implements CreatioEngine {
+	private readonly _provider: CrudProvider;
+
+	public readonly name = 'crud';
+
+	constructor(provider: CrudProvider) {
+		this._provider = provider;
+	}
+
+	public get kind(): string {
+		return this._provider.kind;
+	}
+
+	public listEntitySets(): Promise<string[]> {
+		return this._provider.listEntitySets();
+	}
+
+	public describeEntity(entitySet: string): Promise<EntitySchemaDescription> {
+		return this._provider.describeEntity(entitySet);
+	}
+
+	public read(params: CrudReadParams): Promise<any> {
+		return this._provider.read(params);
+	}
+
+	public create(params: CrudWriteParams): Promise<any> {
+		return this._provider.create(params);
+	}
+
+	public update(params: CrudUpdateParams): Promise<any> {
+		return this._provider.update(params);
+	}
+
+	public delete(params: CrudDeleteParams): Promise<any> {
+		return this._provider.delete(params);
+	}
+}

package/src/creatio/engines/engine-manager.ts

@@ -0,0 +1,102 @@
+import { CreatioProviderContext } from '../provider-context';
+import { CrudProvider, ProcessProvider, SysSettingsProvider, UserProvider } from '../providers';
+
+import { CrudEngine } from './crud/crud-engine';
+import { CreatioEngine } from './engine';
+import { EngineRegistry, EngineType } from './engine-registry';
+import { ProcessEngine } from './process/process-engine';
+import { SysSettingsEngine } from './sys-settings/sys-settings-engine';
+import { UserEngine } from './user/user-engine';
+
+export interface EngineManagerOptions {
+	crudProvider?: CrudProvider;
+	processProvider?: ProcessProvider;
+	sysSettingsProvider?: SysSettingsProvider;
+	userProvider?: UserProvider;
+	enableCrud?: boolean;
+	enableProcess?: boolean;
+	enableSysSettings?: boolean;
+	enableUser?: boolean;
+}
+
+export class CreatioEngineManager {
+	private readonly _context: CreatioProviderContext;
+	private readonly _options: EngineManagerOptions | undefined;
+	private readonly _registry = new EngineRegistry();
+	private readonly _engines = new Map<string, CreatioEngine>();
+
+	public get authProvider() {
+		return this._context.authProvider;
+	}
+
+	public get registry(): EngineRegistry {
+		return this._registry;
+	}
+
+	public get crud(): CrudEngine {
+		return this._registry.require<CrudEngine>(EngineType.Crud);
+	}
+
+	public get process(): ProcessEngine {
+		return this._registry.require<ProcessEngine>(EngineType.Process);
+	}
+
+	public get sysSettings(): SysSettingsEngine {
+		return this._registry.require<SysSettingsEngine>(EngineType.SysSettings);
+	}
+
+	public get user(): UserEngine {
+		return this._registry.require<UserEngine>(EngineType.User);
+	}
+
+	constructor(context: CreatioProviderContext, options?: EngineManagerOptions) {
+		this._context = context;
+		this._options = options;
+		this._initialize();
+	}
+
+	private _initialize() {
+		this._registerEngine(
+			EngineType.Crud,
+			() =>
+				new CrudEngine(this._options?.crudProvider ?? (this._context.crud as CrudProvider)),
+			this._options?.enableCrud ?? true,
+		);
+		this._registerEngine(
+			EngineType.Process,
+			() =>
+				new ProcessEngine(
+					this._options?.processProvider ?? (this._context.process as ProcessProvider),
+				),
+			this._options?.enableProcess ?? true,
+		);
+		this._registerEngine(
+			EngineType.SysSettings,
+			() =>
+				new SysSettingsEngine(
+					this._options?.sysSettingsProvider ??
+						(this._context.sysSettings as SysSettingsProvider),
+				),
+			this._options?.enableSysSettings ?? true,
+		);
+		this._registerEngine(
+			EngineType.User,
+			() =>
+				new UserEngine(this._options?.userProvider ?? (this._context.user as UserProvider)),
+			this._options?.enableUser ?? true,
+		);
+	}
+
+	private _registerEngine<T extends CreatioEngine>(
+		type: EngineType,
+		factory: () => T,
+		enabled: boolean,
+	) {
+		if (!enabled) {
+			return;
+		}
+		const engine = factory();
+		this._engines.set(type, engine);
+		this._registry.register(engine);
+	}
+}

package/src/creatio/engines/engine-registry.ts

@@ -0,0 +1,36 @@
+import { CreatioEngine } from './engine';
+
+export enum EngineType {
+	Crud = 'crud',
+	Process = 'process',
+	SysSettings = 'sys-settings',
+	User = 'user',
+}
+
+export class EngineRegistry {
+	private readonly _engines = new Map<string, CreatioEngine>();
+
+	public register(engine: CreatioEngine): CreatioEngine {
+		if (this._engines.has(engine.name)) {
+			throw new Error(`engine_already_registered:${engine.name}`);
+		}
+		this._engines.set(engine.name, engine);
+		return engine;
+	}
+
+	public get<T extends CreatioEngine = CreatioEngine>(name: string): T | undefined {
+		return this._engines.get(name) as T | undefined;
+	}
+
+	public require<T extends CreatioEngine = CreatioEngine>(name: string): T {
+		const engine = this.get<T>(name);
+		if (!engine) {
+			throw new Error(`engine_not_registered:${name}`);
+		}
+		return engine;
+	}
+
+	public entries(): IterableIterator<[string, CreatioEngine]> {
+		return this._engines.entries();
+	}
+}

package/src/creatio/engines/engine.ts

@@ -0,0 +1,3 @@
+export interface CreatioEngine {
+	readonly name: string;
+}

package/src/creatio/engines/index.ts

@@ -0,0 +1,7 @@
+export * from './engine';
+export * from './engine-manager';
+export * from './engine-registry';
+export * from './crud/crud-engine';
+export * from './process/process-engine';
+export * from './sys-settings/sys-settings-engine';
+export * from './user/user-engine';

package/src/creatio/engines/process/process-engine.ts

@@ -0,0 +1,20 @@
+import { ExecuteProcessParams, ExecuteProcessResult, ProcessProvider } from '../../providers';
+import { CreatioEngine } from '../engine';
+
+export class ProcessEngine implements CreatioEngine {
+	private readonly _provider: ProcessProvider;
+
+	public readonly name = 'process';
+
+	constructor(provider: ProcessProvider) {
+		this._provider = provider;
+	}
+
+	public get kind(): string {
+		return this._provider.kind;
+	}
+
+	public execute(params: ExecuteProcessParams): Promise<ExecuteProcessResult> {
+		return this._provider.executeProcess(params);
+	}
+}