mega-claude-connector 0.1.0__tar.gz

mega_claude_connector-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: mega-claude-connector
+Version: 0.1.0
+Summary: Mega.nz MCP server and Claude-powered CLI for cloud storage management
+Author-email: Mrigank Shekhar Chaubey <mriganksc@infinitywards.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mriganksc/mega-claude-connector
+Keywords: mega,claude,mcp,ai,cloud-storage
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mega.py>=1.0.8
+Requires-Dist: tenacity==5.1.5
+Requires-Dist: anthropic>=0.105.0
+Requires-Dist: mcp>=1.27.0
+Requires-Dist: click>=8.1.0

mega_claude_connector-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mega-claude-connector"
+version = "0.1.0"
+description = "Mega.nz MCP server and Claude-powered CLI for cloud storage management"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Mrigank Shekhar Chaubey", email = "mriganksc@infinitywards.com" }]
+keywords = ["mega", "claude", "mcp", "ai", "cloud-storage"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "mega.py>=1.0.8",
+    "tenacity==5.1.5",
+    "anthropic>=0.105.0",
+    "mcp>=1.27.0",
+    "click>=8.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mriganksc/mega-claude-connector"
+
+[project.scripts]
+mega-claude = "mega_connector.cli:chat"
+mega-claude-mcp = "mega_connector.mcp_server:main_sync"
+
+[tool.setuptools.packages.find]
+where = ["src"]

mega_claude_connector-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: mega-claude-connector
+Version: 0.1.0
+Summary: Mega.nz MCP server and Claude-powered CLI for cloud storage management
+Author-email: Mrigank Shekhar Chaubey <mriganksc@infinitywards.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mriganksc/mega-claude-connector
+Keywords: mega,claude,mcp,ai,cloud-storage
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mega.py>=1.0.8
+Requires-Dist: tenacity==5.1.5
+Requires-Dist: anthropic>=0.105.0
+Requires-Dist: mcp>=1.27.0
+Requires-Dist: click>=8.1.0

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+src/mega_claude_connector.egg-info/PKG-INFO
+src/mega_claude_connector.egg-info/SOURCES.txt
+src/mega_claude_connector.egg-info/dependency_links.txt
+src/mega_claude_connector.egg-info/entry_points.txt
+src/mega_claude_connector.egg-info/requires.txt
+src/mega_claude_connector.egg-info/top_level.txt
+src/mega_connector/__init__.py
+src/mega_connector/cli.py
+src/mega_connector/config.py
+src/mega_connector/mcp_server.py
+src/mega_connector/mega_client.py

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mega-claude = mega_connector.cli:chat
+mega-claude-mcp = mega_connector.mcp_server:main_sync

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/requires.txt

@@ -0,0 +1,5 @@
+mega.py>=1.0.8
+tenacity==5.1.5
+anthropic>=0.105.0
+mcp>=1.27.0
+click>=8.1.0

mega_claude_connector-0.1.0/src/mega_claude_connector.egg-info/top_level.txt

@@ -0,0 +1 @@
+mega_connector

mega_claude_connector-0.1.0/src/mega_connector/cli.py

@@ -0,0 +1,155 @@
+import json
+import click
+import anthropic
+from . import mega_client as mc
+from .config import get_credentials
+
+TOOLS = [
+    {
+        "name": "mega_storage_info",
+        "description": "Get Mega.nz storage usage and quota",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "mega_list_files",
+        "description": "List files and folders. Optionally filter by folder path.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "folder_path": {"type": "string", "description": "Remote folder name (omit for root)"},
+            },
+        },
+    },
+    {
+        "name": "mega_search",
+        "description": "Search for files or folders by name",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string"},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "mega_upload",
+        "description": "Upload a local file to Mega.nz",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "local_path": {"type": "string"},
+                "remote_folder": {"type": "string"},
+            },
+            "required": ["local_path"],
+        },
+    },
+    {
+        "name": "mega_download",
+        "description": "Download a file from Mega.nz",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "file_name": {"type": "string"},
+                "local_dest": {"type": "string"},
+            },
+            "required": ["file_name"],
+        },
+    },
+    {
+        "name": "mega_create_folder",
+        "description": "Create a new folder on Mega.nz",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "folder_name": {"type": "string"},
+                "parent_folder": {"type": "string"},
+            },
+            "required": ["folder_name"],
+        },
+    },
+    {
+        "name": "mega_delete",
+        "description": "Delete a file or folder from Mega.nz",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "file_name": {"type": "string"},
+            },
+            "required": ["file_name"],
+        },
+    },
+]
+
+SYSTEM = (
+    "You are a helpful assistant for managing Mega.nz cloud storage. "
+    "Use the provided tools to list, search, upload, download, create folders, and delete files. "
+    "Always confirm destructive actions (delete) before proceeding."
+)
+
+
+def _run_tool(name: str, args: dict):
+    dispatch = {
+        "mega_storage_info": lambda: mc.get_storage_info(),
+        "mega_list_files": lambda: mc.list_files(args.get("folder_path")),
+        "mega_search": lambda: mc.search_files(args["query"]),
+        "mega_upload": lambda: mc.upload_file(args["local_path"], args.get("remote_folder")),
+        "mega_download": lambda: mc.download_file(args["file_name"], args.get("local_dest", ".")),
+        "mega_create_folder": lambda: mc.create_folder(args["folder_name"], args.get("parent_folder")),
+        "mega_delete": lambda: mc.delete_node(args["file_name"]),
+    }
+    try:
+        return dispatch[name]()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@click.command()
+@click.option("--model", default="claude-sonnet-4-6", show_default=True)
+def chat(model: str):
+    """Interactive Claude-powered Mega.nz file manager."""
+    creds = get_credentials(require_anthropic=True)
+    client = anthropic.Anthropic(api_key=creds["anthropic_api_key"])
+    messages = []
+
+    click.echo("Mega.nz Claude Connector — type 'exit' to quit\n")
+
+    while True:
+        user_input = click.prompt("You").strip()
+        if user_input.lower() in ("exit", "quit"):
+            break
+
+        messages.append({"role": "user", "content": user_input})
+
+        while True:
+            response = client.messages.create(
+                model=model,
+                max_tokens=4096,
+                system=SYSTEM,
+                tools=TOOLS,
+                messages=messages,
+            )
+
+            # Collect assistant content
+            messages.append({"role": "assistant", "content": response.content})
+
+            if response.stop_reason == "tool_use":
+                tool_results = []
+                for block in response.content:
+                    if block.type == "tool_use":
+                        click.echo(f"  [tool] {block.name}({json.dumps(block.input)})")
+                        result = _run_tool(block.name, block.input)
+                        tool_results.append({
+                            "type": "tool_result",
+                            "tool_use_id": block.id,
+                            "content": json.dumps(result),
+                        })
+                messages.append({"role": "user", "content": tool_results})
+            else:
+                for block in response.content:
+                    if hasattr(block, "text"):
+                        click.echo(f"\nClaude: {block.text}\n")
+                break
+
+
+if __name__ == "__main__":
+    chat()

