@masons/agent-network 0.5.28 → 0.5.30

package/dist/broker/reconnecting-buffer.js

@@ -0,0 +1,107 @@
+import { closeSync, fdatasyncSync, mkdirSync, openSync, readFileSync, unlinkSync, writeSync, } from "node:fs";
+import { join } from "node:path";
+class FileBackedBuffer {
+    path;
+    cached = null;
+    constructor(path) {
+        this.path = path;
+    }
+    append(msg) {
+        const line = `${JSON.stringify(msg)}\n`;
+        try {
+            mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        }
+        catch {
+        }
+        const fd = openSync(this.path, "a", 0o600);
+        try {
+            writeSync(fd, line);
+            fdatasyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        this.cached = null;
+    }
+    read() {
+        if (this.cached !== null)
+            return [...this.cached];
+        let raw;
+        try {
+            raw = readFileSync(this.path, "utf8");
+        }
+        catch (err) {
+            if (isNodeErr(err, "ENOENT")) {
+                this.cached = [];
+                return [];
+            }
+            throw err;
+        }
+        const lines = raw.split("\n").filter((l) => l.length > 0);
+        const parsed = [];
+        for (const line of lines) {
+            try {
+                parsed.push(JSON.parse(line));
+            }
+            catch {
+            }
+        }
+        this.cached = parsed;
+        return [...parsed];
+    }
+    drain() {
+        const out = this.read();
+        this.delete();
+        return out;
+    }
+    delete() {
+        try {
+            unlinkSync(this.path);
+        }
+        catch (err) {
+            if (isNodeErr(err, "ENOENT")) {
+            }
+            else {
+                throw err;
+            }
+        }
+        this.cached = [];
+    }
+    size() {
+        if (this.cached !== null)
+            return this.cached.length;
+        return this.read().length;
+    }
+}
+export function createReconnectingBufferManager(buffersDir) {
+    const cache = new Map();
+    return {
+        forEndpoint(endpoint_id) {
+            let buf = cache.get(endpoint_id);
+            if (!buf) {
+                buf = new FileBackedBuffer(join(buffersDir, `${sanitizeId(endpoint_id)}.ndjson`));
+                cache.set(endpoint_id, buf);
+            }
+            return buf;
+        },
+        cleanup(endpoint_id) {
+            const buf = cache.get(endpoint_id);
+            if (buf)
+                buf.delete();
+            cache.delete(endpoint_id);
+        },
+    };
+}
+function sanitizeId(id) {
+    return id.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function dirname(p) {
+    const idx = p.lastIndexOf("/");
+    return idx >= 0 ? p.slice(0, idx) : ".";
+}
+function isNodeErr(err, code) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        err.code === code);
+}

package/dist/broker/routing-table.d.ts

@@ -0,0 +1,22 @@
+import type { BrokerEndpointEntry, EndpointRegistry } from "./endpoint-registry.js";
+export interface InboundMessageMeta {
+    target_endpoint_id?: string;
+    correlation_id?: string;
+}
+export type RouteResult = {
+    kind: "endpoint";
+    entry: BrokerEndpointEntry;
+    via: "target_endpoint_id" | "correlation_id";
+} | {
+    kind: "no_match";
+};
+export interface RoutingTableOptions {
+    onCollision?: (correlation_id: string, count: number) => void;
+}
+export declare class RoutingTable {
+    private readonly registry;
+    private readonly opts;
+    constructor(registry: EndpointRegistry, opts?: RoutingTableOptions);
+    route(meta: InboundMessageMeta): RouteResult;
+}
+//# sourceMappingURL=routing-table.d.ts.map

package/dist/broker/routing-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-table.d.ts","sourceRoot":"","sources":["../../src/broker/routing-table.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,kBAAkB;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,WAAW,GACnB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,GAAG,EAAE,oBAAoB,GAAG,gBAAgB,CAAC;CAC9C,GACD;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB,MAAM,WAAW,mBAAmB;IAElC,WAAW,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/D;AAED,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBADJ,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,GAAE,mBAAwB;IASjD,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW;CAmC7C"}

