@bodhiapp/bodhi-js 0.0.1

package/dist/bodhi-js-sdk/core/src/facade-client-base.d.ts

@@ -0,0 +1,130 @@
+import { CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+import { IConnectionClient } from './interface';
+import { Logger } from './logger';
+import { BodhiClientUserPrefsManager } from './storage';
+import { ApiResponseResult, AuthLoggedIn, AuthLoggedOut, AuthState, BackendServerState, ClientState, ConnectionMode, DirectState, ExtensionState, InitParams, SerializedClientState, SerializedDirectState, SerializedExtensionState, StateChange, StateChangeCallback } from './types';
+
+/**
+ * Base facade client with common delegation logic
+ *
+ * @template TConfig - Configuration type for this facade
+ * @template TExtClient - Extension client type (implements IConnectionClient with SerializedExtensionState)
+ * @template TDirectClient - Direct client type (implements IConnectionClient with SerializedDirectState)
+ */
+export declare abstract class BaseFacadeClient<TConfig, TExtClient extends IConnectionClient<unknown, SerializedExtensionState>, TDirectClient extends IConnectionClient<unknown, SerializedDirectState>> {
+    protected logger: Logger;
+    protected extClient: TExtClient;
+    protected directClient: TDirectClient;
+    protected prefs: BodhiClientUserPrefsManager;
+    protected connectionMode: ConnectionMode | null;
+    protected authClientId: string;
+    protected config: TConfig;
+    protected onStateChange: StateChangeCallback;
+    constructor(authClientId: string, config: TConfig, onStateChange?: StateChangeCallback, storagePrefix?: string);
+    /**
+     * Create logger instance
+     * Subclasses extract logLevel from their specific config type
+     */
+    protected abstract createLogger(config: TConfig): Logger;
+    /**
+     * Create extension-based client (ExtClient or WindowBodhiextClient)
+     */
+    protected abstract createExtClient(config: TConfig, onStateChange: (change: StateChange) => void): TExtClient;
+    /**
+     * Create direct HTTP client (DirectExtClient or DirectWebClient)
+     */
+    protected abstract createDirectClient(authClientId: string, config: TConfig, onStateChange: (change: StateChange) => void): TDirectClient;
+    /**
+     * Notify client state change by calling facade's callback with discriminated union
+     */
+    private notifyStateChange;
+    /**
+     * Handle state changes from internal clients (extClient or directClient)
+     * For client state changes, notifyStateChange that persists and notifies
+     * For auth state changes, notify the callback directly
+     */
+    private handleInternalStateChange;
+    /**
+     * Serialize current state for persistence
+     * Returns SerializedClientState with nested client states
+     */
+    serialize(): SerializedClientState;
+    /**
+     * Debug dump of facade client internal state
+     * Aggregates debug info from both internal clients
+     */
+    debug(): Promise<Record<string, unknown>>;
+    /**
+     * Persist current state to storage
+     */
+    persist(): void;
+    /**
+     * Set or update the state change callback
+     */
+    setStateCallback(callback: StateChangeCallback): void;
+    /**
+     * Check if connection mode is null or direct
+     * Used for delegation - prefers direct on fresh install
+     */
+    protected isNotSetOrDirect(): boolean;
+    /**
+     * Initialize client based on current connectionMode
+     *
+     * State Management:
+     * - Facade owns persistence via prefs - savedState param is NOT used
+     * - Restores connectionMode and internal client states from prefs.getSerializedClientState()
+     * - On fresh install (no saved state), defaults to connectionMode: null
+     *
+     * InitParams (optional):
+     * - serverUrl: Direct mode server URL (overrides saved state)
+     * - testConnection: Test server connectivity during init
+     * - timeoutMs: Extension mode discovery timeout
+     * - selectedConnection, savedState: Internal use only (not for external callers)
+     *
+     * Eager Connection Detection (when connectionMode is null):
+     * Tries direct first, then extension, auto-selecting first one with server ready
+     */
+    init(params?: InitParams): Promise<ExtensionState | DirectState>;
+    getState(): ClientState;
+    isClientInitialized(): boolean;
+    isServerReady(): boolean;
+    sendExtRequest<TParams = void, TRes = unknown>(action: string, params?: TParams): Promise<TRes>;
+    sendApiRequest<TReq = void, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): Promise<ApiResponseResult<TRes>>;
+    login(): Promise<AuthLoggedIn>;
+    logout(): Promise<AuthLoggedOut>;
+    getAuthState(): Promise<AuthState>;
+    pingApi(): Promise<ApiResponseResult<{
+        message: string;
+    }>>;
+    fetchModels(): Promise<ApiResponseResult<{
+        data: Array<{
+            id: string;
+            object: string;
+        }>;
+    }>>;
+    getServerState(): Promise<BackendServerState>;
+    stream<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): AsyncGenerator<TRes>;
+    streamChat(model: string, prompt: string, authenticated?: boolean): AsyncGenerator<CreateChatCompletionStreamResponse>;
+    getConnectionMode(): ConnectionMode | null;
+    setConnectionMode(mode: ConnectionMode): Promise<ClientState>;
+    /**
+     * Test extension connectivity regardless of current connection mode
+     * Fresh connection test - injects testConnection: true internally
+     * @param timeoutMs - Optional timeout for extension discovery
+     */
+    testExtensionConnectivity(timeoutMs?: number): Promise<ExtensionState>;
+    /**
+     * Test direct server connectivity
+     * Fresh connection test - injects testConnection: true internally
+     * @param serverUrl - Optional server URL to test. If not provided, uses saved serverUrl from state
+     */
+    testDirectConnectivity(serverUrl?: string): Promise<DirectState>;
+    /**
+     * Get current extension state (regardless of current connection mode)
+     */
+    getExtensionState(): Promise<ExtensionState>;
+    /**
+     * Get current direct server state
+     */
+    getDirectState(): Promise<DirectState>;
+}

