hyperpocket 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

hyperpocket/auth/provider.py

@@ -10,6 +10,7 @@ class AuthProvider(Enum):
     NOTION = "notion"
     REDDIT = "reddit"
     GUMLOOP = "gumloop"
+    X = "x"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket/auth/x/context.py

@@ -0,0 +1,13 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class XAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "X_AUTH_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {self._ACCESS_TOKEN_KEY: self.access_token}
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/x/oauth2_context.py

@@ -0,0 +1,29 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.x.context import XAuthContext
+from hyperpocket.auth.x.oauth2_schema import XOAuth2Response
+
+
+class XOAuth2AuthContext(XAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="Refresh token")
+
+    @classmethod
+    def from_x_oauth2_response(cls, response: XOAuth2Response) -> "XOAuth2AuthContext":
+        description = f"X OAuth2 Context logged in with {response.scope} scopes"
+        now = datetime.now(tz=timezone.utc)
+
+        if response.expires_in:
+            expires_at = now + timedelta(seconds=response.expires_in)
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=response.access_token,
+            refresh_token=response.refresh_token,
+            description=description,
+            expires_at=expires_at,
+            detail=response,
+        )

hyperpocket/auth/x/oauth2_handler.py

@@ -0,0 +1,165 @@
+import base64
+import traceback
+from typing import Optional
+from urllib.parse import urlencode, urljoin, quote
+from uuid import uuid4
+
+import httpx
+
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.x.oauth2_context import XOAuth2AuthContext
+from hyperpocket.auth.x.oauth2_schema import (
+    XOAuth2Request,
+    XOAuth2Response,
+)
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthProvider
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class XOAuth2AuthHandler(AuthHandlerInterface):
+    _X_AUTH_URL = "https://x.com/i/oauth2/authorize"
+    _X_TOKEN_URL = "https://api.x.com/2/oauth2/token"
+
+    name: str = "x-oauth2"
+    description: str = "This handler is used to authenticate users using X OAuth."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.X
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: XOAuth2Request,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
+        redirect_uri = urljoin(
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/x/oauth2/callback",
+        )
+        code_verifier = "challenge"  # TODO: implement code_verifier
+        code_challenge = code_verifier  # TODO: implement code_challenge with sha256
+        auth_url = self._make_auth_url(
+            auth_req, redirect_uri, future_uid, code_challenge, "plain"
+        )
+
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+                "code_verifier": code_verifier,
+            },
+        )
+
+        return f"User needs to authenticate using the following URL: {auth_url}"
+
+    async def authenticate(
+        self, auth_req: XOAuth2Request, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+
+        async with httpx.AsyncClient() as client:
+            basic_token = f"{auth_req.client_id}:{auth_req.client_secret}"
+            basic_token_encoded = base64.b64encode(basic_token.encode()).decode()
+            resp = await client.post(
+                url=self._X_TOKEN_URL,
+                data={
+                    "code": auth_code,
+                    # "client_id": auth_req.client_id,
+                    # "client_secret": auth_req.client_secret,
+                    "redirect_uri": future_data.data["redirect_uri"],
+                    "code_verifier": future_data.data["code_verifier"],
+                    "grant_type": "authorization_code",
+                },
+                headers={
+                    "Authorization": f"Basic {basic_token_encoded}",
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            )
+
+        if resp.status_code != 200:
+            raise Exception(
+                f"failed to authenticate. status_code : {resp.status_code}, {resp.json()}"
+            )
+
+        resp_json = resp.json()
+        auth_response = XOAuth2Response(**resp_json)
+        return XOAuth2AuthContext.from_x_oauth2_response(auth_response)
+
+    async def refresh(
+        self, auth_req: XOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        x_context: XOAuth2AuthContext = context
+        last_oauth2_resp: XOAuth2Response = x_context.detail
+        refresh_token = x_context.refresh_token
+        if refresh_token is None:
+            raise Exception(
+                f"refresh token is None. last_oauth2_resp: {last_oauth2_resp}"
+            )
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._X_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "refresh_token": refresh_token,
+                    "grant_type": "refresh_token",
+                },
+            )
+
+            if resp.status_code != 200:
+                raise Exception(
+                    f"failed to authenticate. status_code : {resp.status_code}"
+                )
+
+            resp_json = resp.json()
+            if "refresh_token" not in resp_json:
+                resp_json["refresh_token"] = refresh_token
+
+            response = XOAuth2Response(**resp_json)
+            return XOAuth2AuthContext.from_google_oauth2_response(response)
+
+    def _make_auth_url(
+        self,
+        auth_req: XOAuth2Request,
+        redirect_uri: str,
+        state: str,
+        code_challenge: str,
+        code_challenge_method: str,
+    ) -> str:
+        params = {
+            "client_id": auth_req.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "scope": " ".join(auth_req.auth_scopes),
+            "code_challenge": code_challenge,
+            "code_challenge_method": code_challenge_method,
+            "state": state,
+        }
+        return f"{self._X_AUTH_URL}?{urlencode(params)}"
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> XOAuth2Request:
+        return XOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.x.client_id,
+            client_secret=config().auth.x.client_secret,
+        )

