259 lines
8.3 KiB
TypeScript
259 lines
8.3 KiB
TypeScript
import { db, getWorkerUtils } from "@link-stack/bridge-common";
|
|
import * as signalApi from "@link-stack/signal-api";
|
|
const { Configuration, GroupsApi } = signalApi;
|
|
|
|
interface ReceiveSignalMessageTaskOptions {
|
|
token: string;
|
|
to: string;
|
|
from: string;
|
|
messageId: string;
|
|
sentAt: string;
|
|
message: string;
|
|
attachment?: string;
|
|
filename?: string;
|
|
mimeType?: string;
|
|
isGroup?: boolean;
|
|
}
|
|
|
|
const receiveSignalMessageTask = async ({
|
|
token,
|
|
to,
|
|
from,
|
|
messageId,
|
|
sentAt,
|
|
message,
|
|
attachment,
|
|
filename,
|
|
mimeType,
|
|
isGroup,
|
|
}: ReceiveSignalMessageTaskOptions): Promise<void> => {
|
|
console.log(`[receive-signal-message] Processing incoming message:`, {
|
|
messageId,
|
|
from,
|
|
to,
|
|
isGroup,
|
|
hasMessage: !!message,
|
|
hasAttachment: !!attachment,
|
|
token,
|
|
});
|
|
const worker = await getWorkerUtils();
|
|
const row = await db
|
|
.selectFrom("SignalBot")
|
|
.selectAll()
|
|
.where("id", "=", token)
|
|
.executeTakeFirstOrThrow();
|
|
|
|
const backendId = row.id;
|
|
let finalTo = to;
|
|
let createdInternalId: string | undefined;
|
|
|
|
// Check if auto-group creation is enabled and this is NOT already a group message
|
|
const enableAutoGroups = process.env.BRIDGE_SIGNAL_AUTO_GROUPS === "true";
|
|
|
|
console.log(`[receive-signal-message] Auto-groups config:`, {
|
|
enableAutoGroups,
|
|
isGroup,
|
|
shouldCreateGroup: enableAutoGroups && !isGroup && from && to,
|
|
});
|
|
|
|
// If this is already a group message and auto-groups is enabled,
|
|
// use group provided in 'to'
|
|
if (enableAutoGroups && isGroup && to) {
|
|
// Signal sends the internal ID (base64) in group messages
|
|
// We should NOT add "group." prefix - that's for sending messages, not receiving
|
|
console.log(
|
|
`[receive-signal-message] Message is from existing group with internal ID`,
|
|
);
|
|
|
|
finalTo = to;
|
|
} else if (enableAutoGroups && !isGroup && from && to) {
|
|
try {
|
|
const config = new Configuration({
|
|
basePath: process.env.BRIDGE_SIGNAL_URL,
|
|
});
|
|
const groupsClient = new GroupsApi(config);
|
|
|
|
// Always create a new group for direct messages to the helpdesk
|
|
// This ensures each conversation gets its own group/ticket
|
|
console.log(
|
|
`[receive-signal-message] Creating new group for user ${from}`,
|
|
);
|
|
|
|
// Include timestamp to make each group unique
|
|
const timestamp = new Date()
|
|
.toISOString()
|
|
.replace(/[:.]/g, "-")
|
|
.substring(0, 19);
|
|
const groupName = `Support: ${from} (${timestamp})`;
|
|
|
|
// Create new group for this conversation
|
|
const createGroupResponse = await groupsClient.v1GroupsNumberPost({
|
|
number: row.phoneNumber,
|
|
data: {
|
|
name: groupName,
|
|
members: [from],
|
|
description: "Private support conversation",
|
|
},
|
|
});
|
|
|
|
console.log(
|
|
`[receive-signal-message] Full group creation response from Signal API:`,
|
|
JSON.stringify(createGroupResponse, null, 2),
|
|
);
|
|
|
|
if (createGroupResponse.id) {
|
|
// The createGroupResponse.id already contains the full group identifier (group.BASE64)
|
|
finalTo = createGroupResponse.id;
|
|
|
|
// Fetch the group details to get the actual internalId
|
|
// The base64 part of the ID is NOT the same as the internalId!
|
|
try {
|
|
console.log(
|
|
`[receive-signal-message] Fetching group details to get internalId...`,
|
|
);
|
|
const groups = await groupsClient.v1GroupsNumberGet({
|
|
number: row.phoneNumber,
|
|
});
|
|
|
|
console.log(
|
|
`[receive-signal-message] All groups for bot:`,
|
|
JSON.stringify(groups.slice(0, 3), null, 2), // Show first 3 to avoid too much output
|
|
);
|
|
|
|
const createdGroup = groups.find((g) => g.id === finalTo);
|
|
if (createdGroup) {
|
|
console.log(
|
|
`[receive-signal-message] Found created group details:`,
|
|
JSON.stringify(createdGroup, null, 2),
|
|
);
|
|
}
|
|
|
|
if (createdGroup && createdGroup.internalId) {
|
|
createdInternalId = createdGroup.internalId;
|
|
console.log(
|
|
`[receive-signal-message] Got actual internalId: ${createdInternalId}`,
|
|
);
|
|
} else {
|
|
// Fallback: extract base64 part from ID
|
|
if (finalTo.startsWith("group.")) {
|
|
createdInternalId = finalTo.substring(6);
|
|
}
|
|
}
|
|
} catch (fetchError) {
|
|
console.log(
|
|
`[receive-signal-message] Could not fetch group details, using ID base64 part`,
|
|
);
|
|
// Fallback: extract base64 part from ID
|
|
if (finalTo.startsWith("group.")) {
|
|
createdInternalId = finalTo.substring(6);
|
|
}
|
|
}
|
|
|
|
console.log(`[receive-signal-message] Group created successfully:`, {
|
|
fullGroupId: finalTo,
|
|
internalId: createdInternalId,
|
|
});
|
|
console.log(`[receive-signal-message] Created new Signal group:`, {
|
|
groupId: finalTo,
|
|
internalId: createdInternalId,
|
|
groupName,
|
|
forPhoneNumber: from,
|
|
botNumber: row.phoneNumber,
|
|
response: createGroupResponse,
|
|
});
|
|
}
|
|
|
|
// Now handle notifications and message forwarding for both new and existing groups
|
|
if (finalTo && finalTo.startsWith("group.")) {
|
|
// Forward the user's initial message to the group using quote feature
|
|
try {
|
|
console.log(
|
|
`[receive-signal-message] Forwarding initial message to group using quote feature`,
|
|
);
|
|
|
|
const attributionMessage = `Message from ${from}:\n"${message}"\n\n---\nSupport team: Your request has been received. An agent will respond shortly.`;
|
|
|
|
await worker.addJob("signal/send-signal-message", {
|
|
token: row.token,
|
|
to: finalTo,
|
|
message: attributionMessage,
|
|
conversationId: null,
|
|
quoteMessage: message,
|
|
quoteAuthor: from,
|
|
quoteTimestamp: Date.parse(sentAt),
|
|
});
|
|
|
|
console.log(
|
|
`[receive-signal-message] Successfully forwarded initial message to group ${finalTo}`,
|
|
);
|
|
} catch (forwardError) {
|
|
console.error(
|
|
"[receive-signal-message] Error forwarding message to group:",
|
|
forwardError,
|
|
);
|
|
}
|
|
|
|
// Send a response to the original DM informing about the group
|
|
try {
|
|
console.log(
|
|
`[receive-signal-message] Sending group notification to original DM`,
|
|
);
|
|
|
|
const dmNotification = `Hello! A private support group has been created for your conversation.\n\nGroup name: ${groupName}\n\nPlease look for the new group in your Signal app to continue the conversation. Our support team will respond there shortly.\n\nThank you for contacting support!`;
|
|
|
|
await worker.addJob("signal/send-signal-message", {
|
|
token: row.token,
|
|
to: from,
|
|
message: dmNotification,
|
|
conversationId: null,
|
|
});
|
|
|
|
console.log(
|
|
`[receive-signal-message] Successfully sent group notification to user DM`,
|
|
);
|
|
} catch (dmError) {
|
|
console.error(
|
|
"[receive-signal-message] Error sending DM notification:",
|
|
dmError,
|
|
);
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
// Check if error is because group already exists
|
|
const errorMessage =
|
|
error?.response?.data?.error || error?.message || error;
|
|
const isAlreadyExists =
|
|
errorMessage?.toString().toLowerCase().includes("already") ||
|
|
errorMessage?.toString().toLowerCase().includes("exists");
|
|
|
|
if (isAlreadyExists) {
|
|
console.log(
|
|
`[receive-signal-message] Group might already exist for ${from}, continuing with original recipient`,
|
|
);
|
|
} else {
|
|
console.error("[receive-signal-message] Error creating Signal group:", {
|
|
error: errorMessage,
|
|
from,
|
|
to,
|
|
botNumber: row.phoneNumber,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
const payload = {
|
|
to: finalTo,
|
|
from,
|
|
message_id: messageId,
|
|
sent_at: sentAt,
|
|
message,
|
|
attachment,
|
|
filename,
|
|
mime_type: mimeType,
|
|
is_group: finalTo.startsWith("group"),
|
|
};
|
|
|
|
await worker.addJob("common/notify-webhooks", { backendId, payload });
|
|
};
|
|
|
|
export default receiveSignalMessageTask;
|