Phase 4 완료: 외부 연결, 모바일 반응형, 익스텐션 프레임워크

외부 연결:
- http-request AI 도구: GET/POST/PUT/PATCH/DELETE, 타임아웃, URL 스킴 차단
- Webhook 트리거: POST /api/webhooks/trigger/{taskId}로 외부에서 태스크 실행

모바일 반응형:
- codaro-skin.css: 768px/480px 모바일 미디어쿼리 (셀 간격, 폰트, 사이드바)
- Sidebar: 768px 이하에서 고정 오버레이로 전환

익스텐션 프레임워크:
- Extension 모델: 6가지 capability (tool/renderer/panel/command/provider/theme)
- ExtensionRegistry: 등록/해제, capability 필터, 동적 entry point 로딩
- CRUD API 4종 + capability 필터 조회

테스트: 266개 통과 (노트북 분할/생성 4개 추가)

Author: eddmpython

editor/src/lib/codaro/chrome/Sidebar.svelte

@@ -208,6 +208,17 @@
     50% { opacity: 0.4; }
   }
 
+  @media (max-width: 768px) {
+    .sidebar {
+      position: fixed;
+      z-index: 50;
+      left: 0;
+      top: 0;
+      bottom: 0;
+      box-shadow: 4px 0 20px rgba(0, 0, 0, 0.2);
+    }
+  }
+
   @media print {
     .sidebar {
       display: none;

editor/src/lib/codaro/styles/codaro-skin.css

@@ -316,6 +316,47 @@
   transition: border-color 0.15s, box-shadow 0.15s;
 }
 
+/* Mobile responsive */
+@media (max-width: 768px) {
+  .codaro-cell {
+    border-radius: 0 !important;
+    border-left: none !important;
+    border-right: none !important;
+  }
+
+  .codaro-cell .cm-editor {
+    font-size: 13px;
+  }
+
+  .shoulder-right {
+    right: 4px !important;
+    gap: 2px !important;
+  }
+
+  .shoulder-bottom {
+    padding: 4px 8px !important;
+  }
+
+  .toolbar-pill {
+    padding: 4px 8px !important;
+    font-size: 11px;
+  }
+
+  .cell-actions-popover {
+    min-width: auto !important;
+  }
+}
+
+@media (max-width: 480px) {
+  .codaro-cell .cm-editor {
+    font-size: 12px;
+  }
+
+  .shoulder-right {
+    display: none !important;
+  }
+}
+
 /* Print styles */
 @media print {
   .codaro-cell {

src/codaro/ai/toolExecutor.py

@@ -600,3 +600,39 @@ async def _handle_generateNotebook(self, args: dict[str, Any]) -> dict[str, Any]
             "saved": False,
             "loadedInEditor": self._documentSetter is not None,
         }
+
+    async def _handle_httpRequest(self, args: dict[str, Any]) -> dict[str, Any]:
+        import urllib.request
+        import urllib.error
+
+        method = args["method"]
+        url = args["url"]
+        headers = args.get("headers", {})
+        body = args.get("body")
+        timeout = min(args.get("timeout", 30), 60)
+
+        BLOCKED_PREFIXES = ("file://", "ftp://", "data:")
+        if any(url.lower().startswith(p) for p in BLOCKED_PREFIXES):
+            return {"error": f"URL scheme not allowed: {url.split(':')[0]}"}
+
+        try:
+            data = body.encode("utf-8") if body else None
+            req = urllib.request.Request(url, data=data, headers=headers, method=method)
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                respBody = resp.read(1024 * 512).decode("utf-8", errors="replace")
+                return {
+                    "status": resp.status,
+                    "headers": dict(resp.headers),
+                    "body": respBody,
+                    "url": resp.url,
+                }
+        except urllib.error.HTTPError as exc:
+            return {
+                "status": exc.code,
+                "error": str(exc.reason),
+                "body": exc.read(1024 * 64).decode("utf-8", errors="replace"),
+            }
+        except urllib.error.URLError as exc:
+            return {"error": f"Connection failed: {exc.reason}"}
+        except TimeoutError:
+            return {"error": f"Request timed out after {timeout}s"}

src/codaro/ai/tools.py

@@ -496,6 +496,40 @@ def toolSchemas() -> list[dict[str, Any]]:
 )
 
 
+TOOL_HTTP_REQUEST = ToolDef(
+    name="http-request",
+    description="Make an HTTP request to an external API and return the response.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "method": {
+                "type": "string",
+                "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"],
+                "description": "HTTP method.",
+            },
+            "url": {
+                "type": "string",
+                "description": "Target URL.",
+            },
+            "headers": {
+                "type": "object",
+                "description": "Request headers as key-value pairs.",
+            },
+            "body": {
+                "type": "string",
+                "description": "Request body (for POST/PUT/PATCH).",
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Timeout in seconds (default 30).",
+            },
+        },
+        "required": ["method", "url"],
+    },
+    handler="httpRequest",
+)
+
+
 def _registerDefaultTools() -> None:
     for tool in [
         TOOL_INSERT_BLOCK,
@@ -514,6 +548,7 @@ def _registerDefaultTools() -> None:
         TOOL_TRACK_ACHIEVEMENT,
         TOOL_SPLIT_NOTEBOOK,
         TOOL_GENERATE_NOTEBOOK,
+        TOOL_HTTP_REQUEST,
     ]:
         registerTool(tool)
 