mega_claude_connector-0.1.0/src/mega_connector/config.py

@@ -0,0 +1,59 @@
+import os
+import configparser
+from pathlib import Path
+
+_CONFIG_DIR = Path.home() / ".config" / "mega-claude-connector"
+_CONFIG_FILE = _CONFIG_DIR / "config"
+
+
+def _load_file_config() -> dict:
+    if not _CONFIG_FILE.exists():
+        return {}
+    parser = configparser.ConfigParser()
+    parser.read(_CONFIG_FILE)
+    return dict(parser.get("credentials", {})) if parser.has_section("credentials") else {}
+
+
+def _save_config(values: dict):
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    parser = configparser.ConfigParser()
+    parser["credentials"] = values
+    with open(_CONFIG_FILE, "w") as f:
+        parser.write(f)
+    _CONFIG_FILE.chmod(0o600)
+
+
+def _prompt_and_save(require_anthropic: bool = False) -> dict:
+    print("\nFirst-time setup — credentials are stored only in ~/.config/mega-claude-connector/config\n")
+    values = {
+        "mega_email": input("Mega.nz email: ").strip(),
+        "mega_password": input("Mega.nz password: ").strip(),
+    }
+    if require_anthropic:
+        values["anthropic_api_key"] = input("Anthropic API key: ").strip()
+    _save_config(values)
+    print(f"\nCredentials saved to {_CONFIG_FILE}\n")
+    return values
+
+
+def get_credentials(require_anthropic: bool = False) -> dict:
+    """Return credentials from env vars → config file → interactive prompt."""
+    mega_email = os.environ.get("MEGA_EMAIL")
+    mega_password = os.environ.get("MEGA_PASSWORD")
+    anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
+
+    if mega_email and mega_password:
+        creds = {"mega_email": mega_email, "mega_password": mega_password}
+        if anthropic_key:
+            creds["anthropic_api_key"] = anthropic_key
+        return creds
+
+    file_creds = _load_file_config()
+    if file_creds.get("mega_email") and file_creds.get("mega_password"):
+        if require_anthropic and not file_creds.get("anthropic_api_key"):
+            key = input("Anthropic API key (not saved yet): ").strip()
+            file_creds["anthropic_api_key"] = key
+            _save_config(file_creds)
+        return file_creds
+
+    return _prompt_and_save(require_anthropic=require_anthropic)