hyperpocket/auth/x/oauth2_schema.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class XOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class XOAuth2Response(AuthenticateResponse):
+    access_token: str
+    expires_in: int
+    refresh_token: Optional[str] = Field(default=None)
+    scope: str
+    token_type: str

hyperpocket/cli/__main__.py

@@ -6,6 +6,7 @@ from hyperpocket.cli.sync import sync
 from hyperpocket.cli.eject import eject
 from hyperpocket.cli.auth_token import create_token_auth_template
 from hyperpocket.cli.auth_oauth2 import create_oauth2_auth_template
+from hyperpocket.cli.tool import create_tool_template, build_tool
 
 @click.group()
 def cli():
@@ -20,6 +21,8 @@ def devtool():
 cli.add_command(devtool)
 devtool.add_command(create_token_auth_template)
 devtool.add_command(create_oauth2_auth_template)
+devtool.add_command(create_tool_template)
+devtool.add_command(build_tool)
 
 cli.add_command(pull)
 cli.add_command(sync)

hyperpocket/cli/codegen/tool/__init__.py

@@ -0,0 +1,3 @@
+from .tool_main_template import get_tool_main_template
+
+__all__ = ["get_tool_main_template"]

hyperpocket/cli/codegen/tool/tool_main_template.py

@@ -0,0 +1,48 @@
+from jinja2 import Template
+
+def get_tool_main_template() -> Template:
+    return Template('''import json
+import os
+import sys
+
+from pydantic import BaseModel, Field
+
+token = os.getenv('AUTH_PROVIDER_TOKEN')
+
+
+class {{ capitalized_tool_name }}Request(BaseModel):
+    param_1: str = Field(description="")
+
+
+def {{ tool_name }}(req: {{ capitalized_tool_name }}Request):
+    """
+    Example of tool function
+    response = requests.delete(
+        url=f"https://www.googleapis.com/calendar/v3/calendars/{req.calendar_id}/events/{req.event_id}",
+        params={
+            "sendUpdates": req.send_updates
+        },
+        headers={
+            "Authorization": f"Bearer {token}",
+        }
+    )
+
+    if response.status_code != 200:
+        return f"failed to delete calendar events. error : {response.text}"
+
+    return f"successfully deleted calendar events {req.event_id}"
+    """
+    return
+
+
+def main():
+    req = json.load(sys.stdin.buffer)
+    req_typed = {{ capitalized_tool_name }}Request.model_validate(req)
+    response = {{ tool_name }}(req_typed)
+
+    print(response)
+
+
+if __name__ == '__main__':
+    main()
+''')

hyperpocket/cli/tool.py

