note-connector 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "note-connector",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "publishConfig": {
     "access": "public"
   },

package/py/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "note-connector"
-version = "0.2.6"
+version = "0.2.8"
 description = "note-connector: MCP server and ChatGPT connector for note.com"
 readme = "README.md"
 requires-python = ">=3.13"

package/py/src/note_mcp/api/images.py

@@ -1,13 +1,19 @@
 """Image upload operations for note.com API.
 
 Provides functionality for uploading images to note.com.
-Supports both eyecatch (header) images and body (inline) images.
+Supports both eyecatch (header) images and body (inline) images,
+as well as base64-encoded image uploads.
 """
 
 from __future__ import annotations
 
+import base64
+import binascii
+import contextlib
 import logging
+import os
 import re
+import tempfile
 import time
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -90,6 +96,63 @@ IMAGE_UPLOAD_ENDPOINTS: dict[ImageType, str] = {
     ImageType.BODY: "/v1/image_upload/note_eyecatch",  # Same endpoint - URL works for body embedding
 }
 
+# Supported MIME types for base64 image upload
+SUPPORTED_MIME_TYPES: set[str] = {"image/png", "image/jpeg", "image/webp", "image/gif"}
+
+# Mapping from MIME type to file extension
+MIME_TO_EXTENSION: dict[str, str] = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+}
+
+# Magic bytes for image format detection
+# (signature, offset) - signature is checked at the given offset
+_MAGIC_BYTES: dict[str, tuple[bytes, int]] = {
+    "image/png": (b"\x89PNG\r\n\x1a\n", 0),
+    "image/jpeg": (b"\xff\xd8\xff", 0),
+    "image/gif": (b"GIF8", 0),
+    "image/webp": (b"WEBP", 8),
+}
+
+
+def _extract_image_url_from_response(response: dict[str, Any]) -> str | None:
+    """Extract image URL from API response, trying multiple possible field names.
+
+    note.com API may return the URL under different field names.
+    This function tries known field names in order of preference.
+
+    Args:
+        response: Full API response dictionary
+
+    Returns:
+        Image URL string if found, None otherwise
+    """
+    data = response.get("data", {})
+
+    # Try known field names for image URL
+    candidate_keys = [
+        "url",
+        "image_url",
+        "src",
+        "download_url",
+        "note_image_url",
+    ]
+
+    for key in candidate_keys:
+        value = data.get(key)
+        if value and isinstance(value, str) and value.strip():
+            return str(value)
+
+    # Check if the top-level response itself is a string URL
+    for key in candidate_keys:
+        value = response.get(key)
+        if value and isinstance(value, str) and value.strip():
+            return str(value)
+
+    return None
+
 
 def validate_image_file(file_path: str) -> None:
     """Validate image file before upload.
@@ -181,25 +244,36 @@ async def _upload_image_internal(
     async with NoteAPIClient(session) as client:
         response = await client.post(endpoint, files=files, data=data)
 
-    # Parse response - Article 6: validate required fields, no fallback
-    image_data = response.get("data", {})
+    # Debug: log full API response for investigation
+    logger.debug(
+        "Image upload response for note_id=%s, endpoint=%s: %s",
+        numeric_note_id,
+        endpoint,
+        {k: v for k, v in response.items() if k != "data"},
+    )
+    if "data" in response:
+        logger.debug("Image upload response data keys: %s", list(response["data"].keys()))
+        logger.debug("Image upload response data: %s", response["data"])
 
-    # Note: The eyecatch upload endpoint (/v1/image_upload/note_eyecatch) returns
-    # only 'url' in the response, not 'key'. This is expected behavior based on
-    # API testing - body images (via presigned_post) return 'key', eyecatch does not.
+    # Extract image URL from response (tries multiple field names)
+    image_url = _extract_image_url_from_response(response)
+
+    image_data = response.get("data", {})
     image_key = image_data.get("key")
 
-    image_url = image_data.get("url")
+    # URL is optional - eyecatch API may not always return it
+    # The eyecatch is set server-side even without a URL in the response
     if not image_url:
-        raise NoteAPIError(
-            code=ErrorCode.API_ERROR,
-            message="Image upload failed: API response missing required field 'url'",
-            details={"response": response},
+        logger.warning(
+            "Image upload response missing image URL for note_id=%s. Response keys: top=%s, data=%s",
+            numeric_note_id,
+            list(response.keys()),
+            list(image_data.keys()) if image_data else "none",
         )
 
     return Image(
         key=str(image_key) if image_key else None,
-        url=str(image_url),
+        url=str(image_url) if image_url else "",
         original_path=file_path,
         size_bytes=file_size,
         uploaded_at=int(time.time()),
@@ -454,3 +528,181 @@ async def insert_image_via_api(
         "caption": caption,
         "fallback_used": False,  # No fallback in API-only mode
     }
+
+
+# =============================================================================
+# Base64 Image Upload
+# =============================================================================
+
+_DATA_URL_PREFIX_RE = re.compile(r"^data:.*?;base64,")
+
+
+def _strip_data_url_prefix(image_base64: str) -> str:
+    """Strip data URL prefix from a base64 string if present.
+
+    Handles inputs like:
+        data:image/png;base64,iVBORw0KGgo...
+        iVBORw0KGgo... (plain base64)
+
+    Args:
+        image_base64: Raw or data-URL-prefixed base64 string
+
+    Returns:
+        Clean base64 string without the prefix
+    """
+    match = _DATA_URL_PREFIX_RE.match(image_base64)
+    if match:
+        return image_base64[match.end() :]
+    return image_base64
+
+
+def _decode_base64_image(image_base64: str) -> bytes:
+    """Decode a base64 string to image bytes.
+
+    Args:
+        image_base64: Base64-encoded image data (with or without data URL prefix)
+
+    Returns:
+        Decoded image bytes
+
+    Raises:
+        NoteAPIError: If base64 decoding fails
+    """
+    clean = _strip_data_url_prefix(image_base64)
+
+    if not clean.strip():
+        raise NoteAPIError(
+            code=ErrorCode.INVALID_BASE64,
+            message="image_base64 が空です。",
+        )
+
+    try:
+        return base64.b64decode(clean, validate=True)
+    except (binascii.Error, ValueError) as e:
+        raise NoteAPIError(
+            code=ErrorCode.INVALID_BASE64,
+            message="image_base64 のデコードに失敗しました。",
+            details={"error": str(e)},
+        ) from e
+
+
+def _validate_mime_type(mime_type: str) -> None:
+    """Validate that the MIME type is supported.
+
+    Args:
+        mime_type: MIME type string (e.g., "image/png")
+
+    Raises:
+        NoteAPIError: If the MIME type is not supported
+    """
+    if mime_type not in SUPPORTED_MIME_TYPES:
+        raise NoteAPIError(
+            code=ErrorCode.UNSUPPORTED_MIME_TYPE,
+            message=(f"未対応のMIME typeです: {mime_type}。対応形式: {', '.join(sorted(SUPPORTED_MIME_TYPES))}"),
+            details={"mime_type": mime_type},
+        )
+
+
+def _validate_image_bytes(data: bytes, mime_type: str) -> None:
+    """Validate that decoded bytes represent a valid image.
+
+    Checks:
+    - Data is not empty
+    - Magic bytes match the declared MIME type
+    - Size is within limits
+
+    Args:
+        data: Raw image bytes
+        mime_type: Declared MIME type
+
+    Raises:
+        NoteAPIError: If validation fails
+    """
+    if not data:
+        raise NoteAPIError(
+            code=ErrorCode.INVALID_IMAGE,
+            message="デコードされた画像データが空です。",
+        )
+
+    # Size check
+    if len(data) > MAX_FILE_SIZE:
+        raise NoteAPIError(
+            code=ErrorCode.IMAGE_TOO_LARGE,
+            message=(f"画像サイズ ({len(data)} bytes) が上限 ({MAX_FILE_SIZE} bytes) を超えています。"),
+            details={"size": len(data), "max_size": MAX_FILE_SIZE},
+        )
+
+    # Magic byte check
+    magic_info = _MAGIC_BYTES.get(mime_type)
+    if magic_info is not None:
+        signature, offset = magic_info
+        if len(data) < offset + len(signature):
+            raise NoteAPIError(
+                code=ErrorCode.INVALID_IMAGE,
+                message="画像データが短すぎて形式を判別できません。",
+                details={"mime_type": mime_type, "size": len(data)},
+            )
+        if data[offset : offset + len(signature)] != signature:
+            raise NoteAPIError(
+                code=ErrorCode.INVALID_IMAGE,
+                message=f"宣言されたMIME type ({mime_type}) と実画像形式が一致しません。",
+                details={"mime_type": mime_type},
+            )
+
+
+async def upload_eyecatch_base64(
+    session: Session,
+    note_id: str,
+    mime_type: str,
+    image_base64: str,
+) -> Image:
+    """Upload an eyecatch image from base64-encoded data.
+
+    Decodes base64 image data, validates it, writes to a temporary file,
+    and uploads via the standard image upload flow. The temporary file is
+    cleaned up after upload (success or failure).
+
+    Args:
+        session: Authenticated session
+        note_id: The note ID to associate the image with (numeric or key format)
+        mime_type: MIME type of the image (e.g., "image/png")
+        image_base64: Base64-encoded image data (with or without data URL prefix)
+
+    Returns:
+        Image object with upload result
+
+    Raises:
+        NoteAPIError: If validation fails or API request fails
+    """
+    # Step 1: Validate MIME type
+    _validate_mime_type(mime_type)
+
+    # Step 2: Decode base64
+    image_bytes = _decode_base64_image(image_base64)
+
+    # Step 3: Validate image bytes
+    _validate_image_bytes(image_bytes, mime_type)
+
+    # Step 4: Determine file extension
+    extension = MIME_TO_EXTENSION.get(mime_type, ".bin")
+
+    # Step 5: Write to temp file and upload
+    tmp_path: str | None = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(suffix=extension)
+        os.close(fd)
+
+        with open(tmp_path, "wb") as f:
+            f.write(image_bytes)
+
+        image = await _upload_image_internal(
+            session=session,
+            file_path=tmp_path,
+            note_id=note_id,
+            image_type=ImageType.EYECATCH,
+        )
+        return image
+    finally:
+        if tmp_path is not None:
+            with contextlib.suppress(OSError):
+                os.unlink(tmp_path)

package/py/src/note_mcp/models.py

@@ -211,6 +211,11 @@ class ErrorCode(str, Enum):
     API_ERROR = "api_error"
     UPLOAD_FAILED = "upload_failed"
     INVALID_INPUT = "invalid_input"
+    INVALID_BASE64 = "invalid_base64"
+    UNSUPPORTED_MIME_TYPE = "unsupported_mime_type"
+    INVALID_IMAGE = "invalid_image"
+    IMAGE_TOO_LARGE = "image_too_large"
+    EYECATCH_SET_FAILED = "eyecatch_set_failed"
 
 
 class NoteAPIError(Exception):

package/py/src/note_mcp/server.py

@@ -22,7 +22,12 @@ from note_mcp.api.articles import (
     unpublish_article,
     update_article,
 )
-from note_mcp.api.images import insert_image_via_api, upload_body_image, upload_eyecatch_image
+from note_mcp.api.images import (
+    insert_image_via_api,
+    upload_body_image,
+    upload_eyecatch_base64,
+    upload_eyecatch_image,
+)
 from note_mcp.api.preview import get_preview_html
 from note_mcp.auth.browser import login_with_browser
 from note_mcp.auth.session import SessionManager
@@ -280,7 +285,45 @@ async def note_upload_eyecatch(
         アップロード結果（画像URLを含む）
     """
     image = await upload_eyecatch_image(session, file_path, note_id=note_id)
