@vicoa/cli 1.3.10 → 1.3.11-linux-x64

package/bin/_internal/integrations/n8n/src/nodes/Omnara/actions/message/sendAndWait.operation.ts

@@ -0,0 +1,252 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+// This matches Discord's approach - properties for the sendAndWait message
+export const sendAndWaitDescription: INodeProperties[] = [
+	{
+		displayName: 'Agent Instance ID',
+		name: 'agentInstanceId',
+		type: 'string',
+		default: '',
+		required: false,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+			},
+		},
+		placeholder: 'e.g. 550e8400-e29b-41d4-a716-446655440000',
+		description:
+			'A unique identifier for this workflow run. Must be the same across all Vicoa nodes in this workflow. Use webhook data or generate with {{ $uuid() }}. If left empty, a default value will be generated.',
+	},
+	{
+		displayName: 'Agent Type',
+		name: 'agentType',
+		type: 'string',
+		default: '',
+		required: false,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+			},
+		},
+		placeholder: 'e.g. Customer Support',
+		description:
+			'The name of your agent on Vicoa dashboard. Must be the same across all Vicoa nodes. If left empty, the workflow name will be used as the default.',
+	},
+	{
+		displayName: 'Message',
+		name: 'message',
+		type: 'string',
+		default: '',
+		required: true,
+		typeOptions: {
+			rows: 4,
+		},
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+			},
+		},
+		placeholder: 'e.g. Please review and approve this deployment',
+		description:
+			'Question or request that requires a user response. This will appear in their Vicoa web/mobile app and the workflow will pause until they respond. Use this for questions, approvals, or when you need human input to continue',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+			},
+		},
+		options: [
+			{
+				displayName: 'Sync Mode (For AI Agents)',
+				name: 'syncMode',
+				type: 'boolean',
+				default: false,
+				description:
+					'Whether to enable AI Agent compatibility mode. When enabled, the node will wait for a response before continuing. Required when using this node as an AI Agent tool',
+			},
+			{
+				displayName: 'Sync Timeout (Seconds)',
+				name: 'syncTimeout',
+				type: 'number',
+				default: 7200,
+				displayOptions: {
+					show: {
+						syncMode: [true],
+					},
+				},
+				description:
+					'Maximum time to wait for a response in sync mode (in seconds)',
+				typeOptions: {
+					minValue: 10,
+					maxValue: 172800,
+				},
+			},
+			{
+				displayName: 'Poll Interval (Seconds)',
+				name: 'pollInterval',
+				type: 'number',
+				default: 5,
+				displayOptions: {
+					show: {
+						syncMode: [true],
+					},
+				},
+				description: 'How often to check for responses in sync mode (in seconds)',
+				typeOptions: {
+					minValue: 5,
+					maxValue: 60,
+				},
+			},
+			{
+				displayName: 'Send Email',
+				name: 'sendEmail',
+				type: 'boolean',
+				default: true,
+				description: 'Whether to send an email notification',
+			},
+			{
+				displayName: 'Send SMS',
+				name: 'sendSms',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to send an SMS notification',
+			},
+			{
+				displayName: 'Send Push',
+				name: 'sendPush',
+				type: 'boolean',
+				default: true,
+				description: 'Whether to send a push notification',
+			},
+		],
+	},
+	{
+		displayName: 'Limit Wait Time',
+		name: 'limitWaitTime',
+		type: 'boolean',
+		default: false,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+			},
+		},
+		description: 'Whether to set a time limit for how long to wait for a response',
+	},
+	{
+		displayName: 'Limit Type',
+		name: 'limitType',
+		type: 'options',
+		default: 'afterTimeInterval',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+				limitWaitTime: [true],
+			},
+		},
+		options: [
+			{
+				name: 'After Time Interval',
+				value: 'afterTimeInterval',
+				description: 'Wait for a specified amount of time',
+			},
+			{
+				name: 'At Specified Time',
+				value: 'atSpecifiedTime',
+				description: 'Wait until a specific date and time',
+			},
+		],
+		description: 'When to stop waiting if no response is received',
+	},
+	{
+		displayName: 'Resume After',
+		name: 'resumeAmount',
+		type: 'number',
+		default: 1,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+				limitWaitTime: [true],
+				limitType: ['afterTimeInterval'],
+			},
+		},
+		description: 'Amount of time to wait',
+		typeOptions: {
+			minValue: 0,
+		},
+	},
+	{
+		displayName: 'Unit',
+		name: 'resumeUnit',
+		type: 'options',
+		default: 'hours',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+				limitWaitTime: [true],
+				limitType: ['afterTimeInterval'],
+			},
+		},
+		options: [
+			{
+				name: 'Minutes',
+				value: 'minutes',
+			},
+			{
+				name: 'Hours',
+				value: 'hours',
+			},
+			{
+				name: 'Days',
+				value: 'days',
+			},
+		],
+		description: 'Unit of time to wait',
+	},
+	{
+		displayName: 'Max Date and Time',
+		name: 'maxDateAndTime',
+		type: 'dateTime',
+		default: '',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['sendAndWait'],
+				limitWaitTime: [true],
+				limitType: ['atSpecifiedTime'],
+			},
+		},
+		description: 'The date and time to stop waiting for a response',
+	},
+];
+
+// This function is not used - sendAndWait is handled in the main node file
+// following the Slack pattern
+export async function execute(
+	this: IExecuteFunctions,
+	_items: INodeExecutionData[],
+): Promise<INodeExecutionData[][]> {
+	// Should not be called - handled in main node
+	throw new NodeOperationError(
+		this.getNode(),
+		'sendAndWait should be handled in the main node file',
+	);
+}

