@vicoa/cli 1.4.2-win32-x64 → 1.4.2

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

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

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

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

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

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

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

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

@@ -1,20 +0,0 @@
-{
-  "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"]
-}