package/dist/broker/routing-table.js

@@ -0,0 +1,35 @@
+export class RoutingTable {
+    registry;
+    opts;
+    constructor(registry, opts = {}) {
+        this.registry = registry;
+        this.opts = opts;
+    }
+    route(meta) {
+        if (meta.target_endpoint_id) {
+            const entry = this.registry.get(meta.target_endpoint_id);
+            if (entry) {
+                return { kind: "endpoint", entry, via: "target_endpoint_id" };
+            }
+        }
+        if (meta.correlation_id) {
+            let matched;
+            let collisionCount = 0;
+            for (const entry of this.registry.list()) {
+                if (entry.correlation_ring.has(meta.correlation_id)) {
+                    collisionCount++;
+                    if (!matched) {
+                        matched = entry;
+                    }
+                }
+            }
+            if (collisionCount > 1 && this.opts.onCollision) {
+                this.opts.onCollision(meta.correlation_id, collisionCount);
+            }
+            if (matched) {
+                return { kind: "endpoint", entry: matched, via: "correlation_id" };
+            }
+        }
+        return { kind: "no_match" };
+    }
+}

package/dist/broker/runtime-endpoint-port.d.ts

@@ -0,0 +1,8 @@
+import type { RegisterRuntimeEndpointParams, RegisterRuntimeEndpointResponse, TransitionRuntimeEndpointStateParams } from "../runtime-endpoint-client.js";
+export interface RuntimeEndpointPort {
+    register(params: RegisterRuntimeEndpointParams): Promise<RegisterRuntimeEndpointResponse>;
+    heartbeat(endpointId: string): Promise<void>;
+    unregister(endpointId: string, asNodeId?: string): Promise<void>;
+    transitionState(endpointId: string, params: TransitionRuntimeEndpointStateParams): Promise<void>;
+}
+//# sourceMappingURL=runtime-endpoint-port.d.ts.map

package/dist/broker/runtime-endpoint-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-endpoint-port.d.ts","sourceRoot":"","sources":["../../src/broker/runtime-endpoint-port.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,6BAA6B,EAC7B,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CACN,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAC5C,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAO7C,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAQjE,eAAe,CACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,oCAAoC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB"}

package/dist/broker/runtime-endpoint-port.js

@@ -0,0 +1 @@
+export {};

package/dist/broker/undispatched-inbox.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_INBOX_CAPACITY = 256;
+export interface UndispatchedMessage {
+    id: string;
+    arrived_at: string;
+    sender_address: string;
+    content: string;
+    content_type: string;
+    metadata: Record<string, unknown>;
+    reason: "unaddressed" | "closed_session_continuation";
+    original_target_endpoint_id?: string;
+    original_correlation_id?: string;
+}
+export interface UndispatchedInbox {
+    tryAdd(msg: UndispatchedMessage): boolean;
+    list(): UndispatchedMessage[];
+    get(id: string): UndispatchedMessage | undefined;
+    take(id: string): UndispatchedMessage | undefined;
+    size(): number;
+    capacity(): number;
+    isUnderPressure(): boolean;
+}
+export interface UndispatchedInboxOptions {
+    capacity?: number;
+}
+export declare function createUndispatchedInbox(opts?: UndispatchedInboxOptions): UndispatchedInbox;
+//# sourceMappingURL=undispatched-inbox.d.ts.map

package/dist/broker/undispatched-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undispatched-inbox.d.ts","sourceRoot":"","sources":["../../src/broker/undispatched-inbox.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMlC,MAAM,EAAE,aAAa,GAAG,6BAA6B,CAAC;IAEtD,2BAA2B,CAAC,EAAE,MAAM,CAAC;IAErC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAMhC,MAAM,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC;IAE1C,IAAI,IAAI,mBAAmB,EAAE,CAAC;IAE9B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAKjD,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAElD,IAAI,IAAI,MAAM,CAAC;IAEf,QAAQ,IAAI,MAAM,CAAC;IAEnB,eAAe,IAAI,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,GAAE,wBAA6B,GAClC,iBAAiB,CAkDnB"}

