note-connector 0.2.5 → 0.2.6

package/py/src/note_mcp/chatgpt/__main__.py

@@ -0,0 +1,63 @@
+"""HTTP entrypoint for note-connector ChatGPT connector."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+import uvicorn
+from starlette.requests import Request
+from starlette.responses import Response
+
+from note_mcp.chatgpt.auth import load_or_create_token
+from note_mcp.chatgpt.middleware import ConnectorAuthMiddleware
+from note_mcp.chatgpt.tools import register_chatgpt_tools
+from note_mcp.chatgpt.widgets import register_chatgpt_resources
+from note_mcp.server import _session_manager, mcp
+
+
+def _default_config_dir() -> Path:
+    return Path(os.environ.get("NOTE_CONNECTOR_CONFIG_DIR", Path.home() / ".note-connector"))
+
+
+def _configure_mcp_allowed_hosts(host_header: str | None) -> None:
+    if host_header:
+        os.environ.setdefault("MCP_ALLOWED_HOSTS", host_header)
+        os.environ.setdefault("MCP_ALLOWED_ORIGINS", f"https://{host_header}")
+
+
+def build_http_app(token: str) -> ConnectorAuthMiddleware:
+    register_chatgpt_tools(mcp, _session_manager)
+    register_chatgpt_resources(mcp)
+
+    @mcp.custom_route("/healthz", methods=["GET"])
+    async def healthz(_request: Request) -> Response:
+        from starlette.responses import JSONResponse
+
+        return JSONResponse({"status": "ok", "app": "note-connector"})
+
+    app = mcp.http_app(path="/mcp", transport="streamable-http", stateless_http=True)
+    return ConnectorAuthMiddleware(app, token)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="note-connector ChatGPT HTTP server")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8787)
+    parser.add_argument("--token-file", type=Path, default=None)
+    args = parser.parse_args()
+
+    config_dir = _default_config_dir()
+    token_path = args.token_file or (config_dir / "token")
+    token = os.environ.get("NOTE_CONNECTOR_TOKEN") or load_or_create_token(token_path)
+
+    tunnel_host = os.environ.get("NOTE_CONNECTOR_TUNNEL_HOST")
+    _configure_mcp_allowed_hosts(tunnel_host)
+
+    app = build_http_app(token)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

package/py/src/note_mcp/chatgpt/access_log.py

@@ -0,0 +1,25 @@
+"""Record successful ChatGPT MCP access for note-connector CLI."""
+
+from __future__ import annotations
+
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+
+
+def _access_path() -> Path:
+    base = Path(os.environ.get("NOTE_CONNECTOR_CONFIG_DIR", Path.home() / ".note-connector"))
+    return base / "last-mcp-access.json"
+
+
+def record_mcp_access(remote_host: str | None) -> None:
+    """Append latest MCP access timestamp (idempotent overwrite)."""
+    path = _access_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "at": datetime.now(UTC).isoformat(),
+        "remote": remote_host,
+    }
+    import json
+
+    path.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")

package/py/src/note_mcp/chatgpt/auth.py

@@ -0,0 +1,52 @@
+"""Authentication helpers for the ChatGPT HTTP connector."""
+
+from __future__ import annotations
+
+import secrets
+from pathlib import Path
+
+from starlette.requests import Request
+
+
+def extract_bearer_token(request: Request) -> str | None:
+    """Extract auth token from Authorization header or ``?key=`` query."""
+    auth = request.headers.get("authorization")
+    if auth and auth.lower().startswith("bearer "):
+        return auth[7:].strip()
+    key = request.query_params.get("key")
+    if key:
+        return key.strip()
+    header_key = request.headers.get("x-note-connector-token")
+    if header_key:
+        return header_key.strip()
+    return None
+
+
+def is_authorized(request: Request, expected_token: str) -> bool:
+    """Return whether the request may access protected routes."""
+    if request.url.path in ("/healthz", "/health"):
+        return True
+    if request.url.path.startswith("/assets/"):
+        return True
+    token = extract_bearer_token(request)
+    if token is None:
+        return False
+    return secrets.compare_digest(token, expected_token)
+
+
+def load_or_create_token(token_path: Path) -> str:
+    """Load persisted connector token or create a new one."""
+    token_path.parent.mkdir(parents=True, exist_ok=True)
+    if token_path.is_file():
+        stored = token_path.read_text(encoding="utf-8").strip()
+        if stored:
+            return stored
+    token = secrets.token_urlsafe(32)
+    token_path.write_text(token, encoding="utf-8")
+    return token
+
+
+def build_mcp_endpoint_url(public_base: str, token: str) -> str:
+    """Build the ChatGPT connector URL."""
+    base = public_base.rstrip("/")
+    return f"{base}/mcp?key={token}"

package/py/src/note_mcp/chatgpt/images.py

@@ -0,0 +1,92 @@
+"""Image materialization for ChatGPT-generated images."""
+
+from __future__ import annotations
+
+import base64
+import re
+import uuid
+from pathlib import Path
+
+import httpx
+
+from note_mcp.api.images import validate_image_file
+
+_MIME_TO_EXT = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+}
+
+
+def normalize_mime_type(mime_type: str) -> str:
+    """Normalize MIME type by stripping parameters."""
+    return mime_type.split(";", maxsplit=1)[0].strip().lower()
+
+
+def extension_for_mime(mime_type: str) -> str:
+    """Return file extension for a supported image MIME type."""
+    normalized = normalize_mime_type(mime_type)
+    ext = _MIME_TO_EXT.get(normalized)
+    if ext is None:
+        raise ValueError(f"Unsupported image MIME type: {mime_type}")
+    return ext
+
+
+async def download_image_url(url: str, dest_path: Path) -> None:
+    """Download image bytes from URL to dest_path."""
+    async with httpx.AsyncClient(follow_redirects=True, timeout=60.0) as client:
+        response = await client.get(url)
+        response.raise_for_status()
+        dest_path.write_bytes(response.content)
+
+
+def write_base64_image(image_base64: str, dest_path: Path) -> None:
+    """Decode base64 image data and write to dest_path."""
+    cleaned = re.sub(r"\s+", "", image_base64)
+    if cleaned.startswith("data:") and "," in cleaned:
+        cleaned = cleaned.split(",", maxsplit=1)[1]
+    raw = base64.b64decode(cleaned, validate=True)
+    dest_path.write_bytes(raw)
+
+
+def materialize_image_input_sync(
+    work_dir: Path,
+    *,
+    image_base64: str | None,
+    image_url: str | None,
+    mime_type: str,
+) -> Path:
+    """Write image input to a temp file and validate it."""
+    work_dir.mkdir(parents=True, exist_ok=True)
+    ext = extension_for_mime(mime_type)
+    dest = work_dir / f"chatgpt-{uuid.uuid4().hex}{ext}"
+    if image_base64:
+        write_base64_image(image_base64, dest)
+    elif image_url:
+        raise ValueError("image_url requires async materialize_image_input")
+    else:
+        raise ValueError("Provide image_base64 or image_url")
+    validate_image_file(str(dest))
+    return dest
+
+
+async def materialize_image_input(
+    work_dir: Path,
+    *,
+    image_base64: str | None,
+    image_url: str | None,
+    mime_type: str,
+) -> Path:
+    """Write image input to a temp file and validate it."""
+    work_dir.mkdir(parents=True, exist_ok=True)
+    ext = extension_for_mime(mime_type)
+    dest = work_dir / f"chatgpt-{uuid.uuid4().hex}{ext}"
+    if image_base64:
+        write_base64_image(image_base64, dest)
+    elif image_url:
+        await download_image_url(image_url, dest)
+    else:
+        raise ValueError("Provide image_base64 or image_url")
+    validate_image_file(str(dest))
+    return dest

package/py/src/note_mcp/chatgpt/login_once.py

@@ -0,0 +1,26 @@
+"""One-shot note.com browser login for note-connector onboarding."""
+
+from __future__ import annotations
+
+import asyncio
+
+from note_mcp.auth.browser import login_with_browser
+from note_mcp.auth.session import SessionManager
+
+
+async def _main() -> int:
+    if SessionManager().has_session():
+        print("note.com: already authenticated")
+        return 0
+    print("Opening browser for note.com login…")
+    await login_with_browser(timeout=300)
+    print("note.com: login saved")
+    return 0
+
+
+def main() -> None:
+    raise SystemExit(asyncio.run(_main()))
+
+
+if __name__ == "__main__":
+    main()

package/py/src/note_mcp/chatgpt/middleware.py

@@ -0,0 +1,31 @@
+"""ASGI middleware for connector authentication."""
+
+from __future__ import annotations
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from note_mcp.chatgpt.access_log import record_mcp_access
+from note_mcp.chatgpt.auth import is_authorized
+
+
+class ConnectorAuthMiddleware:
+    """Reject unauthorized requests to MCP endpoints."""
+
+    def __init__(self, app: ASGIApp, token: str) -> None:
+        self.app = app
+        self.token = token
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+        request = Request(scope, receive=receive)
+        if not is_authorized(request, self.token):
+            response = JSONResponse({"error": "unauthorized"}, status_code=401)
+            await response(scope, receive, send)
+            return
+        if request.method == "POST" and request.url.path.startswith("/mcp"):
+            record_mcp_access(request.client.host if request.client else None)
+        await self.app(scope, receive, send)

package/py/src/note_mcp/chatgpt/tools.py

@@ -0,0 +1,255 @@
+"""Additional MCP tools for ChatGPT connector."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Annotated, Any
+
+from fastmcp import FastMCP
+
+from note_mcp.api.articles import create_draft, delete_article, list_articles, unpublish_article
+from note_mcp.api.images import insert_image_via_api
+from note_mcp.api.public_notes import fetch_public_article, search_public_notes
+from note_mcp.auth.session import SessionManager
+from note_mcp.chatgpt.images import materialize_image_input
+from note_mcp.chatgpt.widgets import (
+    ARTICLE_PANEL_URI,
+    HOME_URI,
+    widget_tool_meta,
+)
+from note_mcp.models import ArticleInput, ArticleStatus, NoteAPIError
+
+
+def register_chatgpt_tools(mcp: FastMCP, session_manager: SessionManager) -> None:
+    """Register ChatGPT-specific tools and widget resources."""
+
+    @mcp.tool(
+        meta=widget_tool_meta(HOME_URI, "note-connector を開いています…", "note-connector"),
+        annotations={"readOnlyHint": True},
+    )
+    async def note_ui_status() -> dict[str, object]:
+        """ChatGPT用: 認証状態とクイック情報を返します（Apps SDK ウィジェット用 dict）。"""
+        if not session_manager.has_session():
+            return {"authenticated": False, "message": "note_login を実行してください"}
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return {"authenticated": False, "message": "セッションが無効です。note_login を実行してください"}
+        return {
+            "authenticated": True,
+            "message": f"ユーザー: {session.username}",
+            "username": session.username,
+        }
+
+    @mcp.tool(
+        meta=widget_tool_meta(ARTICLE_PANEL_URI, "記事一覧を取得中…", "記事一覧"),
+        annotations={"readOnlyHint": True},
+    )
+    async def note_ui_list_articles(
+        status: Annotated[str | None, "draft/published/all"] = None,
+        page: Annotated[int, "ページ番号"] = 1,
+        limit: Annotated[int, "1ページあたり件数"] = 10,
+    ) -> dict[str, object]:
+        """ChatGPT用: 記事一覧をウィジェット表示用 dict で返します。"""
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return {"articles": [], "error": "未認証。note_login を実行してください", "authenticated": False}
+
+        status_filter: ArticleStatus | None = None
+        if status is not None and status != "all":
+            status_filter = ArticleStatus(status)
+
+        try:
+            result = await list_articles(session, status=status_filter, page=page, limit=limit)
+        except NoteAPIError as exc:
+            return {"articles": [], "error": str(exc), "authenticated": True}
+
+        articles: list[dict[str, Any]] = []
+        for article in result.articles:
+            articles.append(
+                {
+                    "id": article.id,
+                    "key": article.key,
+                    "title": article.title,
+                    "status": article.status.value,
+                }
+            )
+        return {
+            "articles": articles,
+            "total": result.total,
+            "page": result.page,
+            "has_more": result.has_more,
+            "authenticated": True,
+        }
+
+    @mcp.tool()
+    async def note_attach_image(
+        article_key: Annotated[str, "記事キー（n... 形式）"],
+        mime_type: Annotated[str, "image/png など"],
+        image_base64: Annotated[str | None, "Base64画像データ"] = None,
+        image_url: Annotated[str | None, "画像URL"] = None,
+        caption: Annotated[str | None, "キャプション"] = None,
+    ) -> str:
+        """ChatGPT生成画像を記事に挿入します（base64 または URL）。"""
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return "セッションが無効です。note_loginでログインしてください。"
+
+        work_dir = Path(os.environ.get("NOTE_CONNECTOR_WORK_DIR", "/tmp/note-connector"))
+        try:
+            file_path = await materialize_image_input(
+                work_dir,
+                image_base64=image_base64,
+                image_url=image_url,
+                mime_type=mime_type,
+            )
+            result = await insert_image_via_api(
+                session=session,
+                article_id=article_key,
+                file_path=str(file_path),
+                caption=caption,
+            )
+        except (ValueError, NoteAPIError, OSError) as exc:
+            return f"画像挿入に失敗しました: {exc}"
+
+        return f"画像を挿入しました。記事キー: {result['article_key']}\n画像URL: {result['image_url']}"
+
+    @mcp.tool()
+    async def note_create_draft_with_images(
+        title: Annotated[str, "記事タイトル"],
+        body: Annotated[str, "本文（Markdown）"],
+        tags: Annotated[list[str] | None, "タグ"] = None,
+        images: Annotated[
+            list[dict[str, str]] | None,
+            "画像配列。各要素: mime_type, image_base64 または image_url",
+        ] = None,
+    ) -> str:
+        """下書き作成後、ChatGPT画像を本文に挿入します。"""
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return "セッションが無効です。note_loginでログインしてください。"
+
+        article_input = ArticleInput(title=title, body=body, tags=tags or [])
+        try:
+            article = await create_draft(session, article_input)
+        except NoteAPIError as exc:
+            return f"下書き作成に失敗しました: {exc}"
+
+        inserted = 0
+        errors: list[str] = []
+        work_dir = Path(os.environ.get("NOTE_CONNECTOR_WORK_DIR", "/tmp/note-connector"))
+        for index, image_spec in enumerate(images or []):
+            mime = image_spec.get("mime_type", "image/png")
+            b64 = image_spec.get("image_base64")
+            url = image_spec.get("image_url")
+            caption = image_spec.get("caption")
+            try:
+                file_path = await materialize_image_input(
+                    work_dir,
+                    image_base64=b64,
+                    image_url=url,
+                    mime_type=mime,
+                )
+                await insert_image_via_api(
+                    session=session,
+                    article_id=article.key,
+                    file_path=str(file_path),
+                    caption=caption,
+                )
+                inserted += 1
+            except (ValueError, NoteAPIError, OSError) as exc:
+                errors.append(f"image[{index}]: {exc}")
+
+        lines = [
+            f"下書きを作成しました。ID: {article.id}、キー: {article.key}",
+            f"挿入した画像: {inserted}件",
+        ]
+        if errors:
+            lines.append("画像エラー:")
+            lines.extend(f"  - {e}" for e in errors)
+        return "\n".join(lines)
+
+    @mcp.tool(annotations={"readOnlyHint": True})
+    async def note_search_public_articles(
+        query: Annotated[str, "検索キーワード"],
+        size: Annotated[int, "件数（1〜20）"] = 10,
+    ) -> dict[str, object]:
+        """note.com 上の公開記事をキーワード検索します（ログイン不要）。"""
+        try:
+            result = await search_public_notes(query, size=size)
+        except NoteAPIError as exc:
+            return {"items": [], "error": str(exc), "query": query}
+        return {
+            "query": result.query,
+            "is_last_page": result.is_last_page,
+            "items": [item.model_dump() for item in result.items],
+        }
+
+    @mcp.tool(annotations={"readOnlyHint": True})
+    async def note_fetch_public_article(
+        note_key_or_url: Annotated[str, "記事キー（n...）または公開URL"],
+    ) -> dict[str, object]:
+        """他人の公開記事を取得します（ログイン不要）。"""
+        try:
+            article = await fetch_public_article(note_key_or_url)
+        except NoteAPIError as exc:
+            return {"error": str(exc)}
+        return article.model_dump()
+
+    @mcp.tool()
+    async def note_delete_article(
+        article_key: Annotated[str, "削除する記事のキー（例: n1234567890ab）"],
+        confirm: Annotated[bool, "削除を実行する場合はTrue、確認のみの場合はFalse"] = False,
+    ) -> dict[str, object]:
+        """公開記事を含む任意の記事を削除します（下書き・公開問わず削除可、取り消し不可）。"""
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return {"error": "セッションが無効です。note_loginでログインしてください。"}
+
+        try:
+            result = await delete_article(session, article_key, confirm=confirm)
+        except NoteAPIError as exc:
+            return {"error": str(exc)}
+
+        from note_mcp.models import DeletePreview, DeleteResult
+
+        if isinstance(result, DeletePreview):
+            return {
+                "action": "preview",
+                "article_title": result.article_title,
+                "article_key": result.article_key,
+                "status": result.status.value,
+                "message": result.message,
+            }
+        elif isinstance(result, DeleteResult):
+            return {
+                "action": "deleted",
+                "success": result.success,
+                "article_title": result.article_title,
+                "article_key": result.article_key,
+                "message": result.message,
+            }
+        return {"result": str(result)}
+
+    @mcp.tool()
+    async def note_unpublish_article(
+        article_key: Annotated[str, "下書きに戻す公開記事のキー（例: n1234567890ab）"],
+    ) -> dict[str, object]:
+        """公開記事を下書きに戻します（記事内容は保持されます）。"""
+        session = session_manager.load()
+        if session is None or session.is_expired():
+            return {"error": "セッションが無効です。note_loginでログインしてください。"}
+
+        try:
+            article = await unpublish_article(session, article_key)
+        except NoteAPIError as exc:
+            return {"error": str(exc)}
+
+        return {
+            "unpublished": True,
+            "title": article.title,
+            "key": article.key,
+            "status": "draft",
+            "url": article.url,
+            "message": f"記事「{article.title}」を下書きに戻しました。",
+        }

