@mulmobridge/client 0.1.4 → 0.2.0

package/dist/frame.d.ts

@@ -0,0 +1 @@
+export declare function frameText(data: Buffer | ArrayBuffer | Buffer[]): string;

package/dist/frame.js

@@ -0,0 +1,15 @@
+// Decode a `ws` message frame to a utf8 string, shared by the WebSocket-based
+// bridges (Mastodon, Signal).
+//
+// `ws` hands the listener `Buffer | ArrayBuffer | Buffer[]`. The default
+// binaryType is nodebuffer so a Buffer is what actually arrives, but the type
+// admits ArrayBuffer — whose `toString()` is the literal "[object ArrayBuffer]",
+// i.e. a frame silently parsed as garbage. Normalise instead of trusting the
+// runtime default to hold.
+export function frameText(data) {
+    if (Buffer.isBuffer(data))
+        return data.toString("utf8");
+    if (Array.isArray(data))
+        return Buffer.concat(data).toString("utf8");
+    return Buffer.from(data).toString("utf8");
+}

package/dist/http.d.ts

@@ -0,0 +1,10 @@
+export type JsonRecord = Record<string, unknown>;
+/** Narrow a parsed JSON value to a record, defaulting non-objects to `{}` —
+ *  the `isRecord(json) ? json : {}` idiom the REST bridges repeated so they
+ *  never have to cast `JSON.parse` output. */
+export declare function asJsonRecord(json: unknown): JsonRecord;
+/** `fetch` + non-2xx guard + JSON-record narrow. Callers own the URL, auth
+ *  headers, and timeout (via `init.signal`); `errorLabel` prefixes the thrown
+ *  non-2xx error (e.g. "GET /im.list"). Network errors propagate from `fetch`
+ *  unchanged, matching the callers' existing try/catch expectations. */
+export declare function fetchJsonRecord(url: string, init: RequestInit, errorLabel: string): Promise<JsonRecord>;

package/dist/http.js

@@ -0,0 +1,22 @@
+// Minimal JSON-over-REST fetch skeleton shared by the polling bridges
+// (Rocket.Chat, Zulip), which used to carry byte-identical GET/POST wrappers.
+import { isRecord } from "@mulmoclaude/common";
+const MAX_ERROR_BODY_CHARS = 200;
+/** Narrow a parsed JSON value to a record, defaulting non-objects to `{}` —
+ *  the `isRecord(json) ? json : {}` idiom the REST bridges repeated so they
+ *  never have to cast `JSON.parse` output. */
+export function asJsonRecord(json) {
+    return isRecord(json) ? json : {};
+}
+/** `fetch` + non-2xx guard + JSON-record narrow. Callers own the URL, auth
+ *  headers, and timeout (via `init.signal`); `errorLabel` prefixes the thrown
+ *  non-2xx error (e.g. "GET /im.list"). Network errors propagate from `fetch`
+ *  unchanged, matching the callers' existing try/catch expectations. */
+export async function fetchJsonRecord(url, init, errorLabel) {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`${errorLabel}: ${res.status} ${text.slice(0, MAX_ERROR_BODY_CHARS)}`);
+    }
+    return asJsonRecord(await res.json());
+}

package/dist/index.d.ts

