@mulmobridge/client 1.2.0 → 1.3.0

package/dist/inProcess.d.ts

@@ -0,0 +1,34 @@
+import type { Attachment, BridgeOptions } from "@mulmobridge/protocol";
+import type { BridgeClient, PushEvent } from "./client.js";
+/** Shape of `chat-service`'s `RelayResult`, restated so this package does not
+ *  import the server package. Kept structural on purpose: the host passes its
+ *  own function and TypeScript checks the two agree. */
+export type InProcessRelayResult = {
+    kind: "ok";
+    reply: string;
+} | {
+    kind: "error";
+    status: number;
+    message: string;
+};
+export type InProcessRelayFn = (params: {
+    transportId: string;
+    externalChatId: string;
+    text: string;
+    attachments?: Attachment[] | undefined;
+    bridgeOptions?: Readonly<Record<string, string | number | boolean>> | undefined;
+    onChunk?: ((text: string) => void) | undefined;
+}) => Promise<InProcessRelayResult>;
+/** Registers this bridge to receive server → bridge pushes. Returns the
+ *  unregister function, which `close()` calls. */
+export type RegisterInProcessPush = (transportId: string, handler: (event: PushEvent) => void) => () => void;
+export interface InProcessBridgeClientOptions {
+    transportId: string;
+    relay: InProcessRelayFn;
+    registerPush: RegisterInProcessPush;
+    /** Forwarded to the host's `startChat` exactly as the handshake bag is on the
+     *  socket path. Defaults to `{}` — an in-process bridge is configured by the
+     *  host, so there is no env to scrape on its behalf. */
+    options?: BridgeOptions;
+}
+export declare function createInProcessBridgeClient(opts: InProcessBridgeClientOptions): BridgeClient;

package/dist/inProcess.js

@@ -0,0 +1,77 @@
+// A `BridgeClient` that talks to a chat service living in the SAME process,
+// with no socket, no port and no bearer token (#3080).
+//
+// `packages/chat-service/src/relay.ts` calls itself "the shared core of the
+// bridge chat flow ... HTTP (router) and socket.io transports both call the
+// `RelayFn` this factory returns". This is the third caller of that same core,
+// so nothing new is introduced server-side — only a different way in.
+//
+// The relay and the push registration arrive as callbacks rather than imports:
+// `@mulmobridge/client` sits BELOW the server in the dependency direction and
+// must not import `@mulmoclaude/chat-service`.
+export function createInProcessBridgeClient(opts) {
+    const bridgeOptions = opts.options ?? {};
+    const pushHandlers = [];
+    const chunkHandlers = [];
+    let unregisterPush = null;
+    let closed = false;
+    const deliverPush = (event) => {
+        for (const handler of pushHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                // Per subscriber, so one bad handler does not stop the ones after it
+                // from seeing the push — and does not reach the server's stack.
+                console.error(`[${opts.transportId}] push handler threw: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    };
+    const send = async (externalChatId, text, attachments) => {
+        if (closed)
+            return { ok: false, error: "bridge client is closed" };
+        const result = await opts.relay({
+            transportId: opts.transportId,
+            externalChatId,
+            text,
+            attachments,
+            bridgeOptions,
+            // Only subscribe the relay to chunks when someone is listening, so the
+            // serialiser is not paying for a stream nobody reads.
+            onChunk: chunkHandlers.length > 0 ? (chunk) => chunkHandlers.forEach((handler) => handler(chunk)) : undefined,
+        });
+        return result.kind === "ok" ? { ok: true, reply: result.reply } : { ok: false, error: result.message, status: result.status };
+    };
+    return {
+        send,
+        onPush(handler) {
+            pushHandlers.push(handler);
+            // Registered on the FIRST subscriber so a bridge that never listens costs
+            // the host nothing, and only once however many handlers are added.
+            unregisterPush ??= opts.registerPush(opts.transportId, deliverPush);
+        },
+        onTextChunk(handler) {
+            chunkHandlers.push(handler);
+        },
+        // There is no socket, so there is no connection to gain or lose. An
+        // in-process bridge is connected from the moment it is constructed.
+        onConnect(handler) {
+            handler();
+        },
+        onDisconnect() { },
+        close() {
+            closed = true;
+            unregisterPush?.();
+            unregisterPush = null;
+            pushHandlers.length = 0;
+            chunkHandlers.length = 0;
+        },
+        get socket() {
+            // Deliberately loud rather than null. Measured across all 25 bridges: none
+            // reads `.socket`, so the first caller to do so is writing new code against
+            // an assumption that does not hold here, and a null would surface as an
+            // unrelated TypeError somewhere downstream.
+            throw new Error("in-process bridge client has no socket — see packages/client/src/inProcess.ts");
+        },
+    };
+}

package/dist/index.d.ts

@@ -8,3 +8,4 @@ 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";
 export { installProcessGuards, SHUTDOWN_GRACE_MS, type ProcessGuardOptions, type ShutdownTask } from "./processGuards.js";
+export { createInProcessBridgeClient, type InProcessBridgeClientOptions, type InProcessRelayFn, type InProcessRelayResult, type RegisterInProcessPush, } from "./inProcess.js";

package/dist/index.js

@@ -9,3 +9,4 @@ export { asJsonRecord, fetchJsonRecord } from "./http.js";
 export { formatAckReply } from "./reply.js";
 export { mimeFromExtension, isImageMime, isPdfMime, isSupportedAttachmentMime, isNativeAttachmentMime, parseDataUrl, buildDataUrl, } from "./mime.js";
 export { installProcessGuards, SHUTDOWN_GRACE_MS } from "./processGuards.js";
+export { createInProcessBridgeClient, } from "./inProcess.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/client",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Socket.io client library for MulmoBridge — shared by all bridge implementations",
   "type": "module",
   "main": "./dist/index.js",
@@ -50,7 +50,7 @@
     "socket.io-client": "^4.0.0"
   },
   "devDependencies": {
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.5.1",
     "typescript": "^6.0.3"
   },
   "homepage": "https://github.com/receptron/mulmoclaude/tree/main/packages/client#readme",