@vicoa/cli 1.3.10 → 1.3.11-linux-x64

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

@@ -0,0 +1,68 @@
+{
+  "name": "n8n-nodes-vicoa",
+  "version": "0.1.6",
+  "description": "n8n node for Vicoa - communicate with AI agents",
+  "keywords": [
+    "n8n",
+    "n8n-node",
+    "n8n-community-node-package",
+    "vicoa",
+    "ai",
+    "agents",
+    "workflow"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/vicoa-ai/vicoa/tree/main/src/integrations/n8n",
+  "author": {
+    "name": "Vicoa",
+    "email": "hi@vicoa.ai"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vicoa-ai/vicoa.git",
+    "directory": "src/integrations/n8n"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "copy-assets": "cp src/nodes/Vicoa/vicoa.png dist/nodes/Vicoa/ && cp src/nodes/Vicoa/Vicoa.node.json dist/nodes/Vicoa/",
+    "dev": "tsc --watch",
+    "format": "prettier --write .",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/VicoaApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Vicoa/Vicoa.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/uuid": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.54.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.2"
+  },
+  "dependencies": {
+    "uuid": "^9.0.1"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "engines": {
+    "node": ">=20.15.0"
+  }
+}

package/bin/_internal/integrations/n8n/src/credentials/OmnaraApi.credentials.ts

@@ -0,0 +1,52 @@
+import {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class VicoaApi implements ICredentialType {
+	name = 'vicoaApi';
+	displayName = 'Vicoa API';
+	documentationUrl = 'https://github.com/vicoa-ai/vicoa';
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: {
+				password: true,
+			},
+			default: '',
+			required: true,
+			description: 'Your Vicoa API key. Get it from your Vicoa dashboard.',
+		},
+		{
+			displayName: 'API URL',
+			name: 'serverUrl',
+			type: 'string',
+			default: 'https://api.vicoa.ai:8443',
+			required: true,
+			description:
+				'The Vicoa API URL (without /api/v1). Use the default unless you have a custom deployment.',
+			placeholder: 'https://api.vicoa.ai:8443',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.serverUrl}}',
+			url: '/api/v1/auth/verify',
+			method: 'GET',
+		},
+	};
+}

package/bin/_internal/integrations/n8n/src/nodes/Omnara/Omnara.node.json

@@ -0,0 +1,35 @@
+{
+  "node": "n8n-nodes-vicoa.vicoa",
+  "nodeVersion": "1.0",
+  "codexVersion": "1.0",
+  "categories": [
+    "Communication",
+    "Development"
+  ],
+  "resources": {
+    "credentialDocumentation": [
+      {
+        "url": "https://github.com/vicoa-ai/vicoa"
+      }
+    ],
+    "primaryDocumentation": [
+      {
+        "url": "https://github.com/vicoa-ai/vicoa"
+      }
+    ]
+  },
+  "subcategories": {
+    "Communication": [
+      "Chat"
+    ],
+    "Development": [
+      "AI"
+    ]
+  },
+  "alias": [
+    "AI",
+    "Agent",
+    "Claude",
+    "Assistant"
+  ]
+}

package/bin/_internal/integrations/n8n/src/nodes/Omnara/Omnara.node.ts

