proton-drive-mcp 1.0.26 → 1.0.27

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.0.27 — 2026-08-11
+
+A full audit against the Proton Drive CLI SDK source found that 9 existing tools called CLI commands or flags that don't exist, or had wrong semantics. This release fixes all of them and adds 7 new tools for public links, bulk access removal, album updates, and Photos timeline transfers.
+
+### Fixed (existing tools were broken — none of these worked correctly before)
+- **`drive_auth_status`** — `auth status` doesn't exist in the CLI at all; every call errored. Now probes by resolving `/my-files` and treats a not-authenticated error as the signal. The `email` field is removed — the CLI has no way to query the signed-in account's email.
+- **`drive_version`** — the CLI's `version` command ignores `--json` and always prints plain text; the tool was trying to JSON-parse it and always threw. Now parsed directly from stdout.
+- **`drive_mkdir`** — the CLI has no `mkdir`; it's `filesystem create-folder <parentPath> <name>`. The tool now splits the given path into parent + name automatically.
+- **`drive_move`** — the CLI's `move` only accepts a target *parent folder*; renaming is a separate `rename <path> <newName>` command. The tool still accepts a full destination path (unchanged external interface) but now composes `move`/`rename` correctly under the hood.
+- **`drive_delete`** — passed a `--confirm` flag that doesn't exist, and the CLI only permits deleting items already inside `/trash` or `/photos-trash` (it rejects live paths). Flag removed; description corrected.
+- **`drive_trash` / `drive_restore` / `drive_list_trash` / `drive_empty_trash`** — called a top-level `trash` command group that doesn't exist; trash operations are subcommands of `filesystem` (`filesystem trash`, `filesystem restore`, `filesystem empty-trash`), and listing trash is `filesystem list /trash`. `empty-trash` also had a nonexistent `--confirm` flag, removed.
+- **`drive_share_revoke`** — called `sharing revoke --user`, which doesn't exist; the real command is `sharing remove --email`.
+- **`drive_upload` / `drive_download`** — conflict strategy values were `skip`/`overwrite`/`rename`; the CLI's actual allowed values are `skip`/`replace`/`keep-both`/`merge` (`merge` is upload/folder-only). `drive_download` also gained a `conflictStrategy` parameter it never had.
+
+### Added
+- **`drive_share_set_url`** — create or update a public share link (`sharing set-url`), with optional role, password, and expiration
+- **`drive_share_remove_url`** — remove a public share link (`sharing remove-url`)
+- **`drive_share_remove_all`** — remove every member and pending invitation from a shared path in one call (`sharing remove --everyone`)
+- **`photos_update_album`** — rename an album or change its cover photo (`album update`)
+- **`photos_list_timeline`** — list photos in your full Photos library timeline, not scoped to an album (`photo timeline`)
+- **`photos_download`** — download one or more photos to a local folder (`photo download`)
+- **`photos_upload`** — upload local photos/videos directly into your Photos library (`photo upload`)
+
+### Not implemented
+- `sharing report` (abuse reporting) exists as source in the SDK but is not registered in the CLI's command registry — invoking it would fail with `CommandNotFoundError`. Excluded as dead code, not a gap.
+
 ## 1.0.25 — 2026-08-04
 
 ### Added

package/README.md

@@ -30,7 +30,7 @@ Give Claude Desktop (or any MCP client) full access to your Proton Drive and Pro
 
 - **Claude manages your Proton Drive** — list, upload, download, move, share, trash, restore
 - **Proton Photos album management** — list albums, create/delete albums, add and remove photos
-- **Full CLI** — same 29 operations, scriptable and pipeable, works in cron and shell scripts
+- **Full CLI** — same 36 operations, scriptable and pipeable, works in cron and shell scripts
 - **Zero credential exposure** — auth is handled entirely by the official Proton Drive CLI; this MCP never touches your password or session token
 - **Shell injection safe** — all CLI calls use `execFile` with discrete argument arrays, never string interpolation
 - **Privacy-native** — end-to-end encryption is handled by Proton's own CLI; this server is just a thin MCP wrapper
@@ -147,7 +147,7 @@ proton-drive-cli <command> [args]
 ### Auth & info
 
 ```bash
-proton-drive-cli auth status          # check if authenticated
+proton-drive-cli auth status          # probes /my-files; the CLI has no dedicated status command
 proton-drive-cli auth logout          # log out (clears OS keychain session)
 proton-drive-cli version              # CLI and SDK version
 ```
@@ -161,13 +161,14 @@ proton-drive-cli list /my-files/Reports
 proton-drive-cli mkdir /my-files/NewFolder
 
 proton-drive-cli upload ./report.pdf /my-files/Reports
-proton-drive-cli upload ./dist /my-files/Releases --conflict overwrite
+proton-drive-cli upload ./dist /my-files/Releases --conflict replace
 
 proton-drive-cli download /my-files/report.pdf ./local/report.pdf
-proton-drive-cli download /my-files/Reports ./local/Reports
+proton-drive-cli download /my-files/Reports ./local/Reports --conflict keep-both
 
 proton-drive-cli move /my-files/old-name.pdf /my-files/new-name.pdf
-proton-drive-cli delete /my-files/obsolete-draft.pdf
+proton-drive-cli copy /my-files/report.pdf /my-files/Archive
+proton-drive-cli delete /trash/obsolete-draft.pdf --confirm   # only works on items already in trash
 
 # Machine-readable output (pipe-friendly)
 proton-drive-cli list /my-files --json | jq '.[].name'
@@ -180,22 +181,39 @@ proton-drive-cli share status /my-files/Reports
 proton-drive-cli share invite /my-files/Reports alice@pm.me editor
 proton-drive-cli share invite /my-files/Reports bob@pm.me viewer --message "FYI"
 proton-drive-cli share revoke /my-files/Reports alice@pm.me
+proton-drive-cli share remove-all /my-files/Reports --confirm   # strip every member + pending invite
+
+proton-drive-cli share set-url /my-files/Reports --role viewer --expiration 2026-06-06
+proton-drive-cli share remove-url /my-files/Reports
 ```
 
 ### Trash
 
 ```bash
-proton-drive-cli trash /my-files/old-draft.pdf   # move to trash
-proton-drive-cli trash list                       # see what's in trash
-proton-drive-cli restore /my-files/old-draft.pdf # restore from trash
-proton-drive-cli trash empty                      # permanently delete all trashed items
+proton-drive-cli trash /my-files/old-draft.pdf        # move to trash
+proton-drive-cli trash list                            # see what's in trash
+proton-drive-cli restore /my-files/old-draft.pdf       # restore from trash
+proton-drive-cli trash empty --confirm                  # permanently delete all trashed items
+```
+
+### Photos
+
+```bash
+proton-drive-cli album list
+proton-drive-cli album create "Summer 2026"
+proton-drive-cli album update /albums/Summer2026 --name "Summer Trip"
+proton-drive-cli album add-photo /albums/Summer2026 /photos/IMG_001.jpg
+
+proton-drive-cli photo timeline
+proton-drive-cli photo download /photos/IMG_001.jpg ./local/photos --conflict keep-both
+proton-drive-cli photo upload ./camera-roll --conflict skip
 ```
 
 ### Pipe and script
 
 ```bash
 # Backup build output after CI
-proton-drive-cli upload ./dist /my-files/Releases/$(date +%Y-%m-%d) --conflict rename
+proton-drive-cli upload ./dist /my-files/Releases/$(date +%Y-%m-%d) --conflict keep-both
 
 # Download all contracts for audit
 proton-drive-cli download /my-files/Contracts ./audit/contracts