package/dist/bodhi-js-sdk/core/src/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @bodhiapp/bodhi-js-core - Minimal shared types and interfaces
+ *
+ * This package contains the minimal shared code between ext and web SDKs:
+ * - Types (ApiResponseResult, ClientState, UserInfo, etc.)
+ * - Error factories (createApiError, createOperationError)
+ * - Logger (centralized logging)
+ * - UIClient interface (base interface)
+ */
+export * from './types';
+export * from './logger';
+export * from './interface';
+export * from './platform';
+export * from './storage';
+export * from './onboarding';
+export * from './oauth';
+export * from './direct-client-base';
+export * from './facade-client-base';
+export { isOperationError, type OperationError } from '../../../bodhi-browser-ext/src/types';

package/dist/bodhi-js-sdk/core/src/interface.d.ts

@@ -0,0 +1,228 @@
+import { CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+import { ApiResponseResult, AuthLoggedIn, AuthLoggedOut, AuthState, BackendServerState, ClientState, ConnectionMode, DirectState, ExtensionState, InitParams, StateChangeCallback } from './types';
+
+/**
+ * ConnectionClient - Base interface for all client implementations
+ *
+ * Defines common interface for:
+ * - IExtensionClient (chrome.runtime or window.bodhiext)
+ * - DirectClient (direct HTTP fetch)
+ *
+ * Includes both connection methods (API calls, streaming) and auth methods.
+ *
+ * @template IParams - The init params type for this client
+ * @template SerialState - The serialized state type for persistence
+ */
+export interface IConnectionClient<IParams = unknown, SerialState = unknown> {
+    /**
+     * Initialize client discovery/connectivity
+     * - IExtensionClient: Discover bodhi-browser-ext extension
+     * - DirectClient: Test HTTP connectivity to server
+     *
+     * @param params - ExtParams or DirectParams (discriminated by serverUrl presence)
+     * @returns ClientState (ExtensionState or DirectState based on active connection mode)
+     */
+    init(params: IParams): Promise<ClientState>;
+    /**
+     * Get current client state
+     * @returns ClientState with status and connectionMode
+     */
+    getState(): ClientState;
+    /**
+     * Check if client is initialized (has handle/url configured)
+     * - DirectClient: serverUrl is set
+     * - ExtensionClient: extension is 'ready'
+     * @returns true if client is ready to make requests
+     */
+    isClientInitialized(): boolean;
+    /**
+     * Check if backend server is ready (status === 'ready')
+     * @returns true if server is connected and ready
+     */
+    isServerReady(): boolean;
+    /**
+     * Send API request to local server
+     * @param authenticated - If true, injects access token automatically
+     * @returns ApiResponseResult with response or operation error
+     */
+    sendApiRequest<TReq = void, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): Promise<ApiResponseResult<TRes>>;
+    /**
+     * Ping API endpoint
+     * @returns ApiResponseResult with ping response
+     */
+    pingApi(): Promise<ApiResponseResult<{
+        message: string;
+    }>>;
+    /**
+     * Fetch available models from /v1/models
+     * @returns ApiResponseResult with models list
+     */
+    fetchModels(): Promise<ApiResponseResult<{
+        data: Array<{
+            id: string;
+            object: string;
+        }>;
+    }>>;
+    /**
+     * Get backend server state
+     * Calls /bodhi/v1/info and returns structured server state
+     * @returns BackendServerState with status and version
+     */
+    getServerState(): Promise<BackendServerState>;
+    /**
+     * Generic streaming request
+     * - IExtensionClient: chrome.runtime.connect port or window.bodhiext stream
+     * - DirectClient: Server-Sent Events (SSE) via fetch
+     *
+     * @returns AsyncGenerator yielding response chunks
+     */
+    stream<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>, authenticated?: boolean): AsyncGenerator<TRes>;
+    /**
+     * Chat streaming (convenience wrapper for stream)
+     * @returns AsyncGenerator yielding chat completion chunks
+     */
+    streamChat(model: string, prompt: string, authenticated?: boolean): AsyncGenerator<CreateChatCompletionStreamResponse>;
+    /**
+     * Login via OAuth
+     * - IExtensionClient: Delegates to extension (chrome.identity or browser redirect)
+     * - DirectClient: Direct HTTP OAuth flow
+     * @returns AuthLoggedIn with login state and user info
+     */
+    login(): Promise<AuthLoggedIn>;
+    /**
+     * Logout and revoke tokens
+     * @returns AuthLoggedOut with logged out state
+     */
+    logout(): Promise<AuthLoggedOut>;
+    /**
+     * Get current authentication state
+     * @returns AuthState (discriminated union: AuthLoggedIn | AuthLoggedOut)
+     */
+    getAuthState(): Promise<AuthState>;
+    /**
+     * Set or update the state change callback
+     * Allows setting callback after construction (for React dependency injection)
+     * @param callback - Callback invoked on client state or auth state changes
+     */
+    setStateCallback(callback: StateChangeCallback): void;
+    /**
+     * Serialize client state for persistence
+     * @returns Serialized state suitable for localStorage/chrome.storage
+     */
+    serialize(): SerialState;
+    /**
+     * Debug dump of client internal state
+     * Returns free-form object for console.log or UI display
+     * Includes transient state (unlike serialize which is for persistence)
+     * Fetches live authState via async call
+     * @returns Promise resolving to object with internal state for debugging
+     */
+    debug(): Promise<Record<string, unknown>>;
+}
+/**
+ * IExtensionClient - Extension-specific client interface
+ *
+ * Extends IConnectionClient with sendExtRequest for direct extension communication.
+ *
+ * Implementations:
+ * - Ext2ExtClient: chrome.runtime.sendMessage (extension context)
+ * - Web2ExtClient: window.bodhiext (web page context)
+ *
+ * @template IParams - The init params type for this client
+ * @template SerialState - The serialized state type for persistence
+ */
+export interface IExtensionClient<IParams = unknown, SerialState = unknown> extends IConnectionClient<IParams, SerialState> {
+    /**
+     * Send extension request
+     * Communicates with bodhi-browser-ext extension via:
+     * - chrome.runtime.sendMessage (extension context)
+     * - window.bodhiext (web context)
+     *
+     * @param action - Extension action (e.g., 'DISCOVER_EXTENSION', 'LOGIN')
+     * @param params - Action parameters
+     * @returns Response from extension
+     */
+    sendExtRequest<TParams = void, TRes = unknown>(action: string, params?: TParams): Promise<TRes>;
+}
+/**
+ * DirectClient - Direct HTTP client interface
+ *
+ * Extends IConnectionClient with no additional methods.
+ * Communicates directly with local server via HTTP fetch (no extension intermediary).
+ *
+ * @template IParams - The init params type for this client
+ * @template SerialState - The serialized state type for persistence
+ */
+export interface IDirectClient<IParams = unknown, SerialState = unknown> extends IConnectionClient<IParams, SerialState> {
+}
+/**
+ * UIClient - Facade client with connection mode switching
+ *
+ * Combination of ConnectionClient + connection mode management.
+ * Internally holds both IExtensionClient and DirectClient, delegates to active client.
+ *
+ * Usage:
+ * ```
+ * const uiClient: UIClient = new UIClientImpl(extensionClient);
+ * await uiClient.init({ serverUrl: 'http://localhost:1135' }); // Init direct
+ * uiClient.setConnectionMode('extension'); // Switch to extension mode
+ * ```
+ */
+export type UIClient = IConnectionClient<InitParams> & {
+    /**
+     * Set connection mode and switch active client
+     * @param mode - 'direct' or 'extension'
+     * @returns Promise with connection mode result
+     */
+    setConnectionMode(mode: ConnectionMode): Promise<ClientState>;
+    /**
+     * Get current connection mode
+     * @returns 'direct', 'extension', or null if not set
+     */
+    getConnectionMode(): ConnectionMode | null;
+    /**
+     * Test extension connectivity regardless of current connection mode
+     * Initializes extension client and tests backend server connection
+     * @param timeoutMs - Optional timeout for extension discovery
+     * @returns ExtensionState with extension status and server state
+     */
+    testExtensionConnectivity(timeoutMs?: number): Promise<ExtensionState>;
+    /**
+     * Test direct server connectivity
+     * Initializes direct client and tests backend server connection
+     * @param serverUrl - Optional server URL to test. If not provided, uses saved serverUrl from state
+     * @returns DirectState with server status and URL
+     */
+    testDirectConnectivity(serverUrl?: string): Promise<DirectState>;
+    /**
+     * Get current extension state (regardless of current connection mode)
+     * Returns extension status and backend server state
+     * @returns ExtensionState
+     */
+    getExtensionState(): Promise<ExtensionState>;
+    /**
+     * Get current direct server state (if configured)
+     * Returns direct server status and URL
+     * @returns DirectState
+     */
+    getDirectState(): Promise<DirectState>;
+};
+/**
+ * Web-specific UIClient interface with OAuth callback handling
+ * Defines the contract for web mode clients
+ */
+export interface IWebUIClient extends UIClient {
+    /**
+     * Handle OAuth callback after redirect (web mode only)
+     * @param code - Authorization code from OAuth provider
+     * @param state - State parameter for CSRF protection
+     * @returns AuthLoggedIn with login state and user info
+     */
+    handleOAuthCallback(code: string, state: string): Promise<AuthLoggedIn>;
+}
+/**
+ * Type guard to check if client has OAuth callback handling (web mode)
+ * @param client - Client to check
+ * @returns true if client is IWebUIClient with handleOAuthCallback method
+ */
+export declare function isWebUIClient(client: UIClient): client is IWebUIClient;

