@unified-desktop/bridge 0.0.0-stage → 0.2.3

package/dist/common/bridge.d.ts

@@ -0,0 +1,36 @@
+import type { AppBridge, RuntimeKind } from '../types';
+import { type ClipboardBridge } from './clipboard';
+import { type DeepLinkBridge } from './deep-link';
+import { type DialogBridge } from './dialog';
+import { type FileSystemBridge } from './file-system';
+import { type HttpClient } from './http';
+import { type Logger } from './logging';
+import { type NotificationBridge } from './notification';
+import { type ProcessBridge } from './process';
+import { type ShellBridge } from './shell';
+import { type UpdaterBridge } from './updater';
+import { type UploadBridge } from './upload';
+import { type WebSocketBridge } from './websocket';
+import { type WindowStateBridge } from './window-state';
+import { type StoreBridge } from './store';
+import { type SecureStorageBridge } from './secure-storage';
+import { type PermissionBridge } from './permissions';
+export interface BridgeOverrides {
+    http?: HttpClient;
+    clipboard?: ClipboardBridge;
+    dialog?: DialogBridge;
+    notification?: NotificationBridge;
+    upload?: UploadBridge;
+    websocket?: WebSocketBridge;
+    store?: StoreBridge;
+    secureStorage?: SecureStorageBridge;
+    permissions?: PermissionBridge;
+    fileSystem?: Partial<FileSystemBridge>;
+    shell?: Partial<ShellBridge>;
+    process?: Partial<ProcessBridge>;
+    deepLink?: Partial<DeepLinkBridge>;
+    updater?: Partial<UpdaterBridge>;
+    windowState?: Partial<WindowStateBridge>;
+    logger?: Logger;
+}
+export declare function createCommonBridge(runtime: RuntimeKind, baseOverrides?: BridgeOverrides, customOverrides?: BridgeOverrides): AppBridge;

package/dist/common/clipboard.d.ts

@@ -0,0 +1,5 @@
+export interface ClipboardBridge {
+    readText(): Promise<string>;
+    writeText(text: string): Promise<void>;
+}
+export declare function createClipboardBridge(): ClipboardBridge;

package/dist/common/deep-link.d.ts

@@ -0,0 +1,5 @@
+export interface DeepLinkBridge {
+    getInitialUrl(): Promise<string | null>;
+    subscribe(listener: (url: string) => void): () => void;
+}
+export declare function createWebDeepLinkBridge(): DeepLinkBridge;

package/dist/common/dialog.d.ts

@@ -0,0 +1,6 @@
+export interface DialogBridge {
+    alert(message: string, title?: string): Promise<void>;
+    confirm(message: string, title?: string): Promise<boolean>;
+    prompt(message: string, defaultValue?: string, title?: string): Promise<string | null>;
+}
+export declare function createDialogBridge(): DialogBridge;

package/dist/common/file-system.d.ts

@@ -0,0 +1,35 @@
+import type { SaveTextFileInput } from '../types';
+import type { BridgePermissionName } from './permissions';
+export interface FilePickerFilter {
+    name: string;
+    extensions: string[];
+}
+export interface FilePickerOptions {
+    title?: string;
+    defaultPath?: string;
+    filters?: FilePickerFilter[];
+    multiple?: boolean;
+    writable?: boolean;
+    /** Save handles are limited to the capability that authorized the picker. */
+    permission?: 'file-write' | 'file-download';
+}
+export interface FileHandle {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: 'file' | 'directory';
+    readonly writable: boolean;
+    readonly size?: number;
+}
+export interface FileSystemBridge {
+    readTextFile(path: string): Promise<string>;
+    saveTextFile(input: SaveTextFileInput): Promise<void>;
+    pickFiles(options?: FilePickerOptions): Promise<FileHandle[]>;
+    pickDirectory(options?: FilePickerOptions): Promise<FileHandle | null>;
+    pickSaveFile(options?: FilePickerOptions): Promise<FileHandle | null>;
+    readFile(handle: FileHandle): Promise<Uint8Array>;
+    writeFile(handle: FileHandle, data: Uint8Array): Promise<void>;
+    releaseFileHandle(handle: FileHandle): Promise<void>;
+}
+export declare function createWebFileSystemBridge(): FileSystemBridge & {
+    hasPermission(name: BridgePermissionName, id: string): boolean;
+};