package/dist/broker/undispatched-inbox.js

@@ -0,0 +1,53 @@
+export const DEFAULT_INBOX_CAPACITY = 256;
+export function createUndispatchedInbox(opts = {}) {
+    const cap = opts.capacity ?? DEFAULT_INBOX_CAPACITY;
+    if (cap <= 0)
+        throw new Error(`capacity must be positive: ${cap}`);
+    const byId = new Map();
+    const order = [];
+    return {
+        tryAdd(msg) {
+            if (byId.has(msg.id)) {
+                byId.set(msg.id, msg);
+                return true;
+            }
+            if (byId.size >= cap) {
+                return false;
+            }
+            byId.set(msg.id, msg);
+            order.push(msg.id);
+            return true;
+        },
+        list() {
+            const out = [];
+            for (const id of order) {
+                const m = byId.get(id);
+                if (m)
+                    out.push(m);
+            }
+            return out;
+        },
+        get(id) {
+            return byId.get(id);
+        },
+        take(id) {
+            const m = byId.get(id);
+            if (!m)
+                return undefined;
+            byId.delete(id);
+            const idx = order.indexOf(id);
+            if (idx >= 0)
+                order.splice(idx, 1);
+            return m;
+        },
+        size() {
+            return byId.size;
+        },
+        capacity() {
+            return cap;
+        },
+        isUnderPressure() {
+            return byId.size >= Math.floor(cap * 0.9);
+        },
+    };
+}

package/dist/broker/version-handshake.d.ts

@@ -0,0 +1,30 @@
+export declare const IPC_PROTOCOL_VERSION = "1.0";
+export interface IpcCapabilities {
+    endpoint_metadata_v1?: boolean;
+    remote_spawn_v1?: boolean;
+    undispatched_inbox_v1?: boolean;
+}
+export declare const SERVER_CAPABILITIES: Readonly<IpcCapabilities>;
+export interface InitializeRequestBody {
+    client_protocol_version: string;
+    client_kind: string;
+    client_version: string;
+    capabilities?: IpcCapabilities;
+}
+export interface InitializeResponseBody {
+    server_protocol_version: string;
+    server_capabilities: IpcCapabilities;
+    session_id: string;
+}
+export interface InitializeErrorBody {
+    error: "protocol_version_mismatch" | "bad_request";
+    message: string;
+}
+export declare function handleInitialize(req: InitializeRequestBody): {
+    status: 200;
+    body: InitializeResponseBody;
+} | {
+    status: 400;
+    body: InitializeErrorBody;
+};
+//# sourceMappingURL=version-handshake.d.ts.map

package/dist/broker/version-handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-handshake.d.ts","sourceRoot":"","sources":["../../src/broker/version-handshake.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAM1C,MAAM,WAAW,eAAe;IAE9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAG1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAGD,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,eAAe,CAIxD,CAAC;AAEH,MAAM,WAAW,qBAAqB;IAEpC,uBAAuB,EAAE,MAAM,CAAC;IAEhC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,uBAAuB,EAAE,MAAM,CAAC;IAChC,mBAAmB,EAAE,eAAe,CAAC;IAErC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,2BAA2B,GAAG,aAAa,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,qBAAqB,GAExB;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,GAC7C;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,mBAAmB,CAAA;CAAE,CA0C7C"}

package/dist/broker/version-handshake.js

