hyperpocket 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

hyperpocket/cli/codegen/auth/auth_token_context_template.py

@@ -2,13 +2,13 @@ from jinja2 import Template
 
 
 def get_auth_token_context_template() -> Template:
-    return Template("""
-from hyperpocket.auth.{{ service_name }}.context import {{ caplitalized_service_name }}AuthContext
-from hyperpocket.auth.{{ service_name }}.token_schema import {{ caplitalized_service_name }}TokenResponse
-class {{ caplitalized_service_name }}TokenAuthContext({{ caplitalized_service_name }}AuthContext):
+    return Template("""\
+from hyperpocket.auth.{{ service_name }}.context import {{ capitalized_service_name }}AuthContext
+from hyperpocket.auth.{{ service_name }}.token_schema import {{ capitalized_service_name }}TokenResponse
+class {{ capitalized_service_name }}TokenAuthContext({{ capitalized_service_name }}AuthContext):
     @classmethod
-    def from_{{ service_name }}_token_response(cls, response: {{ caplitalized_service_name }}TokenResponse):
-        description = f'{{ caplitalized_service_name }} Token Context logged in'
+    def from_{{ service_name }}_token_response(cls, response: {{ capitalized_service_name }}TokenResponse):
+        description = f'{{ capitalized_service_name }} Token Context logged in'
         return cls(
             access_token=response.access_token,
             description=description,

hyperpocket/cli/codegen/auth/auth_token_handler_template.py

@@ -2,22 +2,22 @@ from jinja2 import Template
 
 
 def get_auth_token_handler_template() -> Template:
-    return Template("""
+    return Template("""\
 from typing import Optional
 from urllib.parse import urljoin, urlencode
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
-from hyperpocket.auth.{{ service_name }}.token_context import {{ caplitalized_service_name }}TokenAuthContext
-from hyperpocket.auth.{{ service_name }}.token_schema import {{ caplitalized_service_name }}TokenResponse, {{ caplitalized_service_name }}TokenRequest
+from hyperpocket.auth.{{ service_name }}.token_context import {{ capitalized_service_name }}TokenAuthContext
+from hyperpocket.auth.{{ service_name }}.token_schema import {{ capitalized_service_name }}TokenResponse, {{ capitalized_service_name }}TokenRequest
 from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 
-class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
+class {{ capitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
     name: str = "{{ auth_handler_name }}-token"
-    description: str = "This handler is used to authenticate users using the {{ caplitalized_service_name }} token."
+    description: str = "This handler is used to authenticate users using the {{ capitalized_service_name }} token."
     scoped: bool = False
 
     _TOKEN_URL: str = urljoin(config().public_base_url + "/", f"{config().callback_url_rewrite_prefix}/auth/token")
@@ -30,7 +30,7 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
     def recommended_scopes() -> set[str]:
         return set()
 
-    def prepare(self, auth_req: {{ caplitalized_service_name }}TokenRequest, thread_id: str, profile: str,
+    def prepare(self, auth_req: {{ capitalized_service_name }}TokenRequest, thread_id: str, profile: str,
                 future_uid: str, *args, **kwargs) -> str:
         redirect_uri = urljoin(
             config().public_base_url + "/",
@@ -45,19 +45,19 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
 
         return f'User needs to authenticate using the following URL: {url}'
 
-    async def authenticate(self, auth_req: {{ caplitalized_service_name }}TokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
+    async def authenticate(self, auth_req: {{ capitalized_service_name }}TokenRequest, future_uid: str, *args, **kwargs) -> AuthContext:
         future_data = FutureStore.get_future(future_uid)
         access_token = await future_data.future
 
-        response = {{ caplitalized_service_name }}TokenResponse(access_token=access_token)
-        context = {{ caplitalized_service_name }}TokenAuthContext.from_{{ service_name }}_token_response(response)
+        response = {{ capitalized_service_name }}TokenResponse(access_token=access_token)
+        context = {{ capitalized_service_name }}TokenAuthContext.from_{{ service_name }}_token_response(response)
 
         return context
 
-    async def refresh(self, auth_req: {{ caplitalized_service_name }}TokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
-        raise Exception("{{ caplitalized_service_name }} token doesn't support refresh")
+    async def refresh(self, auth_req: {{ capitalized_service_name }}TokenRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
+        raise Exception("{{ capitalized_service_name }} token doesn't support refresh")
 
-    def _make_auth_url(self, auth_req: {{ caplitalized_service_name }}TokenRequest, redirect_uri: str, state: str):
+    def _make_auth_url(self, auth_req: {{ capitalized_service_name }}TokenRequest, redirect_uri: str, state: str):
         params = {
             "redirect_uri": redirect_uri,
             "state": state,
@@ -65,6 +65,6 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
         auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
         return auth_url
 
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> {{ caplitalized_service_name }}TokenRequest:
-        return {{ caplitalized_service_name }}TokenRequest()
+    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> {{ capitalized_service_name }}TokenRequest:
+        return {{ capitalized_service_name }}TokenRequest()
 """)

hyperpocket/cli/codegen/auth/auth_token_schema_template.py

@@ -2,12 +2,12 @@ from jinja2 import Template
 
 
 def get_auth_token_schema_template() -> Template:
-    return Template("""
+    return Template("""\
 from typing import List, Optional
 from pydantic import BaseModel
 from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
-class {{ caplitalized_service_name }}TokenRequest(AuthenticateRequest):
+class {{ capitalized_service_name }}TokenRequest(AuthenticateRequest):
     pass
-class {{ caplitalized_service_name }}TokenResponse(AuthenticateResponse):
+class {{ capitalized_service_name }}TokenResponse(AuthenticateResponse):
     access_token: str
 """)

hyperpocket/cli/codegen/auth/server_auth_template.py

@@ -2,24 +2,39 @@ from jinja2 import Template
 
 
 def get_server_auth_token_template() -> Template:
-    return Template('''
+    return Template("""\
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
 from hyperpocket.futures import FutureStore
+
 {{ service_name }}_auth_router = APIRouter(
     prefix="/{{ service_name }}"
 )
+
+
+@{{ service_name }}_auth_router.get("/oauth2/callback")
+async def {{ service_name }}_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
 @{{ service_name }}_auth_router.get("/token/callback")
 async def {{ service_name }}_token_callback(state: str, token: str):
     try:
         FutureStore.resolve_future(state, token)
     except ValueError:
         return HTMLResponse(content="failed")
+
     return HTMLResponse(content="success")
-''')
-    
+""")
+
+
 def get_server_auth_oauth2_template() -> Template:
-    return Template('''
+    return Template("""\
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
 from hyperpocket.futures import FutureStore
@@ -47,4 +62,4 @@ async def {{ service_name }}_token_callback(state: str, token: str):
         return HTMLResponse(content="failed")
 
     return HTMLResponse(content="success")
-''')
+""")

hyperpocket/cli/codegen/tool/__init__.py

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

hyperpocket/cli/codegen/tool/tool_main_template.py

@@ -1,5 +1,6 @@
 from jinja2 import Template
 
+
 def get_tool_main_template() -> Template:
     return Template('''import json
 import os

hyperpocket/cli/{tool.py → tool_create.py}

@@ -9,16 +9,20 @@ from hyperpocket.cli.codegen.tool import get_tool_main_template
 
 
 @click.command()
-@click.argument('tool_name', type=str)
+@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")
+    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('_')])
+    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}")
@@ -37,31 +41,32 @@ def create_tool_template(tool_name, language="python"):
         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)
+        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'
+    init_file = tool_module_path / "__init__.py"
     if not init_file.exists():
-        init_file.write_text(f'''from .__main__ import main
+        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'
+    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
+            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'
+    config_file = tool_path / "config.toml"
     if not config_file.exists():
         config_file.write_text(f'''name = "{tool_name}"
 description = ""
@@ -75,23 +80,23 @@ scopes = []
 
     # Create .gitignore
     print(f"Generating .gitignore file for {tool_name}")
-    gitignore_file = tool_path / '.gitignore'
+    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'
+    readme_file = tool_path / "README.md"
     if not readme_file.exists():
-        readme_file.write_text(f'# {tool_name}\n\n')
+        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 = tool_path / "schema.json"
     schema_file.touch()
 
 
 @click.command()
-@click.argument('tool_path', type=str, required=False)
+@click.argument("tool_path", type=str, required=False)
 def build_tool(tool_path):
     """Build the tool at the specified path or current directory."""
 
@@ -99,7 +104,7 @@ def build_tool(tool_path):
 
     # Determine the tool directory
     if tool_path is None:
-        if not (cwd / 'config.toml').exists():
+        if not (cwd / "config.toml").exists():
             raise ValueError("Current working directory must be a tool directory")
     else:
         potential_path = Path(tool_path)

hyperpocket/cli/tool_export.py

@@ -0,0 +1,240 @@
+import os
+import re
+import ast
+import json
+import toml
+import importlib
+import inspect
+import shutil
+from typing import Callable
+from pathlib import Path
+import click
+
+from hyperpocket.cli.tool_create import create_tool_template
+
+
+@click.command()
+@click.argument("target", type=str, required=False)
+def export_tool(target, language="python"):
+    """Convert the specified tool to a local tool."""
+
+    target_path = Path.cwd() / target if target else Path.cwd()
+
+    if target_path.is_file():
+        process_tool_file(target_path, language)
+    elif target_path.is_dir():
+        process_tool_directory(target_path, language)
+    else:
+        raise ValueError("Invalid target path")
+
+
+def process_tool_file(target_path: Path, language: str):
+    """Process a single Python file containing function_tool decorated functions."""
+    decorated_functions = find_function_tool_decorated_functions(target_path)
+
+    if not decorated_functions:
+        raise ValueError("No function_tool decorated functions found in target file")
+    if len(decorated_functions) > 1:
+        raise ValueError(
+            "Multiple function_tool decorated functions found in target file"
+        )
+
+    func = load_functions_as_callable(decorated_functions, target_path)
+    tool_name = func.func.__name__.replace("-", "_")
+    cleaned_code = clean_tool_source_code(target_path.read_text())
+    tool_main_code = transform_function_to_pydantic(cleaned_code, func)
+
+    generate_tool_template(tool_name)
+    generate_tool_files(target_path, tool_name, tool_main_code, func, language)
+
+
+def process_tool_directory(target_path: Path, language: str):
+    """Process a directory containing function_tool decorated functions."""
+    decorated_function_file = None
+
+    for file in target_path.glob("*.py"):
+        decorated_functions = find_function_tool_decorated_functions(file)
+        if len(decorated_functions) == 1:
+            decorated_function_file = file
+            break
+        elif len(decorated_functions) > 1:
+            raise ValueError(
+                "Multiple function_tool decorated functions found in target file"
+            )
+
+    if not decorated_function_file:
+        raise ValueError(
+            "No function_tool decorated functions found in target directory"
+        )
+
+    func = load_functions_as_callable(decorated_functions, decorated_function_file)
+    tool_name = func.func.__name__.replace("-", "_")
+    cleaned_code = clean_tool_source_code(decorated_function_file.read_text())
+    tool_main_code = transform_function_to_pydantic(cleaned_code, func)
+
+    if tool_name != decorated_function_file.stem:
+        raise ValueError("Tool name must match the file name")
+
+    generate_tool_template(tool_name)
+    copy_tool_directory(target_path, tool_name)
+    generate_tool_files(target_path, tool_name, tool_main_code, func, language)
+
+
+def find_function_tool_decorated_functions(file_path: Path):
+    """Find all functions decorated with @function_tool in a given Python file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        source_code = f.read()
+
+    tree = ast.parse(source_code)
+    decorated_functions = [
+        node.name
+        for node in ast.walk(tree)
+        if isinstance(node, ast.FunctionDef)
+        and any(
+            isinstance(decorator, ast.Call) and decorator.func.id == "function_tool"
+            for decorator in node.decorator_list
+        )
+    ]
+
+    return decorated_functions
+
+
+def load_functions_as_callable(decorated_functions, file_path: Path):
+    """Load function_tool decorated function as a callable object."""
+    module_name = file_path.stem
+    spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    return getattr(module, decorated_functions[0])
+
+
+def clean_tool_source_code(source_code: str) -> str:
+    """Remove hyperpocket import, function_tool decorator, and main execution block."""
+    source_code = re.sub(
+        r"^from hyperpocket\.tool .*?\n", "", source_code, flags=re.MULTILINE
+    )
+    source_code = re.sub(
+        r"@function_tool\([\s\S]*?\)\n", "", source_code, flags=re.MULTILINE
+    )
+    source_code = re.sub(
+        r"\nif __name__ == [\"']__main__[\"']:[\s\S]*",
+        "",
+        source_code,
+        flags=re.MULTILINE,
+    )
+    return source_code.strip()
+
+
+def transform_function_to_pydantic(tool_source_code: str, func: Callable):
+    """Transform function into a Pydantic-based CLI tool."""
+    function_code = extract_function_code(func)
+
+    tree = ast.parse(function_code)
+    function_name = func.func.__name__
+
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name == function_name:
+            params = {
+                arg.arg: arg.annotation.id
+                for arg in node.args.args
+                if isinstance(arg.annotation, ast.Name)
+            }
+            properties = func.argument_json_schema["properties"]
+
+            model_name = function_name.title().replace("_", "") + "Request"
+            model_fields = [
+                f'    {name}: {type_} = Field(..., description="{properties[name]["description"]}")'
+                for name, type_ in params.items()
+            ]
+            model_code = (
+                f"class {model_name}(BaseModel):\n" + "\n".join(model_fields) + "\n"
+            )
+
+            main_code = f"""def main():
+    req = json.load(sys.stdin.buffer)
+    req_typed = {model_name}.model_validate(req)
+    response = {function_name}(**req_typed.model_dump())
+
+    print(json.dumps(response))
+
+
+if __name__ == "__main__":
+    main()
+"""
+            import_code = """import json
+import os
+import sys
+
+from pydantic import BaseModel, Field
+"""
+            return (
+                import_code
+                + "\n"
+                + tool_source_code
+                + "\n\n"
+                + model_code
+                + "\n"
+                + main_code
+            )
+
+    return None
+
+
+def extract_function_code(func: Callable) -> str:
+    """Extract function definition as a string."""
+    tool_source_code = inspect.getsource(func.func.__code__)
+    match = re.search(r"def\s+\w+\(.*\):[\s\S]*", tool_source_code)
+    return match.group(0) if match else ""
+
+
+def generate_tool_template(tool_name: str):
+    """Generate tool template using Click context forwarding."""
+    ctx = click.Context(create_tool_template)
+    ctx.forward(create_tool_template, tool_name=tool_name)
+
+
+def copy_tool_directory(src_path: Path, tool_name: str):
+    """Copy the tool directory to the new tool directory."""
+    tool_directory_name = tool_name.replace("_", "-")
+    dst_path = src_path.parent / tool_directory_name / tool_name
+
+    if dst_path.exists():
+        shutil.rmtree(dst_path)
+
+    shutil.copytree(src_path, dst_path)
+    os.remove(dst_path / f"{tool_name}.py")
+
+    init_file = src_path.parent / tool_directory_name / tool_name / "__init__.py"
+    init_file.write_text(f"from .__main__ import main\n\n__all__ = ['main']")
+
+
+def generate_tool_files(
+    target_path: Path,
+    tool_name: str,
+    tool_main_code: str,
+    func: Callable,
+    language: str,
+):
+    """Generate config.toml, __main__.py, and schema.json for the tool."""
+    tool_directory_name = tool_name.replace("_", "-")
+
+    config_file = target_path.parent / tool_directory_name / "config.toml"
+    config_data = {
+        "name": func.name,
+        "description": func.description,
+        "language": language,
+        "auth": json.loads(func.auth.model_dump_json()),
+        "tool_vars": func.default_tool_vars,
+    }
+
+    with open(config_file, "w", encoding="utf-8") as f:
+        f.write(toml.dumps(config_data))
+
+    main_file = target_path.parent / tool_directory_name / tool_name / "__main__.py"
+    with open(main_file, "w", encoding="utf-8") as f:
+        f.write(tool_main_code)
+
+    schema_file = target_path.parent / tool_directory_name / "schema.json"
+    with open(schema_file, "w", encoding="utf-8") as f:
+        f.write(json.dumps(func.argument_json_schema, indent=4))

hyperpocket/config/auth.py

@@ -7,29 +7,81 @@ class BaseAuthConfig(BaseModel):
     use_recommended_scope: bool = Field(default=True)
 
 
-class SlackAuthConfig(BaseAuthConfig):
+class OAuth2AuthConfig(BaseAuthConfig):
     client_id: str
     client_secret: str
 
 
-class GoogleAuthConfig(BaseAuthConfig):
-    client_id: str
-    client_secret: str
+class SlackAuthConfig(OAuth2AuthConfig):
+    pass
 
 
-class GithubAuthConfig(BaseAuthConfig):
-    client_id: str
-    client_secret: str
+class GoogleAuthConfig(OAuth2AuthConfig):
+    pass
 
 
-class CalendlyAuthConfig(BaseAuthConfig):
-    client_id: str
-    client_secret: str
+class GithubAuthConfig(OAuth2AuthConfig):
+    pass
 
 
-class XAuthConfig(BaseAuthConfig):
-    client_id: str
-    client_secret: str
+class CalendlyAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class XAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class JiraAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class HubspotAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class DiscordAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class ZoomAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class AsanaAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class MailchimpAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class BitbucketAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class NotionAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class LinkedinAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class LinearAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class SalesForceAuthConfig(OAuth2AuthConfig):
+    domain_url: str
+
+
+class SpotifyAuthConfig(OAuth2AuthConfig):
+    pass
+
+
+class FacebookAuthConfig(OAuth2AuthConfig):
+    pass
 
 
 class AuthConfig(BaseModel):
@@ -38,6 +90,19 @@ class AuthConfig(BaseModel):
     github: Optional[GithubAuthConfig] = None
     calendly: Optional[CalendlyAuthConfig] = None
     x: Optional[XAuthConfig] = None
+    jira: Optional[JiraAuthConfig] = None
+    hubspot: Optional[HubspotAuthConfig] = None
+    discord: Optional[DiscordAuthConfig] = None
+    zoom: Optional[ZoomAuthConfig] = None
+    asana: Optional[AsanaAuthConfig] = None
+    mailchimp: Optional[MailchimpAuthConfig] = None
+    bitbucket: Optional[BitbucketAuthConfig] = None
+    notion: Optional[NotionAuthConfig] = None
+    salesforce: Optional[SalesForceAuthConfig] = None
+    spotify: Optional[SpotifyAuthConfig] = None
+    linkedin: Optional[LinkedinAuthConfig] = None
+    linear: Optional[LinearAuthConfig] = None
+    facebook: Optional[FacebookAuthConfig] = None
     use_prebuilt_auth: bool = Field(default=True)
 
 

hyperpocket/pocket_core.py

@@ -298,11 +298,13 @@ class PocketCore:
                 repo_url=tool_like
             )
             lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
-            parsed_tool_like = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
+            parsed_tool_like = WasmToolRequest(
+                lock=lock, rel_path=rel_path, tool_vars={}
+            )
         else:
             parsed_tool_like = None
             RuntimeError(
-                f"Can't convert to ToolRequest. it might be wrong github url or local path. path: {tool_like}")
+                f"Can't convert to ToolRequest. it might be wrong github url or local path. path: {tool_like}"
+            )
 
         return parsed_tool_like
-

hyperpocket/server/auth/activeloop.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+activeloop_auth_router = APIRouter(prefix="/activeloop")
+
+
+@activeloop_auth_router.get("/oauth2/callback")
+async def activeloop_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@activeloop_auth_router.get("/token/callback")
+async def activeloop_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")