proton-drive-mcp 1.0.12

package/dist/cli.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * Companion CLI for proton-drive-mcp.
+ * 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
+ */
+import { DriveService } from "./services/drive.js";
+import { DriveCliError, DriveCliNotFoundError, DriveNotAuthenticatedError, DriveParseError } from "./utils/errors.js";
+import { checkCliAvailable } from "./utils/subprocess.js";
+import { validatePath, validateEmail, validateMessage } from "./utils/validation.js";
+const drive = new DriveService();
+const args = process.argv.slice(2);
+const jsonMode = args.includes("--json");
+function usage() {
+    console.log(`
+proton-drive-cli — Proton Drive companion CLI
+
+Commands:
+  auth status                              Check authentication status
+  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
+  move <src> <dst>                         Move/rename
+  delete <path>                            Delete file/folder permanently
+  share status <path>                      Show sharing info
+  share invite <path> <email> <role>       Invite user (viewer/editor/admin)
+  share revoke <path> <email>              Revoke access
+  trash <path>                             Move to trash
+  trash list                               List trash contents
+  trash empty                              Permanently delete all trash
+  restore <path>                           Restore from trash
+
+Flags:
+  --json                                   Machine-readable JSON output (one line)
+`);
+}
+function requirePath(value, usage) {
+    if (!value) {
+        console.error(`Usage: ${usage}`);
+        process.exit(1);
+    }
+    try {
+        return validatePath(value);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}
+function requireEmail(value) {
+    try {
+        return validateEmail(value);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+    return ""; // unreachable; process.exit(1) above always terminates
+}
+function getFlag(flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    if (idx + 1 >= args.length || args[idx + 1].startsWith("--")) {
+        console.error(`${flag} requires a value`);
+        process.exit(1);
+    }
+    return args[idx + 1];
+}
+function print(data) {
+    console.log(jsonMode ? JSON.stringify(data) : JSON.stringify(data, null, 2));
+}
+async function run() {
+    if (!(await checkCliAvailable())) {
+        console.error("Error: proton-drive CLI not found in PATH.\n" +
+            "Download from https://proton.me/download/drive/cli/index.html");
+        process.exit(1);
+    }
+    // Strip --json from positional parsing
+    const positional = args.filter((a) => a !== "--json");
+    const [cmd, sub, ...rest] = positional;
+    if (!cmd || cmd === "--help" || cmd === "-h") {
+        usage();
+        return;
+    }
+    switch (cmd) {
+        case "auth":
+            if (sub === "status") {
+                print(await drive.authStatus());
+            }
+            else if (sub === "logout") {
+                await drive.authLogout();
+                console.log("Logged out.");
+            }
+            else {
+                console.error(`Unknown auth subcommand: ${sub}`);
+                process.exit(1);
+            }
+            break;
+        case "version":
+            print(await drive.version());
+            break;
+        case "list":
+            print(await drive.list(requirePath(sub, "list <path>")));
+            break;
+        case "upload": {
+            const local = requirePath(sub, "upload <local> <remote>");
+            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.`);
+                process.exit(1);
+            }
+            const conflict = conflictRaw;
+            print(await drive.upload(local, remote, conflict));
+            break;
+        }
+        case "download": {
+            const remote = requirePath(sub, "download <remote> <local>");
+            const local = requirePath(rest[0], "download <remote> <local>");
+            print(await drive.download(remote, local));
+            break;
+        }
+        case "move": {
+            const src = requirePath(sub, "move <src> <dst>");
+            const dst = requirePath(rest[0], "move <src> <dst>");
+            await drive.move(src, dst);
+            console.log("Moved.");
+            break;
+        }
+        case "mkdir":
+            await drive.mkdir(requirePath(sub, "mkdir <path>"));
+            console.log("Folder created.");
+            break;
+        case "delete":
+            await drive.delete(requirePath(sub, "delete <path>"));
+            console.log("Deleted.");
+            break;
+        case "share":
+            if (sub === "status") {
+                print(await drive.shareStatus(requirePath(rest[0], "share status <path>")));
+            }
+            else if (sub === "invite") {
+                const [rawPath, rawEmail, role] = rest;
+                if (!rawPath || !rawEmail || !role) {
+                    console.error("Usage: share invite <path> <email> <role>");
+                    process.exit(1);
+                }
+                if (!["viewer", "editor", "admin"].includes(role)) {
+                    console.error(`Invalid role: ${role}. Must be viewer, editor, or admin.`);
+                    process.exit(1);
+                }
+                const invitePath = requirePath(rawPath, "share invite <path> <email> <role>");
+                const inviteEmail = requireEmail(rawEmail);
+                const rawMessage = getFlag("--message");
+                const message = rawMessage !== undefined ? validateMessage(rawMessage) : undefined;
+                await drive.shareInvite(invitePath, inviteEmail, role, message);
+                console.log(`Invited ${inviteEmail} as ${role}.`);
+            }
+            else if (sub === "revoke") {
+                const [rawPath, rawEmail] = rest;
+                if (!rawPath || !rawEmail) {
+                    console.error("Usage: share revoke <path> <email>");
+                    process.exit(1);
+                }
+                const revokePath = requirePath(rawPath, "share revoke <path> <email>");
+                const revokeEmail = requireEmail(rawEmail);
+                await drive.shareRevoke(revokePath, revokeEmail);
+                console.log(`Revoked access for ${revokeEmail}.`);
+            }
+            else {
+                console.error(`Unknown share subcommand: ${sub}`);
+                process.exit(1);
+            }
+            break;
+        case "trash":
+            if (sub === "empty") {
+                await drive.emptyTrash();
+                console.log("Trash emptied.");
+            }
+            else if (sub === "list" || sub === "ls") {
+                print(await drive.listTrash());
+            }
+            else if (sub) {
+                await drive.trash(requirePath(sub, "trash <path>"));
+                console.log("Moved to trash.");
+            }
+            else {
+                console.error("Usage: trash <path> | trash list | trash empty");
+                process.exit(1);
+            }
+            break;
+        case "restore":
+            await drive.restore(requirePath(sub, "restore <path>"));
+            console.log("Restored.");
+            break;
+        default:
+            console.error(`Unknown command: ${cmd}`);
+            usage();
+            process.exit(1);
+    }
+}
+run().catch((err) => {
+    if (err instanceof DriveCliNotFoundError || err instanceof DriveNotAuthenticatedError) {
+        console.error(err.message);
+    }
+    else if (err instanceof DriveCliError) {
+        console.error(`CLI error: ${err.message}`);
+        if (err.stderr)
+            console.error(err.stderr);
+    }
+    else if (err instanceof DriveParseError) {
+        console.error(`Parse error: ${err.message}`);
+    }
+    else if (err instanceof Error) {
+        console.error(err.message);
+    }
+    else {
+        console.error("Error:", String(err));
+    }
+    process.exit(1);
+});

package/dist/index.js

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { createRequire } from "node:module";
+import { DriveService } from "./services/drive.js";
+import { checkCliAvailable } from "./utils/subprocess.js";
+import { DriveCliNotFoundError, DriveCliError, DriveNotAuthenticatedError, DriveParseError, } from "./utils/errors.js";
+import { validatePath, validateEmail, validateMessage } from "./utils/validation.js";
+import { logger } from "./utils/logger.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const VERSION = pkg.version ?? "1.0.0";
+process.env["PROTON_DRIVE_MCP"] = "1";
+function ok(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}
+function fail(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+function handleError(err) {
+    if (err instanceof DriveCliNotFoundError)
+        return fail(err.message);
+    if (err instanceof DriveNotAuthenticatedError)
+        return fail(err.message);
+    if (err instanceof DriveCliError)
+        return fail(`CLI error: ${err.message}`);
+    if (err instanceof DriveParseError)
+        return fail(`Parse error: ${err.message}`);
+    if (err instanceof Error)
+        return fail(err.message);
+    return fail(`Unexpected error: ${String(err)}`);
+}
+const TOOLS = [
+    // Auth
+    {
+        name: "drive_auth_status",
+        description: "Check whether the Proton Drive CLI is authenticated.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "drive_auth_logout",
+        description: "Log out of Proton Drive (clears stored session).",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "drive_version",
+        description: "Get Proton Drive CLI and SDK version information.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    // Filesystem
+    {
+        name: "drive_list",
+        description: "List files and folders at a Proton Drive path (e.g. /my-files or /my-files/Reports).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to list. E.g. /my-files",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "drive_upload",
+        description: "Upload a local file or folder to Proton Drive.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                localPath: {
+                    type: "string",
+                    description: "Absolute local path to upload.",
+                },
+                remotePath: {
+                    type: "string",
+                    description: "Remote Drive destination path. E.g. /my-files/Reports",
+                },
+                conflictStrategy: {
+                    type: "string",
+                    enum: ["skip", "overwrite", "rename"],
+                    description: "What to do if the file already exists. Default: skip.",
+                },
+            },
+            required: ["localPath", "remotePath"],
+        },
+    },
+    {
+        name: "drive_download",
+        description: "Download a file or folder from Proton Drive to a local path.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                remotePath: {
+                    type: "string",
+                    description: "Remote Drive path to download. E.g. /my-files/report.pdf",
+                },
+                localPath: {
+                    type: "string",
+                    description: "Absolute local destination path.",
+                },
+            },
+            required: ["remotePath", "localPath"],
+        },
+    },
+    {
+        name: "drive_mkdir",
+        description: "Create a new empty folder on Proton Drive.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path for the new folder. E.g. /my-files/NewFolder",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "drive_move",
+        description: "Move or rename a file or folder on Proton Drive.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sourcePath: {
+                    type: "string",
+                    description: "Current remote path of the file/folder.",
+                },
+                destinationPath: {
+                    type: "string",
+                    description: "New remote path.",
+                },
+            },
+            required: ["sourcePath", "destinationPath"],
+        },
+    },
+    {
+        name: "drive_delete",
+        description: "Permanently delete a file or folder from Proton Drive. " +
+            "Requires confirmed=true — always ask the user before calling this.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to delete.",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Must be true. Confirms the user has acknowledged this is permanent.",
+                },
+            },
+            required: ["path", "confirmed"],
+        },
+    },
+    // Sharing
+    {
+        name: "drive_share_status",
+        description: "Get sharing status and member list for a Proton Drive path.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to check sharing for.",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "drive_list_trash",
+        description: "List files and folders currently in the Proton Drive trash.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "drive_share_invite",
+        description: "Invite someone to access a Proton Drive file or folder.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to share.",
+                },
+                email: {
+                    type: "string",
+                    description: "Email address of the person to invite.",
+                },
+                role: {
+                    type: "string",
+                    enum: ["viewer", "editor", "admin"],
+                    description: "Access level to grant.",
+                },
+                message: {
+                    type: "string",
+                    description: "Optional message to include in the invitation.",
+                },
+            },
+            required: ["path", "email", "role"],
+        },
+    },
+    {
+        name: "drive_share_revoke",
+        description: "Remove someone's access to a Proton Drive file or folder.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path.",
+                },
+                email: {
+                    type: "string",
+                    description: "Email address of the person whose access to revoke.",
+                },
+            },
+            required: ["path", "email"],
+        },
+    },
+    // Trash
+    {
+        name: "drive_trash",
+        description: "Move a file or folder to trash on Proton Drive.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to trash.",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "drive_restore",
+        description: "Restore a file or folder from trash on Proton Drive.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Remote Drive path to restore.",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "drive_empty_trash",
+        description: "Permanently delete ALL items in the Proton Drive trash. " +
+            "Requires confirmed=true — always show the trash contents (drive_list_trash) and ask the user before calling this.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                confirmed: {
+                    type: "boolean",
+                    description: "Must be true. Confirms the user has acknowledged this is permanent and irreversible.",
+                },
+            },
+            required: ["confirmed"],
+        },
+    },
+];
+async function main() {
+    const cliAvailable = await checkCliAvailable();
+    if (!cliAvailable) {
+        logger.error("proton-drive CLI not found. Download from https://proton.me/download/drive/cli/index.html");
+        process.exit(1);
+    }
+    const drive = new DriveService();
+    const server = new Server({ name: "proton-drive-mcp", version: VERSION }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOLS.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const { name, arguments: args = {} } = req.params;
+        const a = args;
+        try {
+            switch (name) {
+                case "drive_auth_status":
+                    return ok(await drive.authStatus());
+                case "drive_auth_logout":
+                    await drive.authLogout();
+                    return ok({ message: "Logged out successfully." });
+                case "drive_version":
+                    return ok(await drive.version());
+                case "drive_list":
+                    return ok(await drive.list(validatePath(a.path)));
+                case "drive_mkdir": {
+                    const mkdirPath = validatePath(a.path);
+                    await drive.mkdir(mkdirPath);
+                    return ok({ message: `Folder created: ${mkdirPath}` });
+                }
+                case "drive_upload": {
+                    const cs = typeof a.conflictStrategy === "string" ? a.conflictStrategy : "skip";
+                    if (!["skip", "overwrite", "rename"].includes(cs)) {
+                        throw new Error(`conflictStrategy must be skip, overwrite, or rename`);
+                    }
+                    return ok(await drive.upload(validatePath(a.localPath), validatePath(a.remotePath), cs));
+                }
+                case "drive_download":
+                    return ok(await drive.download(validatePath(a.remotePath), validatePath(a.localPath)));
+                case "drive_move": {
+                    const moveSrc = validatePath(a.sourcePath);
+                    const moveDst = validatePath(a.destinationPath);
+                    await drive.move(moveSrc, moveDst);
+                    return ok({ message: `Moved: ${moveSrc} → ${moveDst}` });
+                }
+                case "drive_delete": {
+                    if (a.confirmed !== true) {
+                        return fail("drive_delete requires confirmed=true. Ask the user to confirm before deleting.");
+                    }
+                    const deletePath = validatePath(a.path);
+                    await drive.delete(deletePath);
+                    return ok({ message: `Deleted: ${deletePath}` });
+                }
+                case "drive_list_trash":
+                    return ok(await drive.listTrash());
+                case "drive_share_status":
+                    return ok(await drive.shareStatus(validatePath(a.path)));
+                case "drive_share_invite": {
+                    const email = validateEmail(a.email);
+                    const role = typeof a.role === "string" ? a.role : "viewer";
+                    if (!["viewer", "editor", "admin"].includes(role)) {
+                        throw new Error("role must be viewer, editor, or admin");
+                    }
+                    const inviteMsg = typeof a.message === "string" ? validateMessage(a.message) : undefined;
+                    await drive.shareInvite(validatePath(a.path), email, role, inviteMsg);
+                    return ok({ message: `Invited ${email} as ${role}.` });
+                }
+                case "drive_share_revoke":
+                    {
+                        const revokeEmail = validateEmail(a.email);
+                        await drive.shareRevoke(validatePath(a.path), revokeEmail);
+                        return ok({ message: `Revoked access for ${revokeEmail}.` });
+                    }
+                case "drive_trash": {
+                    const trashPath = validatePath(a.path);
+                    await drive.trash(trashPath);
+                    return ok({ message: `Moved to trash: ${trashPath}` });
+                }
+                case "drive_restore": {
+                    const restorePath = validatePath(a.path);
+                    await drive.restore(restorePath);
+                    return ok({ message: `Restored from trash: ${restorePath}` });
+                }
+                case "drive_empty_trash":
+                    if (a.confirmed !== true) {
+                        return fail("drive_empty_trash requires confirmed=true. " +
+                            "Use drive_list_trash first to show the user what will be deleted, then ask for confirmation.");
+                    }
+                    await drive.emptyTrash();
+                    return ok({ message: "Trash emptied." });
+                default:
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof McpError)
+                throw err;
+            return handleError(err);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info(`proton-drive-mcp v${VERSION} running`);
+}
+main().catch((err) => {
+    logger.error("Fatal:", err);
+    process.exit(1);
+});