package/dist/common/http-client.d.ts

@@ -0,0 +1 @@
+export * from './http';

package/dist/common/http.d.ts

@@ -0,0 +1,24 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type HttpResponseType = 'json' | 'text' | 'arrayBuffer';
+export interface HttpRequest {
+    url: string;
+    method?: HttpMethod;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    responseType?: HttpResponseType;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface HttpResponse<T> {
+    status: number;
+    headers: Headers;
+    data: T;
+}
+export interface HttpClient {
+    request<T = unknown>(input: HttpRequest): Promise<HttpResponse<T>>;
+}
+export declare function createHttpClient(options?: {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+}): HttpClient;

package/dist/common/index.d.ts

@@ -0,0 +1,16 @@
+export * from './clipboard';
+export * from './deep-link';
+export * from './dialog';
+export * from './file-system';
+export * from './http';
+export * from './logging';
+export * from './notification';
+export * from './process';
+export * from './shell';
+export * from './store';
+export * from './secure-storage';
+export * from './permissions';
+export * from './updater';
+export * from './upload';
+export * from './websocket';
+export * from './window-state';

package/dist/common/logging.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeKind } from '../types';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogContext = Record<string, unknown>;
+export interface Logger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+export type LogSink = (level: LogLevel, message: string, context?: LogContext) => void;
+export declare function createLogger(runtime: RuntimeKind, sink?: LogSink): Logger;

package/dist/common/notification.d.ts

@@ -0,0 +1,10 @@
+export interface NotificationInput {
+    title: string;
+    body?: string;
+    tag?: string;
+}
+export interface NotificationBridge {
+    requestPermission(): Promise<NotificationPermission>;
+    show(input: NotificationInput): Promise<void>;
+}
+export declare function createNotificationBridge(): NotificationBridge;

package/dist/common/permissions.d.ts

@@ -0,0 +1,15 @@
+export type BridgePermissionName = 'microphone' | 'camera' | 'notifications' | 'clipboard-read' | 'clipboard-write' | 'file-read' | 'file-write' | 'file-download' | 'directory-read' | 'directory-write';
+export type BridgePermissionState = 'granted' | 'denied' | 'prompt' | 'unsupported';
+export interface PermissionRequestOptions {
+    handleId?: string;
+}
+export interface PermissionStatus {
+    name: BridgePermissionName;
+    state: BridgePermissionState;
+    scope?: string;
+}
+export interface PermissionBridge {
+    query(name: BridgePermissionName, options?: PermissionRequestOptions): Promise<PermissionStatus>;
+    request(name: BridgePermissionName, options?: PermissionRequestOptions): Promise<PermissionStatus>;
+}
+export declare function createWebPermissionBridge(hasPermission?: (name: BridgePermissionName, id: string) => boolean): PermissionBridge;

package/dist/common/process.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeKind } from '../types';
+export interface ProcessInfo {
+    runtime: RuntimeKind;
+    userAgent: string;
+    pid?: number;
+}
+export interface ProcessBridge {
+    info(): Promise<ProcessInfo>;
+    exit(code?: number): Promise<void>;
+    restart(): Promise<void>;
+}
+export declare function createWebProcessBridge(runtime: RuntimeKind): ProcessBridge;

package/dist/common/secure-storage.d.ts

@@ -0,0 +1,7 @@
+export interface SecureStorageBridge {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+}
+export declare function createStubSecureStorageBridge(): SecureStorageBridge;

package/dist/common/shell.d.ts

@@ -0,0 +1,6 @@
+export interface ShellBridge {
+    openExternal(url: string): Promise<void>;
+    openPath(path: string): Promise<void>;
+    revealItem(path: string): Promise<void>;
+}
+export declare function createWebShellBridge(): ShellBridge;

package/dist/common/store.d.ts

