openrtc 0.1.0

package/dist/core/bridges/NativeIpcBridge.d.ts

@@ -0,0 +1,156 @@
+import { BackendConnectionState, Device, DeviceStatusSnapshot, ExplicitFileDataSendParams, ISignalingBackend, LocalDeviceInfo, NativeConnectResult, SignalingSession, SessionEvent } from '../types';
+import type { AuthContext } from '../IEngineBridge';
+import { WasmBridgeOptions } from './WasmBridge';
+import { type PlutoIpcBridge } from '../../runtime/ipc';
+export interface NativeIpcBridgeOptions extends WasmBridgeOptions {
+    allowWasmFallback?: boolean;
+    ipcBridge?: PlutoIpcBridge;
+}
+export declare class NativeIpcBridge implements ISignalingBackend {
+    /**
+     * NativeIpcBridge is a host adapter for native IPC.
+     *
+     * Allowed:
+     * - lightweight IPC readiness checks
+     * - native auth relay
+     * - typed command/event forwarding
+     *
+     * Not allowed:
+     * - becoming a second lifecycle engine
+     * - owning peer identity policy
+     * - teaching product code to depend on native-specific fallbacks
+     *
+     * Source of truth:
+     * - Rust core owns connection lifecycle and device identity
+     * - RuntimeClient owns host-facing orchestration
+     */
+    private subscriptionNonce;
+    private lastSyncedAuthToken;
+    private cachedLocalDeviceId;
+    private cachedLocalDeviceName;
+    private tauriCoreAvailability;
+    private tauriCoreAvailabilityValue;
+    private tauriCoreAvailabilityCheckedAtMs;
+    private authSyncInFlight;
+    private lastNativeAuthSyncAtMs;
+    private hasLoggedMissingAuthForDevices;
+    private static readonly AUTH_REQUIRED_WAIT_MS;
+    private static readonly CONNECTION_EVENT_SUBSCRIBE_WINDOW_MS;
+    private static readonly CONNECTION_EVENT_RETRY_MIN_DELAY_MS;
+    private static readonly CONNECTION_EVENT_RETRY_MAX_DELAY_MS;
+    private static readonly TAURI_IPC_NEGATIVE_CACHE_MS;
+    readonly app: import("firebase/app").FirebaseApp | null;
+    readonly auth: import("firebase/auth").Auth | null;
+    readonly appTag: string;
+    private readonly fallback;
+    private readonly options;
+    private readonly allowWasmFallback;
+    private readonly ipcBridge;
+    private nativeRtdbPresenceScope;
+    private nativeRtdbTicketVersion;
+    private lastNativePresenceTicket;
+    constructor(options: NativeIpcBridgeOptions);
+    get currentUser(): import("../types").RuntimeIdentity | null;
+    get tag(): string;
+    setWasmClient(client: any): void;
+    onAuthChange(callback: (user: import('../types').RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<import("../types").SignalingEnvelope[]>;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<import("../types").BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<import("../types").BackendPeerUniStream>;
+    isConnected(nodeId: string): Promise<boolean>;
+    private getAuthContext;
+    private getCurrentUserId;
+    private resolveWebLogicalDeviceId;
+    private normalizeDevice;
+    private matchesTag;
+    private buildNativeRtdbScope;
+    private syncNativeRtdbPresenceTicket;
+    private markNativeRtdbOffline;
+    isTauriEnv(): boolean;
+    private sleep;
+    private nextConnectionEventRetryDelayMs;
+    private clearNativeAuthRelay;
+    private canUseTauriIpc;
+    private invokeIpc;
+    private listenIpc;
+    private shouldUseTauriSignaling;
+    signInWithPluto(): Promise<void>;
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity(options?: {
+        userId?: string | null;
+    }): Promise<void>;
+    private ensureNativeAuthOnce;
+    private ensureNativeAuth;
+    private resolveLocalDeviceId;
+    private resolveLocalDeviceName;
+    private normalizeNativeDeviceName;
+    private defaultDeviceNameFallback;
+    private withPresenceMetadata;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<import('../types').PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<import('../types').PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<import('../types').PeerSessionSnapshot | null>;
+    resolvePeerConnectionRecords(id: string): Promise<import('../types').ManagedConnectionRecord[]>;
+    resolvePeerIdentity(id: string): Promise<import('../types').ResolvedPeerIdentity>;
+    setOffline(localNodeId: string): Promise<void>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
+    updateLocalDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getEndpointTicket(): Promise<string>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    registerSessionToken(token: string, grantScope: string, maxConnections: number): Promise<void>;
+    getEndpointTicketWithToken(grantScope: string, maxConnections: number): Promise<string | null>;
+    validateSessionToken(token: string, connectionId?: string): Promise<string | null>;
+    revokeSessionTokensByScope(grantScope: string): Promise<string[]>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeDevices(userId: string): Promise<ReadableStream<import('../types').DeviceEvent[]>>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    getLocalDeviceId(): Promise<string | null>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    forceReconnectSnapshot(): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    startPresenceLoopOnce(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    private shouldUseResolvedDeviceName;
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void>;
+    /**
+     * Subscribe to raw messages forwarded from native iroh connections.
+     * The Rust backend emits `iroh://message` Tauri events for messages that
+     * arrive on the main stream of an incoming connection. This lets the TS
+     * Client.handleMessage() run token validation on native-side connections.
+     *
+     * Payload: { connectionId: string, streamId: string, data: number[] }
+     * The `data` array is the raw frame bytes; for TS-originated messages it is
+     * [4-byte-len BE][1-byte-type][JSON payload].
+     */
+    onIncomingNativeMessage(callback: (connectionId: string, remoteNodeId: string | null, message: any) => void): Promise<() => void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+}