-    return f"アイキャッチ画像をアップロードしました。URL: {image.url}"
+    if image.url:
+        return f"アイキャッチ画像をアップロードしました。URL: {image.url}"
+    return "アイキャッチ画像をアップロードしました。"
+
+
+@mcp.tool()
+@require_session
+@handle_api_error
+async def note_set_eyecatch_base64(
+    session: Session,
+    note_id: Annotated[str, "アイキャッチ画像を設定する記事のID（数値IDまたは記事キー n... 形式）"],
+    mime_type: Annotated[str, "画像のMIMEタイプ（image/png, image/jpeg, image/webp など）"],
+    image_base64: Annotated[str, "base64エンコードされた画像データ（data:image/...;base64, 形式も可）"],
+) -> str:
+    """base64画像データから記事のアイキャッチ画像を設定します。
+
+    ChatGPTなどで生成した画像をbase64形式で直接渡すことで、
+    ファイルパスを必要とせずにnote記事のサムネイル/見出し画像を設定できます。
+
+    対応形式: PNG, JPEG, WebP, GIF
+    最大サイズ: 10MB
+
+    Args:
+        note_id: アイキャッチ画像を設定する記事のID（数値IDまたは記事キー n... 形式）
+        mime_type: 画像のMIMEタイプ
+        image_base64: base64エンコードされた画像データ
+
+    Returns:
+        設定結果（画像URLを含む）
+    """
+    image = await upload_eyecatch_base64(
+        session=session,
+        note_id=note_id,
+        mime_type=mime_type,
+        image_base64=image_base64,
+    )
+    if image.url:
+        return f"アイキャッチ画像を設定しました。URL: {image.url}"
+    return "アイキャッチ画像を設定しました。"
 
 
 @mcp.tool()