@unified-desktop/bridge 0.0.0-stage → 0.2.4

package/dist/tauri-QULQ7SNH.js

@@ -0,0 +1,394 @@
+import {
+  BridgeError,
+  assertSafeExternalUrl,
+  createCommonBridge,
+  createDialogBridge,
+  createLogger,
+  createWebPermissionBridge,
+  getBridgeConfig,
+  toBridgeError
+} from "./chunk-XDKQZC4S.js";
+
+// src/tauri.ts
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { getCurrent, onOpenUrl } from "@tauri-apps/plugin-deep-link";
+import { readText as readClipboardText, writeText as writeClipboardText } from "@tauri-apps/plugin-clipboard-manager";
+import { confirm as showConfirmDialog, message as showMessageDialog } from "@tauri-apps/plugin-dialog";
+import {
+  isPermissionGranted as isNotificationPermissionGranted,
+  requestPermission as requestNotificationPermission,
+  sendNotification
+} from "@tauri-apps/plugin-notification";
+import { openUrl } from "@tauri-apps/plugin-opener";
+import { load } from "@tauri-apps/plugin-store";
+import { Stronghold } from "@tauri-apps/plugin-stronghold";
+import { appDataDir } from "@tauri-apps/api/path";
+import { check as checkForTauriUpdate } from "@tauri-apps/plugin-updater";
+async function invokeCommand(command, args) {
+  try {
+    return await invoke(command, args);
+  } catch (error) {
+    throw toBridgeError(error);
+  }
+}
+function createTauriBridge(overrides = {}) {
+  const updaterConfig = getBridgeConfig().updater;
+  const isEnabled = (name) => getBridgeConfig().runtimePermissions?.[name]?.enabled === true;
+  const assertEnabled = (name) => {
+    if (!isEnabled(name)) throw new BridgeError({ code: "UNSUPPORTED", message: `${name} is disabled by the application policy.`, retryable: false });
+  };
+  let pendingUpdate;
+  const updateListeners = /* @__PURE__ */ new Set();
+  const emitUpdateProgress = (progress) => updateListeners.forEach((listener) => listener(progress));
+  let storePromise;
+  const getStore = () => {
+    storePromise ?? (storePromise = load("unified-desktop-store.json", { autoSave: 100 }));
+    return storePromise;
+  };
+  const fileSystem = {
+    readTextFile: (path) => invokeCommand("read_text_file", { path }),
+    saveTextFile: ({ suggestedName, contents }) => invokeCommand("save_text_file", { suggestedName, contents }),
+    async pickFiles(options) {
+      return invokeCommand("file_pick_open", { options });
+    },
+    async pickDirectory(options) {
+      return invokeCommand("file_pick_directory", { options });
+    },
+    async pickSaveFile(options) {
+      return invokeCommand("file_pick_save", { options });
+    },
+    async readFile(handle) {
+      return new Uint8Array(await invokeCommand("file_read", { id: handle.id }));
+    },
+    writeFile: (handle, data) => invokeCommand("file_write", { id: handle.id, data: Array.from(data) }),
+    releaseFileHandle: (handle) => invokeCommand("file_release_handle", { id: handle.id })
+  };
+  let strongholdPromise;
+  const getSecureStore = async () => {
+    strongholdPromise ?? (strongholdPromise = (async () => {
+      const password = await invokeCommand("secure_vault_password");
+      const vaultPath = `${await appDataDir()}unified-desktop-secure.hold`;
+      const stronghold = await Stronghold.load(vaultPath, password);
+      let client;
+      try {
+        client = await stronghold.loadClient("unified-desktop");
+      } catch {
+        client = await stronghold.createClient("unified-desktop");
+      }
+      return { stronghold, store: client.getStore() };
+    })());
+    return strongholdPromise;
+  };
+  const secureStorage = {
+    async get(key) {
+      try {
+        const value = await (await getSecureStore()).store.get(key);
+        return value === null ? null : new TextDecoder().decode(new Uint8Array(value));
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async set(key, value) {
+      try {
+        const secure = await getSecureStore();
+        await secure.store.insert(key, Array.from(new TextEncoder().encode(value)));
+        await secure.stronghold.save();
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async has(key) {
+      try {
+        const value = await (await getSecureStore()).store.get(key);
+        return value !== null;
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async delete(key) {
+      try {
+        const secure = await getSecureStore();
+        const previous = await secure.store.remove(key);
+        if (previous === null) return false;
+        await secure.stronghold.save();
+        return true;
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    }
+  };
+  const browserPermissions = createWebPermissionBridge();
+  const permissions = {
+    async query(name, options) {
+      try {
+        if (!isEnabled(name)) return { name, state: "unsupported", scope: "security-policy" };
+        if (name === "notifications") {
+          const granted = await isNotificationPermissionGranted();
+          return { name, state: granted ? "granted" : "prompt", scope: "native-notification" };
+        }
+        const native = await invokeCommand("permission_query", { name, handleId: options?.handleId });
+        return native.state === "prompt" && !name.startsWith("file-") && !name.startsWith("directory-") ? browserPermissions.query(name, options) : native;
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async request(name, options) {
+      try {
+        if (!isEnabled(name)) return { name, state: "unsupported", scope: "security-policy" };
+        if (name === "notifications") {
+          const permission = await requestNotificationPermission();
+          return {
+            name,
+            state: permission === "default" ? "prompt" : permission,
+            scope: "native-notification"
+          };
+        }
+        const native = await invokeCommand("permission_request", { name, handleId: options?.handleId });
+        return native.state === "prompt" && !name.startsWith("file-") && !name.startsWith("directory-") ? browserPermissions.request(name, options) : native;
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    }
+  };
+  const clipboard = {
+    async readText() {
+      assertEnabled("clipboard-read");
+      try {
+        return await readClipboardText();
+      } catch (error) {
+        throw toBridgeError(error, { code: "PERMISSION_DENIED", retryable: false });
+      }
+    },
+    async writeText(text) {
+      assertEnabled("clipboard-write");
+      try {
+        await writeClipboardText(text);
+      } catch (error) {
+        throw toBridgeError(error, { code: "PERMISSION_DENIED", retryable: false });
+      }
+    }
+  };
+  const notification = {
+    async requestPermission() {
+      assertEnabled("notifications");
+      try {
+        const granted = await isNotificationPermissionGranted();
+        if (granted) return "granted";
+        return await requestNotificationPermission();
+      } catch (error) {
+        throw toBridgeError(error, { code: "PERMISSION_DENIED", retryable: false });
+      }
+    },
+    async show({ title, body }) {
+      assertEnabled("notifications");
+      try {
+        let granted = await isNotificationPermissionGranted();
+        if (!granted) granted = await requestNotificationPermission() === "granted";
+        if (!granted) throw new Error("Notification permission was not granted.");
+        sendNotification({ title, body });
+      } catch (error) {
+        throw toBridgeError(error, { code: "PERMISSION_DENIED", retryable: false });
+      }
+    }
+  };
+  const webDialog = createDialogBridge();
+  const nativeDialog = {
+    async alert(message, title) {
+      try {
+        await showMessageDialog(message, { title, kind: "info" });
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async confirm(message, title) {
+      try {
+        return await showConfirmDialog(message, { title, kind: "info" });
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    prompt: webDialog.prompt
+  };
+  const store = {
+    get: async (key) => {
+      try {
+        return await (await getStore()).get(key);
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    set: async (key, value) => {
+      try {
+        await (await getStore()).set(key, value);
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    has: async (key) => {
+      try {
+        return await (await getStore()).has(key);
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    delete: async (key) => {
+      try {
+        return await (await getStore()).delete(key);
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    clear: async () => {
+      try {
+        await (await getStore()).clear();
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    keys: async () => {
+      try {
+        return await (await getStore()).keys();
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    entries: async () => {
+      try {
+        return await (await getStore()).entries();
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    save: async () => {
+      try {
+        await (await getStore()).save();
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    subscribe(listener) {
+      let disposed = false;
+      let unlisten;
+      void getStore().then((loadedStore) => loadedStore.onChange((key, value) => listener({ key, value }))).then((stop) => {
+        if (disposed) stop();
+        else unlisten = stop;
+      }).catch(() => void 0);
+      return () => {
+        disposed = true;
+        unlisten?.();
+      };
+    }
+  };
+  const deepLink = {
+    async getInitialUrl() {
+      try {
+        const urls = await getCurrent();
+        return urls?.[0] ?? null;
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    subscribe(listener) {
+      let disposed = false;
+      let unlisten;
+      void onOpenUrl((urls) => urls.forEach(listener)).then((stop) => {
+        if (disposed) stop();
+        else unlisten = stop;
+      });
+      return () => {
+        disposed = true;
+        unlisten?.();
+      };
+    }
+  };
+  const windowState = {
+    get: () => invokeCommand("window_get_state"),
+    set: (bounds) => invokeCommand("window_set_state", { bounds }),
+    subscribe(listener) {
+      let disposed = false;
+      let unlisten;
+      void listen("window-state-changed", (event) => listener(event.payload)).then((stop) => {
+        if (disposed) stop();
+        else unlisten = stop;
+      });
+      return () => {
+        disposed = true;
+        unlisten?.();
+      };
+    }
+  };
+  return createCommonBridge("tauri", {
+    logger: createLogger("tauri", (level, message, context) => {
+      void invokeCommand("log_write", { level, message, context }).catch(() => void 0);
+    }),
+    fileSystem,
+    clipboard,
+    dialog: nativeDialog,
+    notification,
+    shell: {
+      openExternal: async (url) => {
+        try {
+          await openUrl(assertSafeExternalUrl(url));
+        } catch (error) {
+          throw toBridgeError(error);
+        }
+      },
+      openPath: (path) => invokeCommand("shell_open_path", { path }),
+      revealItem: (path) => invokeCommand("shell_reveal_item", { path })
+    },
+    process: {
+      info: () => invokeCommand("process_info"),
+      exit: (code) => invokeCommand("process_exit", { code }),
+      restart: () => invokeCommand("process_restart")
+    },
+    deepLink,
+    updater: {
+      async check() {
+        if (!updaterConfig.enabled) return null;
+        try {
+          pendingUpdate = await checkForTauriUpdate({ timeout: updaterConfig.requestTimeoutMs }) ?? void 0;
+          if (!pendingUpdate) return null;
+          return {
+            version: pendingUpdate.version,
+            notes: pendingUpdate.body,
+            date: pendingUpdate.date,
+            channel: updaterConfig.channel
+          };
+        } catch (error) {
+          throw toBridgeError(error, { code: "NETWORK_ERROR", retryable: true });
+        }
+      },
+      async downloadAndInstall() {
+        if (!updaterConfig.enabled) throw toBridgeError("The Tauri updater is disabled.", { code: "UNSUPPORTED", retryable: false });
+        try {
+          pendingUpdate ?? (pendingUpdate = await checkForTauriUpdate({ timeout: updaterConfig.requestTimeoutMs }) ?? void 0);
+          if (!pendingUpdate) return;
+          let downloaded = 0;
+          let total = 0;
+          await pendingUpdate.downloadAndInstall((event) => {
+            if (event.event === "Started") total = event.data.contentLength ?? 0;
+            if (event.event === "Progress") downloaded += event.data.chunkLength;
+            emitUpdateProgress(total > 0 ? Math.min(100, downloaded / total * 100) : 0);
+          });
+          emitUpdateProgress(100);
+          pendingUpdate = void 0;
+          await invokeCommand("process_restart");
+        } catch (error) {
+          throw toBridgeError(error, { code: "NETWORK_ERROR", retryable: true });
+        }
+      },
+      subscribe(listener) {
+        updateListeners.add(listener);
+        return () => updateListeners.delete(listener);
+      }
+    },
+    windowState,
+    store,
+    secureStorage,
+    permissions
+  }, overrides);
+}
+export {
+  createTauriBridge
+};

package/dist/tauri.d.ts

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

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { ClipboardBridge } from './common/clipboard';
+import type { DeepLinkBridge } from './common/deep-link';
+import type { DialogBridge } from './common/dialog';
+import type { FileSystemBridge } from './common/file-system';
+import type { HttpClient } from './common/http';
+import type { Logger } from './common/logging';
+import type { NotificationBridge } from './common/notification';
+import type { ProcessBridge } from './common/process';
+import type { ShellBridge } from './common/shell';
+import type { UpdaterBridge } from './common/updater';
+import type { UploadBridge } from './common/upload';
+import type { WebSocketBridge } from './common/websocket';
+import type { WindowStateBridge } from './common/window-state';
+import type { StoreBridge } from './common/store';
+import type { SecureStorageBridge } from './common/secure-storage';
+import type { PermissionBridge } from './common/permissions';
+export type RuntimeKind = 'electron' | 'tauri' | 'web';
+export type { AppErrorCode, AppErrorShape, BridgeError } from './errors';
+export interface UpdateInfo {
+    version: string;
+    notes?: string;
+    url?: string;
+    date?: string;
+    channel?: string;
+}
+export interface SaveTextFileInput {
+    suggestedName: string;
+    contents: string;
+}
+/**
+ * The only native API surface the UI should depend on.
+ * Add capabilities here first, then implement them in each shell adapter.
+ */
+export interface AppBridge {
+    readonly runtime: RuntimeKind;
+    readonly http: HttpClient;
+    readonly logger: Logger;
+    readonly fileSystem: FileSystemBridge;
+    readonly deepLink: DeepLinkBridge;
+    readonly clipboard: ClipboardBridge;
+    readonly dialog: DialogBridge;
+    readonly notification: NotificationBridge;
+    readonly process: ProcessBridge;
+    readonly shell: ShellBridge;
+    readonly updater: UpdaterBridge;
+    readonly upload: UploadBridge;
+    readonly websocket: WebSocketBridge;
+    readonly windowState: WindowStateBridge;
+    readonly store: StoreBridge;
+    readonly secureStorage: SecureStorageBridge;
+    readonly permissions: PermissionBridge;
+    /** Backward-compatible aliases. Prefer the namespaced capabilities above. */
+    readTextFile(path: string): Promise<string>;
+    saveTextFile(input: SaveTextFileInput): Promise<void>;
+    openExternal(url: string): Promise<void>;
+    checkUpdate(): Promise<UpdateInfo | null>;
+}

package/dist/web-GCAG6XIV.js

@@ -0,0 +1,11 @@
+import {
+  createCommonBridge
+} from "./chunk-XDKQZC4S.js";
+
+// src/web.ts
+function createWebBridge(overrides = {}) {
+  return createCommonBridge("web", overrides);
+}
+export {
+  createWebBridge
+};

package/dist/web.d.ts

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

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@unified-desktop/bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.4",
+  "type": "module",
+  "description": "Framework-neutral Web/Electron/Tauri bridge",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run --config vitest.config.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.8.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.3.3",
+    "@tauri-apps/plugin-deep-link": "^2.4.0",
+    "@tauri-apps/plugin-dialog": "^2.7.3",
+    "@tauri-apps/plugin-notification": "^2.4.0",
+    "@tauri-apps/plugin-opener": "^2.4.0",
+    "@tauri-apps/plugin-store": "^2.4.0",
+    "@tauri-apps/plugin-stronghold": "^2.3.2",
+    "@tauri-apps/plugin-updater": "^2.11.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2",
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.12"
+  }
+}