tauri-plugin-icloud-container-api 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TensorBinge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# tauri-plugin-icloud-container
+
+> ⚠️ This plugin is under active development. Expect API refinements, behavior fixes, and documentation updates before a stable `1.0` release.
+
+Tauri v2 plugin for accessing an iCloud ubiquity container from a Tauri app.
+
+This plugin provides container identity, coordinated file I/O, directory operations, sync status, download and eviction, and native watch events for iCloud-backed files.
+
+Current support: iOS. Desktop targets are not implemented yet.
+
+## Features
+
+- Resolve iCloud container availability and URL
+- Read and write UTF-8 or byte content
+- Create files and directories with optional file protection
+- List, copy, move, trash, and delete container items
+- Inspect sync status, trigger download, and evict downloaded items
+- Watch directories and files through native iCloud-backed event sources
+- Typed guest JS API for all commands
+
+## Installation
+
+Add the Rust crate to your Tauri app and register the plugin.
+
+```toml
+[dependencies]
+tauri-plugin-icloud-container = "0.1"
+```
+
+```rust
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_icloud_container::init())
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+The plugin also exposes a typed guest API for frontend usage.
+
+If you want to pin a specific ubiquity container identifier at startup, register the plugin with config instead of calling `init()`.
+
+```rust
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_icloud_container::init_with_config(
+            tauri_plugin_icloud_container::IcloudContainerConfig {
+                identifier: Some("iCloud.com.example.app".into()),
+            },
+        ))
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+When `identifier` is omitted, the native resolver falls back to the first entitled iCloud container available to the host app.
+
+## iOS Setup
+
+The host app must be configured for iCloud before any command will succeed.
+
+1. Enable the iCloud capability for the iOS target in Xcode.
+2. Add the target ubiquity container identifier in the Apple Developer portal and Xcode signing configuration.
+3. Ensure the app entitlements include the container identifiers needed by the app.
+4. Build and run on a device or runtime signed into iCloud.
+
+If entitlements are missing or the user is signed out, container resolution will fail and the plugin will report the container as unavailable.
+
+## Usage
+
+The plugin exposes typed frontend helpers for invoking the native commands.
+
+```ts
+import {
+  getContainerStatus,
+  forContainer,
+  readFile,
+  writeFile,
+  watchDirectory,
+  onDirectoryChanged,
+} from "tauri-plugin-icloud-container-api";
+
+const status = await getContainerStatus();
+if (!status.available) {
+  throw new Error(status.reason ?? "iCloud container unavailable");
+}
+
+await writeFile("notes/example.txt", "hello iCloud");
+const file = await readFile("notes/example.txt", { encoding: "utf8" });
+
+const watchId = await watchDirectory("notes", true);
+const unlisten = await onDirectoryChanged((event) => {
+  console.log(event.watchId, event.entries);
+});
+
+await unlisten();
+```
+
+If your app works against a specific ubiquity container for a whole workflow, use a bound container helper instead of passing the identifier on every call.
+
+```ts
+import { forContainer } from "tauri-plugin-icloud-container-api";
+
+const container = forContainer("iCloud.com.example.app");
+
+await container.writeFile("notes/example.txt", "hello iCloud");
+const file = await container.readFile("notes/example.txt", {
+  encoding: "utf8",
+});
+const watchId = await container.watchDirectory("notes", true);
+```
+
+Binary payloads use `Uint8Array` only. The guest API does not expose a base64 transport path.
+
+## Permissions
+
+The plugin ships Tauri ACL entries for all 21 commands under [permissions/autogenerated/commands](permissions/autogenerated/commands).
+
+The default permission set in [permissions/default.toml](permissions/default.toml) currently allows all commands. Host apps can replace that with a narrower allowlist in their own capability configuration.
+
+## API Surface
+
+### Container identity
+
+| Command                          | Native API                                                                                | What it does                                                                                                                                                                                  |
+| -------------------------------- | ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_container_status()`         | `FileManager.ubiquityIdentityToken` + nil-check on `url(forUbiquityContainerIdentifier:)` | Returns `available`, `unavailable`, or `not_signed_in`. Must be called on a background thread; result is cached until `NSUbiquityIdentityDidChange` fires.                                    |
+| `get_container_url(identifier?)` | `FileManager.url(forUbiquityContainerIdentifier:)`                                        | Resolves and returns the absolute path to the iCloud container root. Passing `nil` uses the app's default container. Required before constructing any path-based argument to another command. |
+
+### Coordinated file I/O
+
+All reads and writes go through `NSFileCoordinator` to respect concurrent iCloud syncing.
+
+| Command                               | Native API                                                                | What it does                                                                                                                                                                                                                                         |
+| ------------------------------------- | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `read_file(path, options?)`           | `NSFileCoordinator` read to `Data`                                        | Reads file content using one command. `options.encoding` defaults to `utf8`; set `bytes` for binary payloads. Returns `{ encoding: "utf8", content: string }` or `{ encoding: "bytes", content: Uint8Array }`.                                       |
+| `write_file(path, content, options?)` | Coordinated write via `NSFileCoordinator`                                 | Writes content. `options.encoding` defaults to `utf8`; set `bytes` for binary (`Uint8Array`). `options.fileProtection` sets iOS encryption level. Overwrites by default unless `options.overwrite = false`. The parent directory must already exist. |
+| `create_file(path, options?)`         | Coordinated write via `NSFileCoordinator`                                 | Creates a new file with optional initial content and encoding (`utf8` or `bytes`). `options.fileProtection` sets iOS encryption level. Fails if the file already exists, or if the parent directory does not already exist.                          |
+| `item_exists(path)`                   | `FileManager.fileExists(atPath:isDirectory:)`                             | Returns whether an item exists at the path and whether it is a file or directory. Does not trigger a download.                                                                                                                                       |
+| `get_attributes(path)`                | `FileManager.attributesOfItem` + `URL.resourceValues` for ubiquitous keys | Returns file size, modification date, creation date, type, and iCloud-specific resource values such as sync status.                                                                                                                                  |
+
+### Directory operations
+
+| Command                                    | Native API                                                                          | What it does                                                                                                                                                                                                                                                                         |
+| ------------------------------------------ | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `create_directory(path, options?)`         | `FileManager.createDirectory(at:withIntermediateDirectories:attributes:)`           | Creates a directory with optional ancestor creation. `options.withIntermediateDirectories` defaults to `true`. `options.fileProtection` sets encryption.                                                                                                                             |
+| `list_directory(path, options?)`           | `FileManager.contentsOfDirectory` / `FileManager.enumerator` + `URL.resourceValues` | Lists entries in one command. `options.recursive = false` performs shallow listing; `true` returns all descendants. `options.skipsHiddenFiles = false` includes dot-files. Entries include name, path, file metadata, and sync status when iCloud metadata is available for an item. |
+| `delete_item(path)`                        | `NSFileCoordinator` + `FileManager.removeItem`                                      | Permanently deletes a file or directory and all its contents. Cannot be undone.                                                                                                                                                                                                      |
+| `trash_item(path)`                         | `NSFileCoordinator` + `FileManager.trashItem(at:resultingItemURL:)`                 | Moves the item to native Trash using the platform API. Returns `{ path: string }` with the resulting absolute trash path.                                                                                                                                                            |
+| `move_item(source_path, destination_path)` | `NSFileCoordinator` writing both URLs + `FileManager.moveItem`                      | Moves a file or directory within the container. Can also serve as rename-in-place when source and destination share the same parent. The destination parent must already exist, and the destination path must not already exist.                                                     |
+| `copy_item(source_path, destination_path)` | `NSFileCoordinator` + `FileManager.copyItem`                                        | Copies a file or directory to a new path within the container. The destination parent must already exist, and the destination path must not already exist.                                                                                                                           |
+
+### iCloud sync controls
+
+| Command                      | Native API                                                                                                                                                                                                           | What it does                                                                                                                                                                     |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_item_sync_status(path)` | `URL.resourceValues` for `ubiquitousItemDownloadingStatus`, `ubiquitousItemIsDownloading`, `ubiquitousItemIsUploading`, `ubiquitousItemIsUploaded`, `ubiquitousItemDownloadingError`, `ubiquitousItemUploadingError` | Returns the current iCloud transfer state for a single item: download phase, upload/download activity flags, and any transfer errors exposed through Foundation resource values. |
+| `start_download(path)`       | `FileManager.startDownloadingUbiquitousItem(at:)`                                                                                                                                                                    | Tells iCloud to fetch the local copy of a cloud-only file. Returns immediately; poll `get_item_sync_status` or use `watch_directory` to observe progress.                        |
+| `evict_item(path)`           | `FileManager.evictUbiquitousItem(at:)`                                                                                                                                                                               | Removes the local copy of a file that is safely stored in iCloud, freeing device storage. The file remains visible in `list_directory` with status `notDownloaded`.              |
+| `is_ubiquitous(path)`        | `FileManager.isUbiquitousItem(at:)`                                                                                                                                                                                  | Returns whether the item at the given path is managed by iCloud. Useful when handling paths that may come from outside the container.                                            |
+
+### File watching
+
+| Command                            | Native API                              | What it does                                                                                                                                                                   |
+| ---------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `watch_directory(path, recursive)` | `NSMetadataQuery` live subscription     | Starts a live-updating observer on a directory. Emits the `icloud://directory-changed` event on every iCloud-sync or local change. Returns a `watchId` for later cancellation. |
+| `unwatch(watch_id)`                | `NSMetadataQuery.stop()` + dealloc      | Cancels and releases the watcher registered under `watchId`.                                                                                                                   |
+| `watch_file(path)`                 | `NSFilePresenter`                       | Registers a file-level presenter that emits the `icloud://file-changed` event when the file is modified or its sync state changes. Returns a `watchId`.                        |
+| `unwatch_file(watch_id)`           | `NSFileCoordinator.removeFilePresenter` | Removes the `NSFilePresenter` registered under `watchId`.                                                                                                                      |
+
+Watch events emitted by the guest API:
+
+- `icloud://directory-changed`
+- `icloud://file-changed`

