partiful-mcp 1.1.0__py3-none-any.whl

partiful_agent.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Partiful through Cotlet.dev: stdio MCP server and small CLI over the hosted Cotlet.dev MCP server (stdlib only)."""
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+START_URL = "https://partiful.com"
+SLUG = "partiful"
+URL = "https://cotlet.dev/mcp/v1"
+GUIDE_FIELD = "app"
+KEY_HELP = "Set COTLET_API_KEY. Get a key at https://cotlet.dev/app"
+NAME = "Partiful"
+JOB = "create events and manage guest lists"
+VERSION = "1.1.0"
+PREFIX = "partiful"
+PROTOCOLS = ("2025-06-18", "2025-03-26", "2024-11-05")
+
+CONFIG = {"mcpServers": {"cotlet": {"url": URL, "headers": {"Authorization": "Bearer ${COTLET_API_KEY}"}}}}
+
+
+class Client:
+    def __init__(self, key):
+        self.key = key
+        self.session = None
+        self.next_id = 0
+
+    def _post(self, payload):
+        headers = {
+            "Authorization": "Bearer " + self.key,
+            "Accept": "application/json, text/event-stream",
+            "Content-Type": "application/json",
+        }
+        if self.session:
+            headers["Mcp-Session-Id"] = self.session
+        req = urllib.request.Request(URL, json.dumps(payload).encode(), headers, method="POST")
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                self.session = resp.headers.get("Mcp-Session-Id") or self.session
+                return resp.read().decode(), resp.headers.get("Content-Type", "")
+        except urllib.error.HTTPError as e:
+            raise RuntimeError("HTTP %s: %s" % (e.code, e.read().decode(errors="replace")[:300]))
+
+    @staticmethod
+    def _parse(body, ctype, rid):
+        if "text/event-stream" in ctype:
+            for line in body.splitlines():
+                if line.startswith("data:"):
+                    try:
+                        msg = json.loads(line[5:].strip())
+                    except ValueError:
+                        continue
+                    if msg.get("id") == rid:
+                        return msg
+            raise RuntimeError("No JSON-RPC answer in stream")
+        return json.loads(body)
+
+    def rpc(self, method, params=None):
+        self.next_id += 1
+        rid = self.next_id
+        body, ctype = self._post({"jsonrpc": "2.0", "id": rid, "method": method, "params": params or {}})
+        msg = self._parse(body, ctype, rid)
+        if "error" in msg:
+            raise RuntimeError(msg["error"].get("message", str(msg["error"])))
+        return msg.get("result", {})
+
+    def start(self):
+        self.rpc("initialize", {
+            "protocolVersion": "2025-06-18",
+            "capabilities": {},
+            "clientInfo": {"name": SLUG + "-mcp", "version": "1.0.0"},
+        })
+        self._post({"jsonrpc": "2.0", "method": "notifications/initialized"})
+
+    def call(self, tool, args):
+        res = self.rpc("tools/call", {"name": tool, "arguments": args})
+        text = "\n".join(c.get("text", "") for c in res.get("content", []) if c.get("type") == "text")
+        if res.get("isError"):
+            raise RuntimeError(text or "tool error")
+        return text
+
+
+def _obj(props, required=()):
+    schema = {"type": "object", "properties": props, "additionalProperties": False}
+    if required:
+        schema["required"] = list(required)
+    return schema
+
+
+# Static tool list: answers tools/list without any key. Each tool forwards to one Cotlet.dev tool.
+TOOLS = [
+    (PREFIX + "_guide", "How to work in %s (%s): its screens and the sign-in link. Call this first." % (NAME, JOB),
+     _obj({"task": {"type": "string", "description": "What you want done in %s, in your words." % NAME}})),
+    (PREFIX + "_status", "Check that your Cotlet.dev account and %s are ready: account, credits and %s connection." % (NAME, NAME),
+     _obj({})),
+    (PREFIX + "_open", "Open a %s page in your signed-in Cloud Browser (default %s) to work with %s." % (NAME, START_URL, JOB),
+     _obj({"url": {"type": "string", "description": "Page to open. Default: " + START_URL}})),
+    (PREFIX + "_read", "Read the current %s page: its text and numbered buttons, links and fields." % NAME,
+     _obj({"element": {"type": "integer", "minimum": 1, "description": "Read only inside this element."}})),
+    (PREFIX + "_click", "Click a numbered element on the current %s page." % NAME,
+     _obj({"element": {"type": "integer", "minimum": 1, "description": "Element number from the last read."}}, ["element"])),
+    (PREFIX + "_type", "Type text into a numbered field on the current %s page." % NAME,
+     _obj({"element": {"type": "integer", "minimum": 1, "description": "Field number from the last read."},
+           "text": {"type": "string", "description": "Text to type."}}, ["element", "text"])),
+    (PREFIX + "_close", "Close the %s browser session when the work is done, so credits stop running." % NAME,
+     _obj({})),
+]
+
+
+def _forward(client, short, args):
+    """Run one static tool against the hosted server; returns text."""
+    if short == "guide":
+        up = {GUIDE_FIELD: SLUG}
+        if args.get("task"):
+            up["task"] = str(args["task"])
+        return client.call("cotlet_app_guide", up)
+    if short == "status":
+        return client.call("cotlet_whoami", {}) + "\n\n" + client.call("cotlet_apps", {"app": SLUG})
+    if short == "open":
+        return client.call("cotlet_browser_open", {"url": args.get("url") or START_URL})
+    if short == "read":
+        return client.call("cotlet_browser_read", {k: args[k] for k in ("element",) if k in args})
+    if short == "click":
+        return client.call("cotlet_browser_click", {"element": args["element"]})
+    if short == "type":
+        return client.call("cotlet_browser_type", {"element": args["element"], "text": args["text"]})
+    return client.call("cotlet_browser_close", {})
+
+
+class Server:
+    def __init__(self):
+        self.client = None
+
+    def call_tool(self, name, args):
+        short = name[len(PREFIX) + 1:] if name.startswith(PREFIX + "_") else ""
+        if short not in [t[0][len(PREFIX) + 1:] for t in TOOLS]:
+            return {"content": [{"type": "text", "text": "Unknown tool: %s" % name}], "isError": True}
+        key = os.environ.get("COTLET_API_KEY")
+        if not key:
+            return {"content": [{"type": "text", "text": KEY_HELP}], "isError": True}
+        try:
+            if self.client is None:
+                self.client = Client(key)
+                self.client.start()
+            text = _forward(self.client, short, args or {})
+            return {"content": [{"type": "text", "text": text}]}
+        except Exception as e:
+            self.client = None
+            return {"content": [{"type": "text", "text": str(e)}], "isError": True}
+
+    def handle(self, msg):
+        method, rid, params = msg.get("method"), msg.get("id"), msg.get("params") or {}
+        if rid is None:
+            return None  # notification
+        if method == "initialize":
+            want = params.get("protocolVersion")
+            result = {
+                "protocolVersion": want if want in PROTOCOLS else PROTOCOLS[0],
+                "capabilities": {"tools": {"listChanged": False}},
+                "serverInfo": {"name": SLUG + "-mcp", "version": VERSION},
+                "instructions": "%s through Cotlet.dev. Call %s_guide first. Set COTLET_API_KEY (https://cotlet.dev/app)." % (NAME, PREFIX),
+            }
+        elif method == "ping":
+            result = {}
+        elif method == "tools/list":
+            result = {"tools": [{"name": n, "description": d, "inputSchema": s} for n, d, s in TOOLS]}
+        elif method == "tools/call":
+            result = self.call_tool(params.get("name", ""), params.get("arguments"))
+        else:
+            return {"jsonrpc": "2.0", "id": rid, "error": {"code": -32601, "message": "Method not found: %s" % method}}
+        return {"jsonrpc": "2.0", "id": rid, "result": result}
+
+
+def serve():
+    """MCP stdio transport: one JSON-RPC message per line on stdin/stdout, logs on stderr."""
+    server = Server()
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+            reply = server.handle(msg) if isinstance(msg, dict) else None
+        except ValueError:
+            reply = {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error"}}
+        except Exception as e:
+            print("Error: %s" % e, file=sys.stderr)
+            reply = {"jsonrpc": "2.0", "id": msg.get("id"), "error": {"code": -32603, "message": str(e)}}
+        if reply is not None:
+            sys.stdout.write(json.dumps(reply) + "\n")
+            sys.stdout.flush()
+
+
+def connect():
+    print("Claude Code:\n  claude mcp add --transport http cotlet %s --header \"Authorization: Bearer $COTLET_API_KEY\"\n" % URL)
+    print("Cursor (.cursor/mcp.json):\n" + json.dumps(CONFIG, indent=2) + "\n")
+    print("ChatGPT:\n  Settings -> Apps -> add connector URL %s, sign in with Cotlet.dev (no API key)." % URL)
+
+
+def main():
+    p = argparse.ArgumentParser(description="Partiful through Cotlet.dev")
+    sub = p.add_subparsers(dest="cmd")
+    for name in ("serve", "connect", "status", "guide", "tools"):
+        sub.add_parser(name)
+    r = sub.add_parser("read")
+    r.add_argument("url", nargs="?")
+    args = p.parse_args()
+    if args.cmd in (None, "serve"):
+        return serve()
+    if args.cmd == "connect":
+        return connect()
+    key = os.environ.get("COTLET_API_KEY")
+    if not key:
+        print(KEY_HELP)
+        sys.exit(2)
+    try:
+        c = Client(key)
+        c.start()
+        if args.cmd == "tools":
+            print("\n".join(t["name"] for t in c.rpc("tools/list").get("tools", [])))
+        elif args.cmd == "status":
+            print(c.call("cotlet_apps", {"app": SLUG}))
+        elif args.cmd == "guide":
+            print(c.call("cotlet_app_guide", {GUIDE_FIELD: SLUG}))
+        elif args.cmd == "read":
+            # Works in the user's Web browser, where they sign in to the app once.
+            c.call("cotlet_browser_open", {"url": args.url or START_URL})
+            try:
+                print(c.call("cotlet_browser_read", {}))
+            finally:
+                c.call("cotlet_browser_close", {})
+    except Exception as e:
+        print("Error: %s" % e, file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

partiful_mcp-1.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.5
+Name: partiful-mcp
+Version: 1.1.0
+Summary: Connect Partiful to ChatGPT, Claude, Codex and Claude Code through Cotlet.dev, a hosted MCP server.
+Project-URL: Homepage, https://cotlet.dev/integrations/partiful-api-mcp-server?utm_source=pypi&utm_medium=package&utm_campaign=partiful
+Project-URL: Source, https://github.com/cotlet-connect/partiful-mcp
+Author-email: "Cotlet.dev" <contact@cotlet.dev>
+License-Expression: Elastic-2.0
+License-File: LICENSE
+Keywords: ai agent,chatgpt,claude,cotlet,mcp server,partiful,partiful api,partiful mcp
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Partiful MCP server through Cotlet.dev
+
+Connect Partiful to ChatGPT, Claude, Codex and Claude Code through your signed-in Cotlet.dev Cloud Browser. Work with hosted events, guest lists and RSVP responses.
+
+Unofficial, not affiliated with Partiful.
+
+## Get connected
+
+1. [Sign up for Cotlet.dev](https://cotlet.dev/signup?app=partiful).
+2. Open Partiful in your Cotlet.dev Cloud Browser, sign in with your phone and text code, and enable the app for agents.
+3. Connect your agent to the hosted MCP server at `https://cotlet.dev/mcp/v1`. Chat apps use Cotlet sign-in; local clients use a Cotlet API key from https://cotlet.dev/app.
+
+See the [Partiful integration guide](https://cotlet.dev/integrations/partiful-api-mcp-server) for current setup instructions and event workflows.
+
+## Local stdio server
+
+Python 3.10 or later. This package uses the Python standard library and forwards browser work to Cotlet.dev.
+
+```bash
+pip install partiful-mcp
+partiful-mcp connect
+```
+
+Configure your MCP client:
+
+```json
+{"mcpServers":{"partiful":{"command":"uvx","args":["partiful-mcp"],"env":{"COTLET_API_KEY":"your-key"}}}}
+```
+
+The local wrapper exposes seven browser tools: `partiful_guide`, `partiful_status`, `partiful_open`, `partiful_read`, `partiful_click`, `partiful_type` and `partiful_close`. These are browser operations for your agent; the hosted integration guide describes event operations separately. Tool discovery works without an API key; executing hosted calls requires your Cotlet API key and connected account.
+
+## Example requests
+
+- List the events I host and summarize their RSVP counts.
+- Read the guest list for my upcoming event.
+- Prepare a reminder for guests who have confirmed attendance.
+
+Review the intended recipients and content before asking your agent to send messages.
+
+[Source repository](https://github.com/cotlet-connect/partiful-mcp) | [PyPI](https://pypi.org/project/partiful-mcp/) | [Cotlet.dev](https://cotlet.dev/integrations/partiful-api-mcp-server)

partiful_mcp-1.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+partiful_agent.py,sha256=9NvryU3ar3PCmlaEnJke92xLXwAgAxhl1Yc0XQfZBqU,10336
+partiful_mcp-1.1.0.dist-info/METADATA,sha256=eQ4PVE41HfIB4nHtD1omW85c5fh1R2AYpHQbRcDHKkQ,2695
+partiful_mcp-1.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+partiful_mcp-1.1.0.dist-info/entry_points.txt,sha256=dw1DsSS0iXJ1q3Ssq2phHuAw3zxSvJBRImJ0YTIovOY,53
+partiful_mcp-1.1.0.dist-info/licenses/LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
+partiful_mcp-1.1.0.dist-info/RECORD,,

partiful_mcp-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

partiful_mcp-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+partiful-mcp = partiful_agent:main

partiful_mcp-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.