package/dist/bodhi-js-sdk/core/src/logger.d.ts

@@ -0,0 +1,13 @@
+import { LogLevel } from './types/config';
+
+export declare class Logger {
+    private prefix;
+    private level;
+    constructor(prefix: string, level?: LogLevel | 'silent');
+    private shouldLog;
+    private ts;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}

package/dist/bodhi-js-sdk/core/src/oauth.d.ts

@@ -0,0 +1,45 @@
+import { UserInfo } from './types';
+
+/**
+ * Base64 URL encode a buffer (for PKCE)
+ */
+export declare function base64UrlEncode(buffer: ArrayBuffer): string;
+/**
+ * Generate a random code verifier for PKCE
+ */
+export declare function generateCodeVerifier(): string;
+/**
+ * Generate code challenge from verifier for PKCE
+ */
+export declare function generateCodeChallenge(verifier: string): Promise<string>;
+/**
+ * Parse JWT token and return payload
+ */
+export declare function parseJwt(token: string): Record<string, unknown>;
+/**
+ * Extract UserInfo from JWT token
+ */
+export declare function extractUserInfo(token: string): UserInfo;
+export interface OAuthEndpoints {
+    authorize: string;
+    token: string;
+    revoke: string;
+}
+/**
+ * Create OAuth endpoints from auth server URL
+ */
+export declare function createOAuthEndpoints(authServerUrl: string): OAuthEndpoints;
+export interface RefreshTokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    id_token?: string;
+    expires_in: number;
+}
+/**
+ * Refresh access token using refresh token
+ * @param tokenEndpoint - OAuth token endpoint URL
+ * @param refreshToken - Current refresh token
+ * @param clientId - OAuth client ID
+ * @returns New tokens or null if refresh failed
+ */
+export declare function refreshAccessToken(tokenEndpoint: string, refreshToken: string, clientId: string): Promise<RefreshTokenResponse | null>;