package/bin/_internal/integrations/n8n/src/nodes/Omnara/actions/session/end.operation.ts

@@ -0,0 +1,56 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+import { vicoaApiRequest, generateAgentInstanceId, getAgentType } from '../../../../utils/GenericFunctions';
+
+export const endSessionDescription: INodeProperties[] = [
+	{
+		displayName: 'Agent Instance ID',
+		name: 'agentInstanceId',
+		type: 'string',
+		default: '',
+		required: false,
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['end'],
+			},
+		},
+		placeholder: 'e.g. 550e8400-e29b-41d4-a716-446655440000',
+		description: 'The ID of the agent instance session to end. If left empty, a default value will be generated.',
+	},
+];
+
+export async function execute(
+	this: IExecuteFunctions,
+	index: number,
+): Promise<INodeExecutionData[]> {
+	const agentType = getAgentType.call(this, 0);
+	const agentInstanceId = generateAgentInstanceId.call(this, 0, agentType);
+	const body = {
+		agent_instance_id: agentInstanceId,
+	};
+
+	try {
+		const response = await vicoaApiRequest.call(this, 'POST', '/sessions/end', body);
+
+		const result = {
+			success: response.success,
+			agentInstanceId: response.agent_instance_id,
+			finalStatus: response.final_status,
+			endedAt: new Date().toISOString(),
+		};
+
+		return [{ json: result }];
+	} catch (error) {
+		throw new NodeOperationError(
+			this.getNode(),
+			`Failed to end session: ${error instanceof Error ? error.message : String(error)}`,
+			{ itemIndex: index },
+		);
+	}
+}

package/bin/_internal/integrations/n8n/src/nodes/Omnara/actions/session/index.ts

@@ -0,0 +1,29 @@
+import * as end from './end.operation';
+
+import { INodeProperties } from 'n8n-workflow';
+
+export { end };
+
+export const descriptions: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['session'],
+			},
+		},
+		options: [
+			{
+				name: 'End',
+				value: 'end',
+				description: 'End an agent session',
+				action: 'End agent session',
+			},
+		],
+		default: 'end',
+	},
+	...end.endSessionDescription,
+];

