@haex-space/vault-sdk 2.5.42 → 2.5.45

package/dist/vue.mjs

@@ -398,50 +398,19 @@ var HAEXTENSION_METHODS = {
   filesystem: {
     saveFile: "haextension:filesystem:save-file",
     openFile: "haextension:filesystem:open-file",
-    showImage: "haextension:filesystem:show-image"
-  },
-  filesync: {
-    // Spaces
-    listSpaces: "haextension:filesync:list-spaces",
-    createSpace: "haextension:filesync:create-space",
-    deleteSpace: "haextension:filesync:delete-space",
-    // Files
-    listFiles: "haextension:filesync:list-files",
-    getFile: "haextension:filesync:get-file",
-    uploadFile: "haextension:filesync:upload-file",
-    downloadFile: "haextension:filesync:download-file",
-    deleteFile: "haextension:filesync:delete-file",
-    // Backends
-    listBackends: "haextension:filesync:list-backends",
-    addBackend: "haextension:filesync:add-backend",
-    removeBackend: "haextension:filesync:remove-backend",
-    testBackend: "haextension:filesync:test-backend",
-    // Sync Rules
-    listSyncRules: "haextension:filesync:list-sync-rules",
-    addSyncRule: "haextension:filesync:add-sync-rule",
-    updateSyncRule: "haextension:filesync:update-sync-rule",
-    removeSyncRule: "haextension:filesync:remove-sync-rule",
-    // Sync Operations
-    getSyncStatus: "haextension:filesync:get-sync-status",
-    triggerSync: "haextension:filesync:trigger-sync",
-    pauseSync: "haextension:filesync:pause-sync",
-    resumeSync: "haextension:filesync:resume-sync",
-    // Conflict Resolution
-    resolveConflict: "haextension:filesync:resolve-conflict",
-    // UI Helpers
-    selectFolder: "haextension:filesync:select-folder",
-    scanLocal: "haextension:filesync:scan-local",
-    // Sync Queue (persistent upload/download queue)
-    addToQueue: "haextension:filesync:add-to-queue",
-    getQueue: "haextension:filesync:get-queue",
-    getQueueSummary: "haextension:filesync:get-queue-summary",
-    startQueueEntry: "haextension:filesync:start-queue-entry",
-    completeQueueEntry: "haextension:filesync:complete-queue-entry",
-    failQueueEntry: "haextension:filesync:fail-queue-entry",
-    retryFailedQueue: "haextension:filesync:retry-failed-queue",
-    removeQueueEntry: "haextension:filesync:remove-queue-entry",
-    clearQueue: "haextension:filesync:clear-queue",
-    recoverQueue: "haextension:filesync:recover-queue"
+    showImage: "haextension:filesystem:show-image",
+    // Generic FS operations (Phase 2)
+    readFile: "haextension:filesystem:read-file",
+    writeFile: "haextension:filesystem:write-file",
+    readDir: "haextension:filesystem:read-dir",
+    mkdir: "haextension:filesystem:mkdir",
+    remove: "haextension:filesystem:remove",
+    exists: "haextension:filesystem:exists",
+    stat: "haextension:filesystem:stat",
+    selectFolder: "haextension:filesystem:select-folder",
+    selectFile: "haextension:filesystem:select-file",
+    rename: "haextension:filesystem:rename",
+    copy: "haextension:filesystem:copy"
   },
   storage: {
     getItem: "haextension:storage:get-item",
@@ -587,364 +556,193 @@ var DatabaseAPI = class {
   }
 };
 
-// src/api/filesync.ts
-var FileSyncAPI = class {
+// src/api/filesystem.ts
+var FilesystemAPI = class {
   constructor(client) {
     this.client = client;
   }
-  // --------------------------------------------------------------------------
-  // Spaces
-  // --------------------------------------------------------------------------
-  /**
-   * List all file spaces
-   */
-  async listSpacesAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.listSpaces
-    );
-  }
   /**
-   * Create a new file space
-   */
-  async createSpaceAsync(options) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.createSpace,
-      options
-    );
-  }
-  /**
-   * Delete a file space
-   */
-  async deleteSpaceAsync(spaceId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.deleteSpace, {
-      spaceId
-    });
-  }
-  // --------------------------------------------------------------------------
-  // Files
-  // --------------------------------------------------------------------------
-  /**
-   * List files in a space
+   * Opens a save file dialog and saves the provided data to the selected location
+   * @param data The file data as Uint8Array
+   * @param options Options for the save dialog
+   * @returns The path where the file was saved, or null if cancelled
    */
