@push.rocks/smartjmap 1.0.0

package/dist_ts/classes.jmapclient.js

@@ -0,0 +1,650 @@
+import * as plugins from './smartjmap.plugins.js';
+export const JMAP_CORE_CAPABILITY = 'urn:ietf:params:jmap:core';
+export const JMAP_MAIL_CAPABILITY = 'urn:ietf:params:jmap:mail';
+export const JMAP_SUBMISSION_CAPABILITY = 'urn:ietf:params:jmap:submission';
+/** Error thrown for HTTP-level (RFC 7807 problem details) and JMAP method-level errors. */
+export class JmapError extends Error {
+    constructor(message, fields = {}) {
+        super(message);
+        this.name = 'JmapError';
+        Object.assign(this, fields);
+    }
+}
+const EMAIL_PROPERTIES = [
+    'id',
+    'blobId',
+    'threadId',
+    'mailboxIds',
+    'keywords',
+    'size',
+    'receivedAt',
+    'sentAt',
+    'subject',
+    'from',
+    'to',
+    'cc',
+    'bcc',
+    'replyTo',
+    'hasAttachment',
+    'preview',
+    'bodyValues',
+    'textBody',
+    'htmlBody',
+    'attachments',
+];
+export class JmapClient extends plugins.events.EventEmitter {
+    constructor(config) {
+        super();
+        this.session = null;
+        this.accountId = '';
+        this.apiUrl = '';
+        this.mailbox = null;
+        this.connected = false;
+        this.stopped = false;
+        this.lastEmailState = null;
+        this.seenEmailIds = new Set();
+        this.pollTimer = null;
+        this.sseAbortController = null;
+        this.fetchingDeltas = false;
+        this.deltaQueued = false;
+        const auth = config.auth;
+        const hasBearer = typeof auth.accessToken === 'string';
+        const hasBasic = typeof auth.user === 'string' && typeof auth.pass === 'string';
+        if (!hasBearer && !hasBasic) {
+            throw new Error('JmapClient requires auth as either { accessToken } (Bearer) or { user, pass } (Basic).');
+        }
+        if (hasBearer && (typeof auth.user === 'string' || typeof auth.pass === 'string')) {
+            throw new Error('JmapClient auth accepts either { accessToken } or { user, pass }, not both.');
+        }
+        if (typeof config.sessionUrl !== 'string' || !config.sessionUrl) {
+            throw new Error('JmapClient requires a sessionUrl, e.g. https://host/.well-known/jmap');
+        }
+        this.config = config;
+    }
+    /**
+     * Fetches and validates the JMAP session, resolves the target mailbox,
+     * emits 'connected', emits 'message' for every email currently in the
+     * mailbox, then watches for new mail via the JMAP event source (SSE),
+     * falling back to polling when the event stream is unavailable.
+     * Failures are emitted as 'error' events; connect() does not throw.
+     */
+    async connect() {
+        // Reconnecting on the same instance is supported; release any watchers
+        // from a previous connect() so no SSE stream or poll timer is stranded.
+        this.teardownWatchers();
+        this.stopped = false;
+        try {
+            const response = await fetch(this.config.sessionUrl, {
+                headers: {
+                    authorization: this.getAuthHeader(),
+                    accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw await this.createHttpError(response, 'Failed to fetch JMAP session');
+            }
+            const session = (await response.json());
+            if (!session.capabilities || !(JMAP_CORE_CAPABILITY in session.capabilities)) {
+                throw new Error(`JMAP session is missing the ${JMAP_CORE_CAPABILITY} capability.`);
+            }
+            if (!(JMAP_MAIL_CAPABILITY in session.capabilities)) {
+                throw new Error(`JMAP session is missing the ${JMAP_MAIL_CAPABILITY} capability.`);
+            }
+            const accountId = session.primaryAccounts?.[JMAP_MAIL_CAPABILITY] ??
+                session.primaryAccounts?.[JMAP_CORE_CAPABILITY];
+            if (!accountId) {
+                throw new Error('JMAP session has no primary account for urn:ietf:params:jmap:mail.');
+            }
+            this.session = session;
+            this.accountId = accountId;
+            this.apiUrl = new URL(session.apiUrl, this.config.sessionUrl).toString();
+            this.mailbox = await this.resolveMailbox();
+            // Capture the Email state before the initial sweep so no change is lost
+            // between the sweep and the start of watching (dedupe handles overlap).
+            this.lastEmailState = await this.fetchEmailState();
+            if (this.stopped) {
+                // disconnect() was called while connect() was in flight.
+                return;
+            }
+            this.connected = true;
+            this.emit('connected');
+            await this.emitInitialEmails();
+            this.startWatching();
+        }
+        catch (error) {
+            // Clean up anything that may have been started; this instance holds no
+            // sockets or timers after a failed connect.
+            this.teardownWatchers();
+            this.connected = false;
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Stops watching (event stream and/or polling timer) and emits
+     * 'disconnected' when the client was connected. Leaves no open handles.
+     */
+    async disconnect() {
+        this.stopped = true;
+        this.teardownWatchers();
+        if (this.connected) {
+            this.connected = false;
+            this.emit('disconnected');
+        }
+    }
+    /**
+     * Core JMAP method-call helper (RFC 8620 §3.2): POSTs { using, methodCalls }
+     * to the session's apiUrl and returns the methodResponses. HTTP problem
+     * details (RFC 7807) and JMAP `error` method responses are thrown as
+     * JmapError with `httpStatus`/`problemType`/`jmapErrorType` fields.
+     */
+    async request(methodCalls) {
+        if (!this.apiUrl) {
+            throw new Error('JmapClient is not connected yet — call connect() first.');
+        }
+        const response = await fetch(this.apiUrl, {
+            method: 'POST',
+            headers: {
+                authorization: this.getAuthHeader(),
+                'content-type': 'application/json',
+                accept: 'application/json',
+            },
+            body: JSON.stringify({
+                using: [JMAP_CORE_CAPABILITY, JMAP_MAIL_CAPABILITY, JMAP_SUBMISSION_CAPABILITY],
+                methodCalls,
+            }),
+        });
+        if (!response.ok) {
+            throw await this.createHttpError(response, 'JMAP API request failed');
+        }
+        const parsed = (await response.json());
+        const methodResponses = parsed.methodResponses ?? [];
+        for (const [name, args, callId] of methodResponses) {
+            if (name === 'error') {
+                throw new JmapError(`JMAP method error "${args?.type}"${args?.description ? `: ${args.description}` : ''} (call ${callId})`, {
+                    jmapErrorType: args?.type,
+                    jmapErrorDescription: args?.description,
+                    jmapCallId: callId,
+                });
+            }
+        }
+        return methodResponses;
+    }
+    /** Returns all mailboxes of the account (Mailbox/get with ids: null). */
+    async getMailboxes() {
+        const responses = await this.request([
+            ['Mailbox/get', { accountId: this.accountId, ids: null }, 'mb0'],
+        ]);
+        return (responses[0][1].list ?? []);
+    }
+    /**
+     * Runs Email/query (default filter: the watched mailbox) followed by a full
+     * Email/get and returns resolved messages, newest first.
+     */
+    async queryEmails(filter, limit) {
+        const effectiveFilter = filter ?? (this.mailbox ? { inMailbox: this.mailbox.id } : {});
+        const queryArgs = {
+            accountId: this.accountId,
+            filter: effectiveFilter,
+            sort: [{ property: 'receivedAt', isAscending: false }],
+        };
+        if (typeof limit === 'number') {
+            queryArgs.limit = limit;
+        }
+        const responses = await this.request([['Email/query', queryArgs, 'q0']]);
+        const ids = responses[0][1].ids ?? [];
+        if (!ids.length) {
+            return [];
+        }
+        const emails = await this.getEmailObjects(ids);
+        return emails.map((email) => this.toMessage(email));
+    }
+    /** Fetches a single email with all body values resolved (RFC 8621 §4.2, fetchAllBodyValues). */
+    async getEmail(id) {
+        const [email] = await this.getEmailObjects([id]);
+        if (!email) {
+            throw new Error(`Email "${id}" not found.`);
+        }
+        return this.toMessage(email);
+    }
+    /** Replaces the full keywords object of an email via Email/set. */
+    async setKeywords(emailId, keywords) {
+        await this.updateEmail(emailId, { keywords });
+    }
+    /** Convenience: sets the $seen keyword via an Email/set keywords patch. */
+    async markSeen(emailId) {
+        await this.updateEmail(emailId, { 'keywords/$seen': true });
+    }
+    /**
+     * Sends an email: Identity/get lookup, Email/set create (into the mailbox
+     * with role 'sent', falling back to 'drafts', then the watched mailbox) and
+     * EmailSubmission/set referencing the created email.
+     */
+    async sendEmail(outgoing) {
+        const identityResponses = await this.request([
+            ['Identity/get', { accountId: this.accountId }, 'i0'],
+        ]);
+        const identities = identityResponses[0][1].list ?? [];
+        const identity = (outgoing.from
+            ? identities.find((candidate) => candidate.email === outgoing.from.email)
+            : undefined) ?? identities[0];
+        if (!identity) {
+            throw new Error('No JMAP identity available for sending.');
+        }
+        const from = outgoing.from ?? { name: identity.name ?? null, email: identity.email };
+        const mailboxes = await this.getMailboxes();
+        const targetMailbox = mailboxes.find((mb) => mb.role === 'sent') ??
+            mailboxes.find((mb) => mb.role === 'drafts') ??
+            this.mailbox;
+        if (!targetMailbox) {
+            throw new Error('No mailbox available to store the outgoing email in.');
+        }
+        const bodyValues = {};
+        const textBodyParts = [];
+        const htmlBodyParts = [];
+        if (typeof outgoing.textBody === 'string') {
+            bodyValues.text = { value: outgoing.textBody };
+            textBodyParts.push({ partId: 'text', type: 'text/plain' });
+        }
+        if (typeof outgoing.htmlBody === 'string') {
+            bodyValues.html = { value: outgoing.htmlBody };
+            htmlBodyParts.push({ partId: 'html', type: 'text/html' });
+        }
+        if (!textBodyParts.length && !htmlBodyParts.length) {
+            throw new Error('sendEmail requires textBody and/or htmlBody.');
+        }
+        const emailCreate = {
+            mailboxIds: { [targetMailbox.id]: true },
+            keywords: { $seen: true },
+            from: [from],
+            to: outgoing.to,
+            subject: outgoing.subject,
+            bodyValues,
+        };
+        if (outgoing.cc) {
+            emailCreate.cc = outgoing.cc;
+        }
+        if (outgoing.bcc) {
+            emailCreate.bcc = outgoing.bcc;
+        }
+        if (textBodyParts.length) {
+            emailCreate.textBody = textBodyParts;
+        }
+        if (htmlBodyParts.length) {
+            emailCreate.htmlBody = htmlBodyParts;
+        }
+        const responses = await this.request([
+            ['Email/set', { accountId: this.accountId, create: { newEmail: emailCreate } }, 'c0'],
+            [
+                'EmailSubmission/set',
+                {
+                    accountId: this.accountId,
+                    create: { newSubmission: { emailId: '#newEmail', identityId: identity.id } },
+                },
+                'c1',
+            ],
+        ]);
+        const emailSetResult = responses.find((entry) => entry[2] === 'c0')?.[1] ?? {};
+        const createdEmail = emailSetResult.created?.newEmail;
+        if (!createdEmail) {
+            const notCreated = emailSetResult.notCreated?.newEmail;
+            throw new JmapError(`Email/set create failed${notCreated ? `: ${notCreated.type}${notCreated.description ? ` — ${notCreated.description}` : ''}` : ''}`, { jmapErrorType: notCreated?.type, jmapErrorDescription: notCreated?.description });
+        }
+        const submissionSetResult = responses.find((entry) => entry[2] === 'c1')?.[1] ?? {};
+        const createdSubmission = submissionSetResult.created?.newSubmission;
+        if (!createdSubmission) {
+            const notCreated = submissionSetResult.notCreated?.newSubmission;
+            throw new JmapError(`EmailSubmission/set create failed${notCreated ? `: ${notCreated.type}${notCreated.description ? ` — ${notCreated.description}` : ''}` : ''}`, { jmapErrorType: notCreated?.type, jmapErrorDescription: notCreated?.description });
+        }
+        return { emailId: createdEmail.id, submissionId: createdSubmission.id };
+    }
+    /**
+     * Downloads a blob's raw bytes using the session downloadUrl template
+     * (RFC 8620 §6.2: {accountId}, {blobId}, {type}, {name}).
+     */
+    async downloadBlob(blobId, type = 'application/octet-stream', name = 'blob') {
+        const template = this.session?.downloadUrl;
+        if (!template) {
+            throw new Error('JMAP session provides no downloadUrl — call connect() first.');
+        }
+        const expanded = template
+            .replace('{accountId}', encodeURIComponent(this.accountId))
+            .replace('{blobId}', encodeURIComponent(blobId))
+            .replace('{type}', encodeURIComponent(type))
+            .replace('{name}', encodeURIComponent(name));
+        const url = new URL(expanded, this.config.sessionUrl).toString();
+        const response = await fetch(url, {
+            headers: { authorization: this.getAuthHeader() },
+        });
+        if (!response.ok) {
+            throw await this.createHttpError(response, `Failed to download blob "${blobId}"`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    // ======================
+    // internal helpers
+    // ======================
+    getAuthHeader() {
+        const auth = this.config.auth;
+        if (typeof auth.accessToken === 'string') {
+            return `Bearer ${auth.accessToken}`;
+        }
+        return `Basic ${Buffer.from(`${auth.user}:${auth.pass}`).toString('base64')}`;
+    }
+    async createHttpError(response, messagePrefix) {
+        let problemType;
+        let problemDetail;
+        try {
+            const body = (await response.json());
+            if (body && typeof body === 'object') {
+                problemType = typeof body.type === 'string' ? body.type : undefined;
+                problemDetail = typeof body.detail === 'string' ? body.detail : undefined;
+            }
+        }
+        catch {
+            // non-JSON error body
+        }
+        return new JmapError(`${messagePrefix}: HTTP ${response.status}${problemDetail ? ` — ${problemDetail}` : ''}${problemType ? ` (${problemType})` : ''}`, { httpStatus: response.status, problemType, problemDetail });
+    }
+    async resolveMailbox() {
+        const responses = await this.request([
+            ['Mailbox/get', { accountId: this.accountId, ids: null }, 'mb0'],
+        ]);
+        const list = (responses[0][1].list ?? []);
+        const wanted = this.config.mailbox ?? 'INBOX';
+        const wantedLower = wanted.toLowerCase();
+        const byRole = list.find((mb) => (mb.role ?? '').toLowerCase() === wantedLower);
+        const byName = list.find((mb) => mb.name.toLowerCase() === wantedLower);
+        const mailbox = byRole ?? byName;
+        if (!mailbox) {
+            throw new Error(`JMAP mailbox "${wanted}" not found (no role or name match).`);
+        }
+        return mailbox;
+    }
+    async fetchEmailState() {
+        const responses = await this.request([
+            ['Email/get', { accountId: this.accountId, ids: [] }, 'st0'],
+        ]);
+        return String(responses[0][1].state ?? '');
+    }
+    async getEmailObjects(ids) {
+        const responses = await this.request([
+            [
+                'Email/get',
+                {
+                    accountId: this.accountId,
+                    ids,
+                    properties: EMAIL_PROPERTIES,
+                    fetchAllBodyValues: true,
+                },
+                'g0',
+            ],
+        ]);
+        return (responses[0][1].list ?? []);
+    }
+    async updateEmail(emailId, patch) {
+        const responses = await this.request([
+            ['Email/set', { accountId: this.accountId, update: { [emailId]: patch } }, 'u0'],
+        ]);
+        const result = responses[0][1];
+        const notUpdated = result.notUpdated?.[emailId];
+        if (notUpdated) {
+            throw new JmapError(`Email/set update of "${emailId}" failed: ${notUpdated.type}${notUpdated.description ? ` — ${notUpdated.description}` : ''}`, { jmapErrorType: notUpdated.type, jmapErrorDescription: notUpdated.description });
+        }
+    }
+    toMessage(email) {
+        const bodyValues = email.bodyValues ?? {};
+        const resolveParts = (parts) => parts
+            .map((part) => (part.partId != null ? bodyValues[part.partId]?.value : undefined))
+            .filter((value) => typeof value === 'string')
+            .join('\n');
+        const htmlParts = (email.htmlBody ?? []).filter((part) => part.type === 'text/html');
+        const attachments = (email.attachments ?? [])
+            .filter((part) => typeof part.blobId === 'string')
+            .map((part) => ({
+            blobId: part.blobId,
+            name: part.name ?? undefined,
+            type: part.type,
+            size: part.size,
+        }));
+        return {
+            id: email.id,
+            blobId: email.blobId,
+            threadId: email.threadId,
+            mailboxIds: email.mailboxIds ?? {},
+            keywords: email.keywords ?? {},
+            from: email.from ?? [],
+            to: email.to ?? [],
+            cc: email.cc ?? [],
+            bcc: email.bcc ?? [],
+            replyTo: email.replyTo ?? [],
+            subject: email.subject ?? undefined,
+            receivedAt: email.receivedAt,
+            textBody: resolveParts(email.textBody ?? []),
+            htmlBody: htmlParts.length ? resolveParts(htmlParts) : undefined,
+            attachments,
+            raw: email,
+        };
+    }
+    emitMessage(message) {
+        if (this.seenEmailIds.has(message.id)) {
+            return;
+        }
+        this.seenEmailIds.add(message.id);
+        this.emit('message', message);
+    }
+    async emitInitialEmails() {
+        const messages = await this.queryEmails();
+        // queryEmails sorts newest first; emit oldest first for natural ordering
+        for (const message of messages.reverse()) {
+            this.emitMessage(message);
+        }
+    }
+    startWatching() {
+        if (this.stopped) {
+            return;
+        }
+        const eventSourceUrl = this.session?.eventSourceUrl;
+        if (eventSourceUrl) {
+            this.startEventStream(eventSourceUrl);
+        }
+        else {
+            this.startPolling();
+        }
+    }
+    /**
+     * Watches the JMAP event source (RFC 8620 §7.3) by parsing SSE frames from
+     * a fetch body stream. A hand-rolled parser is used instead of the global
+     * EventSource because JMAP requires an Authorization header, which the
+     * WHATWG EventSource API cannot send.
+     */
+    startEventStream(templateUrl) {
+        const expanded = templateUrl
+            .replace('{types}', '*')
+            .replace('{closeafter}', 'no')
+            .replace('{ping}', '30');
+        const url = new URL(expanded, this.config.sessionUrl).toString();
+        // Last stream wins under any interleaving: abort a previous stream before
+        // installing the new controller.
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+        }
+        const abortController = new AbortController();
+        this.sseAbortController = abortController;
+        void this.runEventStream(url, abortController);
+    }
+    async runEventStream(url, abortController) {
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    authorization: this.getAuthHeader(),
+                    accept: 'text/event-stream',
+                },
+                signal: abortController.signal,
+            });
+            if (!response.ok || !response.body) {
+                throw new Error(`JMAP event source unavailable (HTTP ${response.status}).`);
+            }
+            // The stream is live; catch up on anything that changed between the
+            // initial state snapshot and the stream being established.
+            void this.fetchDeltas();
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let eventName = 'message';
+            let dataLines = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                let newlineIndex;
+                while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                    const line = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (line === '') {
+                        if (dataLines.length) {
+                            this.handleEventStreamEvent(eventName, dataLines.join('\n'));
+                        }
+                        eventName = 'message';
+                        dataLines = [];
+                    }
+                    else if (line.startsWith(':')) {
+                        // comment / keepalive
+                    }
+                    else if (line.startsWith('event:')) {
+                        eventName = line.slice(6).trim();
+                    }
+                    else if (line.startsWith('data:')) {
+                        dataLines.push(line.slice(5).replace(/^ /, ''));
+                    }
+                    // id: and retry: fields are irrelevant here
+                }
+            }
+            // Stream ended server-side: fall back to polling (mirroring the catch
+            // guards so a superseded stream's continuation stays inert).
+            if (!this.stopped && !abortController.signal.aborted) {
+                if (this.sseAbortController === abortController) {
+                    this.sseAbortController = null;
+                }
+                this.startPolling();
+            }
+        }
+        catch (error) {
+            if (this.stopped || abortController.signal.aborted) {
+                return;
+            }
+            // Event stream unavailable or broken: abort so any held response body
+            // (e.g. an unconsumed non-OK response) releases its connection, then
+            // fall back to polling.
+            abortController.abort();
+            if (this.sseAbortController === abortController) {
+                this.sseAbortController = null;
+            }
+            this.startPolling();
+        }
+    }
+    handleEventStreamEvent(eventName, data) {
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        if (eventName !== 'state' && parsed?.['@type'] !== 'StateChange') {
+            return;
+        }
+        const changed = parsed?.changed?.[this.accountId];
+        const emailState = changed?.Email;
+        if (typeof emailState === 'string' && emailState !== this.lastEmailState) {
+            void this.fetchDeltas();
+        }
+    }
+    startPolling() {
+        if (this.pollTimer || this.stopped) {
+            return;
+        }
+        const interval = this.config.pollIntervalMs ?? 30000;
+        this.pollTimer = setInterval(() => {
+            void this.fetchDeltas();
+        }, interval);
+    }
+    async fetchDeltas() {
+        if (this.stopped) {
+            return;
+        }
+        if (this.fetchingDeltas) {
+            this.deltaQueued = true;
+            return;
+        }
+        this.fetchingDeltas = true;
+        try {
+            do {
+                this.deltaQueued = false;
+                await this.fetchDeltasOnce();
+            } while (this.deltaQueued && !this.stopped);
+        }
+        finally {
+            this.fetchingDeltas = false;
+        }
+    }
+    async fetchDeltasOnce() {
+        try {
+            let hasMore = true;
+            while (hasMore && !this.stopped) {
+                const sinceState = this.lastEmailState;
+                const responses = await this.request([
+                    ['Email/changes', { accountId: this.accountId, sinceState }, 'ch0'],
+                ]);
+                const changes = responses[0][1];
+                this.lastEmailState = String(changes.newState ?? sinceState);
+                hasMore = changes.hasMoreChanges === true && this.lastEmailState !== sinceState;
+                const createdIds = changes.created ?? [];
+                if (createdIds.length) {
+                    const emails = await this.getEmailObjects(createdIds);
+                    for (const email of emails) {
+                        if (this.mailbox && email.mailboxIds?.[this.mailbox.id]) {
+                            this.emitMessage(this.toMessage(email));
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (this.stopped) {
+                return;
+            }
+            if (error?.jmapErrorType === 'cannotCalculateChanges') {
+                try {
+                    await this.resyncViaQuery();
+                }
+                catch (resyncError) {
+                    this.emit('error', resyncError);
+                }
+            }
+            else {
+                this.emit('error', error);
+            }
+        }
+    }
+    /** Full resync fallback when the server cannot calculate changes. */
+    async resyncViaQuery() {
+        this.lastEmailState = await this.fetchEmailState();
+        const messages = await this.queryEmails();
+        for (const message of messages.reverse()) {
+            this.emitMessage(message);
+        }
+    }
+    teardownWatchers() {
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.jmapclient.js","sourceRoot":"","sources":["../ts/classes.jmapclient.ts"],"names":[],"mappings":"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"}