@@ -0,0 +1,121 @@
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import click
+
+from hyperpocket.cli.codegen.tool import get_tool_main_template
+
+
+@click.command()
+@click.argument('tool_name', type=str)
+def create_tool_template(tool_name, language="python"):
+    """Create a tool template with the specified tool name."""
+
+    # Validate tool_name
+    if not tool_name.islower() or not tool_name.replace('_', '').isalpha():
+        raise ValueError("tool_name must be lowercase and contain only letters and underscores")
+
+    tool_directory_name = tool_name.replace('_', '-')
+    capitalized_tool_name = ''.join([word.capitalize() for word in tool_name.split('_')])
+
+    # Create tool directory
+    print(f"Generating tool package directory for {tool_name}")
+    cwd = Path.cwd()
+    tool_path = cwd / tool_directory_name
+    tool_path.mkdir(parents=True, exist_ok=True)
+
+    # Create tool module directory
+    print(f"Generating tool module directory for {tool_name}")
+    tool_module_path = tool_path / tool_name
+    tool_module_path.mkdir(parents=True, exist_ok=True)
+
+    # Create uv or poetry init
+    print(f"Generating pyproject.toml file for {tool_name}")
+    if shutil.which("uv"):
+        subprocess.run(["uv", "init"], cwd=tool_path, check=True)
+        os.remove(tool_path / "hello.py")
+    elif shutil.which("poetry"):
+        subprocess.run(["poetry", "init", "--no-interaction"], cwd=tool_path, check=True)
+    else:
+        raise ValueError("uv or poetry must be installed to generate tool project")
+
+    # Create __init__.py file
+    init_file = tool_module_path / '__init__.py'
+    if not init_file.exists():
+        init_file.write_text(f'''from .__main__ import main
+
+__all__ = ["main"]
+''')
+
+    # Create __main__.py file
+    print(f"Generating tool main file for {tool_name}")
+    main_file = tool_module_path / '__main__.py'
+    if not main_file.exists():
+        main_content = get_tool_main_template().render(
+            capitalized_tool_name=capitalized_tool_name,
+            tool_name=tool_name
+        )
+        main_file.write_text(main_content)
+
+    # Create config.toml
+    print(f"Generating config.toml file for {tool_name}")
+    config_file = tool_path / 'config.toml'
+    if not config_file.exists():
+        config_file.write_text(f'''name = "{tool_name}"
+description = ""
+language = "{language}"
+
+[auth]
+auth_provider = ""
+auth_handler = ""
+scopes = []
+''')
+
+    # Create .gitignore
+    print(f"Generating .gitignore file for {tool_name}")
+    gitignore_file = tool_path / '.gitignore'
+    gitignore_file.touch()
+
+    # Create README.md
+    print(f"Generating README.md file for {tool_name}")
+    readme_file = tool_path / 'README.md'
+    if not readme_file.exists():
+        readme_file.write_text(f'# {tool_name}\n\n')
+
+    # Create schema.json
+    print(f"Generating schema.json file for {tool_name}")
+    schema_file = tool_path / 'schema.json'
+    schema_file.touch()
+
+
+@click.command()
+@click.argument('tool_path', type=str, required=False)
+def build_tool(tool_path):
+    """Build the tool at the specified path or current directory."""
+
+    cwd = Path.cwd()
+
+    # Determine the tool directory
+    if tool_path is None:
+        if not (cwd / 'config.toml').exists():
+            raise ValueError("Current working directory must be a tool directory")
+    else:
+        potential_path = Path(tool_path)
+        if (cwd / potential_path).exists():
+            cwd = cwd / potential_path
+        elif potential_path.exists():
+            cwd = potential_path
+        else:
+            raise ValueError(f"Tool path '{tool_path}' does not exist")
+
+    # Build the tool
+    print(f"Building tool in {cwd}")
+    if shutil.which("uv"):
+        subprocess.run(["uv", "build"], cwd=cwd, check=True)
+        os.remove(cwd / "dist/.gitignore")
+    elif shutil.which("poetry"):
+        subprocess.run(["poetry", "build"], cwd=cwd, check=True)
+    else:
+        raise ValueError("Tool must be a poetry or uv project")

hyperpocket/config/auth.py

@@ -27,11 +27,17 @@ class CalendlyAuthConfig(BaseAuthConfig):
     client_secret: str
 
 
+class XAuthConfig(BaseAuthConfig):
+    client_id: str
+    client_secret: str
+
+
 class AuthConfig(BaseModel):
     slack: Optional[SlackAuthConfig] = None
     google: Optional[GoogleAuthConfig] = None
     github: Optional[GithubAuthConfig] = None
     calendly: Optional[CalendlyAuthConfig] = None
+    x: Optional[XAuthConfig] = None
     use_prebuilt_auth: bool = Field(default=True)
 
 

