Интеграции с Support Communication

// Continue after the quickstart; pass the File selected by your user.
async function waitForCleanUpload(fileId) {
  const deadlineAt = Date.now() + 30_000;
  let delayMs = 400;
  while (Date.now() < deadlineAt) {
    const status = await sdk.request("GET",
      "/public/sdk/uploads/" + encodeURIComponent(fileId) + "/status");
    if (status.ready) return status;
    if (!status.retryable) throw new Error("File failed antivirus scanning");
    await new Promise(resolve => setTimeout(resolve,
      Math.min(delayMs, Math.max(1, deadlineAt - Date.now()))));
    delayMs = Math.min(2000, Math.ceil(delayMs * 1.6));
  }
  throw new Error("File scan is still pending; retry sending later");
}

async function sendAttachment(file, text) {
  const descriptor = await sdk.request("POST", "/public/sdk/uploads", {
    fileName: file.name,
    mimeType: file.type || "application/octet-stream",
    sizeBytes: file.size
  });
  const transfer = await fetch(sdk.resolveStorageUrl(descriptor.signedUpload.url), {
    method: descriptor.signedUpload.method,
    headers: descriptor.signedUpload.headers || {},
    credentials: "omit",
    body: file
  }); // No SDK Authorization header on the storage request.
  if (!transfer.ok) throw new Error("File transfer failed: HTTP " + transfer.status);

  const finalized = await sdk.request("POST",
    "/public/sdk/uploads/" + encodeURIComponent(descriptor.fileId) + "/finalize", {});
  if (finalized.storageState !== "uploaded") throw new Error("Upload is not finalized");
  const ready = await waitForCleanUpload(descriptor.fileId);
  return sdk.sendMessage(text, { attachments: [{
    fileId: ready.fileId,
    fileName: ready.fileName,
    mimeType: ready.mimeType,
    sizeBytes: ready.sizeBytes
  }] });
}

const exampleFile = new File(["SDK attachment example\n"], "example.txt", { type: "text/plain" });
await sendAttachment(exampleFile, "Прикладываю документ");
// Only ready operator attachments appear in poll messages[].attachments[].download.
// sdk_attachment_scan_pending rejects the entire message before persistence;
// poll the status route and retry only while retryable=true.

// Continue after the quickstart. Keep one sessionId for this page/session.
const sessionId = crypto.randomUUID();
const presence = {
  sessionId,
  externalId: "customer_42",
  pageUrl: "https://shop.example/orders",
  pagePath: "/orders"
};
async function heartbeat() {
  return sdk.request("POST", "/public/sdk/presence/heartbeat", presence);
}
async function pollInvitations() {
  return sdk.request("GET", "/public/sdk/invitations", undefined, { sessionId });
}
async function acknowledgeInvitation(exposureId, action, failureCode) {
  if (!["shown", "accepted", "dismissed", "failed"].includes(action)) {
    throw new Error("Unknown invitation action");
  }
  let conversationId;
  if (action === "accepted") {
    // Use our identified conversation, never a guessed/foreign conversation id.
    if (!sdk.getState().conversationId) await sdk.identify();
    conversationId = sdk.getState().conversationId;
    if (!conversationId) throw new Error("Identify a conversation before accepting");
  }
  const data = await sdk.request("POST",
    "/public/sdk/invitations/" + encodeURIComponent(exposureId) + "/" + action,
    { sessionId, ...(conversationId ? { conversationId } : {}),
      ...(failureCode ? { failureCode } : {}) });
  if (action === "accepted") sdk.rememberConversation(data);
  return data;
}
async function disconnect() {
  return sdk.request("POST", "/public/sdk/presence/disconnect", { sessionId });
}

await heartbeat();
const pendingInvitations = await pollInvitations();
// Render each exposureId once, then acknowledge "shown" only after visible rendering.
// Buttons call "accepted" or "dismissed"; rendering failure calls "failed" + failureCode.
// Repeat heartbeat ~15 s (TTL 90 s) and invitation poll ~5 s while the page is active.
// Stop both loops before disconnect(); unload delivery is best-effort.

// Continue after the quickstart; wire these functions to explicit user actions.
async function submitRating(score, idempotencyKey) {
  const { conversationId, visitorSessionToken } = sdk.getState();
  return sdk.request("POST",
    "/public/sdk/conversations/" + encodeURIComponent(conversationId) + "/ratings",
    { scale: "CSAT", score, idempotencyKey, visitorSessionToken });
}