package/py/src/note_mcp/chatgpt/widgets.py

@@ -0,0 +1,121 @@
+"""Apps SDK HTML widgets for note-connector."""
+
+from __future__ import annotations
+
+HOME_URI = "ui://note-connector/home-v1.html"
+ARTICLE_PANEL_URI = "ui://note-connector/article-panel-v1.html"
+
+APPS_MIME = "text/html;profile=mcp-app"
+
+WIDGET_RUNTIME = """
+function noteConnectorParsePayload(payload) {
+  if (!payload || typeof payload !== 'object') return {};
+  if (typeof payload.result === 'string') {
+    try { var inner = JSON.parse(payload.result); if (inner && typeof inner === 'object') return inner; } catch (e) {}
+  }
+  if (payload.data && typeof payload.data === 'object') return payload.data;
+  return payload;
+}
+(function() {
+  function boot() {
+    const openai = window.openai || {};
+    const raw = openai.toolOutput || openai.structuredContent || {};
+    const data = noteConnectorParsePayload(raw);
+    const callTool = (name, args) => openai.callTool && openai.callTool(name, args);
+    const ctx = { data: data, callTool: callTool };
+    if (typeof window.NoteConnectorRender === 'function') window.NoteConnectorRender(ctx);
+  }
+  window.addEventListener('openai:set_globals', boot);
+  boot();
+})();
+"""
+
+
+def _widget_document(title: str, body: str, render_js: str) -> str:
+    return f"""<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>{title}</title>
+  <style>
+    body {{ margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; }}
+    .root {{ padding: 12px; font-size: 13px; }}
+    .title {{ font-weight: 600; margin-bottom: 8px; }}
+    .mono {{ font-family: ui-monospace, monospace; white-space: pre-wrap; }}
+    .muted {{ color: #666; }}
+    .card {{ border: 1px solid #ddd; border-radius: 8px; padding: 10px; margin: 8px 0; }}
+  </style>
+</head>
+<body>
+  <div id="root" class="root">{body}</div>
+  <script>{render_js}</script>
+  <script>{WIDGET_RUNTIME}</script>
+</body>
+</html>"""
+
+
+def home_widget_html() -> str:
+    render = """
+window.NoteConnectorRender = function(ctx) {
+  const root = document.getElementById('root');
+  const d = ctx.data || {};
+  root.innerHTML = '<div class="title">note-connector</div>'
+    + '<div class="muted">ChatGPT connector for note.com</div>'
+    + '<div class="card"><div>認証: ' + (d.authenticated ? 'OK' : '未ログイン') + '</div>'
+    + '<div class="small">' + (d.message || '') + '</div></div>';
+};
+"""
+    return _widget_document("note-connector Home", '<div class="muted">Loading…</div>', render)
+
+
+def article_panel_widget_html() -> str:
+    render = """
+window.NoteConnectorRender = function(ctx) {
+  const root = document.getElementById('root');
+  const d = ctx.data || {};
+  const articles = d.articles || [];
+  if (!articles.length) {
+    root.innerHTML = '<div class="muted">記事がありません</div>';
+    return;
+  }
+  root.innerHTML = '<div class="title">記事一覧 (' + articles.length + ')</div>'
+    + articles.map(function(a) {
+      return '<div class="card"><strong>' + (a.title || '') + '</strong><br/>'
+        + '<span class="mono">' + (a.id || '') + ' / ' + (a.key || '') + '</span><br/>'
+        + '<span class="muted">' + (a.status || '') + '</span></div>';
+    }).join('');
+};
+"""
+    return _widget_document("note-connector Articles", '<div class="muted">Loading…</div>', render)
+
+
+def widget_tool_meta(uri: str, invoking: str, invoked: str) -> dict[str, object]:
+    return {
+        "ui": {"resourceUri": uri},
+        "openai/outputTemplate": uri,
+        "openai/toolInvocation/invoking": invoking,
+        "openai/toolInvocation/invoked": invoked,
+        "openai/widgetAccessible": True,
+    }
+
+
+def register_chatgpt_resources(mcp: object) -> None:
+    """Register widget HTML as MCP resources."""
+    from fastmcp import FastMCP
+
+    server = mcp
+    if not isinstance(server, FastMCP):
+        return
+
+    @server.resource(HOME_URI, mime_type=APPS_MIME, meta={"openai/widgetDescription": "note-connector home"})
+    def note_home_resource() -> str:
+        return home_widget_html()
+
+    @server.resource(
+        ARTICLE_PANEL_URI,
+        mime_type=APPS_MIME,
+        meta={"openai/widgetDescription": "note.com article list"},
+    )
+    def note_article_panel_resource() -> str:
+        return article_panel_widget_html()