hyperpocket/server/auth/x.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, Request
+from starlette.responses import HTMLResponse
+
+from hyperpocket.futures import FutureStore
+
+x_auth_router = APIRouter(prefix="/x")
+
+
+@x_auth_router.get("/oauth2/callback")
+async def x_oauth2_callback(request: Request, state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/tool/wasm/README.md

@@ -117,8 +117,8 @@ from_git('https://github.com/your-organization/your-repository/tree/main',tool_v
 })
 ```
 
-2. Injecting envvars by settings.toml
-   If there are remaining envvars, Hyperpocket checks the `settings.toml` from the agent code directory.
+2. Injecting tool_vars by settings.toml
+   Hyperpocket checks the `settings.toml` from the agent code directory.
 
 ## WasmTool
 

{hyperpocket-0.3.1.dist-info → hyperpocket-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.3.1
+Version: 0.3.2
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
@@ -193,32 +193,32 @@ Pocket provides way to use end user auth easily.
 
 - Supported methods
 
-    - [x] OAuth
-    - [x] Token
-    - [ ] Basic Auth (Username, Password)
+  - [x] OAuth
+  - [x] Token
+  - [ ] Basic Auth (Username, Password)
 
 - Supported OAuth Providers
 
-    - [x] Google
-    - [x] GitHub
-    - [x] Slack
-    - [x] Reddit
-    - [x] Calendly
-    - [ ] Facebook
-    - [ ] X (Previously Twitter)
-    - [ ] LinkedIn
-    - [ ] Discord
-    - [ ] Zoom
-    - [ ] Microsoft
-    - [ ] Spotify
-    - [ ] Twitch
+  - [x] Google
+  - [x] GitHub
+  - [x] Slack
+  - [x] Reddit
+  - [x] Calendly
+  - [ ] Facebook
+  - [ ] X (Previously Twitter)
+  - [ ] LinkedIn
+  - [ ] Discord
+  - [ ] Zoom
+  - [ ] Microsoft
+  - [ ] Spotify
+  - [ ] Twitch
 
 - Supported Token Providers
-    - [x] Notion
-    - [x] Slack
-    - [x] Linear
-    - [x] Gumloop
-    - [x] Github
+  - [x] Notion
+  - [x] Slack
+  - [x] Linear
+  - [x] Gumloop
+  - [x] Github
 
 You can manage your auths in request-wise level. (e.g. you can use different auths for different requests)
 
@@ -340,15 +340,15 @@ client_secret = "" # your slack client secret
 
 - While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
   development environment and production environment.
-    - For local testing environment, you can use `https://localhost:8001/proxy/auth/<provider>/callback` for TLS enabled
-      redirect url. (ex. `https://localhost:8001/proxy/auth/github/callback`)
-        - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
-          replace `8000` with your actual port number.
-        - **Note**: But for easy dev experience, you can use TLS proxy on port `8001` provided out-of-the-box.
-            - You can change the `proxy` prefix in settings.toml to your desired prefix with
-              `callback_url_rewrite_prefix` key.
-    - For production environment, you can use `https://yourdomain.com/auth/github/callback`
-        - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.
+  - For local testing environment, you can use `https://localhost:8001/proxy/auth/<provider>/callback` for TLS enabled
+    redirect url. (ex. `https://localhost:8001/proxy/auth/github/callback`)
+    - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
+      replace `8000` with your actual port number.
+    - **Note**: But for easy dev experience, you can use TLS proxy on port `8001` provided out-of-the-box.
+      - You can change the `proxy` prefix in settings.toml to your desired prefix with
+        `callback_url_rewrite_prefix` key.
+  - For production environment, you can use `https://yourdomain.com/auth/github/callback`
+    - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.
 
 #### How to integrate SLACK OAuth app
 
@@ -359,19 +359,92 @@ client_secret = "" # your slack client secret
 - Redirect URLs :
   `{public_server_protocol}://{public_hostname}:[{public_server_port}]/{callback_url_rewrite_prefix}/auth/slack/oauth2/callback`
 - Scopes : What you want to request to user.
