@markmnl/fmsg-mcp 0.1.0

package/dist/client/client.js

@@ -0,0 +1,310 @@
+import { normalizeFmsgAddress } from "../address.js";
+import { normalizeMessageId, parseFmsgJson, stringifyWithIds } from "./message-id.js";
+import { redactSecrets } from "./redact.js";
+/** An HTTP error from the fmsg Web API, with the status and the host's own error text. */
+export class FmsgHttpError extends Error {
+    status;
+    method;
+    path;
+    code;
+    constructor(message, status, method, path, 
+    /** Machine-readable `code` from the body, when the host sends one (thread routes). */
+    code) {
+        super(message);
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.code = code;
+        this.name = "FmsgHttpError";
+    }
+}
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3 || !parts[1])
+        throw new Error("token exchange returned an invalid JWT");
+    try {
+        return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("token exchange returned an unreadable JWT payload");
+    }
+}
+async function readError(response) {
+    const raw = await response.text().catch(() => "");
+    if (!raw)
+        return { message: `HTTP ${response.status}` };
+    try {
+        const parsed = JSON.parse(raw);
+        const message = typeof parsed.error === "string" ? parsed.error : `HTTP ${response.status}`;
+        return typeof parsed.code === "string" ? { message, code: parsed.code } : { message };
+    }
+    catch {
+        return { message: raw.slice(0, 300) };
+    }
+}
+function withId(message, id) {
+    return { ...message, id, terminal: message.terminal === true, reaction: message.reaction ?? null, reactions: message.reactions ?? [] };
+}
+/**
+ * Client for the fmsg Web API (FMSG-003). Exchanges an `fmsgk_` API key for a
+ * short-lived JWT, refreshes it ahead of expiry, and retries once on 401.
+ */
+export class FmsgClient {
+    apiKey;
+    options;
+    apiUrl;
+    token;
+    tokenPromise;
+    constructor(apiUrl, apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = options;
+        this.apiUrl = apiUrl.replace(/\/+$/u, "");
+        if (!/^https?:\/\//u.test(this.apiUrl))
+            throw new Error("FMSG_API_URL must be an http(s) URL");
+        if (!apiKey.startsWith("fmsgk_"))
+            throw new Error("fmsg API key must start with fmsgk_");
+    }
+    get fetchImpl() {
+        return this.options.fetch ?? fetch;
+    }
+    /** The address this client acts as (from the JWT `sub`), exchanging the key if needed. */
+    async address() {
+        return (await this.getToken()).address;
+    }
+    async getToken(force = false) {
+        const margin = this.options.refreshMarginMs ?? 300_000;
+        if (!force && this.token && this.token.expiresAtMs - margin > Date.now())
+            return this.token;
+        if (!force && this.tokenPromise)
+            return this.tokenPromise;
+        this.tokenPromise = this.exchangeToken();
+        try {
+            this.token = await this.tokenPromise;
+            return this.token;
+        }
+        finally {
+            this.tokenPromise = undefined;
+        }
+    }
+    async exchangeToken() {
+        const response = await this.fetchImpl(`${this.apiUrl}/fmsg/token`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${this.apiKey}` },
+            signal: AbortSignal.timeout(this.options.timeoutMs ?? 60_000),
+        });
+        if (!response.ok) {
+            const { message } = await readError(response);
+            throw new FmsgHttpError(`token exchange failed: ${redactSecrets(message).text}`, response.status, "POST", "/fmsg/token");
+        }
+        const body = (await response.json());
+        if (typeof body.access_token !== "string")
+            throw new Error("token response has no access_token");
+        const payload = decodeJwtPayload(body.access_token);
+        const address = typeof payload.sub === "string" ? normalizeFmsgAddress(payload.sub) : undefined;
+        if (!address)
+            throw new Error("token JWT sub is not an fmsg address");
+        const fromResponse = typeof body.expires_at === "string" ? Date.parse(body.expires_at) : Number.NaN;
+        const fromJwt = typeof payload.exp === "number" ? payload.exp * 1000 : Number.NaN;
+        const fromIn = typeof body.expires_in === "number" ? Date.now() + body.expires_in * 1000 : Number.NaN;
+        const expiresAtMs = [fromResponse, fromJwt, fromIn].find(Number.isFinite) ?? Date.now() + 3_600_000;
+        return { accessToken: body.access_token, address, expiresAtMs };
+    }
+    async request(path, init = {}, retry401 = true) {
+        const token = await this.getToken();
+        const headers = new Headers(init.headers);
+        headers.set("authorization", `Bearer ${token.accessToken}`);
+        const signal = init.signal ?? AbortSignal.timeout(this.options.timeoutMs ?? 60_000);
+        const response = await this.fetchImpl(`${this.apiUrl}${path}`, { ...init, headers, signal });
+        if (response.status === 401 && retry401) {
+            await this.getToken(true);
+            return this.request(path, init, false);
+        }
+        if (!response.ok) {
+            const { message, code } = await readError(response);
+            const method = init.method ?? "GET";
+            throw new FmsgHttpError(redactSecrets(message).text, response.status, method, path, code);
+        }
+        return response;
+    }
+    async json(path, init) {
+        const response = await this.request(path, init);
+        return parseFmsgJson(await response.text());
+    }
+    // ── Messages ──────────────────────────────────────────────────────────
+    async listInbox(limit = 20, offset = 0, signal) {
+        const items = await this.json(`/fmsg?limit=${limit}&offset=${offset}`, { signal });
+        if (!Array.isArray(items))
+            throw new Error("inbox response is not an array");
+        return items.map((m) => withId(m, normalizeMessageId(m.id)));
+    }
+    async listSent(limit = 20, offset = 0, signal) {
+        const items = await this.json(`/fmsg/sent?limit=${limit}&offset=${offset}`, { signal });
+        if (!Array.isArray(items))
+            throw new Error("sent response is not an array");
+        return items.map((m) => withId(m, normalizeMessageId(m.id)));
+    }
+    async getMessage(id, signal) {
+        const mid = normalizeMessageId(id);
+        const message = await this.json(`/fmsg/${encodeURIComponent(mid)}`, { signal });
+        return withId(message, mid);
+    }
+    /** Raw message body bytes. */
+    async getData(id, signal) {
+        const mid = normalizeMessageId(id);
+        const response = await this.request(`/fmsg/${encodeURIComponent(mid)}/data`, { signal });
+        const contentType = response.headers.get("content-type") ?? undefined;
+        return { data: new Uint8Array(await response.arrayBuffer()), ...(contentType ? { contentType } : {}) };
+    }
+    /** Whether `short_text` already holds the complete body. */
+    static shortTextIsComplete(message) {
+        if (typeof message.short_text !== "string")
+            return false;
+        if (typeof message.size !== "number")
+            return false;
+        return Buffer.byteLength(message.short_text, "utf8") >= message.size;
+    }
+    static isText(message) {
+        const type = (message.type ?? "").toLowerCase();
+        return type.startsWith("text/") || type.startsWith("application/json") || /\+json\b/u.test(type);
+    }
+    /** Full body text for text-like messages; null for binary bodies. */
+    async getText(message, signal) {
+        if (!FmsgClient.isText(message))
+            return null;
+        if (FmsgClient.shortTextIsComplete(message))
+            return message.short_text ?? "";
+        if (message.size === 0)
+            return "";
+        const { data } = await this.getData(message.id, signal);
+        return Buffer.from(data).toString("utf8");
+    }
+    async getThreadMessages(id, signal) {
+        const mid = normalizeMessageId(id);
+        const thread = await this.json(`/fmsg/${encodeURIComponent(mid)}/thread/messages`, { signal });
+        return {
+            ...thread,
+            root_id: normalizeMessageId(thread.root_id, "root_id"),
+            trigger_id: normalizeMessageId(thread.trigger_id, "trigger_id"),
+            messages: (thread.messages ?? []).map((m) => ({ ...m, id: normalizeMessageId(m.id) })),
+        };
+    }
+    async getThreadText(id, signal) {
+        const mid = normalizeMessageId(id);
+        const response = await this.request(`/fmsg/${encodeURIComponent(mid)}/thread`, { signal });
+        return response.text();
+    }
+    /** Download by a `download` path returned from thread/messages (`/fmsg/...`). */
+    async downloadPath(path, signal) {
+        if (!path.startsWith("/fmsg/") || path.includes("://"))
+            throw new Error(`refusing to download non-fmsg path ${path}`);
+        const response = await this.request(path, { signal });
+        const contentType = response.headers.get("content-type") ?? undefined;
+        return { data: new Uint8Array(await response.arrayBuffer()), ...(contentType ? { contentType } : {}) };
+    }
+    async markRead(id, signal) {
+        const mid = normalizeMessageId(id);
+        const result = await this.json(`/fmsg/${encodeURIComponent(mid)}/read`, {
+            method: "POST",
+            signal,
+        });
+        return { id: mid, time_read: result.time_read ?? null };
+    }
+    async addRecipients(id, addTo, signal) {
+        const mid = normalizeMessageId(id);
+        const result = await this.json(`/fmsg/${encodeURIComponent(mid)}/add-to`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ add_to: addTo }),
+            signal,
+        });
+        return { id: mid, added: result.added ?? addTo.length };
+    }
+    async react(id, emoji, signal) {
+        const mid = normalizeMessageId(id);
+        const result = await this.json(`/fmsg/${encodeURIComponent(mid)}/react`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ emoji: emoji ?? "" }),
+            signal,
+        });
+        return {
+            id: result.id === undefined || result.id === null ? null : normalizeMessageId(result.id),
+            time: result.time ?? null,
+        };
+    }
+    async downloadAttachment(id, filename, signal) {
+        const mid = normalizeMessageId(id);
+        const response = await this.request(`/fmsg/${encodeURIComponent(mid)}/attach/${encodeURIComponent(filename)}`, { signal });
+        const contentType = response.headers.get("content-type") ?? undefined;
+        return { data: new Uint8Array(await response.arrayBuffer()), ...(contentType ? { contentType } : {}) };
+    }
+    async deleteMessage(id, signal) {
+        const mid = normalizeMessageId(id);
+        await this.request(`/fmsg/${encodeURIComponent(mid)}`, { method: "DELETE", signal });
+    }
+    // ── Sending ───────────────────────────────────────────────────────────
+    async createDraft(input, from) {
+        const body = {
+            version: 1,
+            from,
+            to: input.to,
+            type: input.type ?? "text/markdown; charset=utf-8",
+            data: input.body,
+            topic: input.pid ? "" : (input.topic ?? ""),
+            ...(input.important ? { important: true } : {}),
+            ...(input.noReply ? { no_reply: true } : {}),
+        };
+        const serialized = input.pid ? stringifyWithIds(body, { pid: input.pid }) : JSON.stringify(body);
+        const response = await this.request("/fmsg", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: serialized,
+            ...(input.signal ? { signal: input.signal } : {}),
+        });
+        const result = parseFmsgJson(await response.text());
+        if (result.id === undefined || result.id === null)
+            throw new Error("draft response has no id");
+        return normalizeMessageId(result.id);
+    }
+    async uploadAttachment(draftId, attachment, signal) {
+        const form = new FormData();
+        const blob = new Blob([Buffer.from(attachment.data)], { type: attachment.contentType ?? "application/octet-stream" });
+        form.append("file", blob, attachment.filename);
+        const response = await this.request(`/fmsg/${encodeURIComponent(draftId)}/attach`, {
+            method: "POST",
+            body: form,
+            ...(signal ? { signal } : {}),
+        });
+        const result = parseFmsgJson(await response.text());
+        return { filename: result.filename ?? attachment.filename, size: result.size ?? attachment.data.byteLength };
+    }
+    /** Draft → attach → send. The draft is deleted if any step after creation fails. */
+    async send(input) {
+        if (input.to.length === 0)
+            throw new Error("at least one recipient is required");
+        if (input.pid && input.topic)
+            throw new Error("a reply (pid) cannot carry a topic");
+        const from = await this.address();
+        const draftId = await this.createDraft(input, from);
+        try {
+            const attachments = [];
+            for (const attachment of input.attachments ?? []) {
+                attachments.push(await this.uploadAttachment(draftId, attachment, input.signal));
+            }
+            const response = await this.request(`/fmsg/${encodeURIComponent(draftId)}/send`, {
+                method: "POST",
+                ...(input.signal ? { signal: input.signal } : {}),
+            });
+            const result = parseFmsgJson(await response.text());
+            return {
+                id: result.id === undefined || result.id === null ? draftId : normalizeMessageId(result.id),
+                time: result.time ?? null,
+                attachments,
+            };
+        }
+        catch (error) {
+            await this.deleteMessage(draftId).catch(() => undefined);
+            throw error;
+        }
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+export { FmsgClient, FmsgHttpError, type FmsgClientOptions } from "./client.js";
+export { openFmsgWebSocket, parseWsEvent } from "./ws.js";
+export { redactSecrets, safeErrorMessage, type Redacted } from "./redact.js";
+export { normalizeMessageId, compareMessageIds, maxMessageId, parseFmsgJson, stringifyWithIds } from "./message-id.js";
+export { normalizeFmsgAddress, isFmsgAddress } from "../address.js";
+export type * from "./types.js";

package/dist/client/index.js

@@ -0,0 +1,5 @@
+export { FmsgClient, FmsgHttpError } from "./client.js";
+export { openFmsgWebSocket, parseWsEvent } from "./ws.js";
+export { redactSecrets, safeErrorMessage } from "./redact.js";
+export { normalizeMessageId, compareMessageIds, maxMessageId, parseFmsgJson, stringifyWithIds } from "./message-id.js";
+export { normalizeFmsgAddress, isFmsgAddress } from "../address.js";

package/dist/client/message-id.d.ts

@@ -0,0 +1,19 @@
+/**
+ * fmsg message ids are int64 values serialised as bare JSON numbers. JavaScript
+ * numbers lose precision above 2^53, so ids are kept as decimal strings and
+ * only ever cross the JSON boundary through the helpers below.
+ */
+/** Validate and normalise an id (number or digit string) to its decimal string form. */
+export declare function normalizeMessageId(value: unknown, label?: string): string;
+export declare function compareMessageIds(a: string, b: string): number;
+export declare function maxMessageId(ids: Iterable<string>): string | undefined;
+/**
+ * Parse fmsg JSON, converting id fields to exact decimal strings using the
+ * reviver's `context.source` (the original number text, Node 21+).
+ */
+export declare function parseFmsgJson<T = unknown>(text: string): T;
+/**
+ * Serialise an object, emitting the given id fields as bare int64 numbers.
+ * `ids` values must already be normalised decimal strings.
+ */
+export declare function stringifyWithIds(value: Record<string, unknown>, ids: Record<string, string>): string;

package/dist/client/message-id.js

@@ -0,0 +1,70 @@
+/**
+ * fmsg message ids are int64 values serialised as bare JSON numbers. JavaScript
+ * numbers lose precision above 2^53, so ids are kept as decimal strings and
+ * only ever cross the JSON boundary through the helpers below.
+ */
+const MAX_INT64 = 9223372036854775807n;
+/** Validate and normalise an id (number or digit string) to its decimal string form. */
+export function normalizeMessageId(value, label = "message id") {
+    let raw;
+    if (typeof value === "string")
+        raw = value.trim();
+    else if (typeof value === "number" && Number.isSafeInteger(value))
+        raw = String(value);
+    else if (typeof value === "bigint")
+        raw = value.toString();
+    else
+        throw new Error(`invalid ${label}: ${String(value)}`);
+    if (!/^[0-9]+$/u.test(raw))
+        throw new Error(`invalid ${label}: ${raw}`);
+    const big = BigInt(raw);
+    if (big < 1n || big > MAX_INT64)
+        throw new Error(`out-of-range ${label}: ${raw}`);
+    return big.toString();
+}
+export function compareMessageIds(a, b) {
+    const x = BigInt(a);
+    const y = BigInt(b);
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+export function maxMessageId(ids) {
+    let best;
+    for (const id of ids)
+        if (best === undefined || compareMessageIds(id, best) > 0)
+            best = id;
+    return best;
+}
+/** JSON keys whose numeric values are int64 ids on the fmsg wire. */
+const ID_KEYS = new Set(["id", "pid", "batch_id", "root_id", "trigger_id"]);
+/**
+ * Parse fmsg JSON, converting id fields to exact decimal strings using the
+ * reviver's `context.source` (the original number text, Node 21+).
+ */
+export function parseFmsgJson(text) {
+    const parse = JSON.parse;
+    return parse(text, function (key, value, context) {
+        if (ID_KEYS.has(key) && typeof value === "number") {
+            const source = context?.source;
+            if (source && /^[0-9]+$/u.test(source))
+                return source;
+            return normalizeMessageId(value, key);
+        }
+        return value;
+    });
+}
+/**
+ * Serialise an object, emitting the given id fields as bare int64 numbers.
+ * `ids` values must already be normalised decimal strings.
+ */
+export function stringifyWithIds(value, ids) {
+    const entries = Object.entries(ids).filter(([, v]) => v !== undefined);
+    if (entries.length === 0)
+        return JSON.stringify(value);
+    for (const [k] of entries) {
+        if (Object.hasOwn(value, k))
+            throw new Error(`JSON already contains ${k}`);
+    }
+    const base = JSON.stringify(value);
+    const extra = entries.map(([k, v]) => `${JSON.stringify(k)}:${normalizeMessageId(v, k)}`).join(",");
+    return base === "{}" ? `{${extra}}` : `${base.slice(0, -1)},${extra}}`;
+}

package/dist/client/redact.d.ts

@@ -0,0 +1,8 @@
+export type Redacted = {
+    text: string;
+    count: number;
+};
+/** Replace secrets with placeholders and report how many were replaced. */
+export declare function redactSecrets(text: string): Redacted;
+/** One-line, secret-free rendering of an error for logs and tool results. */
+export declare function safeErrorMessage(error: unknown): string;

package/dist/client/redact.js

@@ -0,0 +1,25 @@
+/** Patterns for secrets that must never leave the process in message bodies or logs. */
+const PATTERNS = [
+    [/\bfmsgk_[A-Za-z0-9+/=._~-]{6,}\b/gu, "[REDACTED_FMSG_API_KEY]"],
+    [/\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\b/gu, "[REDACTED_JWT]"],
+    [/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b|\bgithub_pat_[A-Za-z0-9_]{22,}\b/gu, "[REDACTED_GITHUB_TOKEN]"],
+    [/\bsk-[A-Za-z0-9_-]{20,}\b/gu, "[REDACTED_API_KEY]"],
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gu, "[REDACTED_PRIVATE_KEY]"],
+];
+/** Replace secrets with placeholders and report how many were replaced. */
+export function redactSecrets(text) {
+    let count = 0;
+    let out = text;
+    for (const [pattern, replacement] of PATTERNS) {
+        out = out.replace(pattern, () => {
+            count += 1;
+            return replacement;
+        });
+    }
+    return { text: out, count };
+}
+/** One-line, secret-free rendering of an error for logs and tool results. */
+export function safeErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return redactSecrets(message).text.replace(/[\r\n\u2028\u2029]+/gu, " ").slice(0, 2000);
+}

package/dist/client/types.d.ts

@@ -0,0 +1,126 @@
+/** Wire types for the fmsg Web API (FMSG-003). Ids are decimal strings. */
+export type RecipientDelivery = {
+    addr: string;
+    /** RFC3339 UTC; null until delivered. */
+    time_delivered: string | null;
+    /** The receiving host's response code for the last delivery attempt; null if none yet. */
+    response_code: number | null;
+};
+export type AddToBatch = {
+    batch_id?: string;
+    add_to_from?: string;
+    to?: string[];
+    to_delivery?: RecipientDelivery[];
+    time?: number | null;
+};
+export type Attachment = {
+    filename: string;
+    size: number;
+};
+export type ReactionGroup = {
+    emoji: string;
+    from: string[];
+};
+export type FmsgMessage = {
+    /** Present on list items and WebSocket events; absent on GET /fmsg/:id (filled in by the client). */
+    id: string;
+    version?: number;
+    has_pid?: boolean;
+    has_add_to?: boolean;
+    important?: boolean;
+    no_reply?: boolean;
+    deflate?: boolean;
+    terminal?: boolean;
+    pid?: string | null;
+    from: string;
+    to: string[];
+    to_delivery?: RecipientDelivery[];
+    add_to?: AddToBatch[];
+    /** POSIX seconds; null for drafts. */
+    time?: number | null;
+    topic?: string;
+    type?: string;
+    size?: number;
+    short_text?: string;
+    read?: boolean;
+    time_read?: number | null;
+    attachments?: Attachment[];
+    /** Non-null when this message is itself a reaction. */
+    reaction?: string | null;
+    reactions?: ReactionGroup[];
+};
+export type ThreadBody = {
+    type: string;
+    size: number;
+    text?: string;
+    download?: string;
+    cache_key?: string;
+    cacheable?: boolean;
+};
+export type ThreadAttachment = {
+    position: number;
+    type: string;
+    filename: string;
+    size: number;
+    download?: string;
+    cache_key?: string;
+    cacheable?: boolean;
+};
+export type ThreadMessage = {
+    id: string;
+    visible: boolean;
+    version?: number;
+    pid?: string | null;
+    from?: string;
+    to?: string[];
+    add_to?: AddToBatch[];
+    time?: number | null;
+    topic?: string;
+    type?: string;
+    size?: number;
+    message_sha256?: string;
+    body?: ThreadBody;
+    attachments?: ThreadAttachment[];
+};
+export type Thread = {
+    root_id: string;
+    trigger_id: string;
+    complete: boolean;
+    messages: ThreadMessage[];
+};
+export type AccessToken = {
+    accessToken: string;
+    /** fmsg address from the JWT `sub` claim. */
+    address: string;
+    expiresAtMs: number;
+};
+export type OutboundAttachment = {
+    filename: string;
+    data: Uint8Array;
+    contentType?: string;
+};
+export type SendInput = {
+    to: string[];
+    body: string;
+    type?: string;
+    topic?: string;
+    pid?: string;
+    important?: boolean;
+    noReply?: boolean;
+    attachments?: OutboundAttachment[];
+    signal?: AbortSignal;
+};
+export type SendResult = {
+    id: string;
+    time: number | null;
+    attachments: Attachment[];
+};
+export type ReactResult = {
+    id: string | null;
+    time: number | null;
+};
+export type WsEventType = "new_msg" | "delivered" | "recipients_added" | "reaction";
+export type WsEvent = {
+    type: WsEventType | string;
+    data?: FmsgMessage;
+};

package/dist/client/types.js

@@ -0,0 +1,2 @@
+/** Wire types for the fmsg Web API (FMSG-003). Ids are decimal strings. */
+export {};

package/dist/client/ws.d.ts

@@ -0,0 +1,6 @@
+import WebSocket from "ws";
+import type { FmsgClient } from "./client.js";
+import type { WsEvent } from "./types.js";
+/** Open the event WebSocket, authenticating with the bearer JWT in the header. */
+export declare function openFmsgWebSocket(client: FmsgClient): Promise<WebSocket>;
+export declare function parseWsEvent(raw: WebSocket.RawData): WsEvent | undefined;

package/dist/client/ws.js

@@ -0,0 +1,25 @@
+import WebSocket from "ws";
+import { normalizeMessageId, parseFmsgJson } from "./message-id.js";
+/** Open the event WebSocket, authenticating with the bearer JWT in the header. */
+export async function openFmsgWebSocket(client) {
+    const token = await client.getToken();
+    const url = new URL(client.apiUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = `${url.pathname.replace(/\/+$/u, "")}/fmsg/ws`;
+    url.search = "";
+    return new WebSocket(url, { headers: { authorization: `Bearer ${token.accessToken}` } });
+}
+export function parseWsEvent(raw) {
+    try {
+        const parsed = parseFmsgJson(raw.toString());
+        if (!parsed || typeof parsed.type !== "string")
+            return undefined;
+        const data = parsed.data && typeof parsed.data === "object" && parsed.data.id !== undefined
+            ? { ...parsed.data, id: normalizeMessageId(parsed.data.id), reaction: parsed.data.reaction ?? null, reactions: parsed.data.reactions ?? [] }
+            : undefined;
+        return data ? { type: parsed.type, data } : { type: parsed.type };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,31 @@
+export type Transport = "stdio" | "http";
+export type HttpConfig = {
+    host: string;
+    port: number;
+    /** Hostnames accepted in the Host header. Empty means: derive from the bind address (loopback only). */
+    allowedHosts: string[];
+    /** Origins (hostnames) accepted in the Origin header for browser callers; empty = same as allowedHosts. */
+    allowedOrigins: string[];
+    keyCacheMax: number;
+    keyCacheTtlMs: number;
+};
+export type Config = {
+    transport: Transport;
+    apiUrl: string;
+    /** Only set in stdio mode. */
+    apiKey?: string;
+    defaultDomain?: string;
+    directory?: Record<string, string>;
+    /** Hard cap on a single wait_for_message call. */
+    waitMaxSeconds: number;
+    /** Directory attachments may be saved under (stdio only); unset = anywhere. */
+    downloadDir?: string;
+    http: HttpConfig;
+};
+export declare const DEFAULT_HTTP_PORT = 8765;
+export declare const DEFAULT_WAIT_MAX_SECONDS = 230;
+export type ConfigOverrides = {
+    host?: string;
+    port?: number;
+};
+export declare function loadConfig(env: NodeJS.ProcessEnv, transport: Transport, overrides?: ConfigOverrides): Config;