@@ -0,0 +1,47 @@
+import { randomUUID } from "node:crypto";
+export const IPC_PROTOCOL_VERSION = "1.0";
+export const SERVER_CAPABILITIES = Object.freeze({
+    endpoint_metadata_v1: true,
+    remote_spawn_v1: false,
+    undispatched_inbox_v1: false,
+});
+export function handleInitialize(req) {
+    if (typeof req.client_protocol_version !== "string") {
+        return {
+            status: 400,
+            body: {
+                error: "bad_request",
+                message: "client_protocol_version is required and must be a string",
+            },
+        };
+    }
+    if (typeof req.client_kind !== "string" || !req.client_kind) {
+        return {
+            status: 400,
+            body: {
+                error: "bad_request",
+                message: "client_kind is required and must be a non-empty string",
+            },
+        };
+    }
+    const clientMajor = req.client_protocol_version.split(".")[0];
+    const serverMajor = IPC_PROTOCOL_VERSION.split(".")[0];
+    if (clientMajor !== serverMajor) {
+        return {
+            status: 400,
+            body: {
+                error: "protocol_version_mismatch",
+                message: `broker IPC protocol major ${serverMajor} does not match client ` +
+                    `protocol major ${clientMajor}`,
+            },
+        };
+    }
+    return {
+        status: 200,
+        body: {
+            server_protocol_version: IPC_PROTOCOL_VERSION,
+            server_capabilities: { ...SERVER_CAPABILITIES },
+            session_id: randomUUID(),
+        },
+    };
+}

package/dist/broker-client/broker-client.d.ts

@@ -0,0 +1,64 @@
+import { EventEmitter } from "node:events";
+import { type InitializeResponseBody } from "../broker/version-handshake.js";
+export interface BrokerClientDiscoverOptions {
+    accountId: string;
+    runtimeToken: string;
+    userDataDir?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    brokerEntry?: string;
+    nodeBinary?: string;
+}
+export interface BrokerClientConnectOptions {
+    pluginPid: number;
+    clientKind: string;
+    clientVersion: string;
+}
+export interface RegisterEndpointArgs {
+    agentId: string;
+    kind: string;
+    sessionName?: string;
+    workspace?: string;
+    trackingRef?: string;
+    taskHint?: string;
+}
+export interface RegisterEndpointOutcome {
+    endpoint_id: string;
+}
+export interface BrokerInboundMessage {
+    from: string;
+    content: string;
+    contentType: string;
+    metadata?: Record<string, unknown>;
+}
+type Events = {
+    message_received: (msg: BrokerInboundMessage) => void;
+    disconnected: () => void;
+    error: (err: Error) => void;
+};
+export declare class BrokerClient extends EventEmitter {
+    private readonly handle;
+    private ws;
+    private pluginPid;
+    private _sessionId;
+    private constructor();
+    static discover(opts: BrokerClientDiscoverOptions): Promise<BrokerClient>;
+    get spawnedNew(): boolean;
+    get ipcUrl(): string;
+    get sessionId(): string | null;
+    connect(opts: BrokerClientConnectOptions): Promise<InitializeResponseBody>;
+    registerEndpoint(args: RegisterEndpointArgs): Promise<RegisterEndpointOutcome>;
+    send(endpointId: string, to: string, content: string, contentType?: string, metadata?: Record<string, unknown>): Promise<{
+        messageId: string;
+        status: string;
+    }>;
+    close(endpointId?: string): Promise<void>;
+    on<K extends keyof Events>(event: K, listener: Events[K]): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): boolean;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    private httpJson;
+    private handleFrame;
+}
+export {};
+//# sourceMappingURL=broker-client.d.ts.map

package/dist/broker-client/broker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker-client.d.ts","sourceRoot":"","sources":["../../src/broker-client/broker-client.ts"],"names":[],"mappings":"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"}

package/dist/broker-client/broker-client.js