-    - Recommended scopes :
-        - channels:history,
-        - channels:read,
-        - chat:write,
-        - groups:history,
-        - groups:read,
-        - im:history,
-        - mpim:history,
-        - reactions:read,
-        - reactions:write,
-
-3. Set your Slack APP Client ID / Client Secret in `{WORKDIR}/settings.toml`
-
-## Special thanks
-
-- [tott](https://x.com/tott____) for drawing the cute possum in a pocket.
+  - Recommended scopes :
+    - channels:history,
+    - channels:read,
+    - chat:write,
+    - groups:history,
+    - groups:read,
+    - im:history,
+    - mpim:history,
+    - reactions:read,
+    - reactions:write,
+
+3. Set your Slack APP Client ID / Client Secret in `$HOME/.pocket/settings.toml`
+
+#### How to start adding a new token auth
+
+1. Generate boilerplate codes for token-based auth services ?
+
+```
+# service_name should be lowercase including underscore
+poetry run hyperpocket devtool create-token-auth-template {service_name}
+```
+
+It will generate boilerplate code lines for a new token-based auth service
+
+2. Extend AuthProvider enum to add your new auth provider.
+
+```python
+class AuthProvider(Enum):
+SERVICE = 'service'
+```
+
+3. Specify auth provider for tools
+
+1) github repo or local
+
+```toml
+[auth]
+auth_provider = "{service_name}"
+auth_handler = "{service_name}-token"
+scopes = []
+```
+
+2. function_tool
+
+```python
+@function_tool(
+    auth_provider=AuthProvider.SERVICE
+)
+def my_function(**kwargs):
+```
+
+#### How to Start Developing a New Tool
+
+1. Generate Boilerplate Template for the Tool
+
+```bash
+# tool_name must be lowercase and can include underscores
+poetry run hyperpocket devtool create-tool-template your_own_tool
+```
+
+This command will generate the boilerplate directory and files for a new tool.
+
+2. Configure the `config.toml`
+
+Define the language, `auth_provider`, scopes, and other required settings in the `config.toml` file.
+
+```toml
+# Example configuration
+name = "google_delete_calendar_events"
+description = "Delete Google Calendar events"
+language = "python"
+
+[auth]
+auth_provider = "google"
+scopes = ["https://www.googleapis.com/auth/calendar"]
+```
+
+3. Develop the Tool Logic
+
+Implement the `request_model` and the necessary functions for your tool's logic in the `__main__.py` file.
+
+4. Build Your Tool
+
+Use the Hyperpocket CLI to build your tool.
+
+```bash
+# Specify the tool_path or run the command inside the tool's directory
+poetry run hyperpocket devtool build-tool ./your-own-tool
+```

{hyperpocket-0.3.1.dist-info → hyperpocket-0.3.2.dist-info}/RECORD

@@ -10,7 +10,7 @@ hyperpocket/auth/README.md,sha256=zn4QqnFZCA_4X3x8Wb6lE3OP5otYxpByZaCiUkBvaNs,11
 hyperpocket/auth/__init__.py,sha256=pO8M6SAuq0EPqi848_Iy650wqaLekx98e3RRnEAM_r0,607
 hyperpocket/auth/context.py,sha256=m-j2gDYUKBMsiakLHsu9thhM4dYyFiXP0Wp0S_iC0bU,1303
 hyperpocket/auth/handler.py,sha256=5cusl9ANEyG3gORVFjqh709txC0alw6eKtxgV6wjf6k,6683
-hyperpocket/auth/provider.py,sha256=zBuVvrp6SwGRGcfWy6mqIXabw-bfahGfsxpBi899RHs,503
+hyperpocket/auth/provider.py,sha256=Fe5kYX093sd9K0fakPVXYqXL6oIhdPU530W8pkVzZHU,515
 hyperpocket/auth/schema.py,sha256=pl4oRTNj8PdqQg6UVPWf8ei2uYQ4DtOmmD58cVFMYQw,537
 hyperpocket/auth/calendly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/auth/calendly/context.py,sha256=oUQzLy_w5NPvbXjFPOhLD-ggONVSy9VVpFabvX4ZpsY,408
@@ -59,13 +59,19 @@ hyperpocket/auth/slack/oauth2_schema.py,sha256=eu2jF2thmaz66AKcnivTvIBLTbeF-a-xQ
 hyperpocket/auth/slack/token_context.py,sha256=GUqMcPUleo8O9YRNMjOrMiSlHb-OOKwlrO_syCow55w,437
 hyperpocket/auth/slack/token_handler.py,sha256=6L_HiDQ2wpz9x65QUB9t-d5KOpADeG-zZVgEMHu3MUE,2765
 hyperpocket/auth/slack/token_schema.py,sha256=mAwOtRO2tW5OtDzbllDJtR_uhLD8ShQAjezkAZnAgd0,207