package/dist/bodhi-js-sdk/core/src/onboarding/config.d.ts

@@ -0,0 +1,10 @@
+import { Browser, OS } from '../../../../setup-modal/src/types';
+
+/**
+ * Browser configurations with extension store URLs
+ */
+export declare const BROWSER_CONFIGS: Browser[];
+/**
+ * Operating system configurations with download URLs
+ */
+export declare const OS_CONFIGS: OS[];

package/dist/bodhi-js-sdk/core/src/onboarding/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Onboarding module - Framework-agnostic setup modal
+ */
+export { OnboardingModal, type AsyncRequestHandler, type AsyncRequestHandlers, type ModalEvent, type ModalEventMap, type OnboardingModalConfig, } from './modal';
+export { BROWSER_CONFIGS, OS_CONFIGS } from './config';

package/dist/bodhi-js-sdk/core/src/onboarding/modal.d.ts

@@ -0,0 +1,80 @@
+import { MessageType, RequestMessage, ResponsePayload } from '../../../../setup-modal/src/types';
+
+import type * as ModalTypes from '@bodhiapp/setup-modal/types';
+/**
+ * Async handler for modal requests
+ * Supports both sync and async responses
+ */
+export type AsyncRequestHandler<K extends MessageType> = ((msg: RequestMessage<K>) => Promise<ResponsePayload<K>>) | ((msg: RequestMessage<K>) => ResponsePayload<K>);
+/**
+ * Map of message types to async request handlers
+ */
+export type AsyncRequestHandlers = {
+    [K in MessageType]?: AsyncRequestHandler<K>;
+};
+export type ModalEvent = 'complete' | 'close' | 'refresh' | 'lna_connect' | 'lna_skip' | 'confirm_server_install' | 'select_connection';
+/**
+ * Event payload types for type-safe event handlers
+ */
+export interface ModalEventMap {
+    complete: [];
+    close: [];
+    refresh: [];
+    lna_connect: [serverUrl: string];
+    lna_skip: [];
+    confirm_server_install: [];
+    select_connection: [connection: 'lna' | 'extension'];
+}
+/**
+ * Configuration options for OnboardingModal
+ */
+export interface OnboardingModalConfig {
+    /**
+     * Path to modal HTML file relative to extension root
+     * Used with chrome.runtime.getURL() in extension context
+     * @default 'src/sdk/core/onboarding/modal.html'
+     */
+    modalHtmlPath?: string;
+    /**
+     * Message handlers for iframe requests
+     * Required - delegates all business logic to external handlers
+     */
+    handlers: AsyncRequestHandlers;
+}
+/**
+ * OnboardingModal manages the setup modal iframe
+ * Infrastructure layer only - delegates business logic to handlers
+ */
+export declare class OnboardingModal {
+    private overlayElement;
+    private iframeElement;
+    private isIframeReady;
+    private currentSetupState;
+    private messageHandler;
+    private modalHtmlPath;
+    private handlers;
+    constructor(config: OnboardingModalConfig);
+    /**
+     * Show the modal with the given state
+     * State building is handled by SetupModalProcessor
+     */
+    show(state: ModalTypes.SetupState): void;
+    /**
+     * Update the modal state
+     * Used by SetupModalProcessor to push state updates to the modal
+     */
+    updateState(state: ModalTypes.SetupState): void;
+    /**
+     * Destroy the modal and clean up
+     */
+    destroy(): void;
+    /**
+     * Handle postMessage from iframe
+     * Pure routing - delegates to external handlers
+     */
+    private handleMessage;
+    /**
+     * Send current state to modal iframe using event message
+     */
+    private sendStateToModal;
+}

