@masons/runtime-broker 0.1.0

package/dist/broker/paths.js

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import envPaths from "env-paths";
+const AGENT_IDENTITY_HEX_LEN = 16;
+const ENV_PATHS_NAME = "masons-runtime-broker";
+export function resolveBrokerPaths(principal, runtimeToken, opts = {}) {
+    if (!principal) {
+        throw new Error("principal must be a non-empty string");
+    }
+    if (!runtimeToken) {
+        throw new Error("runtimeToken must be a non-empty string");
+    }
+    const userData = opts.userDataDir ?? envPaths(ENV_PATHS_NAME, { suffix: "" }).data;
+    const agentIdentity = createHash("sha256")
+        .update(runtimeToken, "utf8")
+        .digest("hex")
+        .slice(0, AGENT_IDENTITY_HEX_LEN);
+    const discoveryDir = join(userData, "runtime-broker", sanitizeSegment(principal), agentIdentity);
+    const logDir = join(userData, "runtime-broker", "log");
+    const buffersDir = join(discoveryDir, "buffers");
+    return {
+        discoveryFile: join(discoveryDir, "discovery.json"),
+        discoveryDir,
+        logDir,
+        buffersDir,
+    };
+}
+function sanitizeSegment(segment) {
+    return segment.replace(/[^a-zA-Z0-9._-]/g, "_");
+}

package/dist/broker/plugin-liveness.d.ts

@@ -0,0 +1,2 @@
+export declare function isPluginAlive(plugin_pid: number): boolean;
+//# sourceMappingURL=plugin-liveness.d.ts.map

package/dist/broker/plugin-liveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-liveness.d.ts","sourceRoot":"","sources":["../../src/broker/plugin-liveness.ts"],"names":[],"mappings":"AAyBA,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAiBzD"}

package/dist/broker/plugin-liveness.js

@@ -0,0 +1,15 @@
+export function isPluginAlive(plugin_pid) {
+    if (!Number.isFinite(plugin_pid) || plugin_pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(plugin_pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ESRCH")
+            return false;
+        return true;
+    }
+}

package/dist/broker/received-message-correlation-cache.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_TTL_MS = 86400000;
+export declare const DEFAULT_CAP_PER_ENDPOINT = 1000;
+export interface ReceivedMessageCorrelationCacheOptions {
+    ttlMs?: number;
+    capPerEndpoint?: number;
+    now?: () => number;
+}
+export type ReplyAwareResolve = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "unknown_correlation_id" | "wrong_endpoint" | "ttl_expired";
+};
+export interface ReceivedMessageCorrelationCache {
+    record(endpoint_id: string, correlation_id: string): void;
+    resolve(endpoint_id: string, correlation_id: string): ReplyAwareResolve;
+    size(): number;
+    sizeForEndpoint(endpoint_id: string): number;
+    sweep(now?: number): number;
+    forgetEndpoint(endpoint_id: string): void;
+}
+export declare function createReceivedMessageCorrelationCache(opts?: ReceivedMessageCorrelationCacheOptions): ReceivedMessageCorrelationCache;
+//# sourceMappingURL=received-message-correlation-cache.d.ts.map

package/dist/broker/received-message-correlation-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"received-message-correlation-cache.d.ts","sourceRoot":"","sources":["../../src/broker/received-message-correlation-cache.ts"],"names":[],"mappings":"AA8DA,eAAO,MAAM,cAAc,WAAa,CAAC;AAGzC,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,MAAM,WAAW,sCAAsC;IAErD,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IACE,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,wBAAwB,GAAG,gBAAgB,GAAG,aAAa,CAAC;CACrE,CAAC;AAMN,MAAM,WAAW,+BAA+B;IAa9C,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAQ1D,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,iBAAiB,CAAC;IAGxE,IAAI,IAAI,MAAM,CAAC;IAGf,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAQ7C,KAAK,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAM5B,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,wBAAgB,qCAAqC,CACnD,IAAI,GAAE,sCAA2C,GAChD,+BAA+B,CAgIjC"}

package/dist/broker/received-message-correlation-cache.js