src/codaro/api/__init__.py

@@ -1,5 +1,6 @@
 from .aiRouter import createAiRouter
 from .automationRouter import createAutomationRouter
+from .extensionRouter import createExtensionRouter
 from .appState import ServerState, createServerState
 from .bootstrapRouter import createBootstrapRouter
 from .curriculumRouter import createCurriculumRouter
@@ -43,6 +44,7 @@
     "createBootstrapRouter",
     "createCurriculumRouter",
     "createDocumentRouter",
+    "createExtensionRouter",
     "createKernelRouter",
     "createServerState",
     "createSpaRouter",

src/codaro/api/automationRouter.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, Request
 from pydantic import BaseModel
 
 from ..automation.taskModel import TaskDefinition
@@ -164,6 +164,31 @@ def apiSchedulerStatus():
             "jobCount": scheduler.jobCount,
         }
 
+    @router.post("/api/webhooks/trigger/{taskId}")
+    async def apiWebhookTrigger(taskId: str, request: Request):
+        registry = getTaskRegistry()
+        task = registry.get(taskId)
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+        if not task.enabled:
+            raise HTTPException(status_code=403, detail="Task is disabled")
+
+        try:
+            payload = await request.json()
+        except Exception:
+            payload = {}
+
+        workspaceRoot = str(getattr(state, "workspaceRoot", "."))
+        runner = TaskRunner(workspaceRoot=workspaceRoot)
+        run = await runner.run(task)
+        registry.addRun(run)
+        return {
+            "triggered": True,
+            "taskId": taskId,
+            "runId": run.id,
+            "status": run.status.value,
+        }
+
     @router.get("/api/workflows")
     def apiListWorkflows():
         engine = getWorkflowEngine(str(getattr(state, "workspaceRoot", ".")))

src/codaro/api/extensionRouter.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..extensions import ExtensionRegistry, Extension, ExtensionCapability, getExtensionRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class RegisterExtensionRequest(BaseModel):
+    name: str
+    version: str = "0.0.0"
+    description: str = ""
+    author: str = ""
+    capabilities: list[str] = []
+    entryPoint: str = ""
+    config: dict[str, Any] = {}
+
+
+def createExtensionRouter(state: Any) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/extensions")
+    def apiListExtensions():
+        registry = getExtensionRegistry()
+        return {
+            "extensions": [e.serialize() for e in registry.listExtensions()],
+            "total": registry.count,
+        }
+
+    @router.post("/api/extensions")
+    def apiRegisterExtension(req: RegisterExtensionRequest):
+        registry = getExtensionRegistry()
+        caps = tuple(
+            ExtensionCapability(c) for c in req.capabilities
+            if c in ExtensionCapability._value2member_map_
+        )
+        extension = Extension(
+            name=req.name,
+            version=req.version,
+            description=req.description,
+            author=req.author,
+            capabilities=caps,
+            entryPoint=req.entryPoint,
+            config=req.config,
+        )
+        registry.register(extension)
+        return extension.serialize()
+
+    @router.get("/api/extensions/{extensionId}")
+    def apiGetExtension(extensionId: str):
+        registry = getExtensionRegistry()
+        ext = registry.get(extensionId)
+        if ext is None:
+            raise HTTPException(status_code=404, detail="Extension not found")
+        return ext.serialize()
+
+    @router.delete("/api/extensions/{extensionId}")
+    def apiUnregisterExtension(extensionId: str):
+        registry = getExtensionRegistry()
+        removed = registry.unregister(extensionId)
+        if not removed:
+            raise HTTPException(status_code=404, detail="Extension not found")
+        return {"ok": True}
+
+    @router.get("/api/extensions/capability/{capability}")
+    def apiExtensionsByCapability(capability: str):
+        registry = getExtensionRegistry()
+        try:
+            cap = ExtensionCapability(capability)
+        except ValueError:
+            raise HTTPException(status_code=400, detail=f"Unknown capability: {capability}")
+        extensions = registry.listByCapability(cap)
+        return {"extensions": [e.serialize() for e in extensions]}
+
+    return router

src/codaro/extensions/__init__.py

@@ -0,0 +1,9 @@
+from .registry import ExtensionRegistry, getExtensionRegistry
+from .models import Extension, ExtensionCapability
+
+__all__ = [
+    "Extension",
+    "ExtensionCapability",
+    "ExtensionRegistry",
+    "getExtensionRegistry",
+]

src/codaro/extensions/models.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class ExtensionCapability(str, Enum):
+    TOOL = "tool"
+    RENDERER = "renderer"
+    PANEL = "panel"
+    COMMAND = "command"
+    PROVIDER = "provider"
+    THEME = "theme"
+
+
+@dataclass(frozen=True)
+class Extension:
+    id: str = field(default_factory=lambda: f"ext-{uuid.uuid4().hex[:10]}")
+    name: str = ""
+    version: str = "0.0.0"
+    description: str = ""
+    author: str = ""
+    capabilities: tuple[ExtensionCapability, ...] = ()
+    entryPoint: str = ""
+    config: dict[str, Any] = field(default_factory=dict)
+    enabled: bool = True
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "author": self.author,
+            "capabilities": [c.value for c in self.capabilities],
+            "entryPoint": self.entryPoint,
+            "enabled": self.enabled,
+        }