package/bin/_internal/integrations/n8n/src/utils/GenericFunctions.ts

@@ -0,0 +1,93 @@
+import {
+	IExecuteFunctions,
+	ILoadOptionsFunctions,
+	IHttpRequestMethods,
+	IHttpRequestOptions,
+	IDataObject,
+	NodeApiError
+} from 'n8n-workflow';
+import { v5 as uuidv5 } from 'uuid';
+
+export async function vicoaApiRequest(
+	this: IExecuteFunctions | ILoadOptionsFunctions,
+	method: IHttpRequestMethods,
+	endpoint: string,
+	body: IDataObject = {},
+	qs: IDataObject = {},
+	uri?: string,
+	option: IDataObject = {},
+): Promise<any> {
+	const credentials = await this.getCredentials('vicoaApi');
+
+	if (!credentials) {
+		throw new NodeApiError(this.getNode(), {
+			message: 'No credentials found',
+		});
+	}
+
+	const options: IHttpRequestOptions = {
+		method,
+		body,
+		qs,
+		url: uri || `${credentials.serverUrl}/api/v1${endpoint}`,
+		json: true,
+		...option,
+	};
+
+	try {
+		const response = await this.helpers.httpRequestWithAuthentication.call(
+			this,
+			'vicoaApi',
+			options,
+		);
+		return response;
+	} catch (error) {
+		throw new NodeApiError(this.getNode(), error as any);
+	}
+}
+
+export function formatMessageResponse(message: any): IDataObject {
+	return {
+		id: message.id,
+		content: message.content,
+		senderType: message.sender_type || message.senderType,
+		createdAt: message.created_at || message.createdAt,
+		requiresUserInput:
+			message.requires_user_input !== undefined
+				? message.requires_user_input
+				: message.requiresUserInput,
+	};
+}
+
+export function generateAgentInstanceId(this: IExecuteFunctions, index: number, agentType: string): string {
+	// Check if user provided a custom agent instance ID, otherwise generate one
+	var key = this.getNodeParameter('agentInstanceId', index) as string;
+	if (!key || key.trim() === '') {
+		const workflowId = this.getWorkflow().id as string;
+		const executionId = this.getExecutionId();
+		key = `${String(workflowId)}:${executionId}`;
+	}
+
+
+	key = `${key}:${agentType}`;
+    const NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    const agentInstanceId = uuidv5(key, NAMESPACE);
+    
+    // Validate UUID format
+    if (!agentInstanceId || typeof agentInstanceId !== 'string' || agentInstanceId.length !== 36) {
+		throw new Error('Failed to generate valid UUID');
+	}
+    
+    return agentInstanceId;
+}
+
+export function getAgentType(this: IExecuteFunctions, index: number): string {
+	const userProvidedAgentType = this.getNodeParameter('agentType', index) as string;
+	if (userProvidedAgentType && userProvidedAgentType.trim() !== '') {
+		return userProvidedAgentType;
+	}
+	
+	// Use workflow name as default
+	const workflowName = this.getWorkflow().name as string;
+	return workflowName || 'n8n agent';
+}

package/bin/_internal/integrations/n8n/src/utils/sendAndWait/configureWaitTillDate.ts