@@ -0,0 +1,114 @@
+export const DEFAULT_TTL_MS = 86_400_000;
+export const DEFAULT_CAP_PER_ENDPOINT = 1000;
+export function createReceivedMessageCorrelationCache(opts = {}) {
+    const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    const cap = opts.capPerEndpoint ?? DEFAULT_CAP_PER_ENDPOINT;
+    const clock = opts.now ?? Date.now;
+    if (ttlMs <= 0)
+        throw new Error(`ttlMs must be positive: ${ttlMs}`);
+    if (cap <= 0)
+        throw new Error(`capPerEndpoint must be positive: ${cap}`);
+    const perEndpoint = new Map();
+    const correlationOwner = new Map();
+    const evict = (endpoint_id, correlation_id) => {
+        const inner = perEndpoint.get(endpoint_id);
+        if (!inner)
+            return;
+        inner.delete(correlation_id);
+        if (inner.size === 0)
+            perEndpoint.delete(endpoint_id);
+        if (correlationOwner.get(correlation_id) === endpoint_id) {
+            correlationOwner.delete(correlation_id);
+        }
+    };
+    return {
+        record(endpoint_id, correlation_id) {
+            const priorOwner = correlationOwner.get(correlation_id);
+            if (priorOwner && priorOwner !== endpoint_id) {
+                const priorInner = perEndpoint.get(priorOwner);
+                priorInner?.delete(correlation_id);
+                if (priorInner && priorInner.size === 0) {
+                    perEndpoint.delete(priorOwner);
+                }
+            }
+            let inner = perEndpoint.get(endpoint_id);
+            if (!inner) {
+                inner = new Map();
+                perEndpoint.set(endpoint_id, inner);
+            }
+            inner.delete(correlation_id);
+            inner.set(correlation_id, { received_at: clock() });
+            correlationOwner.set(correlation_id, endpoint_id);
+            while (inner.size > cap) {
+                const oldestKey = inner.keys().next().value;
+                if (oldestKey === undefined)
+                    break;
+                inner.delete(oldestKey);
+                if (correlationOwner.get(oldestKey) === endpoint_id) {
+                    correlationOwner.delete(oldestKey);
+                }
+            }
+        },
+        resolve(endpoint_id, correlation_id) {
+            const owner = correlationOwner.get(correlation_id);
+            if (!owner) {
+                return { ok: false, reason: "unknown_correlation_id" };
+            }
+            if (owner !== endpoint_id) {
+                return { ok: false, reason: "wrong_endpoint" };
+            }
+            const inner = perEndpoint.get(endpoint_id);
+            const entry = inner?.get(correlation_id);
+            if (!entry) {
+                correlationOwner.delete(correlation_id);
+                return { ok: false, reason: "unknown_correlation_id" };
+            }
+            if (clock() - entry.received_at >= ttlMs) {
+                evict(endpoint_id, correlation_id);
+                return { ok: false, reason: "ttl_expired" };
+            }
+            return { ok: true };
+        },
+        size() {
+            let total = 0;
+            for (const inner of perEndpoint.values())
+                total += inner.size;
+            return total;
+        },
+        sizeForEndpoint(endpoint_id) {
+            return perEndpoint.get(endpoint_id)?.size ?? 0;
+        },
+        sweep(now = clock()) {
+            let evicted = 0;
+            for (const [endpoint_id, inner] of perEndpoint) {
+                const expired = [];
+                for (const [correlation_id, entry] of inner) {
+                    if (now - entry.received_at >= ttlMs) {
+                        expired.push(correlation_id);
+                    }
+                }
+                for (const correlation_id of expired) {
+                    inner.delete(correlation_id);
+                    if (correlationOwner.get(correlation_id) === endpoint_id) {
+                        correlationOwner.delete(correlation_id);
+                    }
+                    evicted++;
+                }
+                if (inner.size === 0)
+                    perEndpoint.delete(endpoint_id);
+            }
+            return evicted;
+        },
+        forgetEndpoint(endpoint_id) {
+            const inner = perEndpoint.get(endpoint_id);
+            if (!inner)
+                return;
+            for (const correlation_id of inner.keys()) {
+                if (correlationOwner.get(correlation_id) === endpoint_id) {
+                    correlationOwner.delete(correlation_id);
+                }
+            }
+            perEndpoint.delete(endpoint_id);
+        },
+    };
+}

package/dist/broker/reconnecting-buffer.d.ts

