@beeuni/sdk 0.1.0

package/dist/core/stream/event-stream.js

@@ -0,0 +1,372 @@
+import { getSupabaseAccessToken, invalidateTokenCache } from '../http/auth.js';
+import { getClientForUrl } from '../runtime/client.js';
+import { isAuthFailure } from '../http/api/errors.js';
+import { logger } from '../http/logger.js';
+const realTimers = {
+    now: () => Date.now(),
+    setTimeout: (handler, timeoutMs) => setTimeout(handler, timeoutMs),
+    clearTimeout: (handle) => clearTimeout(handle),
+    random: () => Math.random(),
+};
+const COALESCE_FLUSH_MS = 16;
+const YIELD_INTERVAL_MS = 8;
+const HEARTBEAT_MS = 60_000;
+const GAP_REHYDRATE_MS = 5_000;
+const FAST_RECONNECT_DELAY_MS = 250;
+const BASE_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
+const MAX_BACKOFF_EXPONENT = 5;
+const STABLE_LIFETIME_MS = 10_000;
+const MAX_CONSECUTIVE_SHORT_STABLE = 4;
+const RECONNECT_JITTER = 0.5;
+const SSE_DEFAULT_RETRY_DELAY_MS = 3000;
+const SSE_MAX_RETRY_DELAY_MS = 30_000;
+const CONNECT_TIMEOUT_MS = 20_000;
+const HARD_FAILURE_WINDOW_MS = 2_000;
+const MAX_CONSECUTIVE_HARD_FAILURES = 8;
+function getCoalesceKey(event) {
+    if (event.type === 'session.status') {
+        return `session.status:${event.properties.sessionID}`;
+    }
+    if (event.type === 'lsp.updated')
+        return 'lsp.updated';
+    return undefined;
+}
+function mergePartDelta(tail, next) {
+    if (tail?.type !== 'message.part.delta' || next.type !== 'message.part.delta')
+        return undefined;
+    const a = tail.properties;
+    const b = next.properties;
+    if (a.partID !== b.partID ||
+        a.field !== b.field ||
+        a.messageID !== b.messageID ||
+        a.sessionID !== b.sessionID) {
+        return undefined;
+    }
+    const wire = tail.coalesced ?? [tail];
+    wire.push(next);
+    return { ...next, properties: { ...b, delta: a.delta + b.delta }, coalesced: wire };
+}
+function onceAborted(signal) {
+    if (signal.aborted)
+        return { promise: Promise.resolve(), cleanup: () => { } };
+    let handler = () => { };
+    const promise = new Promise((resolve) => {
+        handler = () => resolve();
+        signal.addEventListener('abort', handler, { once: true });
+    });
+    return { promise, cleanup: () => signal.removeEventListener('abort', handler) };
+}
+const liveStreamsByClient = new WeakMap();
+function createLiveStream(client, opts, subscribers) {
+    const t = opts.timers ?? realTimers;
+    const connectTimeoutMs = opts.connectTimeoutMs ?? CONNECT_TIMEOUT_MS;
+    const heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? HEARTBEAT_MS;
+    const maxConsecutiveHardFailures = opts.maxConsecutiveHardFailures ?? MAX_CONSECUTIVE_HARD_FAILURES;
+    const abortController = new AbortController();
+    function dispatchToSubscribers(pick, ...args) {
+        for (const sub of subscribers) {
+            const fn = pick(sub);
+            if (!fn)
+                continue;
+            try {
+                fn(...args);
+            }
+            catch (e) {
+                console.warn('[opencode-events] subscriber handler threw, skipping', e);
+            }
+        }
+    }
+    let connectionState = null;
+    let parked = false;
+    const setConnectionState = (state) => {
+        if (connectionState === state)
+            return;
+        connectionState = state;
+        if (state)
+            dispatchToSubscribers((sub) => sub.onConnectionChange, state);
+    };
+    let lastStreamActivityTime = t.now();
+    let pendingGap = null;
+    let queue = [];
+    let flushTimer;
+    let lastFlush = 0;
+    const coalesced = new Map();
+    const flush = () => {
+        if (flushTimer)
+            t.clearTimeout(flushTimer);
+        flushTimer = undefined;
+        if (queue.length === 0)
+            return;
+        const events = queue;
+        queue = [];
+        coalesced.clear();
+        lastFlush = t.now();
+        lastStreamActivityTime = t.now();
+        for (const item of events) {
+            if (!item)
+                continue;
+            dispatchToSubscribers((sub) => sub.onEvent, item.event);
+        }
+    };
+    const schedule = () => {
+        if (flushTimer)
+            return;
+        const elapsed = t.now() - lastFlush;
+        flushTimer = t.setTimeout(flush, Math.max(0, COALESCE_FLUSH_MS - elapsed));
+    };
+    (async () => {
+        let retryCount = 0;
+        let consecutiveHardFailures = 0;
+        let consecutiveShortStable = 0;
+        while (!abortController.signal.aborted) {
+            let streamHadWork = false;
+            let stableConnection = false;
+            let heartbeatTimer;
+            let connectTimer;
+            let attemptError = null;
+            const attemptStartedAt = t.now();
+            const attemptAbort = new AbortController();
+            setConnectionState('connecting');
+            const outerLink = onceAborted(abortController.signal);
+            outerLink.promise.then(() => attemptAbort.abort());
+            try {
+                const result = await new Promise((resolve, reject) => {
+                    let settled = false;
+                    connectTimer = t.setTimeout(() => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        logger.warn('SSE connect timed out, forcing reconnect', { connectTimeoutMs });
+                        attemptAbort.abort();
+                        reject(new Error(`SSE connect timed out after ${connectTimeoutMs}ms`));
+                    }, connectTimeoutMs);
+                    client.global
+                        .event({
+                        signal: attemptAbort.signal,
+                        sseDefaultRetryDelay: SSE_DEFAULT_RETRY_DELAY_MS,
+                        sseMaxRetryDelay: SSE_MAX_RETRY_DELAY_MS,
+                        sseMaxRetryAttempts: 1,
+                    })
+                        .then((value) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        t.clearTimeout(connectTimer);
+                        resolve(value);
+                    }, (err) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        t.clearTimeout(connectTimer);
+                        reject(err);
+                    });
+                });
+                const { stream } = result;
+                if (pendingGap) {
+                    const gap = t.now() - pendingGap.lastActivityAt;
+                    const eventful = pendingGap.eventful;
+                    pendingGap = null;
+                    if (eventful || gap > GAP_REHYDRATE_MS) {
+                        dispatchToSubscribers((sub) => sub.onGapRehydrate, gap);
+                    }
+                }
+                lastStreamActivityTime = t.now();
+                const resetHeartbeat = () => {
+                    t.clearTimeout(heartbeatTimer);
+                    heartbeatTimer = t.setTimeout(() => {
+                        logger.warn('SSE heartbeat timeout, forcing reconnect');
+                        attemptAbort.abort();
+                    }, heartbeatTimeoutMs);
+                };
+                resetHeartbeat();
+                let yieldedAt = t.now();
+                const iterator = stream[Symbol.asyncIterator]();
+                while (!attemptAbort.signal.aborted) {
+                    const nextOutcome = iterator.next().then((result) => ({ kind: 'next', result }), (error) => ({ kind: 'error', error }));
+                    const abortWatch = onceAborted(attemptAbort.signal);
+                    const outcome = await Promise.race([
+                        nextOutcome,
+                        abortWatch.promise.then(() => ({ kind: 'aborted' })),
+                    ]);
+                    abortWatch.cleanup();
+                    if (outcome.kind === 'aborted')
+                        break;
+                    if (outcome.kind === 'error')
+                        throw outcome.error;
+                    if (outcome.result.done)
+                        break;
+                    setConnectionState('open');
+                    resetHeartbeat();
+                    const raw = outcome.result.value;
+                    const e = (raw && typeof raw === 'object' && 'payload' in raw ? raw.payload : raw);
+                    if (!e?.type)
+                        continue;
+                    if (e.type !== 'server.connected')
+                        streamHadWork = true;
+                    const merged = mergePartDelta(queue[queue.length - 1]?.event, e);
+                    if (merged) {
+                        queue[queue.length - 1] = { type: merged.type, event: merged };
+                    }
+                    else {
+                        const ck = getCoalesceKey(e);
+                        if (ck) {
+                            const existing = coalesced.get(ck);
+                            if (existing !== undefined) {
+                                queue[existing] = undefined;
+                            }
+                            coalesced.set(ck, queue.length);
+                        }
+                        queue.push({ type: e.type, event: e });
+                    }
+                    schedule();
+                    if (t.now() - yieldedAt < YIELD_INTERVAL_MS)
+                        continue;
+                    yieldedAt = t.now();
+                    await new Promise((resolve) => t.setTimeout(resolve, 0));
+                }
+                stableConnection = streamHadWork;
+            }
+            catch (err) {
+                if (abortController.signal.aborted)
+                    break;
+                attemptError = err;
+                const errStr = String(err);
+                const isAuthError = isAuthFailure(err) || isAuthFailure(err?.cause);
+                logger.error('SSE event stream error', {
+                    error: errStr,
+                    retryCount,
+                    isAuthError,
+                });
+                if (isAuthError) {
+                    try {
+                        invalidateTokenCache();
+                        await getSupabaseAccessToken();
+                        logger.info('SSE: refreshed auth token after auth error');
+                    }
+                    catch (refreshErr) {
+                        logger.error('SSE: failed to refresh auth token', {
+                            error: String(refreshErr),
+                        });
+                    }
+                }
+            }
+            finally {
+                t.clearTimeout(heartbeatTimer);
+                t.clearTimeout(connectTimer);
+                attemptAbort.abort();
+                outerLink.cleanup();
+                flush();
+            }
+            if (abortController.signal.aborted)
+                break;
+            const attemptDurationMs = t.now() - attemptStartedAt;
+            const httpStatus = attemptError?.cause?.status;
+            const isHardFailure = !streamHadWork &&
+                ((typeof httpStatus === 'number' && httpStatus >= 400) ||
+                    attemptDurationMs < HARD_FAILURE_WINDOW_MS);
+            consecutiveHardFailures = isHardFailure ? consecutiveHardFailures + 1 : 0;
+            if (consecutiveHardFailures >= maxConsecutiveHardFailures) {
+                logger.error('SSE event stream parked — giving up after consecutive hard failures', {
+                    consecutiveFailures: consecutiveHardFailures,
+                    lastError: String(attemptError),
+                });
+                connectionState = null;
+                parked = true;
+                dispatchToSubscribers((sub) => sub.onParked, {
+                    consecutiveFailures: consecutiveHardFailures,
+                    lastError: attemptError,
+                });
+                break;
+            }
+            setConnectionState('lost');
+            const unrepaired = pendingGap;
+            pendingGap = {
+                lastActivityAt: lastStreamActivityTime,
+                eventful: (unrepaired?.eventful ?? false) || streamHadWork,
+            };
+            consecutiveShortStable =
+                stableConnection && attemptDurationMs < STABLE_LIFETIME_MS ? consecutiveShortStable + 1 : 0;
+            const fastPath = stableConnection && consecutiveShortStable <= MAX_CONSECUTIVE_SHORT_STABLE;
+            if (fastPath) {
+                retryCount = 0;
+            }
+            else {
+                retryCount++;
+                if (retryCount > 1) {
+                    logger.warn('SSE event stream reconnecting', { retryCount });
+                }
+            }
+            const baseDelay = fastPath
+                ? FAST_RECONNECT_DELAY_MS
+                : Math.min(BASE_RECONNECT_DELAY_MS * 2 ** Math.min(retryCount - 1, MAX_BACKOFF_EXPONENT), MAX_RECONNECT_DELAY_MS);
+            const delay = Math.round(baseDelay * (1 + RECONNECT_JITTER * (t.random?.() ?? 0)));
+            await new Promise((resolve) => {
+                const timer = t.setTimeout(resolve, delay);
+                const onAbort = () => {
+                    t.clearTimeout(timer);
+                    resolve();
+                };
+                abortController.signal.addEventListener('abort', onAbort, { once: true });
+            });
+        }
+    })();
+    return {
+        subscribers,
+        connectionState: () => connectionState,
+        isParked: () => parked,
+        teardown: () => {
+            connectionState = null;
+            abortController.abort();
+            if (flushTimer)
+                t.clearTimeout(flushTimer);
+        },
+    };
+}
+export function openEventStream(opts) {
+    const { onEvent, onGapRehydrate, onParked, onConnectionChange, signal: externalSignal } = opts;
+    const client = opts.client ?? (opts.url ? getClientForUrl(opts.url) : undefined);
+    if (!client)
+        throw new Error('openEventStream needs the session runtime `url`');
+    const subscriber = { onEvent, onGapRehydrate, onParked, onConnectionChange };
+    let liveStream = liveStreamsByClient.get(client);
+    if (liveStream?.isParked()) {
+        liveStreamsByClient.delete(client);
+        liveStream = undefined;
+    }
+    if (!liveStream) {
+        const subscribers = new Set([subscriber]);
+        liveStream = createLiveStream(client, opts, subscribers);
+        liveStreamsByClient.set(client, liveStream);
+    }
+    else {
+        liveStream.subscribers.add(subscriber);
+        const state = liveStream.connectionState();
+        if (state)
+            onConnectionChange?.(state);
+    }
+    const stream = liveStream;
+    let closed = false;
+    const leave = () => {
+        if (closed)
+            return;
+        closed = true;
+        if (externalSignal)
+            externalSignal.removeEventListener('abort', onExternalAbort);
+        stream.subscribers.delete(subscriber);
+        if (stream.subscribers.size === 0) {
+            stream.teardown();
+            if (liveStreamsByClient.get(client) === stream)
+                liveStreamsByClient.delete(client);
+        }
+    };
+    const onExternalAbort = () => leave();
+    if (externalSignal) {
+        if (externalSignal.aborted)
+            leave();
+        else
+            externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+    }
+    return { close: leave };
+}
+export { heartbeatGapEvent, narrowChatEvent, } from './chat-events.js';