+hyperpocket/auth/x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/x/context.py,sha256=5Ur9GI8og49E-8FToKlqR3TtPn6vWAdu1boLqYxJL8k,399
+hyperpocket/auth/x/oauth2_context.py,sha256=q2HB14WENz2LU7Qe7KkE7-AtsEOtzXIj7n8alykac8M,955
+hyperpocket/auth/x/oauth2_handler.py,sha256=kEnsbL1YIeIQUlMVPIZYqOswk9_t-sNGiaixj43M1Yc,5634
+hyperpocket/auth/x/oauth2_schema.py,sha256=PKeaHccpxGLJjEd8RxP2wVcrIPCE-W9HEtP8EMzU4To,401
 hyperpocket/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyperpocket/cli/__main__.py,sha256=68fOHIx2zw_k_ncR6PR8S9iZG_yQkPG7yAOj428Op_M,580
+hyperpocket/cli/__main__.py,sha256=T6qnVngoWYmHZONloDafbkTLcVKyZXkIwa9e2wKdnLs,720
 hyperpocket/cli/auth_oauth2.py,sha256=gGQCS8AvaVHvs4Oe6fS7tw2ks_N67-8newinaDlywbw,4680
 hyperpocket/cli/auth_token.py,sha256=gmT-jVMvZ1Ck-1F_yFUChcd9HMtFHNTaUvj_332usjE,4809
 hyperpocket/cli/eject.py,sha256=Te1YhDONk_VCgZ6l2HjLqONJrn04EfPk19sD6D5SOyY,636
 hyperpocket/cli/pull.py,sha256=3xCyTmdbP77l7awNyCY63_ZmUhIlX1PE3apwReXNYco,549
 hyperpocket/cli/sync.py,sha256=OO5zFrLOMXk7TSAFEew04ZzW4HLoQ1uVb80UKvIJha0,517
+hyperpocket/cli/tool.py,sha256=r9dtmU805z5OEs059Zvpki_Vtbc4U6bzC_EK-pl98Nk,3950
 hyperpocket/cli/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/cli/codegen/auth/__init__.py,sha256=wtm3vX2Kk79tyFkguV5oV82_YoJ3w-Clqu2izwE65Vg,959
 hyperpocket/cli/codegen/auth/auth_context_template.py,sha256=89HHp5byHhLazkwtR8bsymg7IBKfp2ltdGikcD5aplY,570
@@ -76,8 +82,10 @@ hyperpocket/cli/codegen/auth/auth_token_context_template.py,sha256=GzpsCY6DlGXu-
 hyperpocket/cli/codegen/auth/auth_token_handler_template.py,sha256=t30JZFTCYCcXWFop4CVEABEtttjJn-F6tcS-ZOQCh-Y,3158
 hyperpocket/cli/codegen/auth/auth_token_schema_template.py,sha256=ZJRcT-0QIIxltkDCgVz7zKl3aObX__bMi33s7_ZxI5k,429
 hyperpocket/cli/codegen/auth/server_auth_template.py,sha256=-S3bqlqsXMytOdrIG68_np3LfU5_Ydy7z-Z0fqfCE8I,1478
+hyperpocket/cli/codegen/tool/__init__.py,sha256=ZJgrXJKwbxkOYz-e_cInlVIKTGEOFchvDVHUdo3LNMU,92
+hyperpocket/cli/codegen/tool/tool_main_template.py,sha256=AlqGMc2xRPPM4ypShFeh7TBzex0rMlQOZjRKFwfofTo,1126
 hyperpocket/config/__init__.py,sha256=gYMHdExdPYScBB8mihSp1yJ9H-RJ8FdNz5mEFubFNAo,138
-hyperpocket/config/auth.py,sha256=IsHQHiwPmO5afbmwkA1lA1P7zF7W6LmXpM4ZmUZ4c-E,795
+hyperpocket/config/auth.py,sha256=5Z8Q01TNvWO1x0ZjCXc6nF1qe6-FFuiV2y7sxXYRq2c,910
 hyperpocket/config/git.py,sha256=CGbY7J1LyN4ccZr9CFGAQwwhjC9kvdU0On_nsAsZ1FQ,362
 hyperpocket/config/logger.py,sha256=T5LESHvQfl2q1F-7FjsVfrz9fWz6jxPo7u6Jml3CQjc,2804
 hyperpocket/config/session.py,sha256=1ng1mARv4R_07SF5CkZWLgX9pNeXTcM0knCRw07Fpms,816