@@ -0,0 +1,21 @@
+export type StoreValue = null | boolean | number | string | StoreValue[] | {
+    [key: string]: StoreValue;
+};
+export interface StoreChange {
+    key: string;
+    value: StoreValue | undefined;
+}
+export interface StoreBridge {
+    get<T extends StoreValue = StoreValue>(key: string): Promise<T | undefined>;
+    set<T extends StoreValue = StoreValue>(key: string, value: T): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    entries<T extends StoreValue = StoreValue>(): Promise<Array<[string, T]>>;
+    save(): Promise<void>;
+    subscribe(listener: (change: StoreChange) => void): () => void;
+    /** Release browser-level listeners owned by this instance. */
+    dispose?(): void;
+}
+export declare function createWebStoreBridge(storageKey?: string, storage?: Storage): StoreBridge;

package/dist/common/updater.d.ts

@@ -0,0 +1,7 @@
+import type { UpdateInfo } from '../types';
+export interface UpdaterBridge {
+    check(): Promise<UpdateInfo | null>;
+    downloadAndInstall(update: UpdateInfo): Promise<void>;
+    subscribe(listener: (progress: number) => void): () => void;
+}
+export declare function createStubUpdaterBridge(): UpdaterBridge;

package/dist/common/upload.d.ts

@@ -0,0 +1,22 @@
+export interface UploadRequest {
+    url: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    body: XMLHttpRequestBodyInit;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    onProgress?: (progress: {
+        loaded: number;
+        total?: number;
+        percent?: number;
+    }) => void;
+}
+export interface UploadResponse<T = unknown> {
+    status: number;
+    headers: Headers;
+    data: T;
+}
+export interface UploadBridge {
+    send<T = unknown>(request: UploadRequest): Promise<UploadResponse<T>>;
+}
+export declare function createUploadBridge(): UploadBridge;

package/dist/common/websocket.d.ts

@@ -0,0 +1,20 @@
+export type WebSocketStatus = 'idle' | 'connecting' | 'open' | 'closed';
+export interface WebSocketOptions {
+    url: string;
+    protocols?: string | string[];
+    reconnect?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+}
+export interface WebSocketClient {
+    readonly status: WebSocketStatus;
+    connect(): Promise<void>;
+    send(data: string | ArrayBuffer | Blob): void;
+    close(code?: number, reason?: string): void;
+    onMessage(listener: (data: unknown) => void): () => void;
+    onStatus(listener: (status: WebSocketStatus) => void): () => void;
+}
+export interface WebSocketBridge {
+    create(options: WebSocketOptions): WebSocketClient;
+}
+export declare function createWebSocketBridge(): WebSocketBridge;

package/dist/common/window-state.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeKind } from '../types';
+export interface WindowBounds {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    maximized?: boolean;
+}
+export interface WindowStateBridge {
+    get(): Promise<WindowBounds | null>;
+    set(bounds: WindowBounds): Promise<void>;
+    subscribe(listener: (bounds: WindowBounds) => void): () => void;
+}
+export declare function createWebWindowStateBridge(runtime: RuntimeKind, key?: string): WindowStateBridge;

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+import type { BridgeOverrides } from './common/bridge';
+export interface BridgeConfig {
+    apiBaseUrl?: string;
+    runtimePermissions?: Record<string, {
+        enabled?: boolean;
+        requirePicker?: boolean;
+    }>;
+    externalProtocols?: string[];
+    updater?: {
+        enabled: boolean;
+        channel: string;
+        requestTimeoutMs: number;
+    };
+    overrides?: BridgeOverrides;
+}
+/** Call before getBridge(). Configuration belongs to the app, never the SDK package. */
+export declare function configureBridge(config: BridgeConfig): void;
+export declare function getBridgeConfig(): BridgeConfig;
+export declare function lockBridgeConfig(): void;

package/dist/electron-NLAZ6NWN.js