@@ -218,7 +236,7 @@ proton-drive-cli share status /my-files/Projects
 `drive_list` · `drive_mkdir` · `drive_upload` · `drive_download` · `drive_move` · `drive_delete`
 
 ### Sharing
-`drive_share_status` · `drive_share_invite` · `drive_share_revoke`
+`drive_share_status` · `drive_share_invite` · `drive_share_revoke` · `drive_share_remove_all` · `drive_share_set_url` · `drive_share_remove_url`
 
 ### Trash
 `drive_list_trash` · `drive_trash` · `drive_restore` · `drive_empty_trash`
@@ -233,7 +251,7 @@ proton-drive-cli share status /my-files/Projects
 `drive_list_invitations` · `drive_invitation_accept` · `drive_invitation_reject` · `drive_share_leave`
 
 ### Photos
-`photos_list_albums` · `photos_create_album` · `photos_delete_album` · `photos_list_album_photos` · `photos_add_to_album` · `photos_remove_from_album`
+`photos_list_albums` · `photos_create_album` · `photos_update_album` · `photos_delete_album` · `photos_list_album_photos` · `photos_add_to_album` · `photos_remove_from_album` · `photos_list_timeline` · `photos_download` · `photos_upload`
 
 ---
 
@@ -241,35 +259,42 @@ proton-drive-cli share status /my-files/Projects
 
 | Tool | Description | Key parameters |
 |------|-------------|----------------|
-| `drive_auth_status` | Check if CLI is authenticated | — |
+| `drive_auth_status` | Check if authenticated (probes `/my-files` — no native status command) | — |
 | `drive_auth_logout` | Log out (clear session) | — |
 | `drive_version` | CLI and SDK version info | — |
 | `drive_list` | List files and folders at a path | `path` |
 | `drive_mkdir` | Create a new empty folder | `path` |
-| `drive_upload` | Upload local file or folder | `localPath`, `remotePath`, `conflictStrategy` (skip/overwrite/rename) |
-| `drive_download` | Download to local path | `remotePath`, `localPath` |
-| `drive_move` | Move or rename | `sourcePath`, `destinationPath` |
-| `drive_delete` | Permanently delete ⚠️ | `path`, `confirmed: true` |
+| `drive_upload` | Upload local file or folder | `localPath`, `remotePath`, `conflictStrategy` (skip/replace/keep-both/merge) |
+| `drive_download` | Download to local path | `remotePath`, `localPath`, `conflictStrategy` (skip/replace/keep-both) |
+| `drive_move` | Move and/or rename | `sourcePath`, `destinationPath` |
+| `drive_copy` | Copy file or folder to another Drive location | `sourcePath`, `destinationPath` |
+| `drive_delete` | Permanently delete an item already in trash ⚠️ | `path`, `confirmed: true` |
 | `drive_list_trash` | List items currently in trash | — |
 | `drive_share_status` | Get sharing members and URL | `path` |
 | `drive_share_invite` | Invite a user | `path`, `email`, `role` (viewer/editor/admin), `message?` |
-| `drive_share_revoke` | Revoke access | `path`, `email` |
+| `drive_share_revoke` | Revoke one person's access | `path`, `email` |
+| `drive_share_remove_all` | Remove every member + pending invitation at once ⚠️ | `path`, `confirmed: true` |
+| `drive_share_set_url` | Create/update a public share link | `path`, `role?` (viewer/editor), `password?`, `expiration?` |
+| `drive_share_remove_url` | Remove the public share link ⚠️ | `path` |
 | `drive_trash` | Move to trash | `path` |
 | `drive_restore` | Restore from trash | `path` |
 | `drive_empty_trash` | Permanently delete all trash ⚠️ | `confirmed: true` |
 | `drive_read_file` | Read text file from local sync folder | `path` |
 | `drive_write_file` | Write text file to local sync folder ⚠️ | `path`, `content` |
-| `drive_copy` | Copy file or folder to another Drive location | `sourcePath`, `destinationPath` |
 | `drive_list_invitations` | List pending sharing invitations received | — |
 | `drive_invitation_accept` | Accept a pending invitation | `uid` (from `drive_list_invitations`) |
 | `drive_invitation_reject` | Reject a pending invitation ⚠️ | `uid` (from `drive_list_invitations`) |
 | `drive_share_leave` | Leave a shared folder shared with you ⚠️ | `path` |
 | `photos_list_albums` | List all Proton Photos albums | — |
 | `photos_create_album` | Create a new empty album | `name` |
+| `photos_update_album` | Rename an album or change its cover photo | `albumPath`, `name?`, `coverPhotoUid?` |
 | `photos_delete_album` | Delete an album ⚠️ | `albumPath`, `confirmed: true`, `force?`, `save?` |
 | `photos_list_album_photos` | List photos in an album | `albumPath` |
 | `photos_add_to_album` | Add a photo from your library to an album | `albumPath`, `photoPath` |
 | `photos_remove_from_album` | Remove a photo from an album (keeps it in library) ⚠️ | `albumPath`, `photoPath` |
+| `photos_list_timeline` | List photos in your full library timeline | `loadDetails?` |
+| `photos_download` | Download photos to a local folder | `photoPaths`, `localFolder`, `conflictStrategy?` (skip/replace/keep-both) |
+| `photos_upload` | Upload local files directly into your Photos library | `localPaths`, `conflictStrategy?` (skip/keep-both) |
 
 > ⚠️ **Destructive tools** require `confirmed: true`. Use `drive_list_trash` first so you know what will be deleted, then pass `confirmed: true` to proceed.
 
@@ -291,9 +316,11 @@ proton-drive-cli share status /my-files/Projects
 ## Operational notes
 
 - `drive_upload` passes `--skip-thumbnails` by default. Remove it from the subprocess args if you want WebP preview generation (requires Bun 1.3.14+ installed).
-- `drive_move` and `drive_delete` are best-effort — the Proton Drive CLI documentation does not guarantee these commands exist in v1. If a command returns a CLI error, the MCP tool surfaces it cleanly.
+- `drive_move` accepts a full destination path (parent + new name) for a familiar interface, but the underlying CLI only has separate `move` (change parent) and `rename` (change name) commands — this MCP translates automatically, issuing one or both as needed.
+- `drive_delete` only works on items already in `/trash` or `/photos-trash` — the CLI rejects live paths. Trash an item first with `drive_trash`, or use `drive_empty_trash` to clear everything at once.
+- `drive_auth_status` has no native CLI equivalent — it probes by resolving `/my-files` and reports authenticated based on whether that succeeds.
 - Paths are always Drive-absolute: `/my-files/folder/file.pdf`. Relative paths are not supported.
-- All calls include `--json` automatically — you never need to pass it manually via the CLI wrapper.
+- All calls include `--json` automatically, except `drive_version`, whose underlying CLI command ignores `--json` and always prints plain text — this MCP parses it directly.
 
 ---
 

package/dist/cli.js

@@ -4,25 +4,7 @@
  * Provides a human-friendly interface to the same DriveService used by the MCP server.
  *
  * Usage: proton-drive-cli <command> [args]
