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

package/src/lib/common/message-utils.ts

@@ -1,449 +0,0 @@
-import { StoreScope } from '@activepieces/pieces-framework';
-import { HttpMethod, httpClient } from '@activepieces/pieces-common';
-import WebSocket from 'ws';
-
-export 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
-export async function tryResumeApprovalFlow(
-	message: SignalMessage,
-	store: any,
-	apiUrl: string
-): Promise<{ resumed: boolean; action?: string }> {
-	console.log('[ReceiveMessages] DEBUG - Processing message:', {
-		hasReaction: !!message.envelope?.dataMessage?.reaction,
-	});
-
-	// Check if it's a reaction
-	if (!message.envelope?.dataMessage?.reaction) {
-		return { resumed: false };
-	}
-
-	console.log('[ReceiveMessages] 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('[ReceiveMessages] 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('[ReceiveMessages] 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('[ReceiveMessages] DEBUG - Cleanup result:', {
-		keysDeleted: keysToDelete.length,
-		validKeysCount: validKeys.length,
-	});
-
-	// Look up the specific approval mapping
-	const storeKey = `approval:${targetTimestamp}:${targetAuthor}`;
-	
-	console.log('[ReceiveMessages] DEBUG - Store lookup:', {
-		storeKey,
-		existingKeysCount: existingKeys.length,
-	});
-	
-	const mapping = await store.get<ApprovalMapping>(storeKey, StoreScope.PROJECT);
-
-	if (!mapping) {
-		// Not an approval message
-		console.log('[ReceiveMessages] DEBUG - No mapping found:', {
-			reason: 'not_an_approval_message',
-			searchedKey: storeKey,
-		});
-		return { resumed: false };
-	}
-
-	console.log('[ReceiveMessages] 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('[ReceiveMessages] 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('[ReceiveMessages] DEBUG - Approval expired');
-		return { resumed: false };
-	}
-
-	// Check emoji and determine action
-	let action: string;
-
-	console.log('[ReceiveMessages] DEBUG - Emoji check:', {
-		receivedEmoji: reactionEmoji,
-		expectedApproveEmoji: mapping.approveEmoji,
-		expectedDisapproveEmoji: mapping.disapproveEmoji,
-	});
-
-	if (reactionEmoji === mapping.approveEmoji) {
-		action = 'approve';
-		console.log('[ReceiveMessages] DEBUG - Emoji matched: approve');
-	} else if (reactionEmoji === mapping.disapproveEmoji) {
-		action = 'disapprove';
-		console.log('[ReceiveMessages] DEBUG - Emoji matched: disapprove');
-	} else {
-		// Invalid emoji - not an approval reaction
-		console.log('[ReceiveMessages] 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('[ReceiveMessages] 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('[ReceiveMessages] 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('[ReceiveMessages] DEBUG - Cleanup completed');
-
-		return { resumed: true, action };
-	} catch (error) {
-		// If resume fails, log but don't throw - message will still be returned
-		console.error('[ReceiveMessages] 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 };
-	}
-}
-
-// WebSocket receive function (for json-rpc mode)
-export async function tryWebSocketReceive(
-	httpUrl: string,
-	headers: Record<string, string>,
-	timeout: number,
-	max_messages?: number
-): Promise<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: 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)
-			return messages.filter((msg) => msg.envelope?.dataMessage);
-		};
-
-		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)
-export async function tryHttpReceive(
-	httpUrl: string,
-	headers: Record<string, string>
-): Promise<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)
-		return messages.filter((msg) => msg.envelope?.dataMessage);
-	} catch (error) {
-		// If no messages are available, return empty array
-		if (error instanceof Error && error.message.includes('No new messages')) {
-			return [];
-		}
-		throw error;
-	}
-}

package/src/lib/common/types.ts