@@ -0,0 +1,23 @@
+export interface BufferedMessage {
+    id: string;
+    arrived_at: string;
+    envelope: {
+        from: string;
+        content: string;
+        contentType: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+export interface ReconnectingBuffer {
+    append(msg: BufferedMessage): void;
+    read(): BufferedMessage[];
+    drain(): BufferedMessage[];
+    delete(): void;
+    size(): number;
+}
+export interface ReconnectingBufferManager {
+    forEndpoint(endpoint_id: string): ReconnectingBuffer;
+    cleanup(endpoint_id: string): void;
+}
+export declare function createReconnectingBufferManager(buffersDir: string): ReconnectingBufferManager;
+//# sourceMappingURL=reconnecting-buffer.d.ts.map

package/dist/broker/reconnecting-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnecting-buffer.d.ts","sourceRoot":"","sources":["../../src/broker/reconnecting-buffer.ts"],"names":[],"mappings":"AA+CA,MAAM,WAAW,eAAe;IAE9B,EAAE,EAAE,MAAM,CAAC;IAEX,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IAEjC,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAAC;IAEnC,IAAI,IAAI,eAAe,EAAE,CAAC;IAE1B,KAAK,IAAI,eAAe,EAAE,CAAC;IAE3B,MAAM,IAAI,IAAI,CAAC;IAEf,IAAI,IAAI,MAAM,CAAC;CAChB;AA8ED,MAAM,WAAW,yBAAyB;IAExC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAAC;IAErD,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,MAAM,GACjB,yBAAyB,CAmB3B"}

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,20 @@
+import type { RegisterRuntimeEndpointParams, RegisterRuntimeEndpointResponse, TransitionRuntimeEndpointStateParams } from "../runtime-endpoint-client.js";
+import type { NetworkPresenceChangedEvent } from "./network-presence-changed-event-types.js";
+import type { UndispatchedChangedEvent } from "./undispatched-changed-event-types.js";
+export type EmitOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    terminal: boolean;
+    status?: number;
+    detail?: string;
+};
+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>;
+    emitUndispatchedChanged?(event: UndispatchedChangedEvent): Promise<EmitOutcome>;
+    emitNetworkPresenceChanged?(event: NetworkPresenceChangedEvent): Promise<EmitOutcome>;
+}
+//# 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;AACvC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAWtF,MAAM,MAAM,WAAW,GACnB;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,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;IAqBjB,uBAAuB,CAAC,CACtB,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,WAAW,CAAC,CAAC;IAYxB,0BAA0B,CAAC,CACzB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}

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

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

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

@@ -0,0 +1,21 @@
+import type { ControlEventDispatcher } from "./control-event-dispatcher.js";
+import type { BrokerLogger } from "./logger.js";
+export declare const DEFAULT_BACKOFF_INITIAL_MS = 1000;
+export declare const DEFAULT_BACKOFF_MAX_MS = 30000;
+export interface ServicesEventClientOptions {
+    apiHost: string;
+    runtimeKey: string;
+    agentId: string;
+    dispatcher: ControlEventDispatcher;
+    logger: BrokerLogger;
+    fetchImpl?: typeof globalThis.fetch;
+    backoffInitialMs?: number;
+    backoffMaxMs?: number;
+}
+export interface ServicesEventClient {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    lastSeenKey(): string | undefined;
+}
+export declare function createServicesEventClient(opts: ServicesEventClientOptions): ServicesEventClient;
+//# sourceMappingURL=services-event-client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"services-event-client.d.ts","sourceRoot":"","sources":["../../src/broker/services-event-client.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAChD,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C,MAAM,WAAW,0BAA0B;IAEzC,OAAO,EAAE,MAAM,CAAC;IAEhB,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAEhB,UAAU,EAAE,sBAAsB,CAAC;IAEnC,MAAM,EAAE,YAAY,CAAC;IAErB,SAAS,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAEpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IASlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB,WAAW,IAAI,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,0BAA0B,GAC/B,mBAAmB,CAuMrB"}

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