-  async listFilesAsync(options) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.listFiles,
-      options
+  async saveFileAsync(data, options = {}) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.saveFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        defaultPath: options.defaultPath,
+        title: options.title,
+        filters: options.filters
+      }
     );
+    return result;
   }
   /**
-   * Scan local files in a sync rule folder
-   * Returns unencrypted local files for display in the UI
+   * Opens a file with the system's default viewer
+   * @param data The file data as Uint8Array
+   * @param options Options for opening the file
+   * @returns The result of the operation
    */
-  async scanLocalAsync(options) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.scanLocal,
-      options
+  async openFileAsync(data, options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.openFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        fileName: options.fileName,
+        mimeType: options.mimeType
+      }
     );
+    return result;
   }
   /**
-   * Get file info by ID
+   * Shows an image using a data URL (safe, read-only viewing)
+   * This is safe to use without special permissions as it only displays images
+   * and doesn't execute any code or open files with external applications
+   * @param options Options containing the data URL
+   * @returns The result of the operation
    */
-  async getFileAsync(fileId) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.getFile,
-      { fileId }
+  async showImageAsync(options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.showImage,
+      {
+        dataUrl: options.dataUrl
+      }
     );
+    return result;
   }
+  // ==========================================================================
+  // Generic Filesystem Operations (Phase 2)
+  // ==========================================================================
   /**
-   * Upload a file to the sync system
+   * Read file contents
+   * @param path Absolute path to the file
+   * @returns File contents as Uint8Array
    */
-  async uploadFileAsync(options) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.uploadFile,
-      options
+  async readFile(path) {
+    const base64 = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.readFile,
+      { path }
     );
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
   }
   /**
-   * Download a file to local storage
+   * Write file contents
+   * @param path Absolute path to the file
+   * @param data File contents as Uint8Array
    */
-  async downloadFileAsync(options) {
+  async writeFile(path, data) {
+    const base64 = btoa(String.fromCharCode(...data));
     await this.client.request(
-      HAEXTENSION_METHODS.filesync.downloadFile,
-      options
+      HAEXTENSION_METHODS.filesystem.writeFile,
+      { path, data: base64 }
     );
   }
   /**
-   * Delete a file from the sync system
+   * Read directory contents
+   * @param path Absolute path to the directory
+   * @returns Array of directory entries
    */
-  async deleteFileAsync(fileId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.deleteFile, {
-      fileId
-    });
-  }
-  // --------------------------------------------------------------------------
-  // Storage Backends
-  // --------------------------------------------------------------------------
-  /**
-   * List configured storage backends
-   */
-  async listBackendsAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.listBackends
-    );
-  }
-  /**
-   * Add a new storage backend
-   */
-  async addBackendAsync(options) {
+  async readDir(path) {
     return this.client.request(
-      HAEXTENSION_METHODS.filesync.addBackend,
-      options
+      HAEXTENSION_METHODS.filesystem.readDir,
+      { path }
     );
   }
   /**
-   * Remove a storage backend
-   */
-  async removeBackendAsync(backendId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.removeBackend, {
-      backendId
-    });
-  }
-  /**
-   * Test backend connection
+   * Create a directory (and parent directories if needed)
+   * @param path Absolute path to create
    */
