@elyx-code/editor-ui 0.0.2

package/src/services/editor/modules/operations-implementations/external-integrations/google-mail/send-email.ts

@@ -0,0 +1,386 @@
+import {
+	ActionDescriptorState,
+	OperationState,
+	IPrimitiveExecutionResult,
+	ExecutionTerminationType,
+	DefinitionEntityState,
+	IDynamicValue,
+	BaseRegisteredExtension,
+	ExtensionContextType,
+	ExtensionManifest,
+	ExtensionPermissions,
+	ExtentionPriority,
+	IRegisteredExtension,
+	DefaultEditorContext,
+	DefaultProjectLogicContext,
+	getConnectionIdFromDefinitionEntity,
+	OperationsImplementation,
+	BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX,
+	ExternalIntegrationOperations,
+	ExternalIntegrationNames,
+	InputMapState,
+	BUILT_IN_BASE_ENTITY_IDS,
+} from '@elyx-code/project-logic-tree';
+import { EditorService } from '../../../../EditorService';
+import axios, { AxiosResponse } from 'axios';
+import { editorRuntimeServiceBaseUrl } from '../../../../../integrations/api';
+import { getAccessToken } from '../../../../../../auth';
+import { Logger } from '@elyx-code/common-ts-utils';
+
+/** ---------- helpers ---------- */
+
+type ProxyConfig = {
+	method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+	endpoint: string;
+	baseUrlOverride?: string;
+	params?: Record<string, any>;
+	data?: any;
+	headers?: Record<string, string>;
+	retries?: number;
+	responseType?: 'json' | 'text' | 'arraybuffer';
+};
+
+type ProxyWrapped<T = any> = {
+	status: number;
+	data: T;
+	headers?: Record<string, string>;
+};
+
+type ProxyStoredEnvelope = {
+	presignedUrl: string;
+	key: string;
+	bytes: number;
+	contentType: string;
+	contentEncoding: string; // gzip
+	note?: string;
+	status?: number;
+	headers?: Record<string, string>;
+};
+
+function isStoredEnvelope(x: any): x is ProxyStoredEnvelope {
+	return !!x && typeof x === 'object' && typeof x.presignedUrl === 'string';
+}
+
+function bail(
+	entity: OperationState,
+	message: string,
+): IPrimitiveExecutionResult {
+	Logger.log('[Gmail] send email error:', message);
+	return {
+		value:
+			entity.catchesError || entity.errorCalls.length
+				? ExecutionTerminationType.CaughtError
+				: ExecutionTerminationType.UnhandledError,
+		error: message,
+		result: null,
+	};
+}
+
+function toArray(v?: string | string[] | null): string | undefined {
+	if (v == null) return undefined;
+	return Array.isArray(v) ? v.filter(Boolean).join(', ') : v;
+}
+
+function headerLine(
+	name: string,
+	value?: string | string[] | null,
+): string | null {
+	const v = toArray(value);
+	return v ? `${name}: ${v}` : null;
+}
+
+/** Gmail expects base64url for the raw RFC822 message */
+function base64UrlEncodeUtf8(input: string): string {
+	const b64 = Buffer.from(input, 'utf8').toString('base64');
+	return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+/** Build a minimal RFC822 email; choose html vs text content-type */
+function buildRawEmail(opts: {
+	from: string;
+	to: string | string[];
+	subject: string;
+	body?: string;
+	bodyHtml?: string;
+	cc?: string | string[];
+	bcc?: string | string[];
+	replyTo?: string | string[];
+	headers?: Record<string, string | string[]>;
+}): string {
+	const {
+		from,
+		to,
+		subject,
+		body,
+		bodyHtml,
+		cc,
+		bcc,
+		replyTo,
+		headers = {},
+	} = opts;
+
+	const extra = Object.entries(headers)
+		.map(([k, v]) => headerLine(k, v))
+		.filter((x): x is string => x != null);
+
+	const contentType = bodyHtml
+		? 'Content-Type: text/html; charset="UTF-8"'
+		: 'Content-Type: text/plain; charset="UTF-8"';
+
+	const headerLines = [
+		headerLine('From', from),
+		headerLine('To', to),
+		headerLine('Cc', cc),
+		headerLine('Bcc', bcc),
+		headerLine('Reply-To', replyTo),
+		headerLine('Subject', subject),
+		...extra,
+		'MIME-Version: 1.0',
+		contentType,
+	].filter((x): x is string => x != null);
+
+	const lines = [
+		...headerLines,
+		'', // blank line separates headers/body
+		bodyHtml ?? body ?? '',
+	];
+
+	const rfc822 = lines.join('\r\n');
+	return base64UrlEncodeUtf8(rfc822);
+}
+
+/** ---------- Implementation module ---------- */
+
+export class OperationsImplementationsSendGoogleMailEmailModule
+	extends BaseRegisteredExtension
+	implements IRegisteredExtension<OperationsImplementation>
+{
+	manifest: ExtensionManifest = {
+		id:
+			BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+			ExternalIntegrationOperations.GoogleMailSendEmail,
+		version: '1.0.0',
+		description:
+			'Send Gmail email operation implementation module (direct API)',
+		initPriority: ExtentionPriority.High,
+		permissions: [ExtensionPermissions.All],
+		contexts: [ExtensionContextType.Editor, ExtensionContextType.Logic],
+	};
+
+	module = {
+		init: (contexts: (DefaultEditorContext | DefaultProjectLogicContext)[]) => {
+			const projectState = contexts.find(
+				(c) => c.contextType === ExtensionContextType.Logic,
+			) as DefaultProjectLogicContext;
+
+			if (projectState) {
+				const operation = projectState.get(
+					ExternalIntegrationOperations.GoogleMailSendEmail,
+				) as ActionDescriptorState;
+
+				if (operation) {
+					operation.implementation = this.module.main;
+				}
+			}
+		},
+
+		/**
+		 * INPUTS (index / expected):
+		 * 0 = connection (DefinitionEntityState, required)
+		 * 1 = from (string)
+		 * 2 = to (string | string[])
+		 * 3 = subject (string)
+		 * 4 = body (string)
+		 * 5 = bodyHtml (string, optional)
+		 * 6 = cc (string | string[], optional)
+		 * 7 = bcc (string | string[], optional)
+		 * 8 = replyTo (string | string[], optional)
+		 * 9 = threadId (string, optional)
+		 * 10 = headers (Record<string, string|string[]>, optional)
+		 *
+		 * OUTPUT:
+		 * { id: string; threadId: string | null }
+		 */
+		main: async (
+			entity: OperationState,
+			_inputs: IDynamicValue[],
+		): Promise<IPrimitiveExecutionResult> => {
+			try {
+				const inputs = _inputs
+					.map((i) => i.value?.valueAsType || i.value?.value)
+					.sort((a, b) => {
+						// Sort by a.index
+						const aIndex = (a as any)?.index ?? 0;
+						const bIndex = (b as any)?.index ?? 0;
+						return aIndex - bIndex;
+					});
+
+				const connectionEntity = _inputs.find(
+					(i) =>
+						(i.valueOwner as InputMapState).declaration?.id ===
+						BUILT_IN_BASE_ENTITY_IDS.operation[
+							'external-integration--google-mail--post--send-email'
+						].inputs.connection.id,
+				)?.value?.valueAsType as DefinitionEntityState;
+				if (!(connectionEntity instanceof DefinitionEntityState)) {
+					return bail(entity, 'Invalid or missing connection entity');
+				}
+
+				const from =
+					(_inputs.find(
+						(i) =>
+							(i.valueOwner as InputMapState).declaration?.id ===
+							BUILT_IN_BASE_ENTITY_IDS.operation[
+								'external-integration--google-mail--post--send-email'
+							].inputs.from.id,
+					)?.value?.value as string | undefined) || '';
+				const to =
+					(_inputs.find(
+						(i) =>
+							(i.valueOwner as InputMapState).declaration?.id ===
+							BUILT_IN_BASE_ENTITY_IDS.operation[
+								'external-integration--google-mail--post--send-email'
+							].inputs.to.id,
+					)?.value?.value as string | string[]) || '';
+				const subject =
+					(_inputs.find(
+						(i) =>
+							(i.valueOwner as InputMapState).declaration?.id ===
+							BUILT_IN_BASE_ENTITY_IDS.operation[
+								'external-integration--google-mail--post--send-email'
+							].inputs.subject.id,
+					)?.value?.value as string | undefined) || '';
+				const body =
+					(_inputs.find(
+						(i) =>
+							(i.valueOwner as InputMapState).declaration?.id ===
+							BUILT_IN_BASE_ENTITY_IDS.operation[
+								'external-integration--google-mail--post--send-email'
+							].inputs.body.id,
+					)?.value?.value as string | undefined) || '';
+				const bodyHtml: any = null; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.bodyHtml.id)?.value?.value as string | undefined;
+				const cc = ''; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.cc.id)?.value?.value as string | string[] | undefined;
+				const bcc = ''; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.bcc.id)?.value?.value as string | string[] | undefined;
+				const replyTo = ''; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.replyTo.id)?.value?.value as string | string[] | undefined;
+				const threadId = ''; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.threadId.id)?.value?.value as string | undefined;
+				const headers = {}; // _inputs.find((i) => (i.valueOwner as InputMapState).declaration?.id === BUILT_IN_BASE_ENTITY_IDS.operation['external-integration--google-mail--post--send-email'].inputs.headers.id)?.value?.value as Record<string, string | string[]> | undefined;
+
+				if (!from || !to) {
+					return bail(entity, '`from` and `to` are required');
+				}
+
+				const connectionId =
+					getConnectionIdFromDefinitionEntity(connectionEntity);
+				if (!connectionId) {
+					return bail(
+						entity,
+						'Connection entity is missing the Connection ID value',
+					);
+				}
+
+				const editor = this.extensionsRegistry.requestContexts(this, [
+					ExtensionContextType.Editor,
+				])[0] as EditorService;
+
+				const accessToken = await getAccessToken();
+				const authHeaders = { Authorization: `Bearer ${accessToken}` };
+				const baseUrl = `${editorRuntimeServiceBaseUrl}/v1/external-integrations/generic-proxy/${editor.projectId}/${ExternalIntegrationNames['google-mail']}/${connectionId}`;
+
+				const proxy = async <T = any>(
+					cfg: ProxyConfig,
+				): Promise<AxiosResponse<ProxyWrapped<T> | ProxyStoredEnvelope>> => {
+					return axios.post(baseUrl, cfg, { headers: authHeaders });
+				};
+
+				const unwrapProxy = async <T = any>(
+					res: AxiosResponse<ProxyWrapped<T> | ProxyStoredEnvelope>,
+				): Promise<ProxyWrapped<T>> => {
+					const payload = res.data as any;
+					if (isStoredEnvelope(payload)) {
+						const r = await axios.get(payload.presignedUrl, {
+							responseType: 'text',
+						});
+						const txt =
+							typeof r.data === 'string'
+								? r.data
+								: new TextDecoder().decode(r.data);
+						const parsed = JSON.parse(txt);
+						return {
+							status: payload.status ?? 200,
+							headers: payload.headers,
+							data: parsed as T,
+						};
+					} else {
+						return payload as ProxyWrapped<T>;
+					}
+				};
+
+				// Build raw RFC822 email & payload
+				const raw = buildRawEmail({
+					from,
+					to,
+					subject,
+					body,
+					bodyHtml,
+					cc,
+					bcc,
+					replyTo,
+					headers,
+				});
+				const payload: Record<string, any> = { raw };
+				if (threadId) payload.threadId = threadId;
+
+				// POST /gmail/v1/users/me/messages/send
+				const resp = await proxy<{ id: string; threadId?: string }>({
+					method: 'POST',
+					endpoint: '/gmail/v1/users/me/messages/send',
+					data: payload,
+					retries: 3,
+				});
+
+				const unwrapped = await unwrapProxy<{ id: string; threadId?: string }>(
+					resp,
+				);
+				if (unwrapped.status < 200 || unwrapped.status >= 300) {
+					const errMsg =
+						((unwrapped as any).data &&
+							(unwrapped as any).data.error &&
+							(unwrapped as any).data.error.message) ||
+						`Gmail send failed (status=${unwrapped.status})`;
+					return bail(entity, errMsg);
+				}
+
+				const { id, threadId: outThreadId } = unwrapped.data || ({} as any);
+
+				Logger.log('[Google Mail] Send email response:', {
+					id,
+					threadId: outThreadId,
+				});
+
+				return {
+					value: ExecutionTerminationType.Success,
+					error: null,
+					result: {
+						id,
+						threadId: outThreadId ?? null,
+					},
+				};
+			} catch (e: any) {
+				// Extract the juicy details from Axios if they exist
+				const errorData = e.response?.data || e.message || e;
+
+				Logger.error('[Gmail] Send email failed:', errorData);
+
+				return {
+					value:
+						entity.catchesError || entity.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					// Pass the extracted error downstream instead of the raw Axios object
+					error: errorData,
+					result: null,
+				};
+			}
+		},
+	};
+}