@@ -0,0 +1,112 @@
+import {
+  assertSafeExternalUrl,
+  createCommonBridge,
+  createDialogBridge,
+  createLogger,
+  createWebPermissionBridge,
+  toBridgeError
+} from "./chunk-XDKQZC4S.js";
+
+// src/electron.ts
+async function invoke(channel, payload) {
+  try {
+    return await window.electronAPI.invoke(channel, payload);
+  } catch (error) {
+    throw toBridgeError(error);
+  }
+}
+function on(channel, listener) {
+  try {
+    return window.electronAPI.on(channel, listener);
+  } catch (error) {
+    throw toBridgeError(error);
+  }
+}
+function createElectronBridge(overrides = {}) {
+  if (!window.electronAPI) {
+    throw new Error("Electron preload API is not available.");
+  }
+  const store = {
+    get: async (key) => invoke("store:get", { key }),
+    set: async (key, value) => invoke("store:set", { key, value }),
+    has: (key) => invoke("store:has", { key }),
+    delete: (key) => invoke("store:delete", { key }),
+    clear: () => invoke("store:clear"),
+    keys: () => invoke("store:keys"),
+    entries: () => invoke("store:entries"),
+    save: () => invoke("store:save"),
+    subscribe: (listener) => on("store:changed", listener)
+  };
+  const fileSystem = {
+    readTextFile: (path) => invoke("fs:readTextFile", { path }),
+    saveTextFile: (input) => invoke("fs:saveTextFile", input),
+    pickFiles: (options) => invoke("file:pick", options),
+    pickDirectory: (options) => invoke("file:pickDirectory", options),
+    pickSaveFile: (options) => invoke("file:pickSave", options),
+    readFile: async (handle) => new Uint8Array(await invoke("file:read", { id: handle.id })),
+    writeFile: (handle, data) => invoke("file:write", { id: handle.id, data }),
+    releaseFileHandle: (handle) => invoke("file:release", { id: handle.id })
+  };
+  const secureStorage = {
+    get: (key) => invoke("secure:get", { key }),
+    set: (key, value) => invoke("secure:set", { key, value }),
+    has: (key) => invoke("secure:has", { key }),
+    delete: (key) => invoke("secure:delete", { key })
+  };
+  const webDialog = createDialogBridge();
+  const nativeDialog = {
+    alert: (message, title) => invoke("dialog:alert", { message, title }),
+    confirm: (message, title) => invoke("dialog:confirm", { message, title }),
+    prompt: webDialog.prompt
+  };
+  const browserPermissions = createWebPermissionBridge();
+  const permissions = {
+    async query(name, options) {
+      const native = await invoke("permission:query", { name, ...options });
+      return native.state === "prompt" && !name.startsWith("file-") && !name.startsWith("directory-") ? browserPermissions.query(name, options) : native;
+    },
+    async request(name, options) {
+      const native = await invoke("permission:request", { name, ...options });
+      return native.state === "prompt" && !name.startsWith("file-") && !name.startsWith("directory-") ? browserPermissions.request(name, options) : native;
+    }
+  };
+  return createCommonBridge("electron", {
+    logger: createLogger("electron", (level, message, context) => {
+      void invoke("log:write", { level, message, context }).catch(() => void 0);
+    }),
+    fileSystem,
+    dialog: nativeDialog,
+    shell: {
+      openExternal: async (url) => {
+        await invoke("app:openExternal", { url: assertSafeExternalUrl(url) });
+      },
+      openPath: (path) => invoke("shell:openPath", { path }),
+      revealItem: (path) => invoke("shell:revealItem", { path })
+    },
+    process: {
+      info: () => invoke("process:getInfo"),
+      exit: (code) => invoke("process:exit", { code }),
+      restart: () => invoke("process:restart")
+    },
+    deepLink: {
+      getInitialUrl: () => invoke("deep-link:getInitial"),
+      subscribe: (listener) => on("deep-link:open", listener)
+    },
+    updater: {
+      check: () => invoke("app:checkUpdate"),
+      downloadAndInstall: () => invoke("app:downloadAndInstall"),
+      subscribe: (listener) => on("updater:progress", listener)
+    },
+    windowState: {
+      get: () => invoke("window:getState"),
+      set: (bounds) => invoke("window:setState", bounds),
+      subscribe: (listener) => on("window:stateChanged", listener)
+    },
+    store,
+    secureStorage,
+    permissions
+  }, overrides);
+}
+export {
+  createElectronBridge
+};

package/dist/electron.d.ts