mega_claude_connector-0.1.0/src/mega_connector/mcp_server.py

@@ -0,0 +1,125 @@
+import json
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp import types
+from . import mega_client as mc
+
+app = Server("mega-connector")
+
+
+@app.list_tools()
+async def list_tools() -> list[types.Tool]:
+    return [
+        types.Tool(
+            name="mega_storage_info",
+            description="Get Mega.nz storage usage and quota",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        types.Tool(
+            name="mega_list_files",
+            description="List files and folders. Optionally filter by folder path.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "folder_path": {"type": "string", "description": "Remote folder name to list (omit for root)"},
+                },
+            },
+        ),
+        types.Tool(
+            name="mega_search",
+            description="Search for files or folders by name",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search term"},
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="mega_upload",
+            description="Upload a local file to Mega.nz",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "local_path": {"type": "string", "description": "Absolute path to the local file"},
+                    "remote_folder": {"type": "string", "description": "Destination folder name on Mega (omit for root)"},
+                },
+                "required": ["local_path"],
+            },
+        ),
+        types.Tool(
+            name="mega_download",
+            description="Download a file from Mega.nz to a local directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_name": {"type": "string", "description": "Name of the file on Mega"},
+                    "local_dest": {"type": "string", "description": "Local directory to save to (default: current dir)"},
+                },
+                "required": ["file_name"],
+            },
+        ),
+        types.Tool(
+            name="mega_create_folder",
+            description="Create a new folder on Mega.nz",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "folder_name": {"type": "string", "description": "Name of the new folder"},
+                    "parent_folder": {"type": "string", "description": "Parent folder name (omit for root)"},
+                },
+                "required": ["folder_name"],
+            },
+        ),
+        types.Tool(
+            name="mega_delete",
+            description="Delete a file or folder from Mega.nz",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_name": {"type": "string", "description": "Name of the file or folder to delete"},
+                },
+                "required": ["file_name"],
+            },
+        ),
+    ]
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+    try:
+        if name == "mega_storage_info":
+            result = mc.get_storage_info()
+        elif name == "mega_list_files":
+            result = mc.list_files(arguments.get("folder_path"))
+        elif name == "mega_search":
+            result = mc.search_files(arguments["query"])
+        elif name == "mega_upload":
+            result = mc.upload_file(arguments["local_path"], arguments.get("remote_folder"))
+        elif name == "mega_download":
+            result = mc.download_file(arguments["file_name"], arguments.get("local_dest", "."))
+        elif name == "mega_create_folder":
+            result = mc.create_folder(arguments["folder_name"], arguments.get("parent_folder"))
+        elif name == "mega_delete":
+            result = mc.delete_node(arguments["file_name"])
+        else:
+            result = {"error": f"Unknown tool: {name}"}
+    except Exception as e:
+        result = {"error": str(e)}
+
+    return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
+
+
+async def main():
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(read_stream, write_stream, app.create_initialization_options())
+
+
+def main_sync():
+    import asyncio
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    main_sync()

