piece-signal-cli-rest-api 0.2.0 → 0.2.1

package/src/lib/triggers/new-message-received.ts

@@ -1,618 +0,0 @@
-import {
-	createTrigger,
-	TriggerStrategy,
-	Property,
-	AppConnectionValueForAuthProperty,
-	StoreScope,
-} from '@activepieces/pieces-framework';
-import {
-	DedupeStrategy,
-	Polling,
-	pollingHelper,
-	HttpMethod,
-	httpClient,
-} from '@activepieces/pieces-common';
-import { signalCliRestApiAuth } from '../common/auth';
-import { formatPhoneNumber } from '../common/utils';
-import WebSocket from 'ws';
-
-interface SignalMessage {
-	envelope: {
-		source: string;
-		sourceNumber?: string;
-		sourceUuid?: string;
-		sourceName?: string;
-		sourceDevice: number;
-		timestamp: number;
-		timestampISO?: string;
-		dataMessage?: {
-			message?: string;
-			timestamp: number;
-			expiresInSeconds?: number;
-			attachments?: Array<{
-				id: string;
-				contentType: string;
-				size: number;
-				fileName?: string;
-				width?: number;
-				height?: number;
-				voiceNote?: boolean;
-				caption?: string;
-			}>;
-			mentions?: Array<{
-				start: number;
-				length: number;
-				recipient: string;
-			}>;
-			groupInfo?: {
-				groupId: string;
-				type: string;
-				members?: string[];
-				name?: string;
-				avatarId?: number;
-			};
-			quote?: {
-				id: number;
-				author: string;
-				text?: string;
-			};
-			preview?: Array<{
-				url: string;
-				title: string;
-				description?: string;
-			}>;
-			sticker?: {
-				packId: string;
-				stickerId: number;
-			};
-			reaction?: {
-				emoji: string;
-				targetAuthor: string;
-				targetTimestamp: number;
-			};
-			viewOnce?: boolean;
-		};
-		syncMessage?: {
-			sentMessage?: {
-				destination: string;
-				timestamp: number;
-				message?: string;
-			};
-		};
-		receipt?: {
-			type: number;
-			timestamp: number;
-			timestamps: number[];
-		};
-		typing?: {
-			action: number;
-			timestamp: number;
-		};
-	};
-	account: string;
-}
-
-interface ApprovalMapping {
-	flowRunId: string;
-	requestId: string;
-	approveEmoji: string;
-	disapproveEmoji: string;
-	targetAuthor: string;
-	messageTimestamp: number;
-	timeoutSeconds: number;
-	createdAt: number;
-}
-
-// Function to automatically resume approval flows
-async function tryResumeApprovalFlow(
-	message: SignalMessage,
-	store: any,
-	apiUrl: string
-): Promise<{ resumed: boolean; action?: string }> {
-	console.log('[NewMessageReceived] DEBUG - Processing message:', {
-		hasReaction: !!message.envelope?.dataMessage?.reaction,
-	});
-
-	// Check if it's a reaction
-	if (!message.envelope?.dataMessage?.reaction) {
-		return { resumed: false };
-	}
-
-	console.log('[NewMessageReceived] DEBUG - Reaction detected');
-	const reaction = message.envelope.dataMessage.reaction;
-	// Convert targetTimestamp from milliseconds to seconds (Unix timestamp)
-	// Note: targetTimestamp in SignalMessage interface might be targetSentTimestamp in actual data
-	const targetTimestampMs = (reaction as any).targetSentTimestamp || reaction.targetTimestamp;
-	const targetTimestamp = Math.floor(targetTimestampMs / 1000);
-	const targetAuthor = reaction.targetAuthor;
-	const reactionEmoji = reaction.emoji;
-
-	console.log('[NewMessageReceived] DEBUG - Reaction data:', {
-		targetSentTimestampOriginal: targetTimestampMs,
-		targetTimestamp,
-		targetAuthor,
-		reactionEmoji,
-	});
-
-	// Cleanup expired approvals
-	const keysListKey = 'approval:keys';
-	const existingKeys = (await store.get<string[]>(keysListKey, StoreScope.PROJECT)) || [];
-	const currentTimestamp = Math.floor(Date.now() / 1000);
-	const validKeys: string[] = [];
-	const keysToDelete: string[] = [];
-
-	console.log('[NewMessageReceived] DEBUG - Store info:', {
-		existingKeysCount: existingKeys.length,
-		existingKeys: existingKeys,
-		currentTimestamp,
-	});
-
-	for (const key of existingKeys) {
-		const mapping = await store.get<ApprovalMapping>(key, StoreScope.PROJECT);
-		if (mapping) {
-			// Check if expired
-			if (currentTimestamp - mapping.createdAt > mapping.timeoutSeconds) {
-				// Expired - delete it and flowRunId mapping
-				await store.delete(key, StoreScope.PROJECT);
-				const flowRunMappingKey = `approval:flowRun:${mapping.flowRunId}`;
-				await store.delete(flowRunMappingKey, StoreScope.PROJECT);
-				keysToDelete.push(key);
-			} else {
-				validKeys.push(key);
-			}
-		} else {
-			// Mapping not found - remove from list
-			keysToDelete.push(key);
-		}
-	}
-
-	// Update keys list if any were deleted
-	if (keysToDelete.length > 0) {
-		await store.put(keysListKey, validKeys, StoreScope.PROJECT);
-	}
-
-	console.log('[NewMessageReceived] DEBUG - Cleanup result:', {
-		keysDeleted: keysToDelete.length,
-		validKeysCount: validKeys.length,
-	});
-
-	// Look up the specific approval mapping
-	const storeKey = `approval:${targetTimestamp}:${targetAuthor}`;
-	
-	console.log('[NewMessageReceived] DEBUG - Store lookup:', {
-		storeKey,
-		existingKeysCount: existingKeys.length,
-	});
-	
-	const mapping = await store.get<ApprovalMapping>(storeKey, StoreScope.PROJECT);
-
-	if (!mapping) {
-		// Not an approval message
-		console.log('[NewMessageReceived] DEBUG - No mapping found:', {
-			reason: 'not_an_approval_message',
-			searchedKey: storeKey,
-		});
-		return { resumed: false };
-	}
-
-	console.log('[NewMessageReceived] DEBUG - Mapping found:', {
-		flowRunId: mapping.flowRunId,
-		requestId: mapping.requestId,
-		approveEmoji: mapping.approveEmoji,
-		disapproveEmoji: mapping.disapproveEmoji,
-		messageTimestamp: mapping.messageTimestamp,
-		createdAt: mapping.createdAt,
-		timeoutSeconds: mapping.timeoutSeconds,
-	});
-
-	// Check if expired
-	const ageInSeconds = currentTimestamp - mapping.createdAt;
-	const isExpired = ageInSeconds > mapping.timeoutSeconds;
-
-	console.log('[NewMessageReceived] DEBUG - Expiration check:', {
-		currentTimestamp,
-		createdAt: mapping.createdAt,
-		ageInSeconds,
-		timeoutSeconds: mapping.timeoutSeconds,
-		isExpired,
-	});
-
-	if (isExpired) {
-		// Expired - delete and return
-		await store.delete(storeKey, StoreScope.PROJECT);
-		const flowRunMappingKey = `approval:flowRun:${mapping.flowRunId}`;
-		await store.delete(flowRunMappingKey, StoreScope.PROJECT);
-		const updatedKeys = validKeys.filter(key => key !== storeKey);
-		await store.put(keysListKey, updatedKeys, StoreScope.PROJECT);
-		console.log('[NewMessageReceived] DEBUG - Approval expired');
-		return { resumed: false };
-	}
-
-	// Check emoji and determine action
-	let action: string;
-
-	console.log('[NewMessageReceived] DEBUG - Emoji check:', {
-		receivedEmoji: reactionEmoji,
-		expectedApproveEmoji: mapping.approveEmoji,
-		expectedDisapproveEmoji: mapping.disapproveEmoji,
-	});
-
-	if (reactionEmoji === mapping.approveEmoji) {
-		action = 'approve';
-		console.log('[NewMessageReceived] DEBUG - Emoji matched: approve');
-	} else if (reactionEmoji === mapping.disapproveEmoji) {
-		action = 'disapprove';
-		console.log('[NewMessageReceived] DEBUG - Emoji matched: disapprove');
-	} else {
-		// Invalid emoji - not an approval reaction
-		console.log('[NewMessageReceived] DEBUG - Invalid emoji:', {
-			reason: 'invalid_emoji',
-			receivedEmoji: reactionEmoji,
-		});
-		return { resumed: false };
-	}
-
-	// Make HTTP request to resume the flow
-	const resumeUrl = `${apiUrl}v1/flow-runs/${mapping.flowRunId}/requests/${mapping.requestId}?action=${action}`;
-	
-	console.log('[NewMessageReceived] DEBUG - Attempting resume:', {
-		resumeUrl,
-		apiUrl,
-		flowRunId: mapping.flowRunId,
-		requestId: mapping.requestId,
-		action,
-	});
-	
-	try {
-		const response = await httpClient.sendRequest({
-			method: HttpMethod.POST,
-			url: resumeUrl,
-			headers: {
-				'Content-Type': 'application/json',
-			},
-		});
-
-		console.log('[NewMessageReceived] DEBUG - Resume successful:', {
-			flowRunId: mapping.flowRunId,
-			action,
-			responseStatus: response.status,
-			responseBody: response.body,
-		});
-
-		// Delete mapping from Store (cleanup)
-		await store.delete(storeKey, StoreScope.PROJECT);
-
-		// Delete flowRunId mapping
-		const flowRunMappingKey = `approval:flowRun:${mapping.flowRunId}`;
-		await store.delete(flowRunMappingKey, StoreScope.PROJECT);
-
-		// Remove key from approval keys list
-		const finalKeys = validKeys.filter(key => key !== storeKey);
-		await store.put(keysListKey, finalKeys, StoreScope.PROJECT);
-
-		console.log('[NewMessageReceived] DEBUG - Cleanup completed');
-
-		return { resumed: true, action };
-	} catch (error) {
-		// If resume fails, log but don't throw - message will still be returned
-		console.error('[NewMessageReceived] DEBUG - Resume failed:', {
-			error: error instanceof Error ? error.message : String(error),
-			errorStack: error instanceof Error ? error.stack : undefined,
-			resumeUrl,
-			flowRunId: mapping.flowRunId,
-			reason: 'resume_failed',
-		});
-		return { resumed: false };
-	}
-}
-
-const polling: Polling<
-	AppConnectionValueForAuthProperty<typeof signalCliRestApiAuth>,
-	{
-		number: string;
-		timeout?: number;
-		ignore_attachments?: boolean;
-		ignore_stories?: boolean;
-		max_messages?: number;
-		send_read_receipts?: boolean;
-	}
-> = {
-	strategy: DedupeStrategy.TIMEBASED,
-	items: async ({ auth, propsValue, lastFetchEpochMS }) => {
-		const { baseUrl, useBasicAuth, basicAuthUsername, basicAuthPassword, mode = 'normal' } = auth.props;
-		const { number, timeout = 1, ignore_attachments = false, ignore_stories = false, max_messages, send_read_receipts = false } = propsValue;
-
-		const formattedNumber = formatPhoneNumber(number);
-
-		// Build query parameters
-		const queryParams = new URLSearchParams();
-		queryParams.append('timeout', timeout.toString());
-		queryParams.append('ignore_attachments', ignore_attachments.toString());
-		queryParams.append('ignore_stories', ignore_stories.toString());
-		if (max_messages) {
-			queryParams.append('max_messages', max_messages.toString());
-		}
-		queryParams.append('send_read_receipts', send_read_receipts.toString());
-
-		const baseUrlClean = baseUrl.replace(/\/$/, '');
-		const httpUrl = `${baseUrlClean}/v1/receive/${encodeURIComponent(formattedNumber)}?${queryParams.toString()}`;
-
-		// Build headers
-		const headers: Record<string, string> = {};
-
-		// Add Basic Auth header if configured
-		if (useBasicAuth && basicAuthUsername && basicAuthPassword) {
-			const credentials = Buffer.from(
-				`${basicAuthUsername}:${basicAuthPassword}`
-			).toString('base64');
-			headers['Authorization'] = `Basic ${credentials}`;
-		}
-
-		// Use the configured mode to determine which method to use
-		if (mode === 'json-rpc') {
-			// Use WebSocket for json-rpc mode
-			return tryWebSocketReceive(httpUrl, headers, timeout, max_messages);
-		} else {
-			// Use HTTP GET for normal/native mode
-			return tryHttpReceive(httpUrl, headers);
-		}
-	},
-};
-
-// WebSocket receive function (for json-rpc mode)
-async function tryWebSocketReceive(
-	httpUrl: string,
-	headers: Record<string, string>,
-	timeout: number,
-	max_messages?: number
-): Promise<Array<{ epochMilliSeconds: number; data: SignalMessage }>> {
-	const wsUrl = httpUrl.replace(/^http:/, 'ws:').replace(/^https:/, 'wss:');
-	const wsHeaders: Record<string, string> = {
-		...headers,
-		'Connection': 'Upgrade',
-		'Upgrade': 'websocket',
-	};
-
-	return new Promise((resolve, reject) => {
-		const messages: SignalMessage[] = [];
-		let messageCount = 0;
-		const maxMessagesToCollect = max_messages || Infinity;
-		const timeoutMs = timeout * 1000;
-		let resolved = false;
-
-		const resolveOnce = (result: Array<{ epochMilliSeconds: number; data: SignalMessage }>) => {
-			if (!resolved) {
-				resolved = true;
-				resolve(result);
-			}
-		};
-
-		const rejectOnce = (error: Error) => {
-			if (!resolved) {
-				resolved = true;
-				reject(error);
-			}
-		};
-
-		const processMessages = () => {
-			// Filter messages that have dataMessage (actual message content)
-			const dataMessages = messages.filter((msg) => msg.envelope?.dataMessage);
-
-			// Map to polling format with timestamp
-			return dataMessages.map((message) => {
-				const timestamp = message.envelope.dataMessage?.timestamp || message.envelope.timestamp || Date.now();
-				return {
-					epochMilliSeconds: timestamp * 1000, // Convert to milliseconds
-					data: message,
-				};
-			});
-		};
-
-		const ws = new WebSocket(wsUrl, {
-			headers: wsHeaders,
-		});
-
-		const timeoutId = setTimeout(() => {
-			if (!resolved) {
-				ws.close();
-				resolveOnce(processMessages());
-			}
-		}, timeoutMs);
-
-		ws.on('open', () => {
-			// WebSocket connection opened successfully
-			// The server will send messages as they arrive
-		});
-
-		ws.on('message', (data: WebSocket.Data) => {
-			try {
-				const messageText = data.toString();
-				
-				// Check if it's an error message
-				if (messageText.includes('"error"') || messageText.includes('"Msg"')) {
-					try {
-						const errorObj = JSON.parse(messageText);
-						if (errorObj.error || errorObj.Msg) {
-							clearTimeout(timeoutId);
-							ws.close();
-							// If it's a "no messages" type error, return empty array
-							if (errorObj.Msg && errorObj.Msg.includes('No new messages')) {
-								resolveOnce([]);
-							} else {
-								rejectOnce(new Error(errorObj.error || errorObj.Msg));
-							}
-							return;
-						}
-					} catch {
-						// Not a JSON error, continue processing
-					}
-				}
-
-				// Try to parse as JSON message
-				try {
-					const message: SignalMessage = JSON.parse(messageText);
-					messages.push(message);
-					messageCount++;
-
-					// If we've reached max_messages, close the connection
-					if (messageCount >= maxMessagesToCollect) {
-						clearTimeout(timeoutId);
-						ws.close();
-						resolveOnce(processMessages());
-					}
-				} catch (parseError) {
-					// If parsing fails, ignore this message
-					// The server might send non-JSON data
-				}
-			} catch (error) {
-				// Ignore individual message errors
-			}
-		});
-
-		ws.on('error', (error) => {
-			clearTimeout(timeoutId);
-			ws.close();
-			// Reject to trigger fallback to HTTP GET
-			rejectOnce(error);
-		});
-
-		ws.on('close', () => {
-			clearTimeout(timeoutId);
-			// If we haven't resolved yet, resolve with collected messages
-			if (!resolved) {
-				resolveOnce(processMessages());
-			}
-		});
-	});
-}
-
-// HTTP GET receive function (for normal/native mode)
-async function tryHttpReceive(
-	httpUrl: string,
-	headers: Record<string, string>
-): Promise<Array<{ epochMilliSeconds: number; data: SignalMessage }>> {
-	try {
-		const response = await httpClient.sendRequest<SignalMessage[] | string>({
-			method: HttpMethod.GET,
-			url: httpUrl,
-			headers,
-		});
-
-		// The API returns either a JSON array of messages or a JSON string
-		let messages: SignalMessage[] = [];
-		if (typeof response.body === 'string') {
-			try {
-				messages = JSON.parse(response.body);
-			} catch {
-				// If parsing fails, try to parse as array
-				messages = [];
-			}
-		} else if (Array.isArray(response.body)) {
-			messages = response.body;
-		} else {
-			messages = [];
-		}
-
-		// Filter messages that have dataMessage (actual message content)
-		const dataMessages = messages.filter((msg) => msg.envelope?.dataMessage);
-
-		// Map to polling format with timestamp
-		return dataMessages.map((message) => {
-			const timestamp = message.envelope.dataMessage?.timestamp || message.envelope.timestamp || Date.now();
-			return {
-				epochMilliSeconds: timestamp * 1000, // Convert to milliseconds
-				data: message,
-			};
-		});
-	} catch (error) {
-		// If no messages are available, return empty array
-		if (error instanceof Error && error.message.includes('No new messages')) {
-			return [];
-		}
-		throw error;
-	}
-}
-
-export const newMessageReceived = createTrigger({
-	auth: signalCliRestApiAuth,
-	name: 'newMessageReceived',
-	displayName: 'New Message Received',
-	description: 'Triggers when a new message is received via Signal. Automatically resumes approval flows if the message is a reaction to an approval request.',
-	type: TriggerStrategy.POLLING,
-	props: {
-		number: Property.ShortText({
-			displayName: 'Phone Number',
-			description: 'Registered phone number in international format (e.g., +43123456789)',
-			required: true,
-		}),
-		timeout: Property.Number({
-			displayName: 'Timeout (seconds)',
-			description: 'Receive timeout in seconds (default: 1)',
-			required: false,
-			defaultValue: 1,
-		}),
-		ignore_attachments: Property.Checkbox({
-			displayName: 'Ignore Attachments',
-			description: 'Ignore attachments when receiving messages',
-			required: false,
-			defaultValue: false,
-		}),
-		ignore_stories: Property.Checkbox({
-			displayName: 'Ignore Stories',
-			description: 'Ignore stories when receiving messages',
-			required: false,
-			defaultValue: false,
-		}),
-		max_messages: Property.Number({
-			displayName: 'Max Messages',
-			description: 'Maximum number of messages to receive (default: unlimited)',
-			required: false,
-		}),
-		send_read_receipts: Property.Checkbox({
-			displayName: 'Send Read Receipts',
-			description: 'Automatically send read receipts when receiving messages',
-			required: false,
-			defaultValue: false,
-		}),
-	},
-	sampleData: {
-		envelope: {
-			source: '+43123456789',
-			sourceNumber: '+43123456789',
-			sourceDevice: 1,
-			timestamp: 1234567890,
-			dataMessage: {
-				message: 'Hello, this is a test message',
-				timestamp: 1234567890,
-			},
-		},
-		account: '+43123456789',
-	},
-	async test(context) {
-		return await pollingHelper.test(polling, context);
-	},
-	async onEnable(context) {
-		await pollingHelper.onEnable(polling, context);
-	},
-	async onDisable(context) {
-		await pollingHelper.onDisable(polling, context);
-	},
-	async run(context) {
-		// Get messages from polling
-		const messages = await pollingHelper.poll(polling, context);
-		
-		// Process each message: try to resume approval flows if applicable
-		// Messages are still returned regardless of whether they triggered a resume
-		// Debug information is output via console.log (visible in Docker logs)
-		const apiUrl = context.server?.apiUrl || '';
-		
-		for (const message of messages) {
-			const signalMessage = message as SignalMessage;
-			// This will output debug info via console.log
-			await tryResumeApprovalFlow(signalMessage, context.store, apiUrl);
-		}
-		
-		// Return messages without debug fields (normal output)
-		return messages;
-	},
-});

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../../../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "../../../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
-  "include": ["src/**/*.ts", "src/lib/actions/common/utils.ts"]
-}