@@ -0,0 +1,164 @@
+import { EventEmitter } from "node:events";
+import WebSocket from "ws";
+import { resolveBrokerPaths } from "../broker/paths.js";
+import { IPC_PROTOCOL_VERSION, } from "../broker/version-handshake.js";
+import { discoverBroker } from "./lazy-spawn.js";
+export class BrokerClient extends EventEmitter {
+    handle;
+    ws = null;
+    pluginPid = null;
+    _sessionId = null;
+    constructor(handle) {
+        super();
+        this.handle = handle;
+    }
+    static async discover(opts) {
+        const paths = resolveBrokerPaths(opts.accountId, opts.runtimeToken, {
+            userDataDir: opts.userDataDir,
+        });
+        const handle = await discoverBroker({
+            discoveryFile: paths.discoveryFile,
+            timeoutMs: opts.timeoutMs,
+            brokerEntry: opts.brokerEntry,
+            nodeBinary: opts.nodeBinary,
+            env: {
+                MASONS_BROKER_ACCOUNT_ID: opts.accountId,
+                ...(opts.userDataDir
+                    ? { MASONS_BROKER_USER_DATA: opts.userDataDir }
+                    : {}),
+                ...(opts.env ?? {}),
+            },
+        });
+        return new BrokerClient(handle);
+    }
+    get spawnedNew() {
+        return this.handle.spawned;
+    }
+    get ipcUrl() {
+        return this.handle.record.ipcUrl;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    async connect(opts) {
+        if (this.ws) {
+            throw new Error("BrokerClient already connected");
+        }
+        this.pluginPid = opts.pluginPid;
+        const initRes = await this.httpJson("POST", "/v1/initialize", {
+            client_protocol_version: IPC_PROTOCOL_VERSION,
+            client_kind: opts.clientKind,
+            client_version: opts.clientVersion,
+            capabilities: { endpoint_metadata_v1: true },
+        });
+        this._sessionId = initRes.session_id;
+        const wsUrl = `${this.handle.record.ipcUrl.replace(/^http/, "ws")}/v1/stream`;
+        const ws = new WebSocket(wsUrl, {
+            headers: {
+                Authorization: `Bearer ${this.handle.record.bearerToken}`,
+                "x-plugin-pid": String(opts.pluginPid),
+            },
+        });
+        this.ws = ws;
+        await new Promise((resolve, reject) => {
+            const onOpen = () => {
+                ws.off("error", onError);
+                resolve();
+            };
+            const onError = (err) => {
+                ws.off("open", onOpen);
+                reject(err);
+            };
+            ws.once("open", onOpen);
+            ws.once("error", onError);
+        });
+        ws.on("message", (data) => this.handleFrame(data.toString()));
+        ws.on("close", () => {
+            this.ws = null;
+            this.emit("disconnected");
+        });
+        ws.on("error", (err) => this.emit("error", err));
+        return initRes;
+    }
+    async registerEndpoint(args) {
+        if (this.pluginPid === null) {
+            throw new Error("BrokerClient.connect must be called before registerEndpoint");
+        }
+        return this.httpJson("POST", "/v1/endpoint/register", {
+            agent_id: args.agentId,
+            plugin_pid: this.pluginPid,
+            kind: args.kind,
+            session_name: args.sessionName,
+            workspace: args.workspace,
+            tracking_ref: args.trackingRef,
+            task_hint: args.taskHint,
+        });
+    }
+    async send(endpointId, to, content, contentType = "text", metadata) {
+        return this.httpJson("POST", "/v1/send", {
+            endpoint_id: endpointId,
+            to,
+            content,
+            contentType,
+            metadata,
+        });
+    }
+    async close(endpointId) {
+        if (endpointId) {
+            try {
+                await this.httpJson("DELETE", `/v1/endpoint/${encodeURIComponent(endpointId)}`);
+            }
+            catch {
+            }
+        }
+        if (this.ws &&
+            (this.ws.readyState === WebSocket.OPEN ||
+                this.ws.readyState === WebSocket.CONNECTING)) {
+            this.ws.close(1000, "client_close");
+        }
+        this.ws = null;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    async httpJson(method, path, body) {
+        const res = await fetch(`${this.handle.record.ipcUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.handle.record.bearerToken}`,
+                ...(body ? { "Content-Type": "application/json" } : {}),
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const errText = await res.text().catch(() => "");
+            throw new Error(`broker ${method} ${path} failed: ${res.status} ${errText}`);
+        }
+        return (await res.json());
+    }
+    handleFrame(raw) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            this.emit("error", new Error("BrokerClient received non-JSON frame"));
+            return;
+        }
+        if (!parsed || typeof parsed !== "object" || !("event" in parsed))
+            return;
+        const event = parsed.event;
+        if (event === "message_received") {
+            const msg = parsed;
+            this.emit("message_received", {
+                from: msg.from,
+                content: msg.content,
+                contentType: msg.contentType,
+                metadata: msg.metadata,
+            });
+        }
+    }
+}