-  async testBackendAsync(backendId) {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.testBackend,
-      { backendId }
+  async mkdir(path) {
+    await this.client.request(
+      HAEXTENSION_METHODS.filesystem.mkdir,
+      { path }
     );
   }
-  // --------------------------------------------------------------------------
-  // Sync Rules
-  // --------------------------------------------------------------------------
   /**
-   * List sync rules
+   * Remove a file or directory
+   * @param path Absolute path to remove
+   * @param recursive If true, remove directories recursively
    */
-  async listSyncRulesAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.listSyncRules
+  async remove(path, recursive = false) {
+    await this.client.request(
+      HAEXTENSION_METHODS.filesystem.remove,
+      { path, recursive }
     );
   }
   /**
-   * Add a sync rule
+   * Check if a path exists
+   * @param path Absolute path to check
+   * @returns True if the path exists
    */
-  async addSyncRuleAsync(options) {
+  async exists(path) {
     return this.client.request(
-      HAEXTENSION_METHODS.filesync.addSyncRule,
-      options
+      HAEXTENSION_METHODS.filesystem.exists,
+      { path }
     );
   }
   /**
-   * Update a sync rule
+   * Get file/directory metadata
+   * @param path Absolute path
+   * @returns File metadata
    */
-  async updateSyncRuleAsync(options) {
+  async stat(path) {
     return this.client.request(
-      HAEXTENSION_METHODS.filesync.updateSyncRule,
-      options
+      HAEXTENSION_METHODS.filesystem.stat,
+      { path }
     );
   }
-  /**
-   * Remove a sync rule
-   */
-  async removeSyncRuleAsync(ruleId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.removeSyncRule, {
-      ruleId
-    });
-  }
-  // --------------------------------------------------------------------------
-  // Sync Operations
-  // --------------------------------------------------------------------------
-  /**
-   * Get current sync status
-   */
-  async getSyncStatusAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.getSyncStatus
-    );
-  }
-  /**
-   * Trigger a manual sync
-   */
-  async triggerSyncAsync() {
-    await this.client.request(HAEXTENSION_METHODS.filesync.triggerSync);
-  }
-  /**
-   * Pause syncing
-   */
-  async pauseSyncAsync() {
-    await this.client.request(HAEXTENSION_METHODS.filesync.pauseSync);
-  }
-  /**
-   * Resume syncing
-   */
-  async resumeSyncAsync() {
-    await this.client.request(HAEXTENSION_METHODS.filesync.resumeSync);
-  }
-  // --------------------------------------------------------------------------
-  // Conflict Resolution
-  // --------------------------------------------------------------------------
-  /**
-   * Resolve a file conflict
-   */
-  async resolveConflictAsync(fileId, resolution) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.resolveConflict, {
-      fileId,
-      resolution
-    });
-  }
-  // --------------------------------------------------------------------------
-  // Folder Selection (Native Dialog)
-  // --------------------------------------------------------------------------
   /**
    * Open a folder selection dialog
+   * @param options Dialog options
+   * @returns Selected folder path, or null if cancelled
    */