@@ -0,0 +1,42 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+
+const WAIT_INDEFINITELY = 'WAIT_INDEFINITELY';
+
+export function configureWaitTillDate(context: IExecuteFunctions, index: number): Date | string {
+	const limitWaitTime = context.getNodeParameter('limitWaitTime', index, false) as boolean;
+
+	if (!limitWaitTime) {
+		return WAIT_INDEFINITELY;
+	}
+
+	const limitType = context.getNodeParameter('limitType', index, 'afterTimeInterval') as string;
+
+	if (limitType === 'afterTimeInterval') {
+		const resumeAmount = context.getNodeParameter('resumeAmount', index, 1) as number;
+		const resumeUnit = context.getNodeParameter('resumeUnit', index, 'hours') as string;
+
+		let waitSeconds = 0;
+		switch (resumeUnit) {
+			case 'minutes':
+				waitSeconds = resumeAmount * 60;
+				break;
+			case 'hours':
+				waitSeconds = resumeAmount * 60 * 60;
+				break;
+			case 'days':
+				waitSeconds = resumeAmount * 60 * 60 * 24;
+				break;
+			default:
+				waitSeconds = resumeAmount;
+		}
+
+		const waitTill = new Date();
+		waitTill.setTime(waitTill.getTime() + waitSeconds * 1000);
+		return waitTill;
+	} else if (limitType === 'atSpecifiedTime') {
+		const maxDateAndTime = context.getNodeParameter('maxDateAndTime', index) as string;
+		return new Date(maxDateAndTime);
+	}
+
+	return WAIT_INDEFINITELY;
+}

package/bin/_internal/integrations/n8n/src/utils/sendAndWait/descriptions.ts

@@ -0,0 +1,20 @@
+import { IWebhookDescription } from 'n8n-workflow';
+
+export const sendAndWaitWebhooksDescription: IWebhookDescription[] = [
+	{
+		name: 'default',
+		httpMethod: 'GET',
+		responseMode: 'onReceived',
+		path: '={{$nodeId}}',
+		restartWebhook: true,
+		isFullPath: true,
+	},
+	{
+		name: 'default',
+		httpMethod: 'POST',
+		responseMode: 'onReceived',
+		path: '={{$nodeId}}',
+		restartWebhook: true,
+		isFullPath: true,
+	},
+];

package/bin/_internal/integrations/n8n/src/utils/sendAndWaitWebhook.ts

@@ -0,0 +1,72 @@
+import {
+	IWebhookFunctions,
+	IWebhookResponseData,
+	INodeExecutionData,
+	IDataObject,
+} from 'n8n-workflow';
+
+/**
+ * Handle webhook responses for Vicoa sendAndWait operations
+ * This receives the user's response from Vicoa and continues the workflow
+ */
+export async function vicoaSendAndWaitWebhook(
+	this: IWebhookFunctions,
+): Promise<IWebhookResponseData> {
+	const headers = this.getHeaderData() as IDataObject;
+	const body = this.getBodyData() as IDataObject;
+
+	// Check if this is a valid Vicoa webhook call
+	if (!headers['x-vicoa-webhook'] && !body.agent_instance_id) {
+		return {
+			webhookResponse: {
+				status: 400,
+				body: {
+					error: 'Invalid webhook call - missing Vicoa headers',
+				},
+			},
+			noWebhookResponse: false,
+		};
+	}
+
+	// Extract the response data from Vicoa
+	const responseData: IDataObject = {
+		userResponse: body.user_message || '',
+		userId: body.user_id,
+		messageId: body.message_id,
+		agentInstanceId: body.agent_instance_id,
+		timestamp: body.timestamp || new Date().toISOString(),
+	};
+
+	// Return the data to continue the workflow
+	const returnData: INodeExecutionData[] = [
+		{
+			json: responseData,
+		},
+	];
+
+	// Return both the workflow data and webhook response
+	return {
+		webhookResponse: {
+			status: 200,
+			body: {
+				success: true,
+				message: 'Webhook received successfully',
+				execution_resumed: true,
+			},
+		},
+		workflowData: [returnData],
+	};
+}
+
+/**
+ * Generate the webhook configuration for sendAndWait
+ */
+export function getVicoaWebhookConfig(instanceId: string): IDataObject {
+	return {
+		name: 'default',
+		httpMethod: 'POST',
+		responseMode: 'onReceived',
+		path: `vicoa-webhook/${instanceId}`,
+		restartWebhook: true,
+	};
+}

package/bin/_internal/integrations/n8n/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}