package/dist/bodhi-js-sdk/core/src/onboarding/protocol-utils.d.ts

@@ -0,0 +1,33 @@
+import { MessageType, RequestPayload, ResponsePayload, RequestMessage, RequestId } from '../../../../setup-modal/src/types';
+
+/** Build fire-and-forget event message */
+export declare function buildEvent<T extends MessageType>(type: T, payload: RequestPayload<T>): {
+    kind: "event";
+    type: T;
+    payload: RequestPayload<T>;
+};
+/** Build response message with requestId correlation */
+export declare function buildResponse<T extends MessageType>(requestId: RequestId, type: T, payload: ResponsePayload<T>): {
+    kind: "response";
+    type: T;
+    requestId: RequestId;
+    payload: ResponsePayload<T>;
+};
+/** Build error message */
+export declare function buildError(requestId: RequestId, error: {
+    code: string;
+    message: string;
+    details?: unknown;
+}): {
+    kind: "error";
+    requestId: RequestId;
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+};
+/** Type-safe request handler - processes incoming requests and returns response */
+export declare function handleRequest<T extends MessageType>(message: RequestMessage<T>, handlers: Partial<{
+    [K in MessageType]: (payload: RequestPayload<K>) => ResponsePayload<K>;
+}>): ReturnType<typeof buildResponse> | null;

