@dxv-systems/helpdesk 0.0.0-stage → 0.1.0

package/dist/inbox/handlers.js

@@ -0,0 +1,535 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ATTACHMENT_DOWNLOAD_BYTES = void 0;
+exports.contentDisposition = contentDisposition;
+exports.createHelpdeskHandlers = createHelpdeskHandlers;
+const cleanup_1 = require("../cleanup");
+const controls_1 = require("../controls");
+const drafting_1 = require("../drafting");
+const errors_1 = require("../errors");
+const ingest_1 = require("../ingest");
+const sending_1 = require("../sending");
+const states_1 = require("../states");
+const reply_attachments_1 = require("../reply-attachments");
+const messages_1 = require("./messages");
+const plain_text_1 = require("./plain-text");
+const MAX_BODY_CHARS = 100000;
+const MAX_DRAFT_CHARS = 50000;
+const DEFAULT_PAGE_SIZE = 25;
+const MAX_PAGE_SIZE = 100;
+const MAX_CURSOR_CHARS = 1000;
+exports.MAX_ATTACHMENT_DOWNLOAD_BYTES = 4 * 1024 * 1024;
+function contentDisposition(name) {
+    const cleaned = name.replace(/[\u0000-\u001f\u007f"\\/]/g, "_").trim() || "bijlage";
+    const ascii = cleaned.replace(/[^\x20-\x7e]/g, "_");
+    const encoded = encodeURIComponent(cleaned).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`;
+}
+class RouteError extends Error {
+    constructor(status, code, extra = {}) {
+        super(code);
+        this.status = status;
+        this.code = code;
+        this.extra = extra;
+    }
+}
+function json(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" },
+    });
+}
+function fail(status, code, extra = {}) {
+    return json(status, { error: code, message: messages_1.INBOX_ERROR_MESSAGES[code], ...extra });
+}
+const DOMAIN_ERRORS = {
+    thread_not_found: [404, "thread_not_found"],
+    mailbox_not_in_scope: [403, "mailbox_not_in_scope"],
+    mailbox_write_blocked: [409, "write_blocked"],
+    stale_draft: [409, "stale_draft"],
+    draft_not_ready: [409, "draft_not_ready"],
+    invalid_transition: [409, "invalid_transition"],
+    stale_thread: [409, "stale_thread"],
+    quote_not_found: [422, "quote_not_found"],
+    send_in_progress: [409, "send_in_progress"],
+    send_outcome_unknown: [409, "send_outcome_unknown"],
+    empty_reply: [422, "empty_reply"],
+    attachments_unavailable: [409, "attachments_unavailable"],
+    attachment_limit: [422, "attachment_limit"],
+    reply_attachment_not_found: [404, "reply_attachment_not_found"],
+};
+async function readJson(request) {
+    const text = await request.text().catch(() => "");
+    if (text.length > MAX_BODY_CHARS)
+        throw new RouteError(400, "invalid_input");
+    if (text.trim() === "")
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+    }
+    throw new RouteError(400, "invalid_input");
+}
+const norm = (address) => address.trim().toLowerCase();
+const person = (staff) => ({ id: staff.id, name: staff.name });
+function summary(thread, assignee) {
+    return {
+        id: thread.id,
+        mailbox: thread.mailbox,
+        state: thread.state,
+        subject: thread.subject,
+        customerAddress: thread.customerAddress,
+        lastActivityAt: thread.lastActivityAt,
+        reviewReason: thread.reviewReason,
+        assignee,
+    };
+}
+async function latestIntent(deps, run) {
+    if (!run)
+        return null;
+    const { perRun, perDraft } = (0, cleanup_1.sendIntentIds)(run);
+    const found = await Promise.all([perRun, perDraft].map((id) => (id ? deps.store.getSendIntent(id) : null)));
+    const intents = found.filter((i) => i !== null);
+    return intents.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0] ?? null;
+}
+function draftView(thread, run) {
+    if (!run)
+        return null;
+    return {
+        generation: run.generation,
+        status: run.status,
+        text: run.status === "succeeded" ? (run.commentText ?? run.text) : null,
+        confidence: run.confidence,
+        category: run.category,
+        stale: thread.latestInboundId !== run.inboundMessageId,
+        inOutlook: run.placedDraftId !== null,
+    };
+}
+function allowedActions(thread, run, intent, paused, mode, hasDrafter, canAttach = false) {
+    const s = thread.state;
+    const actions = [];
+    const hasText = run?.status === "succeeded";
+    const fresh = run === null && thread.latestInboundId !== null;
+    const placed = Boolean(run?.placedDraftId) && run?.placedBodyHtml !== null;
+    const pending = intent !== null && ["sending", "unknown", "sent"].includes(intent.status);
+    const sendUnderWay = intent !== null && ["sending", "unknown"].includes(intent.status);
+    const bounced = s === "review" && thread.reviewReason === "delivery_failed";
+    if (!paused) {
+        if (!bounced && (0, states_1.canTransition)(s, "redraft") && ((hasText && (mode !== "drafts_in_outlook" || placed)) || fresh)) {
+            actions.push("edit");
+        }
+        if (!bounced && (0, states_1.canTransition)(s, "redraft") && thread.latestInboundId && hasDrafter)
+            actions.push("regenerate");
+        const sendable = mode === "drafts_in_app" ? hasText : mode === "drafts_in_outlook" && Boolean(run?.placedDraftId);
+        if (!bounced && (0, states_1.canTransition)(s, "approve") && (sendable || (fresh && mode !== "read_only")) && !pending)
+            actions.push("send");
+        if (!bounced && (0, states_1.canTransition)(s, "approve") && mode === "drafts_in_outlook" && hasText && !run?.placedDraftId) {
+            actions.push("retry_placement");
+        }
+        if ((0, states_1.canTransition)(s, "approve"))
+            actions.push("replied_externally");
+        if ((0, states_1.canTransition)(s, "unignore"))
+            actions.push("unignore");
+        if ((0, states_1.canTransition)(s, "dismiss") && !sendUnderWay)
+            actions.push("dismiss");
+        if (canAttach && s === "review" && !bounced && !sendUnderWay && mode !== "read_only")
+            actions.push("attach");
+    }
+    if ((0, states_1.canTransition)(s, "settle"))
+        actions.push("mark_waiting");
+    if ((0, states_1.canTransition)(s, "close"))
+        actions.push("close");
+    if (intent?.status === "unknown")
+        actions.push("resolve_send");
+    return actions;
+}
+function parseStates(value) {
+    if (value === null || value.trim() === "")
+        return null;
+    const states = value.split(",").map((s) => s.trim());
+    if (!states.every((s) => states_1.TICKET_STATES.includes(s))) {
+        throw new RouteError(400, "invalid_input");
+    }
+    return states;
+}
+function parseLimit(value) {
+    if (value === null)
+        return DEFAULT_PAGE_SIZE;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1)
+        throw new RouteError(400, "invalid_input");
+    return Math.min(n, MAX_PAGE_SIZE);
+}
+const SEND_MESSAGES = {
+    sent: "Verstuurd. Het antwoord staat in Outlook bij Verzonden items.",
+    already_sent: "Dit antwoord was al verstuurd.",
+    in_progress: "Dit antwoord wordt al verstuurd. Vernieuw zo de pagina.",
+    unknown_outcome: "Het is niet zeker of het antwoord is verstuurd. Kijk in Outlook bij Verzonden items en geef hieronder aan wat je ziet.",
+};
+function createHelpdeskHandlers(config) {
+    const { deps, inbox } = config;
+    const basePath = (config.basePath ?? messages_1.HELPDESK_BASE_PATH).replace(/\/$/, "");
+    const onError = config.onError ?? ((error) => console.error("[helpdesk] unexpected error", error));
+    async function loadThread(threadId) {
+        const thread = await deps.store.getThread(threadId);
+        if (!thread)
+            throw new errors_1.ThreadNotFoundError(threadId);
+        (0, controls_1.assertInScope)(deps.config, thread.mailbox);
+        return thread;
+    }
+    async function detail(threadId, staff) {
+        const controls = await (0, controls_1.loadControls)(deps);
+        const thread = await loadThread(threadId);
+        const mode = (0, controls_1.writeModeFor)(controls, thread.mailbox);
+        const [messages, assignee, latestRun] = await Promise.all([
+            inbox.listMessages(thread.id),
+            inbox.getAssignee(thread.id),
+            deps.store.getLatestDraftRunForThread(thread.id),
+        ]);
+        const run = (0, drafting_1.currentReplyRun)(deps, thread, latestRun);
+        const intent = await latestIntent(deps, run);
+        return {
+            viewer: person(staff),
+            thread: {
+                ...summary(thread, assignee),
+                relatedThreadId: thread.relatedThreadId,
+                dismissedBy: thread.dismissedBy,
+                participants: thread.participants,
+                createdAt: thread.createdAt,
+            },
+            pilot: { paused: controls.paused, writeMode: mode },
+            messages: messages
+                .filter((m) => m.threadId === thread.id)
+                .map((m) => ({
+                id: m.id,
+                fromAddress: m.fromAddress,
+                subject: m.subject,
+                receivedAt: m.receivedAt,
+                noise: m.noise.action === "ignore",
+                removed: m.removedAt !== null,
+            })),
+            draft: draftView(thread, run ?? (latestRun?.status === "failed" ? latestRun : null)),
+            send: intent ? { status: intent.status, at: intent.updatedAt } : null,
+            replyAttachments: await replyAttachmentViews(thread.id, intent),
+            actions: allowedActions(thread, run, intent, controls.paused, mode, Boolean(deps.drafter), canAttach(thread.mailbox)),
+        };
+    }
+    async function result(ctx, message, outcome, status = 200) {
+        const body = { detail: await detail(ctx.threadId, ctx.staff), message };
+        if (outcome)
+            body.outcome = outcome;
+        return json(status, body);
+    }
+    function refused(value) {
+        const status = value?.status;
+        if (status === "paused")
+            return fail(423, "paused");
+        if (status === "write_blocked")
+            return fail(409, "write_blocked", { mode: value.mode });
+        return null;
+    }
+    async function list({ request, staff }) {
+        const params = new URL(request.url).searchParams;
+        const states = parseStates(params.get("state"));
+        const limit = parseLimit(params.get("limit"));
+        const cursor = params.get("cursor");
+        if (cursor !== null && cursor.length > MAX_CURSOR_CHARS)
+            throw new RouteError(400, "invalid_input");
+        const mailboxParam = params.get("mailbox");
+        let mailbox = null;
+        if (mailboxParam) {
+            const match = deps.config.connectedMailboxes.find((m) => norm(m) === norm(mailboxParam));
+            if (!match)
+                throw new RouteError(403, "mailbox_not_in_scope");
+            mailbox = match;
+        }
+        const assigneeParam = params.get("assignee");
+        const query = { states, mailbox, cursor: cursor || null, limit };
+        if (assigneeParam === "me")
+            query.assigneeId = staff.id;
+        else if (assigneeParam === "none")
+            query.assigneeId = null;
+        else if (assigneeParam)
+            query.assigneeId = assigneeParam;
+        const controls = await (0, controls_1.loadControls)(deps);
+        const page = await inbox.listThreads(query);
+        const inScope = new Set(deps.config.connectedMailboxes.map(norm));
+        const syncIssues = [];
+        for (const address of deps.config.connectedMailboxes) {
+            const sync = await deps.store.getSyncState(address);
+            if (sync?.failingSince && (sync.failures ?? 0) >= ingest_1.SYNC_FAILING_AFTER) {
+                syncIssues.push({ mailbox: address, failingSince: sync.failingSince });
+            }
+        }
+        const body = {
+            viewer: person(staff),
+            syncIssues,
+            pilot: {
+                paused: controls.paused,
+                mailboxes: deps.config.connectedMailboxes.map((address) => ({
+                    address,
+                    writeMode: (0, controls_1.writeModeFor)(controls, address),
+                })),
+            },
+            threads: page.rows
+                .filter((row) => inScope.has(norm(row.thread.mailbox)))
+                .map((row) => summary(row.thread, row.assignee)),
+            nextCursor: page.nextCursor,
+        };
+        return json(200, body);
+    }
+    async function show(ctx) {
+        return json(200, await detail(ctx.threadId, ctx.staff));
+    }
+    async function ticketMessage(threadId, messageId) {
+        const controls = await (0, controls_1.loadControls)(deps);
+        if (controls.paused)
+            throw new RouteError(423, "paused");
+        const thread = await loadThread(threadId);
+        const messages = await inbox.listMessages(thread.id);
+        if (!messages.some((m) => m.id === messageId && m.threadId === thread.id)) {
+            throw new RouteError(404, "message_not_found");
+        }
+        return (0, controls_1.mailboxAccess)(deps, controls, thread.mailbox).gateway();
+    }
+    function attachmentView(threadId, messageId, a) {
+        const unavailable = a.kind !== "file" ? a.kind : a.size > exports.MAX_ATTACHMENT_DOWNLOAD_BYTES ? "too_large" : null;
+        const path = [threadId, "messages", messageId, "attachments", a.id].map((p) => encodeURIComponent(p)).join("/");
+        return { id: a.id, name: a.name, size: a.size, kind: a.kind, href: unavailable ? null : `${basePath}/threads/${path}`, unavailable };
+    }
+    async function messageBody({ threadId, messageId }) {
+        const gateway = await ticketMessage(threadId, messageId);
+        const message = await gateway.getMessage(messageId, { bodyType: "text" });
+        if (!message)
+            throw new RouteError(404, "message_unavailable");
+        const { contentType, content } = message.body;
+        const text = contentType === "html" ? (0, plain_text_1.htmlToPlainText)(content) : content.replace(/\r\n?/g, "\n").trim();
+        const listed = gateway.listAttachments && message.hasAttachments !== false ? await gateway.listAttachments(messageId) : [];
+        const attachments = listed.filter((a) => !a.isInline).map((a) => attachmentView(threadId, messageId, a));
+        const body = { id: messageId, text, attachments };
+        return json(200, body);
+    }
+    async function attachment({ threadId, messageId, attachmentId }) {
+        const gateway = await ticketMessage(threadId, messageId);
+        if (!gateway.listAttachments || !gateway.downloadAttachment)
+            throw new RouteError(404, "attachment_not_found");
+        const found = (await gateway.listAttachments(messageId)).find((a) => a.id === attachmentId);
+        if (!found)
+            throw new RouteError(404, "attachment_not_found");
+        if (attachmentView(threadId, messageId, found).href === null)
+            throw new RouteError(409, "attachment_unavailable");
+        const bytes = await gateway.downloadAttachment(messageId, attachmentId);
+        if (bytes.byteLength > exports.MAX_ATTACHMENT_DOWNLOAD_BYTES)
+            throw new RouteError(409, "attachment_unavailable");
+        return new Response(bytes, {
+            status: 200,
+            headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Disposition": contentDisposition(found.name),
+                "Content-Length": String(bytes.byteLength),
+                "X-Content-Type-Options": "nosniff",
+                "Content-Security-Policy": "sandbox; default-src 'none'",
+                "Cache-Control": "private, no-store",
+                "Referrer-Policy": "no-referrer",
+            },
+        });
+    }
+    async function saveDraft(ctx) {
+        const body = await readJson(ctx.request);
+        const text = typeof body.text === "string" ? body.text : null;
+        if (text === null || text.trim() === "" || text.length > MAX_DRAFT_CHARS)
+            throw new RouteError(400, "invalid_input");
+        const outcome = await (0, drafting_1.editDraft)(deps, { threadId: ctx.threadId, text });
+        return refused(outcome) ?? result(ctx, "Concept opgeslagen.");
+    }
+    async function regenerate(ctx) {
+        const outcome = await (0, drafting_1.regenerateDraft)(deps, ctx.threadId);
+        return refused(outcome) ?? result(ctx, "Er wordt een nieuw concept geschreven.");
+    }
+    async function send(ctx) {
+        const body = await readJson(ctx.request);
+        const outcome = await (0, sending_1.approveAndSend)(deps, {
+            threadId: ctx.threadId,
+            approvedBy: ctx.staff.id,
+            acceptStale: body.acceptStale === true,
+        });
+        if (outcome.status === "paused" || outcome.status === "write_blocked")
+            return refused(outcome);
+        if (outcome.status === "failed_not_sent")
+            return fail(502, "send_failed");
+        const status = outcome.status;
+        return result(ctx, SEND_MESSAGES[status], status, status === "in_progress" ? 202 : 200);
+    }
+    async function retry(ctx) {
+        const outcome = await (0, drafting_1.retryPlacement)(deps, ctx.threadId);
+        const blocked = refused(outcome);
+        if (blocked)
+            return blocked;
+        const placed = outcome.placementError === null;
+        return result(ctx, placed ? "Het concept staat nu in Outlook." : "Het concept kon nog steeds niet in Outlook worden gezet.");
+    }
+    async function assign(ctx) {
+        await loadThread(ctx.threadId);
+        await inbox.setAssignee(ctx.threadId, person(ctx.staff));
+        return result(ctx, "Ticket aan jou toegewezen.");
+    }
+    async function unassign(ctx) {
+        await loadThread(ctx.threadId);
+        await inbox.setAssignee(ctx.threadId, null);
+        return result(ctx, "Toewijzing weggehaald.");
+    }
+    async function waiting(ctx) {
+        await loadThread(ctx.threadId);
+        await (0, sending_1.markWaiting)(deps, ctx.threadId);
+        return result(ctx, "Ticket wacht nu op de klant.");
+    }
+    async function close(ctx) {
+        await loadThread(ctx.threadId);
+        await (0, sending_1.closeThread)(deps, ctx.threadId);
+        return result(ctx, "Ticket gesloten.");
+    }
+    async function unignore(ctx) {
+        const outcome = await (0, drafting_1.unignoreThread)(deps, ctx.threadId);
+        const next = deps.drafter ? "Er wordt een concept geschreven." : "Schrijf zelf het antwoord.";
+        return refused(outcome) ?? result(ctx, `Ticket teruggezet. ${next}`);
+    }
+    async function repliedExternally(ctx) {
+        const outcome = await (0, sending_1.markRepliedExternally)(deps, ctx.threadId);
+        return refused(outcome) ?? result(ctx, "Gemarkeerd als beantwoord in Outlook.");
+    }
+    function canAttach(mailbox) {
+        return Boolean(deps.attachments && deps.gatewayFor(mailbox).addAttachment);
+    }
+    async function replyAttachmentViews(threadId, intent) {
+        if (!deps.attachments)
+            return [];
+        const rows = await deps.attachments.store.listForThread(threadId);
+        return rows
+            .filter((a) => a.sentIntentId === null || (intent?.status === "sent" && a.sentIntentId === intent.id))
+            .map((a) => ({ id: a.id, name: a.name, size: a.size, sent: a.sentIntentId !== null }));
+    }
+    async function uploadTarget(ctx) {
+        const body = await readJson(ctx.request);
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        const contentType = typeof body.contentType === "string" && body.contentType.trim() ? body.contentType.trim() : "application/octet-stream";
+        const size = body.size;
+        if (!name || name.length > 255 || contentType.length > 255 || typeof size !== "number" || !Number.isInteger(size) || size < 1) {
+            throw new RouteError(400, "invalid_input");
+        }
+        await loadThread(ctx.threadId);
+        const target = await (0, reply_attachments_1.startReplyUpload)(deps, { threadId: ctx.threadId, staffId: ctx.staff.id, name, contentType, size });
+        return json(200, target);
+    }
+    async function attach(ctx) {
+        const body = await readJson(ctx.request);
+        if (typeof body.uploadToken !== "string" || body.uploadToken === "" || body.uploadToken.length > 4000) {
+            throw new RouteError(400, "invalid_input");
+        }
+        await loadThread(ctx.threadId);
+        const added = await (0, reply_attachments_1.addReplyAttachment)(deps, { threadId: ctx.threadId, staffId: ctx.staff.id, uploadToken: body.uploadToken });
+        return result(ctx, `${added.name} is toegevoegd.`);
+    }
+    async function detach(ctx) {
+        await loadThread(ctx.threadId);
+        await (0, reply_attachments_1.removeReplyAttachment)(deps, { threadId: ctx.threadId, attachmentId: ctx.attachmentId });
+        return result(ctx, "De bijlage is verwijderd.");
+    }
+    async function dismiss(ctx) {
+        const outcome = await (0, sending_1.dismissThread)(deps, { threadId: ctx.threadId, dismissedBy: ctx.staff.id });
+        return refused(outcome) ?? result(ctx, "Gemarkeerd als geen antwoord nodig. Het ticket staat nu bij Genegeerd.");
+    }
+    async function resolveSend(ctx) {
+        const body = await readJson(ctx.request);
+        if (body.outcome !== "sent" && body.outcome !== "not_sent")
+            throw new RouteError(400, "invalid_input");
+        await loadThread(ctx.threadId);
+        await (0, sending_1.resolveUnknownSend)(deps, { threadId: ctx.threadId, outcome: body.outcome });
+        return result(ctx, body.outcome === "sent" ? "Vastgelegd: het antwoord is verstuurd." : "Vastgelegd: niet verstuurd. Je kunt het opnieuw versturen.");
+    }
+    const threadActions = {
+        "": { GET: show },
+        draft: { PUT: saveDraft },
+        regenerate: { POST: regenerate },
+        send: { POST: send },
+        "retry-placement": { POST: retry },
+        assign: { POST: assign, DELETE: unassign },
+        waiting: { POST: waiting },
+        close: { POST: close },
+        unignore: { POST: unignore },
+        "replied-externally": { POST: repliedExternally },
+        dismiss: { POST: dismiss },
+        "resolve-send": { POST: resolveSend },
+        attachments: { POST: attach },
+    };
+    function route(path) {
+        const parts = path.split("/").map((p) => {
+            try {
+                return decodeURIComponent(p);
+            }
+            catch {
+                return "";
+            }
+        });
+        if (parts.some((p) => p === "") || parts[0] !== "threads")
+            return null;
+        if (parts.length === 1)
+            return { methods: { GET: list }, threadId: "", messageId: "", attachmentId: "" };
+        const threadId = parts[1];
+        if (parts.length === 4 && parts[2] === "messages") {
+            return { methods: { GET: messageBody }, threadId, messageId: parts[3], attachmentId: "" };
+        }
+        if (parts.length === 6 && parts[2] === "messages" && parts[4] === "attachments") {
+            return { methods: { GET: attachment }, threadId, messageId: parts[3], attachmentId: parts[5] };
+        }
+        if (parts.length === 4 && parts[2] === "attachments") {
+            const attachmentId = parts[3];
+            const methods = attachmentId === "upload" ? { POST: uploadTarget } : { DELETE: detach };
+            return { methods, threadId, messageId: "", attachmentId };
+        }
+        if (parts.length > 3)
+            return null;
+        const methods = threadActions[parts[2] ?? ""];
+        return methods ? { methods, threadId, messageId: "", attachmentId: "" } : null;
+    }
+    function toResponse(error) {
+        if (error instanceof RouteError)
+            return fail(error.status, error.code, error.extra);
+        if (error instanceof errors_1.HelpdeskError) {
+            const mapped = DOMAIN_ERRORS[error.code];
+            if (mapped)
+                return fail(mapped[0], mapped[1]);
+        }
+        onError(error);
+        return fail(500, "internal");
+    }
+    async function handle(request) {
+        const url = new URL(request.url);
+        const sub = url.pathname.startsWith(`${basePath}/`) ? url.pathname.slice(basePath.length + 1).replace(/\/$/, "") : null;
+        const matched = sub === null ? null : route(sub);
+        if (!matched)
+            return fail(404, "not_found");
+        const handler = matched.methods[request.method.toUpperCase()];
+        if (!handler)
+            return fail(405, "method_not_allowed");
+        if (!config.isProduction)
+            return fail(403, "not_production");
+        const allowedOrigin = config.appOrigin ? new URL(config.appOrigin).origin : url.origin;
+        const origin = request.headers.get("origin");
+        if (request.method !== "GET" && origin !== null && origin !== allowedOrigin)
+            return fail(403, "forbidden_origin");
+        try {
+            const staff = await config.getStaff(request);
+            if (!staff)
+                return fail(401, "unauthorized");
+            const { threadId, messageId, attachmentId } = matched;
+            return await handler({ request, staff, threadId, messageId, attachmentId });
+        }
+        catch (error) {
+            return toResponse(error);
+        }
+    }
+    return { handle };
+}

package/dist/inbox/messages.d.ts

@@ -0,0 +1,35 @@
+import type { MailboxWriteMode, ReviewReason, TicketState } from "../types";
+export declare const HELPDESK_BASE_PATH = "/api/helpdesk";
+export declare const INBOX_ERROR_MESSAGES: {
+    readonly not_production: "De helpdesk werkt alleen in de productieomgeving van de app.";
+    readonly unauthorized: "Je hebt geen toegang tot de helpdesk. Log in met een medewerkersaccount.";
+    readonly forbidden_origin: "Dit verzoek komt niet van de app zelf en is geweigerd.";
+    readonly invalid_input: "Controleer de ingevulde gegevens.";
+    readonly not_found: "Onbekende route.";
+    readonly method_not_allowed: "Deze methode is hier niet toegestaan.";
+    readonly thread_not_found: "Dit ticket bestaat niet (meer).";
+    readonly message_not_found: "Dit bericht hoort niet bij dit ticket.";
+    readonly message_unavailable: "Dit bericht staat niet meer in de mailbox.";
+    readonly attachment_not_found: "Deze bijlage staat niet (meer) bij dit bericht.";
+    readonly attachment_unavailable: "Deze bijlage kan alleen in Outlook worden geopend.";
+    readonly attachments_unavailable: "Bij dit antwoord kun je nu geen bijlagen toevoegen.";
+    readonly attachment_limit: "Een antwoord mag samen hoogstens 20 MB aan bijlagen hebben, en hoogstens 10 bestanden.";
+    readonly reply_attachment_not_found: "Deze bijlage staat niet (meer) bij het antwoord.";
+    readonly paused: "De helpdesk staat op pauze. Er wordt niets opgehaald of verstuurd tot de pauze voorbij is.";
+    readonly write_blocked: "Deze mailbox staat op alleen lezen. Antwoorden kan pas als de mailbox daarvoor is vrijgegeven.";
+    readonly mailbox_not_in_scope: "Deze mailbox hoort niet bij de helpdesk.";
+    readonly stale_draft: "Er is een nieuwere mail van de klant binnengekomen na dit concept. Lees die eerst, of verstuur toch.";
+    readonly draft_not_ready: "Er is nog geen concept dat verstuurd of aangepast kan worden.";
+    readonly invalid_transition: "Dit kan niet in de huidige status van het ticket. Vernieuw de pagina.";
+    readonly stale_thread: "Het ticket is net gewijzigd. Vernieuw de pagina en probeer het opnieuw.";
+    readonly quote_not_found: "De eerdere mail in het concept is niet terug te vinden, daarom is de wijziging niet opgeslagen. Pas het concept aan in Outlook.";
+    readonly empty_reply: "Het antwoord is leeg. Schrijf eerst een antwoord; alleen de eerdere mail wordt nooit verstuurd.";
+    readonly send_in_progress: "Er wordt net een antwoord verstuurd. Vernieuw zo de pagina en kijk of het nog nodig is.";
+    readonly send_outcome_unknown: "Het is niet zeker of het vorige antwoord is verstuurd. Geef eerst aan wat je in Outlook bij Verzonden items ziet.";
+    readonly send_failed: "Microsoft heeft het antwoord geweigerd. Er is niets verstuurd; probeer het opnieuw.";
+    readonly internal: "Er ging iets mis. Probeer het opnieuw.";
+};
+export type InboxErrorCode = keyof typeof INBOX_ERROR_MESSAGES;
+export declare const STATE_LABELS: Record<TicketState, string>;
+export declare const REVIEW_REASON_LABELS: Record<ReviewReason, string>;
+export declare const WRITE_MODE_LABELS: Record<MailboxWriteMode, string>;

package/dist/inbox/messages.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_MODE_LABELS = exports.REVIEW_REASON_LABELS = exports.STATE_LABELS = exports.INBOX_ERROR_MESSAGES = exports.HELPDESK_BASE_PATH = void 0;
+exports.HELPDESK_BASE_PATH = "/api/helpdesk";
+exports.INBOX_ERROR_MESSAGES = {
+    not_production: "De helpdesk werkt alleen in de productieomgeving van de app.",
+    unauthorized: "Je hebt geen toegang tot de helpdesk. Log in met een medewerkersaccount.",
+    forbidden_origin: "Dit verzoek komt niet van de app zelf en is geweigerd.",
+    invalid_input: "Controleer de ingevulde gegevens.",
+    not_found: "Onbekende route.",
+    method_not_allowed: "Deze methode is hier niet toegestaan.",
+    thread_not_found: "Dit ticket bestaat niet (meer).",
+    message_not_found: "Dit bericht hoort niet bij dit ticket.",
+    message_unavailable: "Dit bericht staat niet meer in de mailbox.",
+    attachment_not_found: "Deze bijlage staat niet (meer) bij dit bericht.",
+    attachment_unavailable: "Deze bijlage kan alleen in Outlook worden geopend.",
+    attachments_unavailable: "Bij dit antwoord kun je nu geen bijlagen toevoegen.",
+    attachment_limit: "Een antwoord mag samen hoogstens 20 MB aan bijlagen hebben, en hoogstens 10 bestanden.",
+    reply_attachment_not_found: "Deze bijlage staat niet (meer) bij het antwoord.",
+    paused: "De helpdesk staat op pauze. Er wordt niets opgehaald of verstuurd tot de pauze voorbij is.",
+    write_blocked: "Deze mailbox staat op alleen lezen. Antwoorden kan pas als de mailbox daarvoor is vrijgegeven.",
+    mailbox_not_in_scope: "Deze mailbox hoort niet bij de helpdesk.",
+    stale_draft: "Er is een nieuwere mail van de klant binnengekomen na dit concept. Lees die eerst, of verstuur toch.",
+    draft_not_ready: "Er is nog geen concept dat verstuurd of aangepast kan worden.",
+    invalid_transition: "Dit kan niet in de huidige status van het ticket. Vernieuw de pagina.",
+    stale_thread: "Het ticket is net gewijzigd. Vernieuw de pagina en probeer het opnieuw.",
+    quote_not_found: "De eerdere mail in het concept is niet terug te vinden, daarom is de wijziging niet opgeslagen. Pas het concept aan in Outlook.",
+    empty_reply: "Het antwoord is leeg. Schrijf eerst een antwoord; alleen de eerdere mail wordt nooit verstuurd.",
+    send_in_progress: "Er wordt net een antwoord verstuurd. Vernieuw zo de pagina en kijk of het nog nodig is.",
+    send_outcome_unknown: "Het is niet zeker of het vorige antwoord is verstuurd. Geef eerst aan wat je in Outlook bij Verzonden items ziet.",
+    send_failed: "Microsoft heeft het antwoord geweigerd. Er is niets verstuurd; probeer het opnieuw.",
+    internal: "Er ging iets mis. Probeer het opnieuw.",
+};
+exports.STATE_LABELS = {
+    new: "Nieuw",
+    ignored: "Genegeerd",
+    drafted: "Concept wordt gemaakt",
+    review: "Te beoordelen",
+    sent: "Verstuurd",
+    waiting: "Wacht op klant",
+    closed: "Gesloten",
+};
+exports.REVIEW_REASON_LABELS = {
+    low_confidence: "Concept twijfelachtig",
+    policy: "Controle nodig",
+    stale_draft: "Nieuwe mail na concept",
+    drafter_failed: "Concept mislukt",
+    placement_failed: "Niet in Outlook gezet",
+    staff_edited: "Aangepast",
+    no_draft: "Zelf antwoorden",
+    delivery_failed: "Niet afgeleverd",
+};
+exports.WRITE_MODE_LABELS = {
+    read_only: "Alleen lezen",
+    drafts_in_app: "Concepten in de app",
+    drafts_in_outlook: "Concepten in Outlook",
+};

package/dist/inbox/plain-text.d.ts

@@ -0,0 +1 @@
+export declare function htmlToPlainText(html: string): string;