proton-drive-mcp 1.0.12

package/dist/services/drive.js

@@ -0,0 +1,137 @@
+import { runDrive as defaultRunDrive } from "../utils/subprocess.js";
+import { DriveParseError } from "../utils/errors.js";
+export class DriveService {
+    run;
+    constructor(runner) {
+        this.run = runner ?? defaultRunDrive;
+    }
+    // Auth
+    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,
+        };
+    }
+    async authLogout() {
+        await this.run(["auth", "logout"]);
+    }
+    async version() {
+        const result = await this.run(["version"]);
+        const r = result;
+        return {
+            cli: typeof r?.cli === "string" ? r.cli : String(r?.version ?? "unknown"),
+            sdk: typeof r?.sdk === "string" ? r.sdk : "unknown",
+        };
+    }
+    // Filesystem
+    async list(remotePath) {
+        const result = await this.run(["filesystem", "list", remotePath]);
+        if (result === null)
+            return [];
+        if (!Array.isArray(result))
+            throw new DriveParseError(`Expected array from list, got: ${JSON.stringify(result).slice(0, 100)}`);
+        return result.map((item) => ({
+            name: String(item.name ?? ""),
+            path: String(item.path ?? remotePath),
+            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,
+        }));
+    }
+    async upload(localPath, remotePath, conflictStrategy = "skip") {
+        const result = await this.run([
+            "filesystem",
+            "upload",
+            localPath,
+            remotePath,
+            "--conflict-strategy",
+            conflictStrategy,
+            "--skip-thumbnails",
+        ]);
+        const r = result;
+        return {
+            path: remotePath,
+            uploaded: typeof r?.uploaded === "number" ? r.uploaded : 0,
+            skipped: typeof r?.skipped === "number" ? r.skipped : 0,
+            failed: typeof r?.failed === "number" ? r.failed : 0,
+        };
+    }
+    async download(remotePath, localPath) {
+        const result = await this.run(["filesystem", "download", remotePath, localPath]);
+        const r = result;
+        return {
+            path: remotePath,
+            localPath,
+            downloaded: typeof r?.downloaded === "number" ? r.downloaded : 0,
+        };
+    }
+    async mkdir(remotePath) {
+        await this.run(["filesystem", "mkdir", remotePath]);
+    }
+    async move(remoteSrc, remoteDst) {
+        await this.run(["filesystem", "move", remoteSrc, remoteDst]);
+    }
+    async delete(remotePath) {
+        await this.run(["filesystem", "delete", remotePath]);
+    }
+    // Sharing
+    async shareStatus(remotePath) {
+        const result = await this.run(["sharing", "status", remotePath]);
+        const r = result;
+        const members = Array.isArray(r?.members)
+            ? r.members.map((m) => ({
+                email: String(m.email ?? ""),
+                role: (m.role ?? "viewer"),
+                addedAt: typeof m.addedAt === "string" ? m.addedAt : undefined,
+            }))
+            : [];
+        return {
+            path: remotePath,
+            isShared: Boolean(r?.isShared ?? members.length > 0),
+            members,
+            shareUrl: typeof r?.shareUrl === "string" ? r.shareUrl : undefined,
+        };
+    }
+    async shareInvite(remotePath, email, role, message) {
+        await this.run([
+            "sharing", "invite",
+            ...(message ? ["--message", message] : []),
+            "--user", email,
+            "--role", role,
+            remotePath,
+        ]);
+    }
+    async shareRevoke(remotePath, email) {
+        await this.run(["sharing", "revoke", "--user", email, remotePath]);
+    }
+    // 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,
+        }));
+    }
+    async trash(remotePath) {
+        await this.run(["trash", remotePath]);
+    }
+    async restore(remotePath) {
+        await this.run(["restore", remotePath]);
+    }
+    async emptyTrash() {
+        await this.run(["trash", "empty"]);
+    }
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/errors.js

@@ -0,0 +1,27 @@
+export class DriveCliNotFoundError extends Error {
+    constructor() {
+        super("proton-drive CLI not found in PATH. " +
+            "Download it from https://proton.me/download/drive/cli/index.html and ensure it is in your PATH.");
+        this.name = "DriveCliNotFoundError";
+    }
+}
+export class DriveCliError extends Error {
+    stderr;
+    constructor(message, stderr = "") {
+        super(message);
+        this.stderr = stderr;
+        this.name = "DriveCliError";
+    }
+}
+export class DriveNotAuthenticatedError extends Error {
+    constructor() {
+        super("Not authenticated. Run `proton-drive auth login` in your terminal first.");
+        this.name = "DriveNotAuthenticatedError";
+    }
+}
+export class DriveParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DriveParseError";
+    }
+}

package/dist/utils/logger.js

@@ -0,0 +1,15 @@
+const isMcp = () => process.env["PROTON_DRIVE_MCP"] === "1";
+export const logger = {
+    info: (...args) => {
+        if (!isMcp())
+            console.log("[INFO]", ...args);
+        else
+            process.stderr.write(`[INFO] ${args.join(" ")}\n`);
+    },
+    warn: (...args) => {
+        process.stderr.write(`[WARN] ${args.join(" ")}\n`);
+    },
+    error: (...args) => {
+        process.stderr.write(`[ERROR] ${args.join(" ")}\n`);
+    },
+};

package/dist/utils/subprocess.js