@@ -101,6 +109,7 @@ hyperpocket/server/auth/notion.py,sha256=NUKwCK61UADhO4FmFpNYjh1vsDzFZoFRDHdcMIB
 hyperpocket/server/auth/reddit.py,sha256=UloBQNEdhU1_eXaF8qVSQ5ivq5xtWINsHvBDGwgFSLM,443
 hyperpocket/server/auth/slack.py,sha256=frMNtBEfe3fbeNzsQ8udapeau45NZmS8guATmS46qyA,710
 hyperpocket/server/auth/token.py,sha256=Yq5Ym-uEO_3cBpQOsmCBuqtFIdImrNcVUgF5ozs5NHk,1763
+hyperpocket/server/auth/x.py,sha256=CYCD_ajBY6Jt04E2bSEBZFRRIUZmNjF2gn6F0ZV5XuA,450
 hyperpocket/server/tool/__init__.py,sha256=khNLe3H2W7WXKQlHjXuuvd9R87eHOAZhDsQmjDcbYsg,210
 hyperpocket/server/tool/wasm.py,sha256=VJyp6RGsq8llKT_sY6DhV52wsETu-W9bzJ7C9wC17Oo,1698
 hyperpocket/server/tool/dto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -118,7 +127,7 @@ hyperpocket/tool/function/__init__.py,sha256=2zV5ojuzvv38B9J-5l6XomZ3x-8FTC0-Bow
 hyperpocket/tool/function/annotation.py,sha256=mHm_TN2X7xmivBZ8_tbnsaGt_GUQZ-l2IPv0PudZKb8,982
 hyperpocket/tool/function/tool.py,sha256=FVEn8i3HJaG2S-LuBgRc4DJUYWWplsGs0nRmuVstLZQ,6280
 hyperpocket/tool/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyperpocket/tool/wasm/README.md,sha256=QeR7mI8RD6OJ2AXdZCpzNLBW0KUVgYQ0IqCc-wVXgFs,3896
+hyperpocket/tool/wasm/README.md,sha256=DjHtzOS4oe4Mk39M8BfxE0N_hqds32KXx2OWJ2cJOGo,3866
 hyperpocket/tool/wasm/__init__.py,sha256=t6KwkMY0pwZheCf9Q-9Kt7HGHQU7U--b9TTKgNegWUY,72
 hyperpocket/tool/wasm/browser.py,sha256=JWn34P1ybPJCogBB85BePWFXM4AqOI2wSbIb5LcCXTs,1867
 hyperpocket/tool/wasm/invoker.py,sha256=jgW3XqdbAXgDjTlURmD2Xeh5qpjZgvB6PYzNlcdvfQc,1431
@@ -135,7 +144,7 @@ hyperpocket/util/flatten_json_schema.py,sha256=iuNBEmMSKFtPi-uqo6fb3RWN0koHOAihW
 hyperpocket/util/function_to_model.py,sha256=TXUs-qPbzL8C9-qqpz4Ad4D9MOPP61n_p0iPU6SoBeM,2318
 hyperpocket/util/get_objects_from_subpackage.py,sha256=4mR_S8eaJSdU68YfCkiXeIcXxb6q7LjFGsY_IHeNIZw,929
 hyperpocket/util/json_schema_to_model.py,sha256=PqI87pU5dWwcrQWB8eQxRdfgAEvvC1x_DKZnhcsRV-o,3586
-hyperpocket-0.3.1.dist-info/METADATA,sha256=UEJCp-ThPh9eJOzGYyOulcb7QD7shB14LvzMm9tLnL4,11430
-hyperpocket-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperpocket-0.3.1.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
-hyperpocket-0.3.1.dist-info/RECORD,,
+hyperpocket-0.3.2.dist-info/METADATA,sha256=3TczH2IpxfxjkWNyj_ZkzwkRx6RSbk9Jt5AGqiMy1ZM,12958
+hyperpocket-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket-0.3.2.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
+hyperpocket-0.3.2.dist-info/RECORD,,