package/dist/core/stream/fetch-sse.d.ts

@@ -0,0 +1,20 @@
+export interface SSEStreamOptions {
+    url: string;
+    token: string;
+    method?: 'GET' | 'POST';
+    body?: unknown;
+    onEvent?: (event: string, data: string) => void;
+    onOpen?: () => void;
+    onError?: (error: Error) => void;
+    onClose?: () => void;
+    signal?: AbortSignal;
+}
+export interface SSEStream {
+    connect: () => void;
+    close: () => void;
+    addEventListener: (event: string, handler: (data: string) => void) => void;
+    removeEventListener: (event: string, handler: (data: string) => void) => void;
+}
+export declare function buildTunnelEventStreamUrl(_apiUrl: string): string;
+export declare function createSSEStream(options: SSEStreamOptions): SSEStream;
+export declare function createTunnelEventStream(_apiUrl: string, _options: Omit<SSEStreamOptions, 'url'>): SSEStream;

package/dist/core/stream/fetch-sse.js

@@ -0,0 +1,136 @@
+import { retiredEndpointError } from '../http/api/errors.js';
+export function buildTunnelEventStreamUrl(_apiUrl) {
+    throw retiredEndpointError('buildTunnelEventStreamUrl');
+}
+export function createSSEStream(options) {
+    const { url, token, method = 'GET', body, onEvent, onOpen, onError, onClose, signal: externalSignal, } = options;
+    const listeners = new Map();
+    let abortController = null;
+    let closed = false;
+    let lastEventId = '';
+    function emit(event, data) {
+        onEvent?.(event, data);
+        const handlers = listeners.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            try {
+                handler(data);
+            }
+            catch {
+            }
+        }
+    }
+    async function connect() {
+        if (closed)
+            return;
+        const attempt = new AbortController();
+        abortController = attempt;
+        if (externalSignal) {
+            if (externalSignal.aborted)
+                attempt.abort();
+            else
+                externalSignal.addEventListener('abort', () => attempt.abort(), { once: true });
+        }
+        const signal = attempt.signal;
+        try {
+            const headers = {
+                Accept: 'text/event-stream',
+                Authorization: `Bearer ${token}`,
+            };
+            if (method !== 'GET' && body !== undefined) {
+                headers['Content-Type'] = 'application/json';
+            }
+            if (lastEventId)
+                headers['Last-Event-ID'] = lastEventId;
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: method !== 'GET' && body !== undefined ? JSON.stringify(body) : undefined,
+                signal,
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+            }
+            if (!response.body)
+                throw new Error('SSE response has no body');
+            onOpen?.();
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let currentEvent = 'message';
+            let dataLines = [];
+            const processLine = (line) => {
+                if (line === '') {
+                    if (dataLines.length > 0)
+                        emit(currentEvent, dataLines.join('\n'));
+                    currentEvent = 'message';
+                    dataLines = [];
+                    return;
+                }
+                if (line.startsWith(':'))
+                    return;
+                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 === 'event')
+                    currentEvent = value.trim() || 'message';
+                else if (field === 'data')
+                    dataLines.push(value);
+                else if (field === 'id' && !value.includes('\0'))
+                    lastEventId = value;
+            };
+            const consume = (final) => {
+                let held = '';
+                if (!final && buffer.endsWith('\r')) {
+                    held = '\r';
+                    buffer = buffer.slice(0, -1);
+                }
+                const lines = buffer.split(/\r\n|\n|\r/);
+                buffer = (lines.pop() ?? '') + held;
+                for (const line of lines)
+                    processLine(line);
+            };
+            while (!closed) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                consume(false);
+            }
+            if (!closed) {
+                buffer += decoder.decode();
+                consume(true);
+                onClose?.();
+            }
+        }
+        catch (cause) {
+            if (closed)
+                return;
+            if (cause instanceof DOMException && cause.name === 'AbortError')
+                return;
+            onError?.(cause instanceof Error ? cause : new Error(String(cause)));
+        }
+    }
+    function close() {
+        closed = true;
+        abortController?.abort();
+        abortController = null;
+        listeners.clear();
+    }
+    function addEventListener(event, handler) {
+        const handlers = listeners.get(event) ?? new Set();
+        handlers.add(handler);
+        listeners.set(event, handlers);
+    }
+    function removeEventListener(event, handler) {
+        listeners.get(event)?.delete(handler);
+    }
+    return { connect, close, addEventListener, removeEventListener };
+}
+export function createTunnelEventStream(_apiUrl, _options) {
+    throw retiredEndpointError('createTunnelEventStream');
+}