@@ -2,4 +2,7 @@ export { createBridgeClient, requireBearerToken, type MessageAck, type PushEvent
 export { readBridgeToken, TOKEN_FILE_PATH } from "./token.js";
 export { readBridgeEnvOptions } from "./options.js";
 export { chunkText } from "./text.js";
+export { frameText } from "./frame.js";
+export { asJsonRecord, fetchJsonRecord, type JsonRecord } from "./http.js";
+export { formatAckReply } from "./reply.js";
 export { mimeFromExtension, isImageMime, isPdfMime, isSupportedAttachmentMime, isNativeAttachmentMime, parseDataUrl, buildDataUrl, type ParsedDataUrl, } from "./mime.js";

package/dist/index.js

@@ -3,4 +3,7 @@ export { createBridgeClient, requireBearerToken } from "./client.js";
 export { readBridgeToken, TOKEN_FILE_PATH } from "./token.js";
 export { readBridgeEnvOptions } from "./options.js";
 export { chunkText } from "./text.js";
+export { frameText } from "./frame.js";
+export { asJsonRecord, fetchJsonRecord } from "./http.js";
+export { formatAckReply } from "./reply.js";
 export { mimeFromExtension, isImageMime, isPdfMime, isSupportedAttachmentMime, isNativeAttachmentMime, parseDataUrl, buildDataUrl, } from "./mime.js";

package/dist/mime.d.ts

@@ -1,14 +1,17 @@
 /** Infer MIME type from a file extension (case-insensitive).
  *  Returns the fallback if the extension is not recognised. */
 export declare function mimeFromExtension(ext: string, fallback?: string): string;
-/** True when the MIME type is an image Claude can see via vision. */
-export declare function isImageMime(mimeType: string): boolean;
+/** True when the MIME type is an image Claude can see via vision.
+ *  Tolerates `undefined` so callers can pass an attachment's optional
+ *  `mimeType` directly. */
+export declare function isImageMime(mimeType: string | undefined): boolean;
 /** True when the MIME type is a PDF document Claude can read natively
- *  via `type: "document"` content blocks. */
-export declare function isPdfMime(mimeType: string): boolean;
+ *  via `type: "document"` content blocks. Tolerates `undefined`. */
+export declare function isPdfMime(mimeType: string | undefined): boolean;
 /** True when the attachment can be sent to Claude directly as a
- *  native content block (image or PDF) — no conversion needed. */
-export declare function isNativeAttachmentMime(mimeType: string): boolean;
+ *  native content block (image or PDF) — no conversion needed.
+ *  Tolerates `undefined`. */
+export declare function isNativeAttachmentMime(mimeType: string | undefined): boolean;
 export declare const isSupportedAttachmentMime: typeof isNativeAttachmentMime;
 export interface ParsedDataUrl {
     mimeType: string;

package/dist/mime.js

@@ -31,17 +31,20 @@ const EXT_TO_MIME = {
 export function mimeFromExtension(ext, fallback = "application/octet-stream") {
     return EXT_TO_MIME[ext.toLowerCase()] ?? fallback;
 }
-/** True when the MIME type is an image Claude can see via vision. */
+/** True when the MIME type is an image Claude can see via vision.
+ *  Tolerates `undefined` so callers can pass an attachment's optional
+ *  `mimeType` directly. */
 export function isImageMime(mimeType) {
-    return mimeType.startsWith("image/");
+    return typeof mimeType === "string" && mimeType.startsWith("image/");
 }
 /** True when the MIME type is a PDF document Claude can read natively
- *  via `type: "document"` content blocks. */
+ *  via `type: "document"` content blocks. Tolerates `undefined`. */
 export function isPdfMime(mimeType) {
     return mimeType === "application/pdf";
 }
 /** True when the attachment can be sent to Claude directly as a
- *  native content block (image or PDF) — no conversion needed. */
+ *  native content block (image or PDF) — no conversion needed.
+ *  Tolerates `undefined`. */
 export function isNativeAttachmentMime(mimeType) {
     return isImageMime(mimeType) || isPdfMime(mimeType);
 }

package/dist/options.js

@@ -9,38 +9,15 @@
 //
 // Both forms strip the prefix and convert the `UPPER_SNAKE` tail to
 // `lowerCamel`. Empty string values are dropped so a stray
-// `FOO=""` doesn't shadow `BAR`'s match.
+// `FOO=""` doesn't shadow `BAR`'s match. The scan itself is the
+// shared `scanEnvOptions` (#2487) — the host's relay path resolves
+// its `RELAY_*` scheme through the same algorithm.
 //
 // The `_BRIDGE_` segment is deliberate: it lets the bridge keep its
 // own secrets (`SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN`, …) naturally
 // outside the scrape — they have no `_BRIDGE_` segment so they're
 // never picked up, no reserved-list needed.
-// Convert UPPER_SNAKE_CASE → lowerCamelCase. Leading digits and
-// adjacent underscores degrade gracefully (adjacent underscores
-// collapse to a single word break; leading digits are allowed but
-// kept as-is after the first segment is lowercased).
-function snakeToLowerCamel(snake) {
-    const parts = snake
-        .toLowerCase()
-        .split("_")
-        .filter((segment) => segment.length > 0);
-    if (parts.length === 0)
-        return "";
-    const [head, ...rest] = parts;
-    return head + rest.map((part) => (part ? part[0].toUpperCase() + part.slice(1) : "")).join("");
-}
-// Strip the prefix, return null if the name doesn't match.
-function matchBridgePrefix(name, transportPrefix) {
-    if (name.startsWith(transportPrefix)) {
-        const tail = name.slice(transportPrefix.length);
-        return tail.length > 0 ? tail : null;
-    }
-    if (name.startsWith("BRIDGE_")) {
-        const tail = name.slice("BRIDGE_".length);
-        return tail.length > 0 ? tail : null;
-    }
-    return null;
-}
+import { scanEnvOptions } from "@mulmoclaude/common";
 /**
  * Read `<TRANSPORT>_BRIDGE_*` and `BRIDGE_*` env vars into a
  * lowerCamelCase-keyed bag ready to hand to `createBridgeClient`.
@@ -64,25 +41,5 @@ function matchBridgePrefix(name, transportPrefix) {
  */
 export function readBridgeEnvOptions(transportId, env) {
     const transportPrefix = `${transportId.toUpperCase().replace(/-/g, "_")}_BRIDGE_`;
-    const shared = {};
-    const specific = {};
-    for (const [name, value] of Object.entries(env)) {
-        if (typeof value !== "string" || value.length === 0)
-            continue;
-        const tail = matchBridgePrefix(name, transportPrefix);
-        if (tail === null)
-            continue;
-        const key = snakeToLowerCamel(tail);
-        if (!key)
-            continue;
-        if (name.startsWith(transportPrefix)) {
-            specific[key] = value;
-        }
-        else {
-            shared[key] = value;
-        }
-    }
-    // Transport-specific overrides shared on conflict — spread order
-    // (shared first, then specific) gives exactly that behaviour.
-    return { ...shared, ...specific };
+    return scanEnvOptions(env, { prefixes: ["BRIDGE_", transportPrefix] });
 }

package/dist/reply.d.ts

@@ -0,0 +1,8 @@
+import type { MessageAck } from "./client.js";
+/**
+ * Format a `MessageAck` as a single user-facing string.
+ *
+ * - `ok` ack → `reply` content (or empty string if absent).
+ * - Failed ack → `"Error[ (status)]: <error or 'unknown'>"`.
+ */
+export declare function formatAckReply(ack: MessageAck): string;

package/dist/reply.js

@@ -0,0 +1,19 @@
+// Shared reply formatting for bridges.
+//
+// Every bridge converts a `MessageAck` from `BridgeClient.send()`
+// into a single string to send back over its native transport. The
+// happy-path / error-path shape is identical across bridges
+// (LINE / Slack / Teams / Mastodon / XMPP all do the same thing
+// modulo the send call), so the formatting belongs here.
+/**
+ * Format a `MessageAck` as a single user-facing string.
+ *
+ * - `ok` ack → `reply` content (or empty string if absent).
+ * - Failed ack → `"Error[ (status)]: <error or 'unknown'>"`.
+ */
+export function formatAckReply(ack) {
+    if (ack.ok)
+        return ack.reply ?? "";
+    const status = ack.status ? ` (${ack.status})` : "";
+    return `Error${status}: ${ack.error ?? "unknown"}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/client",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Socket.io client library for MulmoBridge — shared by all bridge implementations",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,10 +46,11 @@
   "author": "Receptron Team",
   "dependencies": {
     "@mulmobridge/protocol": "^0.1.4",
+    "@mulmoclaude/common": "^1.1.0",
     "socket.io-client": "^4.0.0"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
+    "@types/node": "^26.1.1",
     "typescript": "^6.0.3"
   }
 }