package/src/services/editor/modules/operations-implementations/external-integrations/index.ts

@@ -0,0 +1,12 @@
+export * from './slack/send-message';
+export * from './slack/channels';
+export * from './slack/messages';
+export * from './slack/replies';
+export * from './google-mail/send-email';
+export * from './google-mail/get-emails';
+// export * from './google-drive/list-drives';
+export * from './google-drive/get-files';
+export * from './google-drive/smart-fetch-document';
+export * from './google-drive/upload-document';
+// export * from './google-drive/list-root-folders';
+export * from './google-gemini/generate-content';

package/src/services/editor/modules/operations-implementations/external-integrations/slack/channels.ts

@@ -0,0 +1,240 @@
+import {
+	ActionDescriptorState,
+	OperationState,
+	IPrimitiveExecutionResult,
+	ExecutionTerminationType,
+	DefinitionEntityState,
+	IDynamicValue,
+	BaseRegisteredExtension,
+	ExtensionContextType,
+	ExtensionManifest,
+	ExtensionPermissions,
+	ExtentionPriority,
+	IRegisteredExtension,
+	DefaultEditorContext,
+	DefaultProjectLogicContext,
+	getConnectionIdFromDefinitionEntity,
+	OperationsImplementation,
+	BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX,
+	ExternalIntegrationOperations,
+	ExternalIntegrationNames,
+} from '@elyx-code/project-logic-tree';
+import { EditorService } from '../../../../EditorService';
+import axios from 'axios';
+import { editorRuntimeServiceBaseUrl } from '../../../../../integrations/api';
+import { getAccessToken } from '../../../../../../auth';
+import { Logger } from '@elyx-code/common-ts-utils';
+
+export class OperationsImplementationsGetSlackChannelsModule
+	extends BaseRegisteredExtension
+	implements IRegisteredExtension<OperationsImplementation>
+{
+	manifest: ExtensionManifest = {
+		id:
+			BUILT_IN_FUNCTION_IMPLEMENTATIONS__PREFIX +
+			ExternalIntegrationOperations.SlackChannels,
+		version: '1.0.0',
+		description: 'Get Slack channels operation implementation module',
+		initPriority: ExtentionPriority.High,
+		permissions: [ExtensionPermissions.All],
+		contexts: [ExtensionContextType.Editor, ExtensionContextType.Logic],
+	};
+
+	module = {
+		init: (contexts: (DefaultEditorContext | DefaultProjectLogicContext)[]) => {
+			const projectState = contexts.find(
+				(c) => c.contextType === ExtensionContextType.Logic
+			) as DefaultProjectLogicContext;
+
+			if (projectState) {
+				const operation = projectState.get(
+					ExternalIntegrationOperations.SlackChannels
+				) as ActionDescriptorState;
+				if (operation) operation.implementation = this.module.main;
+			}
+		},
+
+		main: async (
+			entity: OperationState,
+			_inputs: IDynamicValue[]
+		): Promise<IPrimitiveExecutionResult> => {
+			try {
+				const inputs = _inputs.map(
+					(i) => i.value?.valueAsType || i.value?.value
+				);
+				const connectionEntity = inputs[0] as DefinitionEntityState;
+				if (
+					!connectionEntity ||
+					!(connectionEntity instanceof DefinitionEntityState)
+				) {
+					return {
+						value:
+							entity.catchesError || entity.errorCalls.length
+								? ExecutionTerminationType.CaughtError
+								: ExecutionTerminationType.UnhandledError,
+						error: 'Invalid or missing connection entity',
+						result: null,
+					};
+				}
+
+				const editor = this.extensionsRegistry.requestContexts(this, [
+					ExtensionContextType.Editor,
+				])[0] as EditorService;
+
+				const connectionId =
+					getConnectionIdFromDefinitionEntity(connectionEntity);
+
+				// ---------- Inputs (see below for what to add to your definition) ----------
+				const typesList = (inputs[1] as string[]) || []; // ['public_channel','private_channel','im','mpim']
+				const excludeArchived = (inputs[2] as boolean) ?? false;
+				const pageSize = (inputs[3] as number) || 200; // Slack recommends ≤200 per page
+				const pageToken = (inputs[4] as string | undefined) || undefined; // Slack cursor
+				const onlyJoined = (inputs[5] as boolean) || false; // filter locally by is_member
+				const teamId = (inputs[6] as string | undefined) || undefined; // Enterprise Grid
+				const joinPublicChannels = (inputs[7] as boolean) || false; // optionally join
+				const autoPaginate = (inputs[8] as boolean) || false; // fetch all pages
+				const nameContains = (inputs[9] as string | undefined)
+					?.trim()
+					?.toLowerCase();
+
+				const accessToken = await getAccessToken();
+				const baseUrl = `${editorRuntimeServiceBaseUrl}/v1/external-integrations/proxy/${editor.projectId}/${ExternalIntegrationNames['slack']}/${connectionId}`;
+
+				const headers = { Authorization: `Bearer ${accessToken}` };
+
+				const paramsBase: Record<string, string> = {
+					limit: String(Math.min(Math.max(1, pageSize), 999)), // API allows <1000
+					// default Slack type is public_channel; if you want both public+private by default, pass both
+					types: (typesList.length
+						? typesList
+						: ['public_channel', 'private_channel']
+					).join(','),
+					exclude_archived: String(!!excludeArchived),
+				};
+				if (teamId) paramsBase.team_id = teamId;
+
+				// helper to fetch a page
+				const fetchPage = async (cursor?: string) => {
+					const params = { ...paramsBase };
+					if (cursor) params.cursor = cursor;
+
+					const qs = new URLSearchParams(params).toString();
+					const { data } = await axios.get(
+						`${baseUrl}/conversations.list?${qs}`,
+						{ headers }
+					);
+
+					if (!data?.ok) throw new Error(data?.error || 'Slack API error');
+
+					const channels: any[] = Array.isArray(data.channels)
+						? data.channels
+						: [];
+					const nextCursor: string = data?.response_metadata?.next_cursor || '';
+					return { channels, nextCursor };
+				};
+
+				let all: any[] = [];
+				let next = pageToken || '';
+				let fetchedOnce = false;
+
+				if (autoPaginate) {
+					let guard = 0;
+					do {
+						const { channels, nextCursor } = await fetchPage(next || undefined);
+						all = all.concat(channels);
+						next = nextCursor;
+						guard += 1;
+					} while (next && guard < 50); // safety guard
+				} else {
+					const { channels, nextCursor } = await fetchPage(next || undefined);
+					all = channels;
+					next = nextCursor;
+					fetchedOnce = true;
+				}
+
+				// optional local filters
+				if (onlyJoined) {
+					all = all.filter((c) => c?.is_member === true);
+				}
+				if (nameContains) {
+					all = all.filter((c) =>
+						c?.name?.toLowerCase().includes(nameContains)
+					);
+				}
+
+				// optionally join public channels we’re not in (for the pages we fetched)
+				if (joinPublicChannels) {
+					for (const ch of all) {
+						if (
+							ch?.is_channel &&
+							!ch?.is_private &&
+							!ch?.is_shared &&
+							ch?.is_member === false
+						) {
+							try {
+								// Slack expects x-www-form-urlencoded; most proxies accept JSON too.
+								await axios.post(
+									`${baseUrl}/conversations.join`,
+									{ channel: ch.id },
+									{ headers }
+								);
+							} catch (e) {
+								// don’t fail the whole call if one join fails
+								Logger.warn(
+									`[Slack] conversations.join failed for ${ch?.id}`,
+									e
+								);
+							}
+						}
+					}
+				}
+
+				// map to your output entity
+				const mapped = all.map((c) => ({
+					id: c.id,
+					name: c.name,
+					name_normalized: c.name_normalized,
+					is_shared: !!c.is_shared,
+					is_private: !!c.is_private,
+					is_mpim: !!c.is_mpim,
+					is_im: !!c.is_im,
+					is_group: !!c.is_group,
+					is_channel: !!c.is_channel,
+					is_archived: !!c.is_archived,
+					is_general: !!c.is_general,
+					created: c.created,
+					updated: c.updated,
+					creator: c.creator,
+					num_members: typeof c.num_members === 'number' ? c.num_members : null,
+					raw_json: JSON.stringify(c),
+				}));
+
+				const outNextToken = autoPaginate ? null : next || null;
+
+				Logger.log('[Slack] List channels response:', {
+					count: mapped.length,
+					next: outNextToken,
+				});
+
+				return {
+					value: ExecutionTerminationType.Success,
+					error: null,
+					result: {
+						records: mapped,
+						nextPageToken: outNextToken,
+					},
+				};
+			} catch (e) {
+				Logger.error('[Slack] List channels error:', e);
+				return {
+					value:
+						entity.catchesError || entity.errorCalls.length
+							? ExecutionTerminationType.CaughtError
+							: ExecutionTerminationType.UnhandledError,
+					error: e,
+					result: null,
+				};
+			}
+		},
+	};
+}