package/dist/broker-client/lazy-spawn.d.ts

@@ -0,0 +1,18 @@
+import { type DiscoveryRecord } from "../broker/discovery-file.js";
+export interface LazySpawnOptions {
+    brokerEntry?: string;
+    env?: Record<string, string>;
+    nodeBinary?: string;
+}
+export interface DiscoverOptions extends LazySpawnOptions {
+    discoveryFile: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    forceSpawn?: boolean;
+}
+export interface DiscoveryHandle {
+    record: DiscoveryRecord;
+    spawned: boolean;
+}
+export declare function discoverBroker(opts: DiscoverOptions): Promise<DiscoveryHandle>;
+//# sourceMappingURL=lazy-spawn.d.ts.map

package/dist/broker-client/lazy-spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-spawn.d.ts","sourceRoot":"","sources":["../../src/broker-client/lazy-spawn.ts"],"names":[],"mappings":"AA0CA,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,gBAAgB;IAE/B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAMD,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IAEvD,aAAa,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,eAAe,CAAC;IAExB,OAAO,EAAE,OAAO,CAAC;CAClB;AAMD,wBAAsB,cAAc,CAClC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,eAAe,CAAC,CA8B1B"}

package/dist/broker-client/lazy-spawn.js

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { readDiscoveryFile, } from "../broker/discovery-file.js";
+const DEFAULT_POLL_INTERVAL_MS = 100;
+const DEFAULT_DISCOVER_TIMEOUT_MS = 5_000;
+const DEFAULT_HEALTH_TIMEOUT_MS = 2_000;
+export async function discoverBroker(opts) {
+    const deadline = Date.now() + (opts.timeoutMs ?? DEFAULT_DISCOVER_TIMEOUT_MS);
+    const poll = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    if (!opts.forceSpawn) {
+        const existing = readDiscoveryFile(opts.discoveryFile);
+        if (existing &&
+            (await probeHealth(existing.ipcUrl, existing.bearerToken))) {
+            return { record: existing, spawned: false };
+        }
+    }
+    spawnDaemon(opts);
+    while (Date.now() < deadline) {
+        const rec = readDiscoveryFile(opts.discoveryFile);
+        if (rec && (await probeHealth(rec.ipcUrl, rec.bearerToken))) {
+            return { record: rec, spawned: true };
+        }
+        await sleep(poll);
+    }
+    throw new Error(`broker did not become healthy within ${opts.timeoutMs ?? DEFAULT_DISCOVER_TIMEOUT_MS}ms; ` +
+        `check ${opts.discoveryFile} and the daemon log`);
+}
+function spawnDaemon(opts) {
+    const entry = opts.brokerEntry ?? resolveDefaultBrokerEntry();
+    const child = spawn(opts.nodeBinary ?? process.execPath, [entry], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env, ...(opts.env ?? {}) },
+    });
+    child.unref();
+}
+function resolveDefaultBrokerEntry() {
+    const self = fileURLToPath(import.meta.url);
+    return self.replace(/broker-client\/lazy-spawn\.(c?js|ts)$/, "broker/entry.$1");
+}
+async function probeHealth(ipcUrl, bearerToken) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), DEFAULT_HEALTH_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${ipcUrl}/health`, {
+            headers: { Authorization: `Bearer ${bearerToken}` },
+            signal: ctrl.signal,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}