@@ -0,0 +1,304 @@
+import {
+    IExecuteFunctions,
+    INodeExecutionData,
+    INodeType,
+    INodeTypeDescription,
+    NodeConnectionTypes,
+    NodeOperationError,
+    SEND_AND_WAIT_OPERATION
+} from 'n8n-workflow';
+
+import * as message from './actions/message';
+import * as session from './actions/session';
+import { vicoaSendAndWaitWebhook } from '../../utils/sendAndWaitWebhook';
+import { sendAndWaitWebhooksDescription } from '../../utils/sendAndWait/descriptions';
+import { configureWaitTillDate } from '../../utils/sendAndWait/configureWaitTillDate';
+import { vicoaApiRequest, generateAgentInstanceId, getAgentType } from '../../utils/GenericFunctions';
+
+
+export class Vicoa implements INodeType {
+	webhook = vicoaSendAndWaitWebhook;
+
+	description: INodeTypeDescription = {
+		displayName: 'Vicoa',
+		name: 'vicoa',
+		icon: 'file:vicoa.png',
+		group: ['transform'],
+		version: 1,
+		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+		description:
+			'Send messages to users via Vicoa - a web and mobile platform for human-AI communication',
+		defaults: {
+			name: 'Vicoa',
+		},
+        inputs: [NodeConnectionTypes.Main],
+        outputs: [NodeConnectionTypes.Main],
+		webhooks: sendAndWaitWebhooksDescription,
+		credentials: [
+			{
+				name: 'vicoaApi',
+				required: true,
+			},
+		],
+		properties: [
+			{
+				displayName: 'Resource',
+				name: 'resource',
+				type: 'options',
+				noDataExpression: true,
+				options: [
+					{
+						name: 'Message',
+						value: 'message',
+						description: 'Send messages to Vicoa agents',
+					},
+					{
+						name: 'Session',
+						value: 'session',
+						description: 'Manage agent sessions',
+					},
+				],
+				default: 'message',
+			},
+			...message.descriptions,
+			...session.descriptions,
+		],
+		usableAsTool: true,
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+		const resource = this.getNodeParameter('resource', 0) as string;
+		const operation = this.getNodeParameter('operation', 0) as string;
+		for (let i = 0; i < items.length; i++) {
+			try {
+				let responseData: INodeExecutionData[] = [];
+				if (resource === 'message') {
+					if (operation === 'send') {
+						responseData = await message.send.execute.call(this, i);
+					} else if (operation === SEND_AND_WAIT_OPERATION || operation === 'sendAndWait') {
+						// FOLLOWING SLACK PATTERN EXACTLY		
+						const agentType = getAgentType.call(this, 0);				
+						const agentInstanceId = generateAgentInstanceId.call(this, 0, agentType);
+						const messageContent = this.getNodeParameter('message', 0) as string;
+						const options = this.getNodeParameter('options', 0, {}) as any;
+
+                        // Check if sync mode is enabled (for AI Agent compatibility)
+                        const syncMode = options.syncMode === true;
+						
+						if (syncMode) {
+							// Sync mode: Poll for responses instead of using putExecutionToWait
+							// This is necessary for AI Agents which don't support async/await properly
+							const syncTimeout = options.syncTimeout || 7200; // Default 2 hours
+							const pollInterval = options.pollInterval || 5; // Default 5 seconds
+
+							// Send the message first
+							const body: any = {
+								agent_instance_id: agentInstanceId,
+								agent_type: agentType,
+								content: messageContent,
+								requires_user_input: true,
+								// Don't send webhook URL in sync mode
+								message_metadata: {
+									sync_mode: true,
+									node_id: this.getNode().id,
+								},
+							};
+
+							if (options.sendEmail !== undefined) {
+								body.send_email = options.sendEmail;
+							}
+							if (options.sendSms !== undefined) {
+								body.send_sms = options.sendSms;
+							}
+							if (options.sendPush !== undefined) {
+								body.send_push = options.sendPush;
+							}
+
+							const sendResponse = await vicoaApiRequest.call(
+								this,
+								'POST',
+								'/messages/agent',
+								body,
+							);
+
+							const messageId = sendResponse.message_id;
+
+							// Now poll for responses
+							const startTime = Date.now();
+							const timeoutMs = syncTimeout * 1000;
+							const lastReadMessageId = messageId;
+
+							while (Date.now() - startTime < timeoutMs) {
+								// Wait for poll interval using Date.now()
+								// Community nodes must avoid restricted globals
+								const pollStart = Date.now();
+								const pollMs = pollInterval * 1000;
+								while (Date.now() - pollStart < pollMs) {
+									// Small delay to avoid blocking
+									await new Promise((resolve) => resolve(undefined));
+								}
+
+								// Check for pending messages
+								try {
+									const pendingResponse = await vicoaApiRequest.call(
+										this,
+										'GET',
+										'/messages/pending',
+										{},
+										{
+											agent_instance_id: agentInstanceId,
+											last_read_message_id: lastReadMessageId,
+										},
+									);
+
+									// Check if we got any user messages
+									if (pendingResponse.messages && pendingResponse.messages.length > 0) {
+										// Return the last user message as the result
+										const lastMessage =
+											pendingResponse.messages[pendingResponse.messages.length - 1];
+
+										// Return the response in a format compatible with the workflow
+										return [
+											[
+												{
+													json: {
+														success: true,
+														agent_instance_id: agentInstanceId,
+														user_response: lastMessage.content,
+														message_id: lastMessage.id,
+														response_time: lastMessage.created_at,
+														all_responses: pendingResponse.messages.map((m: any) => ({
+															content: m.content,
+															id: m.id,
+															created_at: m.created_at,
+														})),
+													},
+													pairedItem: i,
+												},
+											],
+										];
+									}
+
+									// If status is 'stale', continue polling
+									if (pendingResponse.status === 'stale') {
+										// We might need to re-fetch to get the current state
+										// For now, continue polling
+									}
+								} catch (pollError) {
+									// Continue polling on error
+								}
+							}
+
+							// Timeout reached without response
+							return [
+								[
+									{
+										json: {
+											success: false,
+											agent_instance_id: agentInstanceId,
+											error: 'Timeout waiting for user response',
+											timeout_seconds: syncTimeout,
+										},
+										pairedItem: i,
+									},
+								],
+							];
+						} else {
+							// Original async mode with putExecutionToWait
+							// Get the webhook URL from n8n's execution context
+							// This automatically provides the correct URL for any n8n instance
+							const resumeUrl = this.evaluateExpression('{{ $execution?.resumeUrl }}', 0) as string;
+							const nodeId = this.evaluateExpression('{{ $nodeId }}', 0) as string;
+							const executionId = this.getExecutionId();
+							
+							// Construct the full webhook URL with node ID appended
+							const webhookUrl = `${resumeUrl}/${nodeId}`;
+
+							const body: any = {
+								agent_instance_id: agentInstanceId,
+								agent_type: agentType,
+								content: messageContent,
+								requires_user_input: true,
+								// Send webhook URL in metadata so Vicoa knows where to send the response
+								message_metadata: {
+									webhook_url: webhookUrl, // Full URL with execution ID and node ID
+									execution_id: executionId,
+									node_id: nodeId,
+									webhook_type: 'n8n_send_and_wait',
+								},
+							};
+
+							if (options.sendEmail !== undefined) {
+								body.send_email = options.sendEmail;
+							}
+							if (options.sendSms !== undefined) {
+								body.send_sms = options.sendSms;
+							}
+							if (options.sendPush !== undefined) {
+								body.send_push = options.sendPush;
+							}
+
+							// Send message to Vicoa (like Slack sends to chat.postMessage)
+							await vicoaApiRequest.call(this, 'POST', '/messages/agent', body);
+
+							// Configure wait time
+							const waitTill = configureWaitTillDate(this, 0);
+
+							// Put execution to wait
+							if (waitTill === 'WAIT_INDEFINITELY') {
+								await this.putExecutionToWait(new Date(Date.now() + 365 * 24 * 60 * 60 * 1000));
+							} else {
+								await this.putExecutionToWait(waitTill as Date);
+							}
+
+							// Return input data
+							return [this.getInputData()];
+						}
+					} else {
+						throw new NodeOperationError(
+							this.getNode(),
+							`The operation "${operation}" is not supported for resource "${resource}"`,
+							{ itemIndex: i },
+						);
+					}
+				} else if (resource === 'session') {
+					if (operation === 'end') {
+						responseData = await session.end.execute.call(this, i);
+					} else {
+						throw new NodeOperationError(
+							this.getNode(),
+							`The operation "${operation}" is not supported for resource "${resource}"`,
+							{ itemIndex: i },
+						);
+					}
+				} else {
+					throw new NodeOperationError(
+						this.getNode(),
+						`The resource "${resource}" is not supported`,
+						{ itemIndex: i },
+					);
+				}
+
+				returnData.push(...responseData);
+			} catch (error) {
+				if (this.continueOnFail()) {
+					returnData.push({
+						json: {
+							error: error instanceof Error ? error.message : String(error),
+							resource,
+							operation,
+							itemIndex: i,
+						},
+						pairedItem: i,
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+
+		return [returnData];
+	}
+}

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

@@ -0,0 +1,37 @@
+import * as send from './send.operation';
+import * as sendAndWait from './sendAndWait.operation';
+
+import { INodeProperties } from 'n8n-workflow';
+
+export { send, sendAndWait };
+
+export const descriptions: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+			},
+		},
+		options: [
+			{
+				name: 'Send',
+				value: 'send',
+				description: 'Send a non-blocking message to the user (for status updates, progress reports, or sharing your thought process). Use this when you want to inform the user but do not need their response to continue',
+				action: 'Send message',
+			},
+			{
+				name: 'Send and Wait',
+				value: 'sendAndWait',
+				description: 'Send a message and wait for the user\'s response (for questions, approvals, or conversations). Use this when you need the user\'s input to proceed with your task',
+				action: 'Send message and wait for response',
+			},
+		],
+		default: 'send',
+	},
+	...send.sendMessageDescription,
+	...sendAndWait.sendAndWaitDescription,
+];

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

@@ -0,0 +1,151 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+import { vicoaApiRequest, formatMessageResponse, generateAgentInstanceId, getAgentType } from '../../../../utils/GenericFunctions';
+
+export const sendMessageDescription: INodeProperties[] = [
+	{
+		displayName: 'Agent Instance ID',
+		name: 'agentInstanceId',
+		type: 'string',
+		default: '',
+		required: false,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send'],
+			},
+		},
+		placeholder: 'e.g. 550e8400-e29b-41d4-a716-446655440000',
+		description:
+			'A unique UUID 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: ['send'],
+			},
+		},
+		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: ['send'],
+			},
+		},
+		placeholder: 'e.g. Build completed successfully',
+		description:
+			'Status update or informational message to send to the user. This will appear in their Vicoa web/mobile app. The workflow will continue immediately without waiting for a response.',
+	},
+	{
+		displayName: 'Additional Options',
+		name: 'additionalOptions',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send'],
+			},
+		},
+		options: [
+			{
+				displayName: 'Send Email Notification',
+				name: 'sendEmail',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to send an email notification',
+			},
+			{
+				displayName: 'Send SMS Notification',
+				name: 'sendSms',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to send an SMS notification',
+			},
+			{
+				displayName: 'Send Push Notification',
+				name: 'sendPush',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to send a push notification',
+			},
+		],
+	},
+];
+
+export async function execute(
+	this: IExecuteFunctions,
+	index: number,
+): Promise<INodeExecutionData[]> {
+
+	const agentType = getAgentType.call(this, 0);
+	const agentInstanceId = generateAgentInstanceId.call(this, 0, agentType);
+
+	const message = this.getNodeParameter('message', index) as string;
+	const additionalOptions = this.getNodeParameter('additionalOptions', index, {}) as any;
+
+	if (!message) {
+		throw new NodeOperationError(this.getNode(), 'Message is required', { itemIndex: index });
+	}
+
+	const body: any = {
+		agent_instance_id: agentInstanceId,
+		agent_type: agentType,
+		content: message,
+		requires_user_input: false,
+	};
+	if (additionalOptions.sendEmail !== undefined) {
+		body.send_email = additionalOptions.sendEmail;
+	}
+	if (additionalOptions.sendSms !== undefined) {
+		body.send_sms = additionalOptions.sendSms;
+	}
+	if (additionalOptions.sendPush !== undefined) {
+		body.send_push = additionalOptions.sendPush;
+	}
+
+	try {
+		const response = await vicoaApiRequest.call(this, 'POST', '/messages/agent', body);
+
+		const result = {
+			success: response.success,
+			agentInstanceId: response.agent_instance_id,
+			messageId: response.message_id,
+			queuedUserMessages: response.queued_user_messages
+				? response.queued_user_messages.map(formatMessageResponse)
+				: [],
+		};
+
+		return [{ json: result }];
+	} catch (error) {
+		throw new NodeOperationError(
+			this.getNode(),
+			`Failed to send message: ${error instanceof Error ? error.message : String(error)}`,
+			{ itemIndex: index },
+		);
+	}
+}