package/dist/bodhi-js-sdk/core/src/platform.d.ts

@@ -0,0 +1,11 @@
+import { BrowserInfo, OSInfo } from './types';
+
+/**
+ * Detects the current browser using UAParser.js
+ */
+export declare function detectBrowser(): BrowserInfo;
+/**
+ * Detects the current operating system using UAParser.js
+ * Maps all OS variants to simplified supported types
+ */
+export declare function detectOS(): OSInfo;

package/dist/bodhi-js-sdk/core/src/storage.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Namespaced storage key generator
+ *
+ * Creates consistent storage keys with prefixes to avoid conflicts between
+ * different connection modes and other applications.
+ */
+export interface StorageKeys {
+    ACCESS_TOKEN: string;
+    REFRESH_TOKEN: string;
+    EXPIRES_AT: string;
+    CODE_VERIFIER: string;
+    STATE: string;
+    RESOURCE_SCOPE: string;
+}
+/**
+ * Create namespaced storage keys with a given prefix
+ *
+ * @param prefix - Namespace prefix (e.g., 'bodhi:direct', 'bodhi:web')
+ * @returns Storage keys object with namespaced keys
+ */
+export declare function createStorageKeys(prefix: string): StorageKeys;
+/**
+ * Standard prefixes for different connection modes
+ */
+export declare const STORAGE_PREFIXES: {
+    readonly DIRECT: "bodhi:direct";
+    readonly WEB: "bodhi:web";
+    readonly EXT: "bodhi:ext";
+};
+/**
+ * User Preferences Storage Manager
+ *
+ * Manages localStorage for user preferences including connection mode,
+ * server URL, and other client configuration.
+ *
+ * Storage keys use configurable prefix to namespace all app storage.
+ * Defaults to 'bodhijs:' for SDK usage.
+ */
+/**
+ * Manager for reading/writing user preferences to localStorage
+ */
+export declare class BodhiClientUserPrefsManager {
+    private readonly storagePrefix;
+    private readonly STORAGE_KEYS;
+    private readonly SERVER_INSTALL_KEY;
+    /**
+     * @param storagePrefix - Prefix for localStorage keys (default: 'bodhijs:')
+     */
+    constructor(storagePrefix?: string);
+    /**
+     * Get direct connection status (LNA permission state)
+     */
+    getDirectStatus(): 'granted' | 'skipped' | 'denied' | null;
+    /**
+     * Set direct connection status (LNA permission state)
+     */
+    setDirectStatus(status: 'granted' | 'skipped' | 'denied' | null): void;
+    /**
+     * Clear all preferences
+     */
+    clear(): void;
+    /**
+     * Check if server install was confirmed
+     * (Separate from connection prefs - stored at server:installed key)
+     */
+    isServerInstallConfirmed(): boolean;
+    /**
+     * Set server install confirmation
+     */
+    setServerInstallConfirmed(confirmed: boolean): void;
+    /**
+     * Get serialized client state
+     */
+    getSerializedClientState<T>(): T | null;
+    /**
+     * Set serialized client state
+     */
+    setSerializedClientState<T>(state: T): void;
+    private getStorageValue;
+    private setStorageValue;
+}