mega_claude_connector-0.1.0/src/mega_connector/mega_client.py

@@ -0,0 +1,109 @@
+import os
+from mega import Mega
+from .config import get_credentials
+
+_mega = Mega()
+_client = None
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        creds = get_credentials()
+        _client = _mega.login(creds["mega_email"], creds["mega_password"])
+    return _client
+
+
+def get_storage_info() -> dict:
+    m = _get_client()
+    quota = m.get_quota()
+    storage = m.get_storage_space()
+    return {
+        "used_bytes": storage.get("used", 0),
+        "total_bytes": storage.get("total", 0),
+        "quota_bytes": quota,
+    }
+
+
+def list_files(folder_path: str | None = None) -> list[dict]:
+    m = _get_client()
+    if folder_path:
+        folder = m.find(folder_path)
+        if not folder:
+            raise ValueError(f"Folder not found: {folder_path}")
+        files = m.get_files_in_node(folder[0])
+    else:
+        files = m.get_files()
+
+    result = []
+    for file_id, file_data in files.items():
+        attrs = file_data.get("a", {})
+        result.append({
+            "id": file_id,
+            "name": attrs.get("n", "[no name]") if attrs else "[no name]",
+            "type": "folder" if file_data.get("t") == 1 else "file",
+            "size": file_data.get("s", 0),
+        })
+    return result
+
+
+def search_files(query: str) -> list[dict]:
+    m = _get_client()
+    results = m.find(query)
+    if not results:
+        return []
+    output = []
+    for item in results:
+        attrs = item.get("a", {})
+        output.append({
+            "id": item.get("h"),
+            "name": attrs.get("n", "[no name]") if attrs else "[no name]",
+            "type": "folder" if item.get("t") == 1 else "file",
+            "size": item.get("s", 0),
+        })
+    return output
+
+
+def upload_file(local_path: str, remote_folder: str | None = None) -> dict:
+    m = _get_client()
+    if not os.path.exists(local_path):
+        raise FileNotFoundError(f"Local file not found: {local_path}")
+    dest = None
+    if remote_folder:
+        folder = m.find(remote_folder)
+        if not folder:
+            raise ValueError(f"Remote folder not found: {remote_folder}")
+        dest = folder[0]
+    file = m.upload(local_path, dest)
+    link = m.get_upload_link(file)
+    return {"name": os.path.basename(local_path), "link": link}
+
+
+def download_file(file_name: str, local_dest: str = ".") -> str:
+    m = _get_client()
+    results = m.find(file_name)
+    if not results:
+        raise FileNotFoundError(f"File not found on Mega: {file_name}")
+    m.download(results[0], local_dest)
+    return os.path.join(local_dest, file_name)
+
+
+def create_folder(folder_name: str, parent_folder: str | None = None) -> dict:
+    m = _get_client()
+    parent = None
+    if parent_folder:
+        found = m.find(parent_folder)
+        if not found:
+            raise ValueError(f"Parent folder not found: {parent_folder}")
+        parent = found[0]
+    folder = m.create_folder(folder_name, parent)
+    return {"name": folder_name, "id": folder.get(folder_name)}
+
+
+def delete_node(file_name: str) -> bool:
+    m = _get_client()
+    results = m.find(file_name)
+    if not results:
+        raise FileNotFoundError(f"Not found: {file_name}")
+    m.delete(results[0])
+    return True