@@ -0,0 +1,221 @@
+export const DEFAULT_BACKOFF_INITIAL_MS = 1_000;
+export const DEFAULT_BACKOFF_MAX_MS = 30_000;
+export function createServicesEventClient(opts) {
+    const { dispatcher, logger } = opts;
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const backoffInitial = opts.backoffInitialMs ?? DEFAULT_BACKOFF_INITIAL_MS;
+    const backoffMax = opts.backoffMaxMs ?? DEFAULT_BACKOFF_MAX_MS;
+    let stopped = false;
+    let lastEventId;
+    let currentAbort = null;
+    let backoffMs = backoffInitial;
+    let loopPromise = null;
+    let started = false;
+    const baseUrl = makeBaseUrl(opts.apiHost);
+    const subscribeOnce = async () => {
+        const ctrl = new AbortController();
+        currentAbort = ctrl;
+        const url = new URL(`${baseUrl}/runtime/control-events`);
+        url.searchParams.set("agent_id", opts.agentId);
+        const headers = {
+            Authorization: `Bearer ${opts.runtimeKey}`,
+            Accept: "text/event-stream",
+        };
+        if (lastEventId)
+            headers["Last-Event-ID"] = lastEventId;
+        const res = await fetchImpl(url.toString(), {
+            method: "GET",
+            headers,
+            signal: ctrl.signal,
+        });
+        if (!res.ok || !res.body) {
+            throw new Error(`SSE subscribe failed: ${res.status}`);
+        }
+        backoffMs = backoffInitial;
+        const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += value.replace(/\r\n?/g, "\n");
+            let sep = buffer.indexOf("\n\n");
+            while (sep >= 0) {
+                const frame = buffer.slice(0, sep);
+                buffer = buffer.slice(sep + 2);
+                await handleFrame(frame).catch((err) => {
+                    logger.warn("sse_frame_error", {
+                        err: err instanceof Error ? err.message : String(err),
+                    });
+                });
+                sep = buffer.indexOf("\n\n");
+            }
+        }
+    };
+    const handleFrame = async (frame) => {
+        let id;
+        const dataLines = [];
+        for (const line of frame.split("\n")) {
+            if (line === "" || line.startsWith(":"))
+                continue;
+            const colon = line.indexOf(":");
+            const field = colon === -1 ? line : line.slice(0, colon);
+            let value = colon === -1 ? "" : line.slice(colon + 1);
+            if (value.startsWith(" "))
+                value = value.slice(1);
+            if (field === "id")
+                id = value;
+            else if (field === "data")
+                dataLines.push(value);
+        }
+        if (dataLines.length === 0)
+            return;
+        const data = dataLines.join("\n");
+        if (id)
+            lastEventId = id;
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            logger.warn("sse_frame_unparseable", { data: data.slice(0, 80) });
+            return;
+        }
+        if (hasIdempotencyKey(parsed) && hasUnsupportedVersion(parsed)) {
+            await postAck({
+                idempotency_key: parsed.idempotency_key,
+                status: "failed",
+                detail: "unsupported_protocol_version",
+            });
+            return;
+        }
+        if (!isControlEvent(parsed)) {
+            if (hasIdempotencyKey(parsed)) {
+                await postAck({
+                    idempotency_key: parsed.idempotency_key,
+                    status: "applied",
+                    detail: "unknown_variant_dropped",
+                });
+            }
+            return;
+        }
+        const outcome = await dispatcher.dispatch(parsed);
+        await postAck(outcomeToAck(parsed.idempotency_key, outcome));
+    };
+    const postAck = async (ack) => {
+        try {
+            const res = await fetchImpl(`${baseUrl}/runtime/control-ack`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${opts.runtimeKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(ack),
+            });
+            if (!res.ok) {
+                logger.warn("ack_post_failed", {
+                    status: res.status,
+                    idempotency_key: ack.idempotency_key,
+                });
+            }
+        }
+        catch (err) {
+            logger.warn("ack_post_error", {
+                err: err instanceof Error ? err.message : String(err),
+                idempotency_key: ack.idempotency_key,
+            });
+        }
+    };
+    const loop = async () => {
+        while (!stopped) {
+            try {
+                await subscribeOnce();
+            }
+            catch (err) {
+                if (stopped)
+                    return;
+                logger.warn("sse_reconnect", {
+                    backoff_ms: backoffMs,
+                    err: err instanceof Error ? err.message : String(err),
+                });
+            }
+            if (stopped)
+                return;
+            await sleep(backoffMs);
+            backoffMs = Math.min(backoffMs * 2, backoffMax);
+        }
+    };
+    return {
+        async start() {
+            if (started)
+                return;
+            started = true;
+            stopped = false;
+            loopPromise = loop();
+        },
+        async stop() {
+            stopped = true;
+            if (currentAbort) {
+                try {
+                    currentAbort.abort();
+                }
+                catch {
+                }
+            }
+            if (loopPromise) {
+                await loopPromise.catch(() => { });
+            }
+        },
+        lastSeenKey() {
+            return lastEventId;
+        },
+    };
+}
+function outcomeToAck(idempotency_key, outcome) {
+    if (outcome.ok) {
+        if (outcome.ack_hint === "received") {
+            return { idempotency_key, status: "received" };
+        }
+        return { idempotency_key, status: "applied" };
+    }
+    return {
+        idempotency_key,
+        status: "failed",
+        detail: outcome.detail,
+    };
+}
+function isControlEvent(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    if (v.version !== 1)
+        return false;
+    if (typeof v.idempotency_key !== "string")
+        return false;
+    if (typeof v.emitted_at !== "number")
+        return false;
+    if (typeof v.type !== "string")
+        return false;
+    return (v.type === "dispatch_undispatched" ||
+        v.type === "spawn_request" ||
+        v.type === "force_unregister");
+}
+function hasIdempotencyKey(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.idempotency_key === "string");
+}
+function hasUnsupportedVersion(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return typeof v.version === "number" && v.version !== 1;
+}
+function makeBaseUrl(apiHost) {
+    const trimmed = apiHost.replace(/\/+$/, "");
+    const origin = /^https?:\/\//.test(trimmed) ? trimmed : `https://${trimmed}`;
+    return `${origin}/v1`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}