package/dist/core/stream/keepalive.d.ts

@@ -0,0 +1,4 @@
+export declare const BEEUNI_KEEPALIVE_EVENT = "beeuni.keepalive";
+export declare function isRuntimeLivenessEvent(e: {
+    type?: unknown;
+} | undefined): boolean;

package/dist/core/stream/keepalive.js

@@ -0,0 +1,6 @@
+export const BEEUNI_KEEPALIVE_EVENT = 'beeuni.keepalive';
+export function isRuntimeLivenessEvent(e) {
+    if (!e || typeof e.type !== 'string' || e.type.length === 0)
+        return false;
+    return e.type !== BEEUNI_KEEPALIVE_EVENT;
+}

package/dist/core/stream/platform-event-transport.d.ts

@@ -0,0 +1,2 @@
+import { type RuntimeEventTransport } from '../runtime/runtime-rest-client.js';
+export declare const platformEventTransport: RuntimeEventTransport;

package/dist/core/stream/platform-event-transport.js

@@ -0,0 +1,20 @@
+import { authenticatedFetch } from '../http/auth.js';
+import { platformConfig } from '../http/config.js';
+import { platformRequestHeaders } from '../http/transport.js';
+import { fetchEventTransport } from '../runtime/runtime-rest-client.js';
+export const platformEventTransport = async function* (request) {
+    const custom = platformConfig().eventStreamTransport;
+    if (!custom) {
+        yield* fetchEventTransport(((input, init) => authenticatedFetch(input, init, { timeoutMs: null })))(request);
+        return;
+    }
+    const { headers, rejected } = await platformRequestHeaders(request.url, request.headers);
+    try {
+        yield* custom({ ...request, headers });
+    }
+    catch (error) {
+        if (error?.status === 401)
+            rejected();
+        throw error;
+    }
+};