@@ -1,73 +0,0 @@
-export interface SendMessageV2Request {
-	number: string;
-	recipients: string[];
-	message: string;
-	base64_attachments?: string[];
-	sticker?: string;
-	mentions?: MessageMention[];
-	quote_timestamp?: number;
-	quote_author?: string;
-	quote_message?: string;
-	quote_mentions?: MessageMention[];
-	text_mode?: 'normal' | 'styled';
-	edit_timestamp?: number;
-	notify_self?: boolean;
-	link_preview?: LinkPreviewType;
-	view_once?: boolean;
-}
-
-export interface MessageMention {
-	start: number;
-	length: number;
-	recipient: string;
-}
-
-export interface LinkPreviewType {
-	url: string;
-	title: string;
-	description?: string;
-	base64_thumbnail?: string;
-}
-
-export interface GroupEntry {
-	id: string;
-	name: string;
-	description?: string;
-	members: string[];
-	admins: string[];
-	blocked: boolean;
-	permissions?: GroupPermissions;
-	group_link?: string;
-	expiration_time?: number;
-	pending_requests?: string[];
-	pending_invites?: string[];
-}
-
-export interface GroupPermissions {
-	add_members: 'every-member' | 'only-admins';
-	edit_group: 'every-member' | 'only-admins';
-	send_messages: 'every-member' | 'only-admins';
-}
-
-export interface ContactEntry {
-	number: string;
-	name?: string;
-	expiration_in_seconds?: number;
-}
-
-export interface IdentityEntry {
-	number: string;
-	trust_level: string;
-	added: string;
-	safety_number: string;
-}
-
-export interface SendMessageResponse {
-	timestamp: string;
-}
-
-export interface ErrorResponse {
-	error: string;
-	challenge_tokens?: string[];
-	account?: string;
-}

package/src/lib/common/utils.ts

@@ -1,106 +0,0 @@
-import { Property, ApFile } from '@activepieces/pieces-framework';
-import mime from 'mime-types';
-
-export const commonProps = {
-	number: Property.ShortText({
-		displayName: 'Phone Number',
-		description: 'Registered phone number in international format (e.g., +43123456789). If not provided, uses the default number from the connection.',
-		required: false,
-	}),
-	recipients: Property.Array({
-		displayName: 'Recipients',
-		description: 'Array of phone numbers or group IDs',
-		required: true,
-	}),
-	message: Property.LongText({
-		displayName: 'Message',
-		description: 'Message text to send',
-		required: true,
-	}),
-};
-
-/**
- * Gets the phone number from props or connection default
- */
-export function getPhoneNumber(
-	numberFromProps: string | undefined,
-	defaultNumberFromConnection: string | undefined
-): string {
-	const phoneNumber = numberFromProps || defaultNumberFromConnection;
-	if (!phoneNumber) {
-		throw new Error('Phone number is required. Please provide it in the action or set a default in the connection settings.');
-	}
-	return formatPhoneNumber(phoneNumber);
-}
-
-export function validatePhoneNumber(number: string): boolean {
-	// Basic validation for international phone number format
-	// Should start with + and contain only digits after that
-	return /^\+[1-9]\d{1,14}$/.test(number);
-}
-
-export function formatPhoneNumber(number: string): string {
-	// Remove any spaces, dashes, or parentheses
-	const cleaned = number.replace(/[\s\-\(\)]/g, '');
-	// Ensure it starts with +
-	if (!cleaned.startsWith('+')) {
-		return '+' + cleaned;
-	}
-	return cleaned;
-}
-
-/**
- * Converts a file data URL or base64 string to a format suitable for the API
- * Supports:
- * - Base64 strings (with or without data URL prefix)
- * - Data URLs (data:mime/type;base64,base64data)
- * - File data URLs with filename (data:mime/type;filename=name;base64,base64data)
- */
-export function normalizeBase64Attachment(
-	attachment: string
-): string {
-	// If it's already a plain base64 string, return as is
-	if (!attachment.includes(',')) {
-		return attachment;
-	}
-
-	// If it's a data URL, extract the base64 part
-	if (attachment.startsWith('data:')) {
-		const parts = attachment.split(',');
-		if (parts.length === 2) {
-			// Extract mime type and other metadata from the first part
-			const header = parts[0];
-			const base64Data = parts[1];
-
-			// Check if it has filename
-			if (header.includes('filename=')) {
-				// Format: data:mime/type;filename=name;base64,data
-				return attachment;
-			} else if (header.includes('base64')) {
-				// Format: data:mime/type;base64,data
-				return attachment;
-			} else {
-				// Just base64 data, add data URL prefix
-				const mimeType = header.replace('data:', '').split(';')[0] || 'application/octet-stream';
-				return `data:${mimeType};base64,${base64Data}`;
-			}
-		}
-	}
-
-	return attachment;
-}
-
-/**
- * Converts file data to base64 string
- */
-export async function fileToBase64(file: File | Blob): Promise<string> {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onload = () => {
-			const result = reader.result as string;
-			resolve(result);
-		};
-		reader.onerror = reject;
-		reader.readAsDataURL(file);
-	});
-}