@beeuni/sdk 0.1.0

package/dist/core/session-sync/saved-copy-store.js

@@ -0,0 +1,232 @@
+export function isPaintableSavedCopy(envelope) {
+    return (!!envelope &&
+        envelope.available === true &&
+        envelope.source === 'mirror' &&
+        Array.isArray(envelope.messages) &&
+        envelope.messages.length > 0 &&
+        !!(envelope.runtime_session_id ?? envelope.opencode_session_id));
+}
+const VERSION = 1;
+const DEFAULT_MAX_SESSIONS = 12;
+const DEFAULT_MAX_BYTES = 1_500_000;
+const DEFAULT_MAX_ENVELOPE_BYTES = 300_000;
+const DEFAULT_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+const DEFAULT_NAMESPACE = 'beeuni.saved-copy';
+function isPromise(value) {
+    return !!value && typeof value.then === 'function';
+}
+function then(value, fn) {
+    return isPromise(value) ? value.then(fn) : fn(value);
+}
+function fitSavedCopy(stored, maxChars) {
+    const whole = JSON.stringify(stored);
+    if (whole.length <= maxChars)
+        return whole;
+    const { messages } = stored.e;
+    if (messages.length === 0)
+        return null;
+    const trimmed = (keep) => {
+        const kept = messages.slice(messages.length - keep);
+        return JSON.stringify({
+            ...stored,
+            e: {
+                ...stored.e,
+                messages: kept,
+                message_count: kept.length,
+                complete: false,
+                next_cursor: String(kept[0].info.id),
+            },
+        });
+    };
+    let size = trimmed(1).length - JSON.stringify(messages[messages.length - 1]).length;
+    let keep = 0;
+    while (keep < messages.length) {
+        const next = JSON.stringify(messages[messages.length - 1 - keep]).length + (keep > 0 ? 1 : 0);
+        if (size + next > maxChars)
+            break;
+        size += next;
+        keep += 1;
+    }
+    for (; keep > 0; keep -= 1) {
+        const text = trimmed(keep);
+        if (text.length <= maxChars)
+            return text;
+    }
+    return null;
+}
+function capturedAtMs(envelope) {
+    const parsed = envelope.captured_at ? Date.parse(envelope.captured_at) : Number.NaN;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export function createSavedCopyStore(options) {
+    const { storage, userId, maxSessions = DEFAULT_MAX_SESSIONS, maxBytes = DEFAULT_MAX_BYTES, maxEnvelopeBytes = DEFAULT_MAX_ENVELOPE_BYTES, maxAgeMs = DEFAULT_MAX_AGE_MS, namespace = DEFAULT_NAMESPACE, now = () => Date.now(), } = options;
+    const prefix = `${namespace}:${userId}:`;
+    const indexKey = `${prefix}index`;
+    const keyFor = (projectId, sessionId) => `${prefix}${projectId}/${sessionId}`;
+    const safeGet = (key) => {
+        try {
+            const value = storage.getItem(key);
+            return isPromise(value) ? value.catch(() => null) : value;
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeNow = (key) => {
+        try {
+            const removal = storage.removeItem(key);
+            if (isPromise(removal))
+                removal.catch(() => undefined);
+        }
+        catch {
+        }
+    };
+    const safeRemove = async (key) => {
+        try {
+            await storage.removeItem(key);
+        }
+        catch {
+        }
+    };
+    const parseIndex = (raw) => {
+        if (!raw)
+            return [];
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed?.v === VERSION && Array.isArray(parsed.entries) ? parsed.entries : [];
+        }
+        catch {
+            return [];
+        }
+    };
+    let queue = Promise.resolve();
+    const enqueue = (task) => {
+        const run = queue.then(task, task);
+        queue = run.catch(() => undefined);
+        return run;
+    };
+    const saveIndex = async (entries) => {
+        try {
+            await storage.setItem(indexKey, JSON.stringify({ v: VERSION, entries }));
+        }
+        catch {
+        }
+    };
+    const loadIndex = async () => parseIndex(await safeGet(indexKey));
+    const evict = async (entries, keep) => {
+        const kept = [...entries].sort((a, b) => a.u - b.u);
+        let total = kept.reduce((sum, entry) => sum + entry.b, 0);
+        while (kept.length > maxSessions || total > maxBytes) {
+            const index = kept.findIndex((entry) => entry.s !== keep);
+            if (index === -1)
+                break;
+            const [dropped] = kept.splice(index, 1);
+            total -= dropped.b;
+            await safeRemove(`${prefix}${dropped.s}`);
+        }
+        return kept;
+    };
+    const touch = (scope) => {
+        void enqueue(async () => {
+            const entries = await loadIndex();
+            const entry = entries.find((candidate) => candidate.s === scope);
+            if (!entry)
+                return;
+            entry.u = now();
+            await saveIndex(entries);
+        });
+    };
+    const forgetScope = (scope) => enqueue(async () => {
+        await safeRemove(`${prefix}${scope}`);
+        const entries = await loadIndex();
+        const kept = entries.filter((entry) => entry.s !== scope);
+        if (kept.length !== entries.length)
+            await saveIndex(kept);
+    });
+    return {
+        keyFor,
+        read(projectId, sessionId) {
+            const scope = `${projectId}/${sessionId}`;
+            return then(safeGet(keyFor(projectId, sessionId)), (raw) => {
+                if (!raw)
+                    return null;
+                let stored;
+                try {
+                    stored = JSON.parse(raw);
+                }
+                catch {
+                    removeNow(keyFor(projectId, sessionId));
+                    void forgetScope(scope);
+                    return null;
+                }
+                if (!stored ||
+                    stored.v !== VERSION ||
+                    stored.user !== userId ||
+                    now() - stored.at > maxAgeMs ||
+                    !isPaintableSavedCopy(stored.e)) {
+                    removeNow(keyFor(projectId, sessionId));
+                    void forgetScope(scope);
+                    return null;
+                }
+                touch(scope);
+                return stored.e;
+            });
+        },
+        write(projectId, sessionId, envelope) {
+            const scope = `${projectId}/${sessionId}`;
+            if (!isPaintableSavedCopy(envelope))
+                return forgetScope(scope);
+            const stored = { v: VERSION, user: userId, at: now(), e: envelope };
+            const text = fitSavedCopy(stored, maxEnvelopeBytes);
+            if (text === null)
+                return forgetScope(scope);
+            const captured = capturedAtMs(envelope);
+            return enqueue(async () => {
+                const entries = await loadIndex();
+                const existing = entries.find((entry) => entry.s === scope);
+                if (existing && captured > 0 && existing.c > captured)
+                    return;
+                const others = entries.filter((entry) => entry.s !== scope);
+                const entry = { s: scope, b: text.length, u: now(), c: captured };
+                let kept = await evict([...others, entry], scope);
+                const key = keyFor(projectId, sessionId);
+                try {
+                    await storage.setItem(key, text);
+                }
+                catch {
+                    const oldest = kept.filter((candidate) => candidate.s !== scope).sort((a, b) => a.u - b.u)[0];
+                    if (oldest) {
+                        await safeRemove(`${prefix}${oldest.s}`);
+                        kept = kept.filter((candidate) => candidate.s !== oldest.s);
+                    }
+                    try {
+                        await storage.setItem(key, text);
+                    }
+                    catch {
+                        await safeRemove(key);
+                        kept = kept.filter((candidate) => candidate.s !== scope);
+                    }
+                }
+                await saveIndex(kept);
+            });
+        },
+        remove(projectId, sessionId) {
+            return forgetScope(`${projectId}/${sessionId}`);
+        },
+        clear() {
+            return enqueue(async () => {
+                const entries = await loadIndex();
+                for (const entry of entries)
+                    await safeRemove(`${prefix}${entry.s}`);
+                await safeRemove(indexKey);
+            });
+        },
+    };
+}
+let currentStore = null;
+export function setSavedCopyStore(store) {
+    currentStore = store;
+}
+export function currentSavedCopyStore() {
+    return currentStore;
+}

package/dist/core/session-sync/saved-transcript.d.ts

@@ -0,0 +1,20 @@
+import type { SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+export type SavedTranscript = 'loading' | 'shown' | 'none';
+export interface SavedTranscriptInput {
+    enabled: boolean;
+    hasMessages: boolean;
+    history: 'off' | 'loading' | 'present' | 'absent';
+    mirror: 'idle' | 'loading' | 'painted' | 'absent';
+    root: 'known' | 'pending' | 'unknown';
+    emptyAwaitingTurnRead?: boolean;
+}
+export declare function resolveSavedTranscript(input: SavedTranscriptInput): SavedTranscript;
+export declare function savedCopyEmptyRoot(envelope: SessionTranscriptSyncEnvelope | null | undefined): string | null;
+export interface EmptyConversationInput {
+    savedEmptyRoot: string | null;
+    rootSessionId: string;
+    turnRead: boolean;
+    hasEndedTurn: boolean;
+    hasOpenOrQueuedTurn: boolean;
+}
+export declare function isEmptyConversation(input: EmptyConversationInput): boolean;

package/dist/core/session-sync/saved-transcript.js

@@ -0,0 +1,35 @@
+export function resolveSavedTranscript(input) {
+    if (input.hasMessages)
+        return 'shown';
+    if (!input.enabled)
+        return 'loading';
+    if (input.emptyAwaitingTurnRead)
+        return 'loading';
+    if (input.history === 'absent')
+        return 'none';
+    if (input.history === 'loading')
+        return 'loading';
+    if (input.root === 'unknown')
+        return 'none';
+    if (input.root === 'pending')
+        return 'loading';
+    if (input.mirror === 'absent')
+        return 'none';
+    return 'loading';
+}
+export function savedCopyEmptyRoot(envelope) {
+    return envelope?.available &&
+        envelope.source === 'mirror' &&
+        envelope.complete &&
+        envelope.total === 0 &&
+        envelope.messages.length === 0
+        ? (envelope.runtime_session_id ?? envelope.opencode_session_id ?? null)
+        : null;
+}
+export function isEmptyConversation(input) {
+    return (input.savedEmptyRoot !== null &&
+        input.savedEmptyRoot === input.rootSessionId &&
+        input.turnRead &&
+        !input.hasEndedTurn &&
+        !input.hasOpenOrQueuedTurn);
+}

package/dist/core/session-sync/session-sync-controller.d.ts

@@ -0,0 +1,111 @@
+import type { Message, Part, SessionStatus } from '../runtime/runtime-types.js';
+export declare const SESSION_SYNC_PAGE_SIZE = 100;
+export declare const SESSION_SYNC_TAIL_PAGE_SIZE = 50;
+export declare const MAX_TURN_BACKFILL_PAGES = 10;
+export type SessionSyncFreshness = 'idle' | 'loading' | 'fresh' | 'stale' | 'error';
+export interface SessionSyncMessage {
+    info: Message;
+    parts: Part[];
+}
+export interface SessionSyncPage {
+    messages: SessionSyncMessage[];
+    nextCursor?: string;
+}
+export interface SessionSyncSnapshot {
+    freshness: SessionSyncFreshness;
+    hasOlder: boolean;
+    isLoadingOlder: boolean;
+}
+export interface SessionSyncScheduler {
+    now: () => number;
+    setInterval: (handler: () => void, intervalMs: number) => unknown;
+    clearInterval: (handle: unknown) => void;
+    setTimeout?: (handler: () => void, timeoutMs: number) => unknown;
+    clearTimeout?: (handle: unknown) => void;
+}
+export type SessionSyncReason = 'initial' | 'poll' | 'sse-gap' | 'compaction' | 'session-error' | 'send-recovery' | 'turn-end' | 'visible' | 'eviction' | 'manual';
+export interface SessionSyncTelemetryEvent {
+    operation: 'tail' | 'older';
+    reason: SessionSyncReason;
+    durationMs: number;
+    messageCount: number;
+    succeeded: boolean;
+}
+export interface SessionSyncControllerOptions {
+    sessionId: string;
+    loadPage: (request: {
+        limit: number;
+        before?: string;
+    }, signal?: AbortSignal) => Promise<SessionSyncPage>;
+    loadStatus?: () => Promise<SessionStatus>;
+    hydrate: (messages: SessionSyncMessage[]) => void;
+    markLoaded: () => void;
+    setStatus?: (status: SessionStatus) => void;
+    onTelemetry?: (event: SessionSyncTelemetryEvent) => void;
+    scheduler?: SessionSyncScheduler;
+    livenessIntervalMs?: number;
+    verifyIntervalMs?: number;
+    readTimeoutMs?: number;
+}
+export interface HttpSessionSyncControllerOptions extends Pick<SessionSyncControllerOptions, 'sessionId' | 'hydrate' | 'markLoaded' | 'setStatus' | 'onTelemetry' | 'scheduler' | 'livenessIntervalMs' | 'verifyIntervalMs' | 'readTimeoutMs'> {
+    baseUrl: string;
+    getToken?: () => string | null | Promise<string | null>;
+    fetch?: SessionSyncFetch;
+}
+export type SessionSyncFetch = (input: string, init?: RequestInit) => Promise<Response>;
+type HttpSessionSyncSourceOptions = Pick<HttpSessionSyncControllerOptions, 'baseUrl' | 'sessionId' | 'getToken' | 'fetch'>;
+export declare function createHttpSessionSyncPageLoader(options: HttpSessionSyncSourceOptions): SessionSyncControllerOptions['loadPage'];
+export declare function loadHttpSessionHistory(options: HttpSessionSyncSourceOptions): Promise<SessionSyncMessage[]>;
+export declare function createHttpSessionSyncController(options: HttpSessionSyncControllerOptions): SessionSyncController;
+export declare function loadCompleteSessionHistory(loadPage: SessionSyncControllerOptions['loadPage']): Promise<SessionSyncMessage[]>;
+export declare class SessionSyncController {
+    private readonly options;
+    private readonly scheduler;
+    private readonly livenessIntervalMs;
+    private readonly verifyIntervalMs;
+    private readonly readTimeoutMs;
+    private lastTailReadAt;
+    private retryAttempt;
+    private tailUnavailable;
+    private tailRetryTimer;
+    private snapshot;
+    private nextCursor;
+    private knownUserMessageIds;
+    private olderHistoryStarted;
+    private tailRequest;
+    private turnEndPending;
+    private olderRequest;
+    private livenessTimer;
+    private livenessBusy;
+    private streamReliable;
+    private lastActivityAt;
+    private listeners;
+    private destroyed;
+    private readonly abortController;
+    constructor(options: SessionSyncControllerOptions);
+    getSnapshot: () => SessionSyncSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    start(): Promise<void>;
+    reconcile(reason?: SessionSyncReason): Promise<void>;
+    loadOlder: () => Promise<void>;
+    noteActivity(): void;
+    setStreamReliable(reliable: boolean): void;
+    setBusy(isBusy: boolean, watchIdle?: boolean): void;
+    destroy(): void;
+    private reconcileTurnEnd;
+    private loadTail;
+    private scheduleTailRetry;
+    private loadPage;
+    private boundedRead;
+    private loadCompleteOlderTurn;
+    private loadCompleteTurn;
+    private rememberUserMessages;
+    private checkLiveness;
+    private raceDeadline;
+    private setCursor;
+    private stopLivenessTimer;
+    private startTimer;
+    private cancelTimer;
+    private update;
+}
+export {};