package/guest-js/index.ts

@@ -0,0 +1,366 @@
+import { addPluginListener, invoke, type PluginListener } from '@tauri-apps/api/core'
+
+const PLUGIN_NAME = 'icloud-container'
+const COMMAND_PREFIX = `plugin:${PLUGIN_NAME}|`
+const textEncoder = new TextEncoder()
+
+export const DIRECTORY_CHANGED_EVENT = 'icloud://directory-changed'
+export const FILE_CHANGED_EVENT = 'icloud://file-changed'
+
+export type FileEncoding = 'utf8' | 'bytes'
+export type FileProtectionType =
+  | 'complete'
+  | 'completeUnlessOpen'
+  | 'completeUntilFirstUserAuth'
+  | 'none'
+
+export interface ContainerStatus {
+  available: boolean
+  reason?: string | null
+}
+
+export interface Utf8FileContent {
+  encoding: 'utf8'
+  content: string
+}
+
+export interface BytesFileContent {
+  encoding: 'bytes'
+  content: Uint8Array
+}
+
+export type FileContent = Utf8FileContent | BytesFileContent
+
+export interface FolderEntry {
+  name: string
+  path: string
+  isDirectory: boolean
+  size?: number | null
+  modifiedDate?: number | null
+  createdDate?: number | null
+  syncStatus?: SyncStatus | null
+}
+
+export interface ItemExistence {
+  exists: boolean
+  isDirectory: boolean
+}
+
+export interface SyncStatus {
+  phase: 'current' | 'notDownloaded' | 'downloaded'
+  isDownloading: boolean
+  isUploading: boolean
+  isUploaded: boolean
+  downloadError?: string | null
+  uploadError?: string | null
+}
+
+export interface ItemAttributes {
+  size: number
+  modifiedDate: number
+  createdDate: number
+  type: 'file' | 'dir'
+  syncStatus?: SyncStatus | null
+}
+
+export interface TrashItemResult {
+  path: string
+}
+
+export interface WriteFileOptions {
+  encoding?: FileEncoding
+  overwrite?: boolean
+  fileProtection?: FileProtectionType
+}
+
+export interface ReadFileOptions {
+  encoding?: FileEncoding
+}
+
+export interface CreateFileOptions {
+  content?: string | Uint8Array
+  encoding?: FileEncoding
+  fileProtection?: FileProtectionType
+}
+
+export interface CreateDirectoryOptions {
+  withIntermediateDirectories?: boolean
+  fileProtection?: FileProtectionType
+}
+
+export interface ListDirectoryOptions {
+  recursive?: boolean
+  skipsHiddenFiles?: boolean
+}
+
+export interface DirectoryWatchEvent {
+  watchId: string
+  path: string
+  recursive: boolean
+  entries: string[]
+}
+
+export interface FileWatchEvent {
+  watchId: string
+  path: string
+}
+
+export type ContainerIdentifier = string | undefined
+
+export interface ICloudContainerHandle {
+  readonly identifier: string
+  getStatus(): Promise<ContainerStatus>
+  getUrl(): Promise<string>
+  readFile(path: string, options?: ReadFileOptions): Promise<FileContent>
+  writeFile(path: string, content: string | Uint8Array, options?: WriteFileOptions): Promise<void>
+  createFile(path: string, options?: CreateFileOptions): Promise<FolderEntry>
+  itemExists(path: string): Promise<ItemExistence>
+  getAttributes(path: string): Promise<ItemAttributes>
+  createDirectory(path: string, options?: CreateDirectoryOptions): Promise<void>
+  listDirectory(path: string, options?: ListDirectoryOptions): Promise<FolderEntry[]>
+  deleteItem(path: string): Promise<void>
+  trashItem(path: string): Promise<TrashItemResult>
+  moveItem(sourcePath: string, destinationPath: string): Promise<FolderEntry>
+  copyItem(sourcePath: string, destinationPath: string): Promise<FolderEntry>
+  getItemSyncStatus(path: string): Promise<SyncStatus>
+  startDownload(path: string): Promise<void>
+  evictItem(path: string): Promise<void>
+  isUbiquitous(path: string): Promise<boolean>
+  watchDirectory(path: string, recursive?: boolean): Promise<string>
+  watchFile(path: string): Promise<string>
+}
+
+function invokeCommand<T>(command: string, args?: Record<string, unknown>): Promise<T> {
+  return invoke(`${COMMAND_PREFIX}${command}`, args)
+}
+
+function inferEncoding(content: string | Uint8Array | undefined, encoding?: FileEncoding): FileEncoding {
+  if (encoding) {
+    return encoding
+  }
+
+  return content instanceof Uint8Array ? 'bytes' : 'utf8'
+}
+
+function toCreateFilePayload(options?: CreateFileOptions): {
+  content?: Uint8Array
+  encoding?: FileEncoding
+  fileProtection?: FileProtectionType
+} | undefined {
+  if (!options) {
+    return undefined
+  }
+
+  const encoding = inferEncoding(options.content, options.encoding)
+  const content =
+    typeof options.content === 'string'
+      ? textEncoder.encode(options.content)
+      : options.content
+
+  return {
+    content,
+    encoding,
+    fileProtection: options.fileProtection,
+  }
+}
+
+function toWriteFilePayload(content: string | Uint8Array, encoding?: FileEncoding): FileContent {
+  const resolvedEncoding = inferEncoding(content, encoding)
+
+  if (content instanceof Uint8Array) {
+    if (resolvedEncoding !== 'bytes') {
+      throw new Error('Uint8Array content requires encoding "bytes"')
+    }
+
+    return { encoding: 'bytes', content }
+  }
+
+  if (resolvedEncoding === 'bytes') {
+    return { encoding: 'bytes', content: textEncoder.encode(content) }
+  }
+
+  return { encoding: 'utf8', content }
+}
+
+export async function getContainerStatus(identifier?: string): Promise<ContainerStatus> {
+  return invokeCommand('get_container_status', { identifier })
+}
+
+export async function getContainerUrl(identifier?: string): Promise<string> {
+  return invokeCommand('get_container_url', { identifier })
+}
+
+export async function readFile(
+  path: string,
+  options?: ReadFileOptions,
+  identifier?: ContainerIdentifier,
+): Promise<FileContent> {
+  return invokeCommand('read_file', { path, identifier, options })
+}
+
+export async function writeFile(
+  path: string,
+  content: string | Uint8Array,
+  options?: WriteFileOptions,
+  identifier?: ContainerIdentifier,
+): Promise<void> {
+  return invokeCommand('write_file', {
+    path,
+    identifier,
+    content: toWriteFilePayload(content, options?.encoding),
+    options,
+  })
+}
+
+export async function createFile(
+  path: string,
+  options?: CreateFileOptions,
+  identifier?: ContainerIdentifier,
+): Promise<FolderEntry> {
+  return invokeCommand('create_file', {
+    path,
+    identifier,
+    options: toCreateFilePayload(options),
+  })
+}
+
+export async function itemExists(
+  path: string,
+  identifier?: ContainerIdentifier,
+): Promise<ItemExistence> {
+  return invokeCommand('item_exists', { path, identifier })
+}
+
+export async function getAttributes(
+  path: string,
+  identifier?: ContainerIdentifier,
+): Promise<ItemAttributes> {
+  return invokeCommand('get_attributes', { path, identifier })
+}
+
+export async function createDirectory(
+  path: string,
+  options?: CreateDirectoryOptions,
+  identifier?: ContainerIdentifier,
+): Promise<void> {
+  return invokeCommand('create_directory', { path, identifier, options })
+}
+
+export async function listDirectory(
+  path: string,
+  options?: ListDirectoryOptions,
+  identifier?: ContainerIdentifier,
+): Promise<FolderEntry[]> {
+  return invokeCommand('list_directory', { path, identifier, options })
+}
+
+export async function deleteItem(path: string, identifier?: ContainerIdentifier): Promise<void> {
+  return invokeCommand('delete_item', { path, identifier })
+}
+
+export async function trashItem(
+  path: string,
+  identifier?: ContainerIdentifier,
+): Promise<TrashItemResult> {
+  return invokeCommand('trash_item', { path, identifier })
+}
+
+export async function moveItem(
+  sourcePath: string,
+  destinationPath: string,
+  identifier?: ContainerIdentifier,
+): Promise<FolderEntry> {
+  return invokeCommand('move_item', { sourcePath, destinationPath, identifier })
+}
+
+export async function copyItem(
+  sourcePath: string,
+  destinationPath: string,
+  identifier?: ContainerIdentifier,
+): Promise<FolderEntry> {
+  return invokeCommand('copy_item', { sourcePath, destinationPath, identifier })
+}
+
+export async function getItemSyncStatus(
+  path: string,
+  identifier?: ContainerIdentifier,
+): Promise<SyncStatus> {
+  return invokeCommand('get_item_sync_status', { path, identifier })
+}
+
+export async function startDownload(path: string, identifier?: ContainerIdentifier): Promise<void> {
+  return invokeCommand('start_download', { path, identifier })
+}
+
+export async function evictItem(path: string, identifier?: ContainerIdentifier): Promise<void> {
+  return invokeCommand('evict_item', { path, identifier })
+}
+
+export async function isUbiquitous(
+  path: string,
+  identifier?: ContainerIdentifier,
+): Promise<boolean> {
+  return invokeCommand('is_ubiquitous', { path, identifier })
+}
+
+export async function watchDirectory(
+  path: string,
+  recursive = false,
+  identifier?: ContainerIdentifier,
+): Promise<string> {
+  return invokeCommand('watch_directory', { path, recursive, identifier })
+}
+
+export async function unwatch(watchId: string): Promise<void> {
+  return invokeCommand('unwatch', { watchId })
+}
+
+export async function watchFile(path: string, identifier?: ContainerIdentifier): Promise<string> {
+  return invokeCommand('watch_file', { path, identifier })
+}
+
+export async function unwatchFile(watchId: string): Promise<void> {
+  return invokeCommand('unwatch_file', { watchId })
+}
+
+export async function onDirectoryChanged(
+  handler: (event: DirectoryWatchEvent) => void,
+): Promise<PluginListener> {
+  return addPluginListener<DirectoryWatchEvent>(PLUGIN_NAME, DIRECTORY_CHANGED_EVENT, handler)
+}
+
+export async function onFileChanged(
+  handler: (event: FileWatchEvent) => void,
+): Promise<PluginListener> {
+  return addPluginListener<FileWatchEvent>(PLUGIN_NAME, FILE_CHANGED_EVENT, handler)
+}
+
+export function forContainer(identifier: string): ICloudContainerHandle {
+  const trimmedIdentifier = identifier.trim()
+  if (!trimmedIdentifier) {
+    throw new Error('identifier is required and cannot be empty')
+  }
+
+  return {
+    identifier: trimmedIdentifier,
+    getStatus: () => getContainerStatus(trimmedIdentifier),
+    getUrl: () => getContainerUrl(trimmedIdentifier),
+    readFile: (path, options) => readFile(path, options, trimmedIdentifier),
+    writeFile: (path, content, options) => writeFile(path, content, options, trimmedIdentifier),
+    createFile: (path, options) => createFile(path, options, trimmedIdentifier),
+    itemExists: (path) => itemExists(path, trimmedIdentifier),
+    getAttributes: (path) => getAttributes(path, trimmedIdentifier),
+    createDirectory: (path, options) => createDirectory(path, options, trimmedIdentifier),
+    listDirectory: (path, options) => listDirectory(path, options, trimmedIdentifier),
+    deleteItem: (path) => deleteItem(path, trimmedIdentifier),
+    trashItem: (path) => trashItem(path, trimmedIdentifier),
+    moveItem: (sourcePath, destinationPath) => moveItem(sourcePath, destinationPath, trimmedIdentifier),
+    copyItem: (sourcePath, destinationPath) => copyItem(sourcePath, destinationPath, trimmedIdentifier),
+    getItemSyncStatus: (path) => getItemSyncStatus(path, trimmedIdentifier),
+    startDownload: (path) => startDownload(path, trimmedIdentifier),
+    evictItem: (path) => evictItem(path, trimmedIdentifier),
+    isUbiquitous: (path) => isUbiquitous(path, trimmedIdentifier),
+    watchDirectory: (path, recursive) => watchDirectory(path, recursive, trimmedIdentifier),
+    watchFile: (path) => watchFile(path, trimmedIdentifier),
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "tauri-plugin-icloud-container-api",
+  "version": "0.1.0-beta.1",
+  "description": "Typed guest JS API for tauri-plugin-icloud-container",
+  "license": "MIT",
+  "homepage": "https://github.com/TensorBinge/tauri-plugin-icloud-container",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TensorBinge/tauri-plugin-icloud-container.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TensorBinge/tauri-plugin-icloud-container/issues"
+  },
+  "type": "module",
+  "files": [
+    "guest-js",
+    "README.md"
+  ],
+  "main": "./guest-js/index.ts",
+  "types": "./guest-js/index.ts",
+  "exports": {
+    ".": "./guest-js/index.ts"
+  },
+  "scripts": {
+    "test": "node ./tests/guest_api_contract.mjs",
+    "test:guest-api": "node ./tests/guest_api_contract.mjs",
+    "pack:artifact": "mkdir -p artifacts && npm pack --pack-destination artifacts",
+    "prepublishOnly": "npm test"
+  },
+  "peerDependencies": {
+    "@tauri-apps/api": "^2.0.0"
+  }
+}