@@ -0,0 +1,3 @@
+import { type BridgeOverrides } from './common/bridge';
+import type { AppBridge } from './types';
+export declare function createElectronBridge(overrides?: BridgeOverrides): AppBridge;

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+export type AppErrorCode = 'CANCELLED' | 'PERMISSION_DENIED' | 'NOT_FOUND' | 'UNSUPPORTED' | 'INVALID_INPUT' | 'NETWORK_ERROR' | 'UNKNOWN';
+export interface AppErrorShape {
+    code: AppErrorCode;
+    message: string;
+    retryable: boolean;
+}
+export declare class BridgeError extends Error implements AppErrorShape {
+    readonly code: AppErrorCode;
+    readonly retryable: boolean;
+    constructor({ code, message, retryable }: AppErrorShape);
+}
+/** Convert shell-specific rejected values into one stable error type for UI code. */
+export declare function toBridgeError(error: unknown, fallback?: Pick<AppErrorShape, 'code' | 'retryable'>): BridgeError;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { AppBridge } from './types';
+export { configureBridge } from './config';
+export type { BridgeConfig } from './config';
+export type { AppBridge, RuntimeKind, SaveTextFileInput, UpdateInfo } from './types';
+export { BridgeError, toBridgeError } from './errors';
+export type { AppErrorCode, AppErrorShape } from './errors';
+export { createCommonBridge } from './common/bridge';
+export type { BridgeOverrides } from './common/bridge';
+export * from './common';
+export declare function isTauri(): boolean;
+export declare function isElectron(): boolean;
+/** Resolve the shell adapter once and reuse it for the lifetime of the page. */
+export declare function getBridge(): Promise<AppBridge>;
+/** Shared React/Vue startup handoff after the first paint. */
+export declare function finishDesktopStartup(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,84 @@
+import {
+  BridgeError,
+  configureBridge,
+  createClipboardBridge,
+  createCommonBridge,
+  createDialogBridge,
+  createHttpClient,
+  createLogger,
+  createNotificationBridge,
+  createStubSecureStorageBridge,
+  createStubUpdaterBridge,
+  createUploadBridge,
+  createWebDeepLinkBridge,
+  createWebFileSystemBridge,
+  createWebPermissionBridge,
+  createWebProcessBridge,
+  createWebShellBridge,
+  createWebSocketBridge,
+  createWebStoreBridge,
+  createWebWindowStateBridge,
+  getBridgeConfig,
+  lockBridgeConfig,
+  toBridgeError
+} from "./chunk-XDKQZC4S.js";
+
+// src/index.ts
+function isTauri() {
+  return typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+}
+function isElectron() {
+  return typeof window !== "undefined" && Boolean(window.electronAPI);
+}
+var bridgePromise;
+function getBridge() {
+  bridgePromise ?? (bridgePromise = (async () => {
+    lockBridgeConfig();
+    if (isTauri()) {
+      const { createTauriBridge } = await import("./tauri-QULQ7SNH.js");
+      return createTauriBridge(getBridgeConfig().overrides);
+    }
+    if (isElectron()) {
+      const { createElectronBridge } = await import("./electron-NLAZ6NWN.js");
+      return createElectronBridge(getBridgeConfig().overrides);
+    }
+    const { createWebBridge } = await import("./web-GCAG6XIV.js");
+    return createWebBridge(getBridgeConfig().overrides);
+  })());
+  return bridgePromise;
+}
+async function finishDesktopStartup() {
+  if (typeof window === "undefined") return;
+  await new Promise((resolve) => window.requestAnimationFrame(() => resolve()));
+  document.getElementById("boot-splash")?.classList.add("is-hidden");
+  if (isTauri()) {
+    const { invoke } = await import("@tauri-apps/api/core");
+    await invoke("finish_startup");
+  }
+}
+export {
+  BridgeError,
+  configureBridge,
+  createClipboardBridge,
+  createCommonBridge,
+  createDialogBridge,
+  createHttpClient,
+  createLogger,
+  createNotificationBridge,
+  createStubSecureStorageBridge,
+  createStubUpdaterBridge,
+  createUploadBridge,
+  createWebDeepLinkBridge,
+  createWebFileSystemBridge,
+  createWebPermissionBridge,
+  createWebProcessBridge,
+  createWebShellBridge,
+  createWebSocketBridge,
+  createWebStoreBridge,
+  createWebWindowStateBridge,
+  finishDesktopStartup,
+  getBridge,
+  isElectron,
+  isTauri,
+  toBridgeError
+};

package/dist/security.d.ts

@@ -0,0 +1,2 @@
+/** Validate URLs before they reach a shell or the browser. Native layers repeat this check. */
+export declare function assertSafeExternalUrl(value: string): string;