- *   auth status
- *   auth logout
- *   version
- *   list <remote-path>
- *   mkdir <remote-path>
- *   upload <local-path> <remote-path> [--conflict skip|overwrite|rename]
- *   download <remote-path> <local-path>
- *   move <src> <dst>
- *   delete <path>
- *   share status <path>
- *   share invite <path> <email> <role> [--message "..."]
- *   share revoke <path> <email>
- *   trash <path>
- *   trash list
- *   trash empty
- *   restore <path>
- *
- * Global flags:
- *   --json   Machine-readable JSON output
+ * Run with --help (or see usage() below) for the full command list.
  */
 import { DriveService } from "./services/drive.js";
 import { DriveCliError, DriveCliNotFoundError, DriveNotAuthenticatedError, DriveParseError } from "./utils/errors.js";
@@ -36,28 +18,40 @@ function usage() {
 proton-drive-cli — Proton Drive companion CLI
 
 Commands:
-  auth status                              Check authentication status
+  auth status                              Check authentication status (probes /my-files)
   auth logout                              Log out
   version                                  Show CLI/SDK version
   list <path>                              List files at path
   mkdir <path>                             Create a new folder
-  upload <local> <remote> [--conflict X]  Upload file/folder (skip/overwrite/rename)
-  download <remote> <local>               Download file/folder
+  upload <local> <remote> [--conflict X]  Upload file/folder (skip/replace/keep-both/merge)
+  download <remote> <local> [--conflict X] Download file/folder (skip/replace/keep-both)
   move <src> <dst>                         Move/rename
-  delete <path>                            Delete file/folder permanently
+  delete <path> --confirm                  Delete a file/folder already in trash, permanently
   share status <path>                      Show sharing info
   share invite <path> <email> <role>       Invite user (viewer/editor/admin)
-  share revoke <path> <email>              Revoke access
+  share revoke <path> <email>              Revoke one user's access
+  share remove-all <path> --confirm        Remove everyone's access + pending invitations
+  share set-url <path> [--role] [--password] [--expiration]  Create/update public link
+  share remove-url <path>                  Remove public link
+  share leave <path>                       Leave a folder shared with you
+  copy <src> <dst>                         Copy file/folder
   trash <path>                             Move to trash
   trash list                               List trash contents
-  trash empty                              Permanently delete all trash
+  trash empty --confirm                    Permanently delete all trash
   restore <path>                           Restore from trash
+  invitation list                          List pending invitations
+  invitation accept <uid>                  Accept an invitation
+  invitation reject <uid>                  Reject an invitation
   album list                               List all photo albums
   album create <name>                      Create a new album
-  album delete <path> [--force] [--save]  Delete an album
+  album update <path> [--name] [--cover-photo-uid]  Rename/update album cover
+  album delete <path> --confirm [--force] [--save]  Delete an album
   album photos <path>                      List photos in an album
   album add-photo <album> <photo>          Add a photo to an album
   album remove-photo <album> <photo>       Remove a photo from an album
+  photo timeline [--load-details]          List photos in your timeline
+  photo download <photo>... <local> [--conflict X]  Download photos (skip/replace/keep-both)
+  photo upload <local>... [--conflict X]   Upload photos to your library (skip/keep-both)
 
 Flags:
   --json                                   Machine-readable JSON output (one line)
@@ -160,8 +154,8 @@ async function run() {
             }
             const remote = requirePath(rest[0], "upload <local> <remote>");
             const conflictRaw = getFlag("--conflict") ?? "skip";
-            if (!["skip", "overwrite", "rename"].includes(conflictRaw)) {
-                console.error(`Invalid --conflict value: ${conflictRaw}. Must be skip, overwrite, or rename.`);
+            if (!["skip", "replace", "keep-both", "merge"].includes(conflictRaw)) {
+                console.error(`Invalid --conflict value: ${conflictRaw}. Must be skip, replace, keep-both, or merge.`);
                 process.exit(1);
             }
             const conflict = conflictRaw;
@@ -185,7 +179,12 @@ async function run() {
                 process.exit(1);
                 return;
             }
-            print(await drive.download(remote, local));
+            const dConflictRaw = getFlag("--conflict") ?? "skip";
+            if (!["skip", "replace", "keep-both"].includes(dConflictRaw)) {
+                console.error(`Invalid --conflict value: ${dConflictRaw}. Must be skip, replace, or keep-both.`);
+                process.exit(1);
+            }
+            print(await drive.download(remote, local, dConflictRaw));
             break;
         }
         case "move": {
@@ -202,7 +201,7 @@ async function run() {
         case "delete": {
             const delPath = requirePath(sub, "delete <path> --confirm");
             if (!args.includes("--confirm")) {
-                console.error(`This will permanently delete: ${delPath}\nPass --confirm to proceed.`);
+                console.error(`This permanently deletes an item already in trash: ${delPath}\nPass --confirm to proceed.`);
                 process.exit(1);
             }
             await drive.delete(delPath);
@@ -241,6 +240,31 @@ async function run() {
                 await drive.shareRevoke(revokePath, revokeEmail);
                 console.log(`Revoked access for ${revokeEmail}.`);
             }
+            else if (sub === "remove-all") {
+                const removeAllPath = requirePath(rest[0], "share remove-all <path> --confirm");
+                if (!args.includes("--confirm")) {
+                    console.error(`This removes everyone's access to: ${removeAllPath}\nPass --confirm to proceed.`);
+                    process.exit(1);
+                }
+                await drive.shareRemove(removeAllPath, [], true);
+                console.log(`Removed all access to: ${removeAllPath}`);
+            }
+            else if (sub === "set-url") {
+                const setUrlPath = requirePath(rest[0], "share set-url <path> [--role] [--password] [--expiration]");
+                const roleRaw = getFlag("--role") ?? "viewer";
+                if (!["viewer", "editor"].includes(roleRaw)) {
+                    console.error(`Invalid --role value: ${roleRaw}. Must be viewer or editor.`);
+                    process.exit(1);
+                }
+                const password = getFlag("--password");
+                const expiration = getFlag("--expiration");
+                print(await drive.shareSetUrl(setUrlPath, roleRaw, password, expiration));
+            }
+            else if (sub === "remove-url") {
+                const removeUrlPath = requirePath(rest[0], "share remove-url <path>");
+                await drive.shareRemoveUrl(removeUrlPath);
+                console.log(`Public link removed: ${removeUrlPath}`);
+            }
             else if (sub === "leave") {
                 const leavePath = requirePath(rest[0], "share leave <path>");
                 await drive.shareLeave(leavePath);
@@ -323,6 +347,17 @@ async function run() {
                 await drive.createAlbum(albumName);
                 console.log(`Album created: ${albumName}`);
             }
+            else if (sub === "update") {
+                const albumPath = requirePath(rest[0], "album update <path> [--name] [--cover-photo-uid]");
+                const newName = getFlag("--name");
+                const coverPhotoUid = getFlag("--cover-photo-uid");
+                if (!newName && !coverPhotoUid) {
+                    console.error("Usage: album update <path> [--name <name>] [--cover-photo-uid <uid>] (at least one required)");
+                    process.exit(1);
+                }
+                await drive.updateAlbum(albumPath, newName, coverPhotoUid);
+                console.log(`Album updated: ${albumPath}`);
+            }
             else if (sub === "delete") {
                 const albumPath = requirePath(rest[0], "album delete <path> [--force] [--save] --confirm");
                 if (!args.includes("--confirm")) {
@@ -349,10 +384,72 @@ async function run() {
                 console.log(`Removed ${photoPath} from ${albumPath}`);
             }
             else {
-                console.error("Usage: album list | album create <name> | album delete <path> | album photos <path> | album add-photo <album> <photo> | album remove-photo <album> <photo>");
+                console.error("Usage: album list | album create <name> | album update <path> | album delete <path> | album photos <path> | album add-photo <album> <photo> | album remove-photo <album> <photo>");
                 process.exit(1);
             }
             break;
+        case "photo": {
+            // Strip --conflict <value> out of a variadic positional list.
+            const conflictFlagIdx = rest.indexOf("--conflict");
+            const positionals = conflictFlagIdx === -1
+                ? rest
+                : [...rest.slice(0, conflictFlagIdx), ...rest.slice(conflictFlagIdx + 2)];
+            const conflictRaw = getFlag("--conflict") ?? "skip";
+            if (sub === "timeline") {
+                print(await drive.photoTimeline(args.includes("--load-details")));
+            }
+            else if (sub === "download") {
+                if (positionals.length < 2) {
+                    console.error("Usage: photo download <photo>... <local-folder> [--conflict X]");
+                    process.exit(1);
+                    return;
+                }
+                const localFolder = positionals[positionals.length - 1];
+                const photoPaths = positionals.slice(0, -1).map((p) => requirePath(p, "photo download <photo>... <local-folder>"));
+                let localFolderValidated;
+                try {
+                    localFolderValidated = validateLocalPath(localFolder);
+                }
+                catch (e) {
+                    console.error(e instanceof Error ? e.message : String(e));
+                    process.exit(1);
+                    return;
+                }
+                if (!["skip", "replace", "keep-both"].includes(conflictRaw)) {
+                    console.error(`Invalid --conflict value: ${conflictRaw}. Must be skip, replace, or keep-both.`);
+                    process.exit(1);
+                }
+                print(await drive.photoDownload(photoPaths, localFolderValidated, conflictRaw));
+            }
+            else if (sub === "upload") {
+                if (positionals.length === 0) {
+                    console.error("Usage: photo upload <local>... [--conflict X]");
+                    process.exit(1);
+                    return;
+                }
+                const localPaths = [];
+                for (const p of positionals) {
+                    try {
+                        localPaths.push(validateLocalPath(p));
+                    }
+                    catch (e) {
+                        console.error(e instanceof Error ? e.message : String(e));
+                        process.exit(1);
+                        return;
+                    }
+                }
+                if (!["skip", "keep-both"].includes(conflictRaw)) {
+                    console.error(`Invalid --conflict value: ${conflictRaw}. Must be skip or keep-both.`);
+                    process.exit(1);
+                }
+                print(await drive.photoUpload(localPaths, conflictRaw));
+            }
+            else {
+                console.error("Usage: photo timeline [--load-details] | photo download <photo>... <local> | photo upload <local>...");
+                process.exit(1);
+            }
+            break;
+        }
         default:
             console.error(`Unknown command: ${cmd}`);
             usage();

package/dist/index.js

@@ -46,9 +46,9 @@ const TOOLS = [
     {
         name: "drive_auth_status",
         description: "Check whether the Proton Drive CLI has an active authenticated session. " +
-            "Returns {authenticated: boolean, email?: string}. " +
+            "Returns {authenticated: boolean}. The underlying CLI has no dedicated status command — this probes by resolving /my-files, which makes a real (lightweight) call. " +
             "Use before any file operation when you need to confirm the session is valid — all other drive_* tools (except drive_version) require authentication. " +
-            "Does not make a network call if the session token is already cached locally.",
+            "Does not expose the signed-in account's email — the CLI provides no way to query it.",
         annotations: { readOnlyHint: true, idempotentHint: true },
         inputSchema: { type: "object", properties: {}, required: [], additionalProperties: false },
     },
@@ -96,7 +96,7 @@ const TOOLS = [
         description: "Upload a local file or folder to Proton Drive with end-to-end encryption. Requires authentication. " +
             "For folders, uploads recursively and preserves directory structure. " +
             "Returns {uploaded, skipped, failed} counts — fails the call if failed > 0 (common causes: quota exceeded, destination path not found, permission denied). " +
-            "conflictStrategy defaults to 'skip' — only use 'overwrite' with explicit user confirmation since it permanently replaces the remote file. " +
+            "conflictStrategy defaults to 'skip'. Values: 'skip' (leave existing remote file unchanged), 'replace' (permanently overwrite — confirm with user first), 'keep-both' (upload with a unique name), 'merge' (folders only — merge contents instead of failing). " +
             "Do not use to move files already on Drive (use drive_move) or to write text content directly (use drive_write_file if PROTON_DRIVE_SYNC_PATH is set). " +
             "Ensure destination folder exists first with drive_list; create it with drive_mkdir if needed.",
         annotations: { openWorldHint: true },
@@ -113,10 +113,11 @@ const TOOLS = [
                 },
                 conflictStrategy: {
                     type: "string",
-                    enum: ["skip", "overwrite", "rename"],
+                    enum: ["skip", "replace", "keep-both", "merge"],
                     description: "'skip' leaves existing remote files unchanged (default). " +
-                        "'overwrite' permanently replaces the remote file — confirm with user first. " +
-                        "'rename' uploads with a unique name to avoid conflicts.",
+                        "'replace' permanently overwrites the remote file — confirm with user first. " +
+                        "'keep-both' uploads with a unique name to avoid conflicts. " +
+                        "'merge' merges folder contents instead of failing (folders only).",
                 },
             },
             required: ["localPath", "remotePath"],
@@ -127,7 +128,7 @@ const TOOLS = [
         name: "drive_download",
         description: "Download a file or folder from Proton Drive to the local filesystem. Requires authentication. " +
             "For folders, downloads recursively. " +
-            "Silently overwrites any existing local file at localPath — verify the destination before calling. " +
+            "conflictStrategy defaults to 'skip' — pass 'replace' to overwrite an existing local file, or 'keep-both' to save under a unique name. " +
             "Fails if the local parent directory does not exist. " +
             "Returns {downloaded} count. " +
             "Do not use to move files within Drive (use drive_move) or to read a small text file's contents (use drive_read_file if PROTON_DRIVE_SYNC_PATH is set).",
@@ -143,6 +144,13 @@ const TOOLS = [
                     type: "string",
                     description: "Absolute local destination path (must start with '/'). Parent directory must already exist.",
                 },
+                conflictStrategy: {
+                    type: "string",
+                    enum: ["skip", "replace", "keep-both"],
+                    description: "'skip' leaves an existing local file unchanged (default). " +
+                        "'replace' overwrites it — confirm with user first. " +
+                        "'keep-both' downloads under a unique name.",
+                },
             },
             required: ["remotePath", "localPath"],
             additionalProperties: false,
@@ -173,7 +181,7 @@ const TOOLS = [
             "To rename: keep the same parent, change only the filename (e.g. /my-files/old.pdf → /my-files/new.pdf). " +
             "To move: provide a different parent folder. " +
             "Fails if destinationPath is already occupied or if its parent folder does not exist. " +
-            "Do not use to copy a file (no copy operation exists — upload again instead) or to download to local storage (use drive_download).",
+            "Do not use to copy a file while keeping the original (use drive_copy) or to download to local storage (use drive_download).",
         annotations: { destructiveHint: false },
         inputSchema: {
             type: "object",
@@ -193,9 +201,10 @@ const TOOLS = [
     },
     {
         name: "drive_delete",
-        description: "Permanently delete a file or folder from Proton Drive — no trash step, no recovery possible. Requires authentication. " +
-            "Requires confirmed=true; always show the exact path to the user and get explicit confirmation before calling. " +
-            "Do not use when reversible deletion is acceptable — use drive_trash instead so the item can be recovered with drive_restore.",
+        description: "Permanently delete a file or folder that is already in the Proton Drive trash — irreversible. Requires authentication. " +
+            "The underlying CLI only allows permanent deletion of items already inside /trash or /photos-trash; it rejects live paths. " +
+            "Use drive_trash first to move a live item into trash, then pass its trash path here — or drive_empty_trash to clear everything at once. " +
+            "Requires confirmed=true; always show the exact path to the user and get explicit confirmation before calling.",
         annotations: { destructiveHint: true },
         inputSchema: {
             type: "object",
@@ -448,6 +457,80 @@ const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "drive_share_set_url",
+        description: "Create or update a public share link for a Proton Drive file or folder. Requires authentication. " +
+            "Anyone with the link can access the item at the given role — no invitation or Proton account required. " +
+            "Calling this again on the same path updates the existing link's role/password/expiration rather than creating a duplicate. " +
+            "Returns {url?, role?, expirationTime?} — the exact shape depends on the CLI/SDK response and fields may be absent. " +
+            "The password, if set, is passed as a CLI argument and will appear in shell history/process list on the machine running this server. " +
+            "Do not use for private sharing with specific people — use drive_share_invite instead.",
+        annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Absolute remote Drive path to create a public link for (must start with '/').",
+                },
+                role: {
+                    type: "string",
+                    enum: ["viewer", "editor"],
+                    description: "Access level for anyone with the link. Defaults to 'viewer' if omitted.",
+                },
+                password: {
+                    type: "string",
+                    description: "Optional custom password required to access the link. Omit for no password.",
+                },
+                expiration: {
+                    type: "string",
+                    description: "Optional expiration date in ISO format, e.g. '2026-06-06'. Omit for no expiration.",
+                },
+            },
+            required: ["path"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "drive_share_remove_url",
+        description: "Remove the public share link from a Proton Drive file or folder. Requires authentication. " +
+            "The link stops working immediately — direct member access (from drive_share_invite) is not affected. " +
+            "Do not use to remove a specific person's access — use drive_share_revoke instead.",
+        annotations: { destructiveHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Absolute remote Drive path whose public link should be removed (must start with '/').",
+                },
+            },
+            required: ["path"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "drive_share_remove_all",
+        description: "Remove access for every member and every pending invitation (Proton and non-Proton) on a shared Proton Drive path, in a single call. Requires authentication and confirmed=true. " +
+            "Use drive_share_status first to show the user who currently has access. " +
+            "For removing one specific person, use drive_share_revoke instead — it is cheaper and less error-prone.",
+        annotations: { destructiveHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Absolute remote Drive path to strip all sharing access from (must start with '/').",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Must be true. Confirms the user has acknowledged this removes everyone's access at once.",
+                },
+            },
+            required: ["path", "confirmed"],
+            additionalProperties: false,
+        },
+    },
     // Photos / Albums
     {
         name: "photos_list_albums",
@@ -476,6 +559,32 @@ const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "photos_update_album",
+        description: "Rename an album or change its cover photo in Proton Photos. Requires authentication. " +
+            "At least one of name or coverPhotoUid must be provided. " +
+            "Use photos_list_album_photos to find a nodeUid to set as the cover.",
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: "object",
+            properties: {
+                albumPath: {
+                    type: "string",
+                    description: "Absolute path of the album to update. Must start with /albums/. E.g. /albums/Vacation 2024",
+                },
+                name: {
+                    type: "string",
+                    description: "New name for the album. Omit to leave unchanged.",
+                },
+                coverPhotoUid: {
+                    type: "string",
+                    description: "nodeUid (from photos_list_album_photos) of the photo to set as the album cover. Omit to leave unchanged.",
+                },
+            },
+            required: ["albumPath"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "photos_delete_album",
         description: "Delete a Proton Photos album. Requires authentication and confirmed=true. " +
@@ -572,6 +681,78 @@ const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "photos_list_timeline",
+        description: "List photos in your Proton Photos timeline (your full photo library, not scoped to an album). Requires authentication. " +
+            "Returns [{nodeUid}] by default — pass loadDetails=true for full node metadata (slower; buffers the whole list in memory first). " +
+            "Use photos_download to download items by path, or photos_add_to_album to add them to an album.",
+        annotations: { readOnlyHint: true, idempotentHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                loadDetails: {
+                    type: "boolean",
+                    description: "If true, fetch full node metadata for each photo instead of just its nodeUid. Default false.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "photos_download",
+        description: "Download one or more photos from Proton Photos (timeline, an album, or shared-with-me) to a local folder. Requires authentication. " +
+            "Multiple timeline photos can share the same filename — with conflictStrategy 'replace' or 'skip' only one copy survives locally; use 'keep-both' to keep all. " +
+            "Fails if any item fails to download. " +
+            "Do not use for regular Drive files — use drive_download instead.",
+        annotations: { openWorldHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                photoPaths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "One or more absolute photo paths to download (each must start with '/'). E.g. ['/photos/IMG_001.jpg']",
+                },
+                localFolder: {
+                    type: "string",
+                    description: "Absolute local destination folder (must start with '/'). Created if it does not exist.",
+                },
+                conflictStrategy: {
+                    type: "string",
+                    enum: ["skip", "replace", "keep-both"],
+                    description: "How to handle local filename collisions. Defaults to 'skip'.",
+                },
+            },
+            required: ["photoPaths", "localFolder"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "photos_upload",
+        description: "Upload one or more local photo or video files directly into your Proton Photos library (My Photos timeline). Requires authentication. " +
+            "Non-photo/video files are silently skipped. Folders are recursed but flattened into My Photos — folder structure is not preserved. " +
+            "Never overwrites — duplicates (matched by name + content hash) resolve to 'keep-both' or 'skip' only. " +
+            "Do not use for regular Drive files — use drive_upload instead.",
+        annotations: { openWorldHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                localPaths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "One or more absolute local paths to files or folders to upload (each must start with '/').",
+                },
+                conflictStrategy: {
+                    type: "string",
+                    enum: ["skip", "keep-both"],
+                    description: "How to handle duplicate photos (matched by name + content hash). Defaults to 'skip'.",
+                },
+            },
+            required: ["localPaths"],
+            additionalProperties: false,
+        },
+    },
     // Sync-folder tools (requires PROTON_DRIVE_SYNC_PATH env var)
     {
         name: "drive_read_file",
@@ -660,8 +841,8 @@ export async function main() {
                 }
                 case "drive_upload": {
                     const cs = typeof a.conflictStrategy === "string" ? a.conflictStrategy : "skip";
-                    if (!["skip", "overwrite", "rename"].includes(cs)) {
-                        return fail(`conflictStrategy must be skip, overwrite, or rename`);
+                    if (!["skip", "replace", "keep-both", "merge"].includes(cs)) {
+                        return fail(`conflictStrategy must be skip, replace, keep-both, or merge`);
                     }
                     const uploadResult = await drive.upload(validateLocalPath(a.localPath), validateRemotePath(a.remotePath), cs);
                     if (uploadResult.failed > 0) {
@@ -669,8 +850,13 @@ export async function main() {
                     }
                     return ok(uploadResult);
                 }
-                case "drive_download":
-                    return ok(await drive.download(validateRemotePath(a.remotePath), validateLocalPath(a.localPath)));
+                case "drive_download": {
+                    const dcs = typeof a.conflictStrategy === "string" ? a.conflictStrategy : "skip";
+                    if (!["skip", "replace", "keep-both"].includes(dcs)) {
+                        return fail(`conflictStrategy must be skip, replace, or keep-both`);
+                    }
+                    return ok(await drive.download(validateRemotePath(a.remotePath), validateLocalPath(a.localPath), dcs));
+                }
                 case "drive_move": {
                     const moveSrc = validateRemotePath(a.sourcePath);
                     const moveDst = validateRemotePath(a.destinationPath);
@@ -750,6 +936,29 @@ export async function main() {
                     await drive.shareLeave(leavePath);
                     return ok({ message: `Left shared folder: ${leavePath}` });
                 }
+                case "drive_share_set_url": {
+                    const setUrlPath = validateRemotePath(a.path);
+                    const role = typeof a.role === "string" ? a.role : "viewer";
+                    if (!["viewer", "editor"].includes(role))
+                        return fail("role must be viewer or editor");
+                    const password = typeof a.password === "string" ? a.password : undefined;
+                    const expiration = typeof a.expiration === "string" ? a.expiration : undefined;
+                    const link = await drive.shareSetUrl(setUrlPath, role, password, expiration);
+                    return ok(link);
+                }
+                case "drive_share_remove_url": {
+                    const removeUrlPath = validateRemotePath(a.path);
+                    await drive.shareRemoveUrl(removeUrlPath);
+                    return ok({ message: `Public link removed: ${removeUrlPath}` });
+                }
+                case "drive_share_remove_all": {
+                    if (a.confirmed !== true) {
+                        return fail("drive_share_remove_all requires confirmed=true. Use drive_share_status first to show the user who has access.");
+                    }
+                    const removeAllPath = validateRemotePath(a.path);
+                    await drive.shareRemove(removeAllPath, [], true);
+                    return ok({ message: `Removed all access to: ${removeAllPath}` });
+                }
                 case "photos_list_albums":
                     return ok(await drive.listAlbums());
                 case "photos_create_album": {
@@ -758,6 +967,17 @@ export async function main() {
                     await drive.createAlbum(a.name.trim());
                     return ok({ message: `Album created: ${a.name.trim()}` });
                 }
+                case "photos_update_album": {
+                    const updateAlbumPath = validateRemotePath(a.albumPath);
+                    if (!updateAlbumPath.startsWith("/albums/"))
+                        return fail("albumPath must start with /albums/");
+                    const newName = typeof a.name === "string" && a.name.trim() ? a.name.trim() : undefined;
+                    const coverPhotoUid = typeof a.coverPhotoUid === "string" && a.coverPhotoUid.trim() ? a.coverPhotoUid.trim() : undefined;
+                    if (!newName && !coverPhotoUid)
+                        return fail("At least one of name or coverPhotoUid must be provided");
+                    await drive.updateAlbum(updateAlbumPath, newName, coverPhotoUid);
+                    return ok({ message: `Album updated: ${updateAlbumPath}` });
+                }
                 case "photos_delete_album": {
                     if (a.confirmed !== true)
                         return fail("photos_delete_album requires confirmed=true. Show the user the album name and photo count first.");
@@ -793,6 +1013,35 @@ export async function main() {
                     await drive.removePhotoFromAlbum(remAlbumPath, remPhotoPath);
                     return ok({ message: `Removed ${remPhotoPath} from ${remAlbumPath}` });
                 }
+                case "photos_list_timeline":
+                    return ok(await drive.photoTimeline(a.loadDetails === true));
+                case "photos_download": {
+                    if (!Array.isArray(a.photoPaths) || a.photoPaths.length === 0)
+                        return fail("photoPaths must be a non-empty array of strings");
+                    const downloadPaths = a.photoPaths.map((p) => validateRemotePath(p));
+                    const downloadFolder = validateLocalPath(a.localFolder);
+                    const pdcs = typeof a.conflictStrategy === "string" ? a.conflictStrategy : "skip";
+                    if (!["skip", "replace", "keep-both"].includes(pdcs))
+                        return fail("conflictStrategy must be skip, replace, or keep-both");
+                    const downloadSummary = await drive.photoDownload(downloadPaths, downloadFolder, pdcs);
+                    if (downloadSummary.failedItems > 0) {
+                        return fail(`Download completed with ${downloadSummary.failedItems} failed item(s). transferred=${downloadSummary.transferredItems}`);
+                    }
+                    return ok(downloadSummary);
+                }
+                case "photos_upload": {
+                    if (!Array.isArray(a.localPaths) || a.localPaths.length === 0)
+                        return fail("localPaths must be a non-empty array of strings");
+                    const uploadPaths = a.localPaths.map((p) => validateLocalPath(p));
+                    const pucs = typeof a.conflictStrategy === "string" ? a.conflictStrategy : "skip";
+                    if (!["skip", "keep-both"].includes(pucs))
+                        return fail("conflictStrategy must be skip or keep-both");
+                    const uploadSummary = await drive.photoUpload(uploadPaths, pucs);
+                    if (uploadSummary.failedItems > 0) {
+                        return fail(`Upload completed with ${uploadSummary.failedItems} failed item(s). transferred=${uploadSummary.transferredItems}`);
+                    }
+                    return ok(uploadSummary);
+                }
                 case "drive_read_file": {
                     const syncRoot = getSyncRoot();
                     if (!syncRoot)

package/dist/services/drive.js

@@ -1,32 +1,44 @@
-import { runDrive as defaultRunDrive } from "../utils/subprocess.js";
-import { DriveParseError } from "../utils/errors.js";
+import { posix as posixPath } from "node:path";
+import { runDrive as defaultRunDrive, runDriveRaw as defaultRunDriveRaw } from "../utils/subprocess.js";
+import { DriveNotAuthenticatedError, DriveParseError } from "../utils/errors.js";
 export class DriveService {
     run;
-    constructor(runner) {
+    runRaw;
+    constructor(runner, rawRunner) {
         this.run = runner ?? defaultRunDrive;
+        this.runRaw = rawRunner ?? defaultRunDriveRaw;
     }
     // Auth
+    //
+    // The CLI has no `auth status` command (it doesn't exist). We probe by
+    // resolving a path every authenticated user has (/my-files) and treating
+    // a DriveNotAuthenticatedError as the signal. Any other error propagates —
+    // it means something unexpected happened, not that the session is invalid.
     async authStatus() {
-        const result = await this.run(["auth", "status"]);
-        if (result === null)
-            return { authenticated: false };
-        const r = result;
-        return {
-            authenticated: Boolean(r?.authenticated ?? r?.loggedIn ?? false),
-            email: typeof r?.email === "string" ? r.email : undefined,
-        };
+        try {
+            await this.run(["filesystem", "info", "/my-files"]);
+            return { authenticated: true };
+        }
+        catch (err) {
+            if (err instanceof DriveNotAuthenticatedError)
+                return { authenticated: false };
+            throw err;
+        }
     }
     async authLogout() {
         await this.run(["auth", "logout"]);
     }
+    // `version` ignores --json entirely and always prints plain text:
+    //   Proton Drive CLI 1.2.3
+    //   Proton Drive SDK 4.5.6
+    //   ...update-check line...
     async version() {
-        const result = await this.run(["version"]);
-        if (result === null)
-            throw new DriveParseError("version command returned no output");
-        const r = result;
+        const text = await this.runRaw(["version"]);
+        const cliMatch = text.match(/Proton Drive CLI\s+(\S+)/);
+        const sdkMatch = text.match(/Proton Drive SDK\s+(\S+)/);
         return {
-            cli: typeof r.cli === "string" ? r.cli : String(r.version ?? "unknown"),
-            sdk: typeof r.sdk === "string" ? r.sdk : "unknown",
+            cli: cliMatch ? cliMatch[1] : "unknown",
+            sdk: sdkMatch ? sdkMatch[1] : "unknown",
         };
     }
     // Filesystem
@@ -63,8 +75,11 @@ export class DriveService {
             failed: typeof r?.failed === "number" ? r.failed : 0,
         };
     }
-    async download(remotePath, localPath) {
-        const result = await this.run(["filesystem", "download", remotePath, localPath]);
+    async download(remotePath, localPath, conflictStrategy = "skip") {
+        const result = await this.run([
+            "filesystem", "download", remotePath, localPath,
+            "--conflict-strategy", conflictStrategy,
+        ]);
         const r = (result ?? {});
         return {
             path: remotePath,
@@ -72,14 +87,41 @@ export class DriveService {
             downloaded: typeof r?.downloaded === "number" ? r.downloaded : 0,
         };
     }
+    // The CLI has no `mkdir` — it's `create-folder <parentPath> <name>`.
     async mkdir(remotePath) {
-        await this.run(["filesystem", "mkdir", remotePath]);
+        const parent = posixPath.dirname(remotePath);
+        const name = posixPath.basename(remotePath);
+        if (!name || parent === remotePath) {
+            throw new Error(`path must include a folder name to create: ${remotePath}`);
+        }
+        await this.run(["filesystem", "create-folder", parent, name]);
     }
-    async move(remoteSrc, remoteDst) {
-        await this.run(["filesystem", "move", remoteSrc, remoteDst]);
+    // The CLI has no single "move to any full path" command — `move` only
+    // accepts a target *parent folder*, and renaming is a separate `rename`
+    // command. We keep the tool's external contract (a full destination path)
+    // by translating into the right combination of the two real commands.
+    async move(sourcePath, destinationPath) {
+        const srcParent = posixPath.dirname(sourcePath);
+        const srcName = posixPath.basename(sourcePath);
+        const dstParent = posixPath.dirname(destinationPath);
+        const dstName = posixPath.basename(destinationPath);
+        if (srcParent === dstParent) {
+            if (srcName === dstName)
+                return;
+            await this.run(["filesystem", "rename", sourcePath, dstName]);
+            return;
+        }
+        await this.run(["filesystem", "move", sourcePath, dstParent]);
+        if (srcName !== dstName) {
+            const movedPath = posixPath.join(dstParent, srcName);
+            await this.run(["filesystem", "rename", movedPath, dstName]);
+        }
     }
+    // `filesystem delete` permanently deletes — but only items already inside
+    // /trash or /photos-trash (the CLI rejects live paths). No --confirm flag
+    // exists on the CLI side; our own confirmed-gate lives in the MCP layer.
     async delete(remotePath) {
-        await this.run(["filesystem", "delete", "--confirm", remotePath]);
+        await this.run(["filesystem", "delete", remotePath]);
     }
     // Sharing
     async shareStatus(remotePath) {
@@ -111,33 +153,57 @@ export class DriveService {
             remotePath,
         ]);
     }
+    // `sharing revoke` doesn't exist — it's `sharing remove --email <email>`.
     async shareRevoke(remotePath, email) {
-        await this.run(["sharing", "revoke", "--user", email, remotePath]);
+        await this.shareRemove(remotePath, [email], false);
+    }
+    // General form of remove: specific emails, or --everyone to strip all
+    // members and pending invitations (Proton and non-Proton) in one call.
+    async shareRemove(remotePath, emails, everyone) {
+        const args = ["sharing", "remove"];
+        for (const email of emails)
+            args.push("--email", email);
+        if (everyone)
+            args.push("--everyone");
+        args.push(remotePath);
+        await this.run(args);
+    }
+    async shareSetUrl(remotePath, role = "viewer", password, expiration) {
+        const args = ["sharing", "set-url", remotePath, "--role", role];
+        if (password)
+            args.push("--password", password);
+        if (expiration)
+            args.push("--expiration", expiration);
+        const result = await this.run(args);
+        return this.parsePublicLink(result);
+    }
+    async shareRemoveUrl(remotePath) {
+        await this.run(["sharing", "remove-url", remotePath]);
+    }
+    parsePublicLink(result) {
+        const r = (result ?? {});
+        const urlAccess = (r.urlAccess ?? {});
+        const url = r.url ?? urlAccess.url;
+        const role = r.role ?? urlAccess.role;
+        const expirationTime = r.expirationTime ?? urlAccess.expirationTime;
+        return {
+            url: typeof url === "string" ? url : undefined,
+            role: (["viewer", "editor", "admin"].includes(String(role)) ? role : undefined),
+            expirationTime: typeof expirationTime === "string" ? expirationTime : undefined,
+        };
     }
     // Trash
     async listTrash() {
-        const result = await this.run(["trash", "list"]);
-        if (result === null)
-            return [];
-        if (!Array.isArray(result))
-            throw new DriveParseError(`Expected array from trash list, got: ${JSON.stringify(result).slice(0, 100)}`);
-        return result.map((item) => ({
-            name: String(item.name ?? ""),
-            path: String(item.path ?? ""),
-            type: item.type === "folder" ? "folder" : "file",
-            size: typeof item.size === "number" ? item.size : undefined,
-            modifiedAt: typeof item.modifiedAt === "string" ? item.modifiedAt : undefined,
-            mimeType: typeof item.mimeType === "string" ? item.mimeType : undefined,
-        }));
+        return this.list("/trash");
     }
     async trash(remotePath) {
-        await this.run(["trash", remotePath]);
+        await this.run(["filesystem", "trash", remotePath]);
     }
     async restore(remotePath) {
-        await this.run(["trash", "restore", remotePath]);
+        await this.run(["filesystem", "restore", remotePath]);
     }
     async emptyTrash() {
-        await this.run(["trash", "empty", "--confirm"]);
+        await this.run(["filesystem", "empty-trash"]);
     }
     async copy(remoteSrc, remoteDst) {
         await this.run(["filesystem", "copy", remoteSrc, remoteDst]);
@@ -188,6 +254,14 @@ export class DriveService {
     async createAlbum(name) {
         await this.run(["album", "create", name]);
     }
+    async updateAlbum(albumPath, name, coverPhotoUid) {
+        const args = ["album", "update", albumPath];
+        if (name)
+            args.push("--name", name);
+        if (coverPhotoUid)
+            args.push("--cover-photo-uid", coverPhotoUid);
+        await this.run(args);
+    }
     async deleteAlbum(albumPath, force, save) {
         const args = ["album", "delete", albumPath];
         if (force)
@@ -212,4 +286,42 @@ export class DriveService {
     async removePhotoFromAlbum(albumPath, photoPath) {
         await this.run(["album", "remove-photo", albumPath, photoPath]);
     }
+    // Photos timeline / library-level transfers (distinct from album-scoped
+    // filesystem-style paths above — these hit the `photo` CLI group).
+    async photoTimeline(loadDetails) {
+        const args = ["photo", "timeline"];
+        if (loadDetails)
+            args.push("--load-details");
+        const result = await this.run(args);
+        if (result === null)
+            return [];
+        if (!Array.isArray(result))
+            throw new DriveParseError(`Expected array from photo timeline, got: ${JSON.stringify(result).slice(0, 100)}`);
+        return result.map((item) => ({
+            nodeUid: String(item.nodeUid ?? item.uid ?? ""),
+        }));
+    }
+    async photoDownload(remotePaths, localFolder, conflictStrategy = "skip") {
+        const result = await this.run([
+            "photo", "download", ...remotePaths, localFolder,
+            "--conflict-strategy", conflictStrategy,
+        ]);
+        return this.parseTransferSummary(result);
+    }
+    async photoUpload(localPaths, conflictStrategy = "skip") {
+        const result = await this.run([
+            "photo", "upload", ...localPaths,
+            "--conflict-strategy", conflictStrategy,
+        ]);
+        return this.parseTransferSummary(result);
+    }
+    parseTransferSummary(result) {
+        const r = (result ?? {});
+        return {
+            transferredItems: typeof r.transferredItems === "number" ? r.transferredItems : 0,
+            transferredBytes: typeof r.transferredBytes === "number" ? r.transferredBytes : 0,
+            skippedItems: typeof r.skippedItems === "number" ? r.skippedItems : 0,
+            failedItems: typeof r.failedItems === "number" ? r.failedItems : 0,
+        };
+    }
 }

package/dist/utils/subprocess.js

@@ -7,13 +7,45 @@ const DEFAULT_TIMEOUT_MS = 60_000;
 // Upload and download transfer actual file bytes — use a much longer timeout.
 const TRANSFER_TIMEOUT_MS = 30 * 60_000; // 30 minutes
 const TRANSFER_COMMANDS = new Set(["upload", "download"]);
+const TRANSFER_GROUPS = new Set(["filesystem", "photo"]);
 function timeoutFor(args) {
     // args[0] is the group (e.g. "filesystem"), args[1] is the subcommand
-    if (args[0] === "filesystem" && args[1] && TRANSFER_COMMANDS.has(args[1])) {
+    if (args[0] && TRANSFER_GROUPS.has(args[0]) && args[1] && TRANSFER_COMMANDS.has(args[1])) {
         return TRANSFER_TIMEOUT_MS;
     }
     return DEFAULT_TIMEOUT_MS;
 }
+function isAuthError(stderr) {
+    const lower = stderr.toLowerCase();
+    return (lower.includes("not authenticated") ||
+        lower.includes("not logged in") ||
+        lower.includes("you need to login first"));
+}
+// Normalizes a raw execFile failure into one of our typed errors. Shared by
+// runDrive and runDriveRaw so both entry points fail the same way.
+function normalizeExecError(err, args) {
+    if (err instanceof DriveCliError ||
+        err instanceof DriveNotAuthenticatedError ||
+        err instanceof DriveParseError) {
+        throw err;
+    }
+    const e = err;
+    if (e.code === "ENOENT") {
+        throw new DriveCliNotFoundError();
+    }
+    if (e.killed === true || e.code === "ETIMEDOUT") {
+        const secs = timeoutFor(args) / 1000;
+        throw new DriveCliError(`CLI process timed out after ${secs}s`, "");
+    }
+    if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+        throw new DriveCliError("CLI output exceeded buffer limit (50 MB)", "");
+    }
+    const stderr = e.stderr ?? "";
+    if (isAuthError(stderr)) {
+        throw new DriveNotAuthenticatedError();
+    }
+    throw new DriveCliError(e.message ?? String(e), stderr);
+}
 export async function runDrive(args) {
     try {
         const { stdout, stderr } = await execFileAsync(CLI_BINARY, [...args, "--json"], { timeout: timeoutFor(args), maxBuffer: 50 * 1024 * 1024, killSignal: "SIGKILL" });
@@ -21,11 +53,8 @@ export async function runDrive(args) {
         // Only check stderr for auth errors when stdout is empty. If the CLI wrote
         // valid JSON, we honour it even when warnings appear on stderr.
         if (!raw) {
-            if (stderr && stderr.trim()) {
-                const lower = stderr.toLowerCase();
-                if (lower.includes("not authenticated") || lower.includes("not logged in")) {
-                    throw new DriveNotAuthenticatedError();
-                }
+            if (stderr && stderr.trim() && isAuthError(stderr)) {
+                throw new DriveNotAuthenticatedError();
             }
             return null;
         }
@@ -41,28 +70,21 @@ export async function runDrive(args) {
         }
     }
     catch (err) {
-        if (err instanceof DriveCliError ||
-            err instanceof DriveNotAuthenticatedError ||
-            err instanceof DriveParseError) {
-            throw err;
-        }
-        const e = err;
-        if (e.code === "ENOENT") {
-            throw new DriveCliNotFoundError();
-        }
-        if (e.killed === true || e.code === "ETIMEDOUT") {
-            const secs = timeoutFor(args) / 1000;
-            throw new DriveCliError(`CLI process timed out after ${secs}s`, "");
-        }
-        if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
-            throw new DriveCliError("CLI output exceeded buffer limit (50 MB)", "");
-        }
-        const stderr = e.stderr ?? "";
-        const lower = stderr.toLowerCase();
-        if (lower.includes("not authenticated") || lower.includes("not logged in")) {
+        normalizeExecError(err, args);
+    }
+}
+// Some CLI commands (namely `version`) ignore --json entirely and always
+// print plain text. This runs without appending --json and returns raw stdout.
+export async function runDriveRaw(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync(CLI_BINARY, args, { timeout: timeoutFor(args), maxBuffer: 50 * 1024 * 1024, killSignal: "SIGKILL" });
+        if (!stdout.trim() && stderr && stderr.trim() && isAuthError(stderr)) {
             throw new DriveNotAuthenticatedError();
         }
-        throw new DriveCliError(e.message ?? String(e), stderr);
+        return stdout;
+    }
+    catch (err) {
+        normalizeExecError(err, args);
     }
 }
 // Returns false only when the binary is not installed (ENOENT) or not executable (EACCES).
@@ -70,7 +92,7 @@ export async function runDrive(args) {
 // is present and real errors will surface on the first actual tool call.
 export async function checkCliAvailable() {
     try {
-        await execFileAsync(CLI_BINARY, ["version", "--json"], { timeout: 5_000 });
+        await execFileAsync(CLI_BINARY, ["version"], { timeout: 5_000 });
         return { available: true };
     }
     catch (e) {

package/glama.json

@@ -126,6 +126,34 @@
     {
       "name": "photos_remove_from_album",
       "description": "Remove a photo from a Proton Photos album."
+    },
+    {
+      "name": "drive_share_set_url",
+      "description": "Create or update a public share link for a Proton Drive file or folder."
+    },
+    {
+      "name": "drive_share_remove_url",
+      "description": "Remove the public share link from a Proton Drive file or folder."
+    },
+    {
+      "name": "drive_share_remove_all",
+      "description": "Remove all members and pending invitations from a shared Proton Drive path in one call."
+    },
+    {
+      "name": "photos_update_album",
+      "description": "Rename an album or change its cover photo in Proton Photos."
+    },
+    {
+      "name": "photos_list_timeline",
+      "description": "List photos in your Proton Photos timeline."
+    },
+    {
+      "name": "photos_download",
+      "description": "Download one or more photos from Proton Photos to a local folder."
+    },
+    {
+      "name": "photos_upload",
+      "description": "Upload local photos or videos directly into your Proton Photos library."
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proton-drive-mcp",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "MCP server and CLI that gives Claude full access to Proton Drive — upload, download, share, and manage your end-to-end encrypted files without leaving the conversation.",
   "type": "module",
   "main": "dist/index.js",

package/smithery.yaml

@@ -41,6 +41,13 @@ tools:
   - photos_list_album_photos
   - photos_add_to_album
   - photos_remove_from_album
+  - drive_share_set_url
+  - drive_share_remove_url
+  - drive_share_remove_all
+  - photos_update_album
+  - photos_list_timeline
+  - photos_download
+  - photos_upload
 startCommand:
   type: stdio
   configSchema: