@beeuni/sdk 0.1.0

package/dist/platform/storage/managed-storage.js

@@ -0,0 +1,215 @@
+'use client';
+import { createJSONStorage } from 'zustand/middleware';
+const disposableFamilies = new Set();
+const disposableKeys = new Set();
+export function registerDisposableFamily(prefix) {
+    disposableFamilies.add(prefix);
+}
+export function registerDisposableKey(key) {
+    disposableKeys.add(key);
+}
+function resolveStorage(name) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        return window[name] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function allKeys(storage) {
+    const keys = [];
+    try {
+        for (let i = 0; i < storage.length; i++) {
+            const k = storage.key(i);
+            if (k !== null)
+                keys.push(k);
+        }
+    }
+    catch {
+    }
+    return keys;
+}
+function keyBelongsToFamily(key, family) {
+    return key.startsWith(`${family}:`);
+}
+function entryTimestamp(raw) {
+    if (!raw)
+        return 0;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed.t === 'number' ? parsed.t : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function disposableEntriesOldestFirst(storage) {
+    const entries = [];
+    for (const key of allKeys(storage)) {
+        if (disposableKeys.has(key)) {
+            entries.push({ key, t: Number.MAX_SAFE_INTEGER });
+            continue;
+        }
+        for (const family of disposableFamilies) {
+            if (keyBelongsToFamily(key, family)) {
+                entries.push({ key, t: entryTimestamp(safeGetItem(key)) });
+                break;
+            }
+        }
+    }
+    return entries.sort((a, b) => a.t - b.t);
+}
+export function safeSetItem(key, value) {
+    const storage = resolveStorage('localStorage');
+    if (!storage)
+        return false;
+    try {
+        storage.setItem(key, value);
+        return true;
+    }
+    catch {
+        const victims = disposableEntriesOldestFirst(storage).filter((e) => e.key !== key);
+        for (const victim of victims) {
+            try {
+                storage.removeItem(victim.key);
+            }
+            catch {
+            }
+            try {
+                storage.setItem(key, value);
+                return true;
+            }
+            catch {
+            }
+        }
+        return false;
+    }
+}
+export function safeGetItem(key) {
+    try {
+        return resolveStorage('localStorage')?.getItem(key) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function safeRemoveItem(key) {
+    try {
+        resolveStorage('localStorage')?.removeItem(key);
+    }
+    catch {
+    }
+}
+export function safeSessionGetItem(key) {
+    try {
+        return resolveStorage('sessionStorage')?.getItem(key) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function safeSessionSetItem(key, value) {
+    const storage = resolveStorage('sessionStorage');
+    if (!storage)
+        return false;
+    try {
+        storage.setItem(key, value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function safeSessionRemoveItem(key) {
+    try {
+        resolveStorage('sessionStorage')?.removeItem(key);
+    }
+    catch {
+    }
+}
+const registeredCaches = [];
+export class ScopedCache {
+    family;
+    maxScopes;
+    constructor(family, maxScopes) {
+        if (maxScopes < 1)
+            throw new Error('ScopedCache maxScopes must be >= 1');
+        this.family = family;
+        this.maxScopes = maxScopes;
+        registerDisposableFamily(family);
+        registeredCaches.push(this);
+    }
+    keyFor(scope) {
+        return `${this.family}:${scope}`;
+    }
+    get(scope) {
+        const raw = safeGetItem(this.keyFor(scope));
+        if (!raw)
+            return undefined;
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && 't' in parsed) {
+                return parsed.v;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    set(scope, value) {
+        const wrapped = { v: value, t: Date.now() };
+        safeSetItem(this.keyFor(scope), JSON.stringify(wrapped));
+        this.prune();
+    }
+    remove(scope) {
+        safeRemoveItem(this.keyFor(scope));
+    }
+    prune() {
+        const storage = resolveStorage('localStorage');
+        if (!storage)
+            return;
+        const entries = [];
+        for (const key of allKeys(storage)) {
+            if (keyBelongsToFamily(key, this.family)) {
+                entries.push({ key, t: entryTimestamp(safeGetItem(key)) });
+            }
+        }
+        if (entries.length <= this.maxScopes)
+            return;
+        entries
+            .sort((a, b) => b.t - a.t)
+            .slice(this.maxScopes)
+            .forEach((e) => safeRemoveItem(e.key));
+    }
+}
+export function pruneDisposableCaches(caches) {
+    for (const cache of caches)
+        cache.prune();
+}
+export function pruneAllRegisteredCaches() {
+    for (const cache of registeredCaches)
+        cache.prune();
+}
+export const safeLocalStorage = {
+    getItem: (name) => safeGetItem(name),
+    setItem: (name, value) => {
+        safeSetItem(name, value);
+    },
+    removeItem: (name) => safeRemoveItem(name),
+};
+export function createSafeJSONStorage() {
+    return createJSONStorage(() => safeLocalStorage);
+}
+export const safeSessionStorage = {
+    getItem: (name) => safeSessionGetItem(name),
+    setItem: (name, value) => {
+        safeSessionSetItem(name, value);
+    },
+    removeItem: (name) => safeSessionRemoveItem(name),
+};
+export function createSafeSessionJSONStorage() {
+    return createJSONStorage(() => safeSessionStorage);
+}

package/dist/platform/strings.d.ts

@@ -0,0 +1 @@
+export declare function stripTrailingSlashes(s: string): string;

package/dist/platform/strings.js

@@ -0,0 +1,6 @@
+export function stripTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s.charCodeAt(end - 1) === 47)
+        end--;
+    return end === s.length ? s : s.slice(0, end);
+}

package/dist/platform/ui.d.ts

@@ -0,0 +1,5 @@
+export declare function infoToast(message: string, options?: unknown): void;
+export declare function notifyTaskComplete(sessionId: string, sessionTitle?: string): void;
+export declare function notifySessionError(sessionId: string, errorTitle: string, sessionTitle?: string): void;
+export declare function notifyQuestion(sessionId: string, questionText: string, sessionTitle?: string): void;
+export declare function notifyPermissionRequest(sessionId: string, toolName: string, sessionTitle?: string): void;

package/dist/platform/ui.js

@@ -0,0 +1,16 @@
+import { platformConfig } from '../core/http/config.js';
+export function infoToast(message, options) {
+    platformConfig().onToast?.('info', message, options);
+}
+export function notifyTaskComplete(sessionId, sessionTitle) {
+    platformConfig().onNotify?.({ kind: 'task-complete', sessionId, sessionTitle });
+}
+export function notifySessionError(sessionId, errorTitle, sessionTitle) {
+    platformConfig().onNotify?.({ kind: 'session-error', sessionId, errorTitle, sessionTitle });
+}
+export function notifyQuestion(sessionId, questionText, sessionTitle) {
+    platformConfig().onNotify?.({ kind: 'question', sessionId, questionText, sessionTitle });
+}
+export function notifyPermissionRequest(sessionId, toolName, sessionTitle) {
+    platformConfig().onNotify?.({ kind: 'permission', sessionId, toolName, sessionTitle });
+}

package/dist/react/agent-selection-scope.d.ts

@@ -0,0 +1,7 @@
+interface AgentSelectionScopeInput {
+    sessionId?: string;
+    boundAgentName?: string | null;
+    projectId?: string | null;
+}
+export declare function createAgentSelectionScope({ sessionId, boundAgentName, projectId, }: AgentSelectionScopeInput): string;
+export {};

package/dist/react/agent-selection-scope.js

@@ -0,0 +1,3 @@
+export function createAgentSelectionScope({ sessionId, boundAgentName, projectId, }) {
+    return `${sessionId ?? ''}\u0000${boundAgentName ?? ''}\u0000${projectId ?? ''}`;
+}

package/dist/react/bedrock-invokable.d.ts

@@ -0,0 +1 @@
+export * from '../core/models/bedrock-invokable.js';

package/dist/react/bedrock-invokable.js

@@ -0,0 +1 @@
+export * from '../core/models/bedrock-invokable.js';

package/dist/react/chat/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatTurns, type TurnView } from './use-chat-turns.js';
+export { renderParts, type PartRenderers } from './render-parts.js';

package/dist/react/chat/index.js

@@ -0,0 +1,3 @@
+'use client';
+export { useChatTurns } from './use-chat-turns.js';
+export { renderParts } from './render-parts.js';

package/dist/react/chat/render-parts.d.ts

@@ -0,0 +1,11 @@
+import type { ClassifiedPart } from '../../core/turns/index.js';
+type PartOfKind<K extends ClassifiedPart['kind']> = Extract<ClassifiedPart, {
+    kind: K;
+}>;
+export type PartRenderers<T> = {
+    [K in ClassifiedPart['kind']]: (part: PartOfKind<K>) => T;
+} & {
+    fallback?: (part: ClassifiedPart) => T;
+};
+export declare function renderParts<T>(parts: ClassifiedPart[], renderers: PartRenderers<T>): T[];
+export {};

package/dist/react/chat/render-parts.js

@@ -0,0 +1,10 @@
+export function renderParts(parts, renderers) {
+    return parts.map((part) => {
+        const renderer = renderers[part.kind];
+        if (renderer)
+            return renderer(part);
+        if (renderers.fallback)
+            return renderers.fallback(part);
+        throw new Error(`renderParts: no renderer registered for part kind "${part.kind}"`);
+    });
+}

package/dist/react/chat/use-chat-turns.d.ts

@@ -0,0 +1,9 @@
+import type { ClassifiedPart, TurnError } from '../../core/turns/index.js';
+import type { MessageWithParts } from '../use-opencode-sessions/index.js';
+export interface TurnView {
+    message: MessageWithParts;
+    parts: ClassifiedPart[];
+    error?: TurnError;
+    isEmpty: boolean;
+}
+export declare function useChatTurns(messages: MessageWithParts[]): TurnView[];

package/dist/react/chat/use-chat-turns.js

@@ -0,0 +1,9 @@
+'use client';
+import { useMemo } from 'react';
+import { classifyTurn } from '../../core/turns/index.js';
+export function useChatTurns(messages) {
+    return useMemo(() => messages.map((message) => {
+        const { parts, error, isEmpty } = classifyTurn(message);
+        return { message, parts, error, isEmpty };
+    }), [messages]);
+}

package/dist/react/connector-setup.d.ts

@@ -0,0 +1,21 @@
+import { type LinkInfoStorage } from '../core/rest/platform-client/connector-setup.js';
+import { type ConnectorSetupLinkInfo } from '../core/rest/platform-client/host-boundary.js';
+export type ConnectorSetupPhase = 'loading' | 'error' | 'ready' | 'starting' | 'opened' | 'connected';
+export type ConnectorPopupOpener = (url: string) => void;
+export interface ConnectorLinkInfoOptions {
+    backendUrl: string;
+    storage?: LinkInfoStorage | null;
+}
+export interface ConnectorSetupOptions extends ConnectorLinkInfoOptions {
+    openPopup: ConnectorPopupOpener;
+    onOpened?: () => void;
+}
+export declare function useConnectorLinkInfo(token: string | null, options: ConnectorLinkInfoOptions): ConnectorSetupLinkInfo | null | undefined;
+export declare function useConnectorSetup(token: string, options: ConnectorSetupOptions): {
+    phase: ConnectorSetupPhase;
+    info: ConnectorSetupLinkInfo | null;
+    error: string | null;
+    connectedAs: string | null;
+    alreadyConnected: boolean;
+    connect: () => Promise<void>;
+};

package/dist/react/connector-setup.js

@@ -0,0 +1,130 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { createConnectorLinkInfoCache, nextConnectorPollDelay, resolveConnectorStart, } from '../core/rest/platform-client/connector-setup.js';
+import { finalizeConnectorSetupLink, getConnectorSetupLink, startConnectorSetupLink, } from '../core/rest/platform-client/host-boundary.js';
+let sharedCache = null;
+function sharedConnectorLinkInfoCache(options) {
+    sharedCache ??= createConnectorLinkInfoCache((token) => getConnectorSetupLink(token, { backendUrl: options.backendUrl }), { storage: options.storage ?? null });
+    return sharedCache;
+}
+export function useConnectorLinkInfo(token, options) {
+    const cache = sharedConnectorLinkInfoCache(options);
+    const [info, setInfo] = useState(() => {
+        const seen = token === null ? undefined : cache.peek(token);
+        return token !== null && seen ? { token, value: seen } : null;
+    });
+    useEffect(() => {
+        if (token === null)
+            return;
+        let cancelled = false;
+        cache.load(token).then((value) => {
+            if (!cancelled)
+                setInfo({ token, value });
+        }, () => {
+            if (!cancelled)
+                setInfo((prev) => (prev?.token === token ? prev : { token, value: null }));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [token, cache]);
+    if (info && info.token === token)
+        return info.value;
+    return token === null ? undefined : cache.peek(token);
+}
+export function useConnectorSetup(token, options) {
+    const { backendUrl } = options;
+    const cache = sharedConnectorLinkInfoCache(options);
+    const [seed] = useState(() => cache.peek(token));
+    const [phase, setPhase] = useState(seed ? 'ready' : 'loading');
+    const [info, setInfo] = useState(seed ?? null);
+    const [error, setError] = useState(null);
+    const [openedAt, setOpenedAt] = useState(0);
+    const [connectedAs, setConnectedAs] = useState(null);
+    const [alreadyConnected, setAlreadyConnected] = useState(false);
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            try {
+                const body = await cache.load(token);
+                if (cancelled)
+                    return;
+                setInfo(body);
+                setPhase((current) => (current === 'loading' ? 'ready' : current));
+            }
+            catch (cause) {
+                if (!cancelled && !seed) {
+                    setError(cause instanceof Error
+                        ? cause.message
+                        : 'Could not reach Beeuni. Check your connection and try again.');
+                    setPhase('error');
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [backendUrl, token, seed, cache]);
+    useEffect(() => {
+        if (phase !== 'opened')
+            return;
+        let cancelled = false;
+        let timer;
+        const startedAt = Date.now();
+        let attempt = 0;
+        const schedule = () => {
+            const delay = nextConnectorPollDelay(attempt, Date.now() - startedAt);
+            if (delay === null)
+                return;
+            attempt += 1;
+            timer = setTimeout(poll, delay);
+        };
+        const poll = async () => {
+            try {
+                const body = await finalizeConnectorSetupLink(token, { backendUrl });
+                if (cancelled)
+                    return;
+                if (body.connected) {
+                    setConnectedAs(body.connected_as ?? null);
+                    setPhase('connected');
+                    return;
+                }
+            }
+            catch {
+            }
+            if (cancelled)
+                return;
+            schedule();
+        };
+        schedule();
+        return () => {
+            cancelled = true;
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [phase, openedAt, token, backendUrl]);
+    async function connect() {
+        setPhase('starting');
+        setError(null);
+        const outcome = await resolveConnectorStart({
+            start: () => startConnectorSetupLink(token, { backendUrl }),
+            finalize: () => finalizeConnectorSetupLink(token, { backendUrl }),
+        });
+        if (outcome.kind === 'error') {
+            setError(outcome.message);
+            setPhase('ready');
+            return;
+        }
+        if (outcome.kind === 'connected') {
+            setAlreadyConnected(outcome.alreadyConnected);
+            setConnectedAs(outcome.connectedAs);
+            setPhase('connected');
+            return;
+        }
+        options.openPopup(outcome.url);
+        setOpenedAt(Date.now());
+        setPhase('opened');
+        options.onOpened?.();
+    }
+    return { phase, info, error, connectedAs, alreadyConnected, connect };
+}

package/dist/react/file-keys.d.ts

@@ -0,0 +1,16 @@
+export declare const fileContentKeys: {
+    all: readonly ["runtime-files", "content"];
+    file: (serverUrl: string, filePath: string) => readonly ["runtime-files", "content", string, string];
+};
+export declare const binaryBlobKeys: {
+    all: readonly ["runtime-files", "binary-blob"];
+    file: (serverUrl: string, filePath: string) => readonly ["runtime-files", "binary-blob", string, string];
+};
+export declare const fileListKeys: {
+    all: readonly ["runtime-files", "list"];
+    dir: (serverUrl: string, dirPath: string) => readonly ["runtime-files", "list", string, string];
+};
+export declare const gitStatusKeys: {
+    all: readonly ["runtime-files", "git-status"];
+    status: (serverUrl: string) => readonly ["runtime-files", "git-status", string];
+};

package/dist/react/file-keys.js

@@ -0,0 +1,16 @@
+export const fileContentKeys = {
+    all: ['runtime-files', 'content'],
+    file: (serverUrl, filePath) => ['runtime-files', 'content', serverUrl, filePath],
+};
+export const binaryBlobKeys = {
+    all: ['runtime-files', 'binary-blob'],
+    file: (serverUrl, filePath) => ['runtime-files', 'binary-blob', serverUrl, filePath],
+};
+export const fileListKeys = {
+    all: ['runtime-files', 'list'],
+    dir: (serverUrl, dirPath) => ['runtime-files', 'list', serverUrl, dirPath],
+};
+export const gitStatusKeys = {
+    all: ['runtime-files', 'git-status'],
+    status: (serverUrl) => ['runtime-files', 'git-status', serverUrl],
+};

package/dist/react/hold-live-start.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStartResult } from '../core/rest/projects-client/session-sandbox.js';
+export declare function holdLiveStart(previous: SessionStartResult | null | undefined, next: SessionStartResult | null): SessionStartResult | null;
+export declare function liveStartPollMode(previous: SessionStartResult | null | undefined, documentHidden: boolean): 'skip' | 'keep-stopped' | 'open';

package/dist/react/hold-live-start.js

@@ -0,0 +1,27 @@
+const TRANSPORT_REASONS = new Set([
+    'unreachable',
+    'runtime_status_unknown',
+    'runtime_stop_unconfirmed',
+]);
+export function holdLiveStart(previous, next) {
+    if (previous?.stage !== 'ready')
+        return next;
+    if (!next)
+        return previous;
+    if (next.stage !== 'starting')
+        return next;
+    if (next.sandbox) {
+        if (next.sandbox.sandbox_id !== previous.sandbox?.sandbox_id)
+            return next;
+        if (next.sandbox.external_id !== previous.sandbox?.external_id)
+            return next;
+        if (next.sandbox.status !== 'active')
+            return next;
+    }
+    return TRANSPORT_REASONS.has(next.reason ?? '') ? previous : next;
+}
+export function liveStartPollMode(previous, documentHidden) {
+    if (previous?.stage !== 'ready')
+        return 'open';
+    return documentHidden ? 'skip' : 'keep-stopped';
+}

package/dist/react/human-presence.d.ts

@@ -0,0 +1,15 @@
+export declare const PRESENCE_INPUT_WINDOW_MS: number;
+export declare const PRESENCE_CHECK_MS = 30000;
+export interface HumanPresenceEnv {
+    doc: Pick<Document, 'hidden' | 'addEventListener' | 'removeEventListener'>;
+    win: Pick<Window, 'addEventListener' | 'removeEventListener' | 'setInterval' | 'clearInterval'>;
+    now?: () => number;
+}
+export declare function watchHumanPresence(env: HumanPresenceEnv, send: (active: boolean) => void, streamConnected: () => boolean, pageExit?: () => boolean): () => void;
+export declare function presenceReporter(put: (report: {
+    active: boolean;
+    alerts: boolean;
+}) => void, alerts: boolean): {
+    report(active: boolean): void;
+    setAlerts(next: boolean): void;
+};

package/dist/react/human-presence.js

@@ -0,0 +1,62 @@
+export const PRESENCE_INPUT_WINDOW_MS = 10 * 60_000;
+export const PRESENCE_CHECK_MS = 30_000;
+const INPUT_EVENTS = ['pointerdown', 'pointermove', 'keydown', 'wheel', 'touchstart', 'scroll', 'focus'];
+export function watchHumanPresence(env, send, streamConnected, pageExit = () => false) {
+    const now = env.now ?? Date.now;
+    let lastInput = now();
+    let sent = null;
+    const present = () => !env.doc.hidden && now() - lastInput < PRESENCE_INPUT_WINDOW_MS;
+    const report = (renew = false) => {
+        const active = present();
+        if (renew || active !== sent) {
+            sent = active;
+            send(active);
+        }
+    };
+    const onInput = () => {
+        lastInput = now();
+        if (sent !== true)
+            report();
+    };
+    const onVisibility = () => {
+        if (!env.doc.hidden)
+            lastInput = now();
+        report();
+    };
+    const onPageHide = () => {
+        if (!pageExit())
+            return;
+        lastInput = -Infinity;
+        report();
+    };
+    report();
+    const interval = env.win.setInterval(() => report(present() && !streamConnected()), PRESENCE_CHECK_MS);
+    for (const type of INPUT_EVENTS)
+        env.win.addEventListener(type, onInput, { capture: true, passive: true });
+    env.win.addEventListener('pagehide', onPageHide);
+    env.doc.addEventListener('visibilitychange', onVisibility);
+    return () => {
+        env.win.clearInterval(interval);
+        for (const type of INPUT_EVENTS)
+            env.win.removeEventListener(type, onInput, { capture: true });
+        env.win.removeEventListener('pagehide', onPageHide);
+        env.doc.removeEventListener('visibilitychange', onVisibility);
+        send(false);
+    };
+}
+export function presenceReporter(put, alerts) {
+    let present = false;
+    return {
+        report(active) {
+            present = active;
+            put({ active, alerts });
+        },
+        setAlerts(next) {
+            if (next === alerts)
+                return;
+            alerts = next;
+            if (present)
+                put({ active: true, alerts });
+        },
+    };
+}

package/dist/react/identity-reset-registry.d.ts

@@ -0,0 +1,2 @@
+export declare function registerIdentityReset(reset: () => void): void;
+export declare function runIdentityResets(): void;

package/dist/react/identity-reset-registry.js

@@ -0,0 +1,14 @@
+const resets = new Set();
+export function registerIdentityReset(reset) {
+    resets.add(reset);
+}
+export function runIdentityResets() {
+    for (const reset of resets) {
+        try {
+            reset();
+        }
+        catch (error) {
+            console.warn('[resetIdentityState] a reset threw; continuing', error);
+        }
+    }
+}