link-stack/apps/bridge-worker/tasks/signal/send-signal-message.ts

import {
  db,
  getWorkerUtils,
  getMaxAttachmentSize,
  getMaxTotalAttachmentSize,
  MAX_ATTACHMENTS,
  buildSignalGroupName,
} from "@link-stack/bridge-common";
import { createLogger } from "@link-stack/logger";
import * as signalApi from "@link-stack/signal-api";
const { Configuration, MessagesApi, GroupsApi } = signalApi;

const logger = createLogger("bridge-worker-send-signal-message");

interface SendSignalMessageTaskOptions {
  token: string;
  to: string;
  message: any;
  conversationId?: string; // Zammad ticket/conversation ID for callback
  quoteMessage?: string; // Optional: message text to quote
  quoteAuthor?: string; // Optional: author of quoted message (phone number)
  quoteTimestamp?: number; // Optional: timestamp of quoted message in milliseconds
  attachments?: Array<{
    data: string; // base64
    filename: string;
    mime_type: string;
  }>;
}

const sendSignalMessageTask = async ({
  token,
  to,
  message,
  conversationId,
  quoteMessage,
  quoteAuthor,
  quoteTimestamp,
  attachments,
}: SendSignalMessageTaskOptions): Promise<void> => {
  logger.debug(
    {
      token,
      to,
      conversationId,
      messageLength: message?.length,
    },
    "Processing outgoing message",
  );
  const bot = await db
    .selectFrom("SignalBot")
    .selectAll()
    .where("token", "=", token)
    .executeTakeFirstOrThrow();

  const { phoneNumber: number } = bot;
  const config = new Configuration({
    basePath: process.env.BRIDGE_SIGNAL_URL,
  });
  const messagesClient = new MessagesApi(config);
  const groupsClient = new GroupsApi(config);
  const worker = await getWorkerUtils();

  let finalTo = to;
  let groupCreated = false;

  try {
    // Check if 'to' is a group ID (group.base64 format or base64 internal ID) vs individual recipient
    // Signal group IDs are 32 bytes = 44 chars base64 (or 43 without padding)
    // Signal user UUIDs (ACIs) are 36 chars with hyphens: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    // Phone numbers start with +, usernames with u:, PNIs with PNI:
    const isGroupPrefix = to.startsWith("group.");
    const isBase64GroupId =
      /^[A-Za-z0-9+/]+=*$/.test(to) && to.length >= 43 && to.length <= 44;
    const isGroupId = isGroupPrefix || isBase64GroupId;
    const enableAutoGroups = process.env.BRIDGE_SIGNAL_AUTO_GROUPS === "true";

    logger.debug(
      {
        to,
        isGroupId,
        enableAutoGroups,
        shouldCreateGroup: enableAutoGroups && !isGroupId && to && conversationId,
      },
      "Recipient analysis",
    );

    // If sending to a phone number and auto-groups is enabled, create a group first
    if (enableAutoGroups && !isGroupId && to && conversationId) {
      try {
        const groupName = buildSignalGroupName(conversationId);
        const createGroupResponse = await groupsClient.v1GroupsNumberPost({
          number: bot.phoneNumber,
          data: {
            name: groupName,
            members: [to],
            description: "Private support conversation",
          },
        });

        if (createGroupResponse.id) {
          // The createGroupResponse.id already contains the full group identifier (group.BASE64)
          finalTo = createGroupResponse.id;
          groupCreated = true;

          // Fetch the group details to get the actual internalId
          let internalId: string | undefined;
          try {
            const groups = await groupsClient.v1GroupsNumberGet({
              number: bot.phoneNumber,
            });

            const createdGroup = groups.find((g) => g.id === finalTo);
            if (createdGroup && createdGroup.internalId) {
              internalId = createdGroup.internalId;
              logger.debug({ internalId }, "Got actual internalId");
            } else {
              // Fallback: extract base64 part from ID
              if (finalTo.startsWith("group.")) {
                internalId = finalTo.substring(6);
              }
            }
          } catch (fetchError) {
            logger.debug("Could not fetch group details, using ID base64 part");
            // Fallback: extract base64 part from ID
            if (finalTo.startsWith("group.")) {
              internalId = finalTo.substring(6);
            }
          }
          logger.debug(
            {
              groupId: finalTo,
              internalId,
              groupName,
              conversationId,
              originalRecipient: to,
              botNumber: bot.phoneNumber,
            },
            "Created new Signal group",
          );

          // Notify Zammad about the new group ID via webhook
          // Set group_joined: false initially - will be updated when user accepts invitation
          await worker.addJob("common/notify-webhooks", {
            backendId: bot.id,
            payload: {
              event: "group_created",
              conversation_id: conversationId,
              original_recipient: to,
              group_id: finalTo,
              internal_group_id: internalId,
              group_joined: false,
              timestamp: new Date().toISOString(),
            },
          });
        }
      } catch (groupError) {
        logger.error(
          {
            error: groupError instanceof Error ? groupError.message : groupError,
            to,
            conversationId,
          },
          "Error creating Signal group",
        );
        // Continue with original recipient if group creation fails
      }
    }

    logger.debug(
      {
        fromNumber: number,
        toRecipient: finalTo,
        originalTo: to,
        recipientChanged: to !== finalTo,
        groupCreated,
        isGroupRecipient: finalTo.startsWith("group."),
      },
      "Sending message via API",
    );

    // Build the message data with optional quote parameters
    const messageData: signalApi.ApiSendMessageV2 = {
      number,
      recipients: [finalTo],
      message,
    };

    logger.debug(
      {
        number,
        recipients: [finalTo],
        messageLength: message?.length,
        hasQuoteParams: !!(quoteMessage && quoteAuthor && quoteTimestamp),
      },
      "Message data being sent",
    );

    // Add quote parameters if all are provided
    if (quoteMessage && quoteAuthor && quoteTimestamp) {
      messageData.quoteTimestamp = quoteTimestamp;
      messageData.quoteAuthor = quoteAuthor;
      messageData.quoteMessage = quoteMessage;

      logger.debug(
        {
          quoteAuthor,
          quoteMessageLength: quoteMessage?.length,
          quoteTimestamp,
        },
        "Including quote in message",
      );
    }

    // Add attachments if provided with size validation
    if (attachments && attachments.length > 0) {
      const MAX_ATTACHMENT_SIZE = getMaxAttachmentSize();
      const MAX_TOTAL_SIZE = getMaxTotalAttachmentSize();

      if (attachments.length > MAX_ATTACHMENTS) {
        throw new Error(
          `Too many attachments: ${attachments.length} (max ${MAX_ATTACHMENTS})`,
        );
      }

      let totalSize = 0;
      const validatedAttachments = [];

      for (const attachment of attachments) {
        // Calculate size from base64 string (rough estimate: length * 3/4)
        const estimatedSize = (attachment.data.length * 3) / 4;

        if (estimatedSize > MAX_ATTACHMENT_SIZE) {
          logger.warn(
            {
              filename: attachment.filename,
              size: estimatedSize,
              maxSize: MAX_ATTACHMENT_SIZE,
            },
            "Attachment exceeds size limit, skipping",
          );
          continue;
        }

        totalSize += estimatedSize;
        if (totalSize > MAX_TOTAL_SIZE) {
          logger.warn(
            {
              totalSize,
              maxTotalSize: MAX_TOTAL_SIZE,
            },
            "Total attachment size exceeds limit, skipping remaining",
          );
          break;
        }

        validatedAttachments.push(attachment.data);
      }

      if (validatedAttachments.length > 0) {
        messageData.base64Attachments = validatedAttachments;
        logger.debug(
          {
            attachmentCount: validatedAttachments.length,
            attachmentNames: attachments
              .slice(0, validatedAttachments.length)
              .map((att) => att.filename),
            totalSizeBytes: totalSize,
          },
          "Including attachments in message",
        );
      }
    }

    const response = await messagesClient.v2SendPost({
      data: messageData,
    });

    logger.debug(
      {
        to: finalTo,
        groupCreated,
        response: response?.timestamp || "no timestamp",
      },
      "Message sent successfully",
    );
  } catch (error: any) {
    // Try to get the actual error message from the response
    if (error.response) {
      try {
        const errorBody = await error.response.text();
        logger.error(
          {
            status: error.response.status,
            statusText: error.response.statusText,
            body: errorBody,
            sentTo: finalTo,
            messageDetails: {
              fromNumber: number,
              toRecipients: [finalTo],
              hasQuote: !!quoteMessage,
            },
          },
          "Signal API error",
        );
      } catch (e) {
        logger.error("Could not parse error response");
      }
    }
    logger.error({ error }, "Full error details");
    throw error;
  }
};

export default sendSignalMessageTask;