@@ -0,0 +1,74 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { DriveCliError, DriveCliNotFoundError, DriveNotAuthenticatedError, DriveParseError } from "./errors.js";
+const execFileAsync = promisify(execFile);
+const CLI_BINARY = process.env["PROTON_DRIVE_BIN"] ?? "proton-drive";
+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"]);
+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])) {
+        return TRANSFER_TIMEOUT_MS;
+    }
+    return DEFAULT_TIMEOUT_MS;
+}
+export async function runDrive(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync(CLI_BINARY, [...args, "--json"], { timeout: timeoutFor(args), maxBuffer: 50 * 1024 * 1024, killSignal: "SIGKILL" });
+        const raw = stdout.trim();
+        // 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();
+                }
+            }
+            return null;
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            process.stderr.write(`[proton-drive-mcp] parse error: ${raw.slice(0, 500)}\n`);
+            throw new DriveParseError("Failed to parse CLI output as JSON");
+        }
+    }
+    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" || e.signal != null) {
+            const secs = timeoutFor(args) / 1000;
+            throw new DriveCliError(`CLI process timed out after ${secs}s`, "");
+        }
+        const stderr = e.stderr ?? "";
+        const lower = stderr.toLowerCase();
+        if (lower.includes("not authenticated") || lower.includes("not logged in")) {
+            throw new DriveNotAuthenticatedError();
+        }
+        throw new DriveCliError(e.message ?? String(e), stderr);
+    }
+}
+// Returns false only when the binary is not installed (ENOENT). Any other
+// error (non-zero exit, auth required, etc.) still returns true — the binary
+// 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 });
+        return true;
+    }
+    catch (e) {
+        const err = e;
+        return err.code !== "ENOENT";
+    }
+}

package/dist/utils/validation.js

@@ -0,0 +1,35 @@
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+// Control chars: 0x00-0x1F, DEL (0x7F), Unicode separators U+2028 and U+2029.
+const CONTROL_RE = new RegExp("[\\x00-\\x1f\\x7f\\u2028\\u2029]");
+export function validatePath(path) {
+    const p = String(path ?? "").trim();
+    if (!p)
+        throw new Error("path must not be empty");
+    if (p.startsWith("-"))
+        throw new Error(`path must not start with '-': ${p}`);
+    if (CONTROL_RE.test(p))
+        throw new Error("path contains control characters");
+    if (p.includes(".."))
+        throw new Error(`path must not contain '..' segments: ${p}`);
+    return p;
+}
+export function validateMessage(message) {
+    const m = String(message ?? "").trim();
+    if (m.startsWith("-"))
+        throw new Error(`message must not start with '-': ${m}`);
+    if (CONTROL_RE.test(m))
+        throw new Error("message contains control characters");
+    if (m.length > 2000)
+        throw new Error("message must be 2000 characters or fewer");
+    return m;
+}
+export function validateEmail(email) {
+    const e = String(email ?? "").trim();
+    if (e.startsWith("-"))
+        throw new Error(`email must not start with '-': ${e}`);
+    if (CONTROL_RE.test(e))
+        throw new Error("email contains control characters");
+    if (!EMAIL_RE.test(e))
+        throw new Error(`invalid email address: ${e}`);
+    return e;
+}

package/glama.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/glama.json",
+  "name": "proton-drive-mcp",
+  "description": "Claude Desktop MCP and CLI for Proton Drive. List, upload, download, share, and manage end-to-end encrypted files.",
+  "icon": "https://proton.me/favicon.ico",
+  "categories": ["storage", "productivity", "privacy"],
+  "license": "MIT",
+  "repository": "https://github.com/googlarz/proton-drive-mcp"
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "proton-drive-mcp",
+  "version": "1.0.12",
+  "description": "Proton Drive MCP — Claude Desktop MCP and CLI for Proton Drive. List, upload, download, share, and manage files with end-to-end encryption.",
+  "type": "module",
+  "packageManager": "npm@10.9.3",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "proton-drive-mcp": "dist/index.js",
+    "proton-drive-cli": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "cli": "npm run build && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "ci": "npm run lint && npm test",
+    "pack:check": "npm pack --dry-run",
+    "release:check": "npm run lint && npm test && npm run pack:check"
+  },
+  "keywords": [
+    "proton",
+    "proton-drive",
+    "mcp",
+    "cloud-storage",
+    "encryption",
+    "claude",
+    "ai",
+    "automation",
+    "typescript"
+  ],
+  "author": {
+    "name": "googlarz",
+    "url": "https://github.com/googlarz"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/googlarz/proton-drive-mcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlarz/proton-drive-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/googlarz/proton-drive-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "glama.json",
+    "smithery.yaml"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,37 @@
+name: proton-drive-mcp
+displayName: Proton Drive MCP
+description: >
+  Claude Desktop MCP and companion CLI for Proton Drive.
+  List, upload, download, share, and manage end-to-end encrypted files
+  without credential exposure — auth handled by the official Proton Drive CLI.
+license: MIT
+homepage: https://github.com/googlarz/proton-drive-mcp
+repository: https://github.com/googlarz/proton-drive-mcp
+categories:
+  - storage
+  - productivity
+  - privacy
+tools:
+  - drive_auth_status
+  - drive_auth_logout
+  - drive_version
+  - drive_list
+  - drive_mkdir
+  - drive_upload
+  - drive_download
+  - drive_move
+  - drive_delete
+  - drive_list_trash
+  - drive_share_status
+  - drive_share_invite
+  - drive_share_revoke
+  - drive_trash
+  - drive_restore
+  - drive_empty_trash
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties: {}
+  commandFunction: |-
+    (_config) => ({ command: "npx", args: ["-y", "proton-drive-mcp"] })