-  async selectFolderAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.selectFolder
-    );
-  }
-  // --------------------------------------------------------------------------
-  // Sync Queue
-  // --------------------------------------------------------------------------
-  /**
-   * Add files to the sync queue
-   */
-  async addToQueueAsync(options) {
+  async selectFolder(options = {}) {
     return this.client.request(
-      HAEXTENSION_METHODS.filesync.addToQueue,
+      HAEXTENSION_METHODS.filesystem.selectFolder,
       options
     );
   }
   /**
-   * Get queue entries for the current device
+   * Open a file selection dialog
+   * @param options Dialog options
+   * @returns Selected file paths, or null if cancelled
    */
-  async getQueueAsync(options) {
+  async selectFile(options = {}) {
     return this.client.request(
-      HAEXTENSION_METHODS.filesync.getQueue,
+      HAEXTENSION_METHODS.filesystem.selectFile,
       options
     );
   }
   /**
-   * Get aggregated queue summary for the current device
-   */
-  async getQueueSummaryAsync() {
-    return this.client.request(
-      HAEXTENSION_METHODS.filesync.getQueueSummary
-    );
-  }
-  /**
-   * Mark a queue entry as started (in_progress)
-   */
-  async startQueueEntryAsync(entryId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.startQueueEntry, {
-      entryId
-    });
-  }
-  /**
-   * Mark a queue entry as completed
-   */
-  async completeQueueEntryAsync(entryId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.completeQueueEntry, {
-      entryId
-    });
-  }
-  /**
-   * Mark a queue entry as failed
-   */
-  async failQueueEntryAsync(entryId, errorMessage) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.failQueueEntry, {
-      entryId,
-      errorMessage
-    });
-  }
-  /**
-   * Retry all failed queue entries (reset to pending)
-   */
-  async retryFailedQueueAsync() {
-    await this.client.request(HAEXTENSION_METHODS.filesync.retryFailedQueue);
-  }
-  /**
-   * Remove a queue entry
-   */
-  async removeQueueEntryAsync(entryId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.removeQueueEntry, {
-      entryId
-    });
-  }
-  /**
-   * Clear all queue entries for a sync rule
-   */
-  async clearQueueAsync(ruleId) {
-    await this.client.request(HAEXTENSION_METHODS.filesync.clearQueue, {
-      ruleId
-    });
-  }
-  /**
-   * Reset in_progress entries to pending (for recovery after crash)
-   */
-  async recoverQueueAsync() {
-    await this.client.request(HAEXTENSION_METHODS.filesync.recoverQueue);
-  }
-};
-
-// src/api/filesystem.ts
-var FilesystemAPI = class {
-  constructor(client) {
-    this.client = client;
-    this.sync = new FileSyncAPI(client);
-  }
-  /**
-   * Opens a save file dialog and saves the provided data to the selected location
-   * @param data The file data as Uint8Array
-   * @param options Options for the save dialog
-   * @returns The path where the file was saved, or null if cancelled
-   */
-  async saveFileAsync(data, options = {}) {
-    const result = await this.client.request(
-      HAEXTENSION_METHODS.filesystem.saveFile,
-      {
-        data: Array.from(data),
-        // Convert Uint8Array to regular array for postMessage
-        defaultPath: options.defaultPath,
-        title: options.title,
-        filters: options.filters
-      }
-    );
-    return result;
-  }
-  /**
-   * Opens a file with the system's default viewer
-   * @param data The file data as Uint8Array
-   * @param options Options for opening the file
-   * @returns The result of the operation
+   * Rename/move a file or directory
+   * @param from Source path
+   * @param to Destination path
    */
-  async openFileAsync(data, options) {
-    const result = await this.client.request(
-      HAEXTENSION_METHODS.filesystem.openFile,
-      {
-        data: Array.from(data),
-        // Convert Uint8Array to regular array for postMessage
-        fileName: options.fileName,
-        mimeType: options.mimeType
-      }
+  async rename(from, to) {
+    await this.client.request(
+      HAEXTENSION_METHODS.filesystem.rename,
+      { from, to }
     );
-    return result;
   }
   /**
-   * Shows an image using a data URL (safe, read-only viewing)
-   * This is safe to use without special permissions as it only displays images
-   * and doesn't execute any code or open files with external applications
-   * @param options Options containing the data URL
-   * @returns The result of the operation
+   * Copy a file
+   * @param from Source path
+   * @param to Destination path
    */
-  async showImageAsync(options) {
-    const result = await this.client.request(
-      HAEXTENSION_METHODS.filesystem.showImage,
-      {
-        dataUrl: options.dataUrl
-      }
+  async copy(from, to) {
+    await this.client.request(
+      HAEXTENSION_METHODS.filesystem.copy,
+      { from, to }
     );
-    return result;
   }
 };
 
@@ -1440,8 +1238,7 @@ var TAURI_COMMANDS = {
   filesystem: {
     saveFile: "webview_extension_fs_save_file",
     openFile: "webview_extension_fs_open_file",
-    showImage: "webview_extension_fs_show_image"
-  },
+    showImage: "webview_extension_fs_show_image"},
   external: {
     // Response handling (called by extensions running in WebView)
     respond: "webview_extension_external_respond"},