async function chooseFeedbackComment() {
  const { conversationId, visitorSessionToken } = sdk.getState();
  return sdk.request("POST",
    "/public/sdk/conversations/" + encodeURIComponent(conversationId) + "/csat-feedback/decline",
    { visitorSessionToken });
  // Legacy name: declined=true means offered -> awaiting, NOT "skip comment".
}

async function sendFeedbackComment(text) {
  const current = await sdk.poll(); // also refreshes the visitor token
  if (current?.csatSurvey?.state !== "feedback") {
    throw new Error("Feedback window is not active; ask before starting a new appeal");
  }
  const sent = await sdk.sendMessage(text);
  // A concurrent state change can still close the feedback window.
  return { recordedAsFeedback: sent.recordedAsFeedback === true, message: sent };
}

// 1. When csatSurvey.state === "rating", create and keep one key for this rating:
// const ratingKey = crypto.randomUUID();
// const rating = await submitRating(5, ratingKey);
// 2. Only if rating.feedback.offered and the user chooses "Оставить отзыв":
// await chooseFeedbackComment();
// 3. On the next explicit submit: await sendFeedbackComment("Спасибо за помощь");
// To ask a new question instead: do NOT call chooseFeedbackComment; sendMessage normally.

{
  "event_name": "chat_accepted",
  "widget_id": "sdk_connection_1",
  "user_token": "customer_42",
  "chat_id": 537183224,
  "agent": {
    "email": "",
    "id": "operator_7",
    "name": "Мария"
  },
  "assigned_agent": null,
  "organization": null,
  "status": null,
  "tags": [
    {
      "id": "vip",
      "title": "vip"
    }
  ],
  "visitor": {
    "chats_count": 1,
    "description": "",
    "email": "customer@example.com",
    "name": "Анна",
    "number": "122557678",
    "phone": "+79990000000",
    "social": {}
  },
  "session": {
    "geoip": {},
    "ip_addr": "",
    "user_agent": "",
    "utm": "",
    "utm_json": {}
  },
  "page": {
    "url": "https://shop.example/orders/1024"
  },
  "analytics": {}
}

// Node.js 22+, save as receiver.mjs. Terminate HTTPS at your reverse proxy.
// Set WEBHOOK_PATH to /callbacks/<long-random-secret>.
// Open Channel: set this HTTPS callback URL in the connection UI.
// Event subscriptions: arrange the URL/events with your workspace administrator/support.
import { createServer } from "node:http";
import { open } from "node:fs/promises";

const callbackPath = process.env.WEBHOOK_PATH;
if (!/^\/callbacks\/[A-Za-z0-9_-]{32,}$/.test(callbackPath || "")) {
  throw new Error("Set a long random WEBHOOK_PATH; do not log it");
}
const eventNames = new Set([
  "chat_accepted", "chat_updated", "chat_finished",
  "client_updated", "client_attribute_updated", "offline_message"
]);
let writeQueue = Promise.resolve();
function persist(payload) {
  // Minimal durable inbox, not a complete business-event consumer.
  writeQueue = writeQueue.catch(() => {}).then(async () => {
    const file = await open("webhook-inbox.ndjson", "a", 0o600);
    try {
      await file.appendFile(JSON.stringify({ receivedAt: new Date().toISOString(), payload }) + "\n");
      await file.sync();
    } finally { await file.close(); }
  });
  return writeQueue;
}

const server = createServer(async (request, response) => {
  if (request.url !== callbackPath) { response.writeHead(404).end(); return; }
  if (request.method !== "POST") { response.writeHead(405).end(); return; }
  const chunks = [];
  let bytes = 0;
  try {
    for await (const chunk of request) {
      bytes += chunk.length;
      if (bytes > 1024 * 1024) { response.writeHead(413).end(); return; }
      chunks.push(chunk);
    }
    let payload;
    try { payload = JSON.parse(Buffer.concat(chunks).toString("utf8")); }
    catch { response.writeHead(400).end(); return; }
    const event = payload && eventNames.has(payload.event_name);
    const message = payload?.recipient?.id && typeof payload?.message?.type === "string";
    if (!event && !message) { response.writeHead(400).end(); return; }
    // Validate all consumed fields against the webhook OpenAPI contract.
    // No HMAC/Authorization/delivery-id is sent by these public callback flows.
    // Treat all input as untrusted; the secret URL is not a signed identity.
    await persist(payload);
    response.writeHead(204).end(); // Any 2xx acknowledges delivery; body is optional.
  } catch {
    response.writeHead(503).end(); // Persist failed; this response is retryable.
  }
});
server.listen(8080, "127.0.0.1");