albabot-mcp 1.2.0 → 1.2.1

package/Todo.md

@@ -1,22 +1,25 @@
-# AlbaBot MCP — Todo
-
-## 🔴 미구현 (High Priority)
-- [x] **Twitter/X API 연동** — 클레임 성공 시 트윗 자동 게시
-    - [ ] Twitter Developer Portal에서 앱 생성 및 API 키 발급
-    - [ ] Vercel 환경변수에 Twitter API 키 등록 (`TWITTER_API_KEY`, `TWITTER_API_SECRET`, `TWITTER_ACCESS_TOKEN`, `TWITTER_ACCESS_TOKEN_SECRET`)
-    - [x] Twitter API v2 게시 코드 구현 (`api/lib/twitter.ts` + `api/claim.ts`에 연동)
-    - [x] 게시 내용 템플릿 작성 (예: "🤖 {agent_name} 에이전트가 @{owner} 에 의해 활성화되었습니다! #AlbaBot")
-
-## 🟡 개선 사항 (Medium Priority)
-- [ ] Twitter OAuth 실제 인증 구현 (현재는 핸들 직접 입력 방식)
-- [x] 디버그 엔드포인트 정리/제거 (`api/v1/debug/`)
-- [x] 에러 응답에서 `debug` 필드 프로덕션 환경에서 제거
-
-## 🟢 완료
-- [x] 에이전트 등록 (`register_agent`)
-- [x] 클레임 상태 확인 (`check_claim_status`)
-- [x] 프로필 조회/수정 (`get_agent_profile`, `update_agent_profile`)
-- [x] 작업 검색 (`search_jobs`)
-- [x] 작업 지원/딜 (`apply_job`)
-- [x] 클레임 URL 및 소유권 확인 페이지 (`/claim/:token`)
-- [x] Swagger 문서 업데이트
+# AlbaBot MCP — Todo
+
+## 🔴 미구현 (High Priority)
+- [x] Twitter/X API 연동 — 클레임 성공 시 트윗 자동 게시
+- [x] **봇 입력 스키마 (`input_schema`) 지원** (PRISM 연동 필수)
+    - [x] `agents` 테이블에 `input_schema` (JSONB) 컬럼 추가
+    - [x] `register_agent`, `update_agent_profile` API에 `input_schema` 파라미터 추가
+    - [x] 의뢰 프로세스에서 스키마 기반 입력 폼 렌더링 및 `job.metadata` 저장 로직 설계
+- [x] **작업 진행 상태 및 결과 전달 API 개선** (PRISM 연동 필수)
+    - [x] `PUT /jobs/{id}/status`: 에이전트가 직접 상태 변경 가능하게 구현
+    - [x] `POST /jobs/{id}/deliver`: 결과물(HTML/PDF URL 등) 전달 전용 API 구현 (apply와 분리)
+
+## 🟡 개선 사항 (Medium Priority)
+- [ ] Twitter OAuth 실제 인증 구현 (현재는 핸들 직접 입력 방식)
+- [x] 디버그 엔드포인트 정리/제거 (`api/v1/debug/`)
+- [x] 에러 응답에서 `debug` 필드 프로덕션 환경에서 제거
+- [x] **Webhook 알림 방식 지원** (완료)
+    - [x] 봇 설정에 `webhook_url` 필드 추가
+    - [x] 새 작업 발생 시 등록된 URL로 POST 요청 전송
+- [x] **결과물 파일 직접 업로드 API** (완료)
+    - [x] POST `/api/v1/jobs/upload` API 구현
+    - [x] `upload_job_result` MCP 도구 추가
+    - [x] 저장소 버킷 생성 (`results`, `uploads`)
+    - [x] 데이터베이스 스키마 마이그레이션 완료
+- [x] Swagger 및 MCP Tool 업데이트 완료

package/api/v1/agents/me.ts

@@ -89,6 +89,9 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
                     status: agent.status,
                     owner_x_handle: agent.owner_x_handle || null,
                     manager_phone: agent.manager_phone || null,
+                    input_schema: agent.input_schema || null,
+                    webhook_url: agent.webhook_url || null,
+                    youtube_url: agent.youtube_url || null,
                     ethics_agreed_at: agent.ethics_agreed_at || null,
                     profile_url: `https://albabot-mcp.vercel.app/agent/${agent.name}`,
                     created_at: agent.created_at,
@@ -109,13 +112,16 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
             if (req.body?.monthly_price !== undefined) updates.monthly_price = req.body.monthly_price ?? null;
             if (req.body?.monthly_task_limit !== undefined) updates.monthly_task_limit = req.body.monthly_task_limit ?? null;
             if (req.body?.manager_phone) updates.manager_phone = req.body.manager_phone;
+            if (req.body?.input_schema !== undefined) updates.input_schema = req.body.input_schema || null;
+            if (req.body?.webhook_url !== undefined) updates.webhook_url = req.body.webhook_url || null;
+            if (req.body?.youtube_url !== undefined) updates.youtube_url = req.body.youtube_url || null;
             if (req.body?.ai_collab !== undefined) updates.ai_collab = req.body.ai_collab === true;
 
             if (Object.keys(updates).length === 0) {
                 return res.status(400).json({
                     success: false,
                     error: "수정할 항목이 없습니다.",
-                    hint: "name, description, skills, image_url, solana_wallet, price_per_task, monthly_price, monthly_task_limit, manager_phone 중 하나 이상 전달하세요.",
+                    hint: "name, description, skills, image_url, solana_wallet, price_per_task, monthly_price, monthly_task_limit, manager_phone, input_schema 중 하나 이상 전달하세요.",
                 });
             }
 
@@ -154,6 +160,9 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
                     status: updated.status,
                     owner_x_handle: updated.owner_x_handle || null,
                     manager_phone: updated.manager_phone || null,
+                    input_schema: updated.input_schema || null,
+                    webhook_url: updated.webhook_url || null,
+                    youtube_url: updated.youtube_url || null,
                     ethics_agreed_at: updated.ethics_agreed_at || null,
                     profile_url: `https://albabot-mcp.vercel.app/agent/${updated.name}`,
                     created_at: updated.created_at,

package/api/v1/agents/outcomes.ts

@@ -0,0 +1,149 @@
+import { createClient } from "@supabase/supabase-js";
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+
+function getSupabase() {
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!url || !key) throw new Error("Supabase 환경변수가 설정되지 않았습니다.");
+    return createClient(url, key);
+}
+
+function extractApiKey(req: VercelRequest): string | null {
+    const auth = req.headers.authorization;
+    if (!auth?.startsWith("Bearer ")) return null;
+    return auth.slice(7).trim();
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") return res.status(200).end();
+
+    try {
+        const apiKey = extractApiKey(req);
+        if (!apiKey) {
+            return res.status(401).json({ success: false, error: "Authorization 헤더가 필요합니다." });
+        }
+
+        const supabase = getSupabase();
+
+        // 1. 에이전트 인증
+        const { data: agent, error: authError } = await supabase
+            .from("agents")
+            .select("id")
+            .eq("api_key", apiKey)
+            .single();
+
+        if (authError || !agent) {
+            return res.status(401).json({ success: false, error: "유효하지 않은 API 키입니다." });
+        }
+
+        // --- GET: 결과물 리스트 조회 ---
+        if (req.method === "GET") {
+            const { data, error } = await supabase
+                .from("agent_outcomes")
+                .select("*")
+                .eq("agent_id", agent.id)
+                .order("created_at", { ascending: false });
+
+            if (error) return res.status(500).json({ success: false, error: error.message });
+            return res.status(200).json({ success: true, outcomes: data });
+        }
+
+        // --- POST: 새 결과물 이미지 업로드 ---
+        if (req.method === "POST") {
+            const { fileData, fileName, contentType, description } = req.body || {};
+
+            if (!fileData || !fileName) {
+                return res.status(400).json({ success: false, error: "fileData(base64)와 fileName은 필수입니다." });
+            }
+
+            // Base64 디코딩
+            const base64Content = fileData.includes("base64,") ? fileData.split("base64,")[1] : fileData;
+            const buffer = Buffer.from(base64Content, "base64");
+
+            // Storage 업로드 (버킷: outcomes)
+            const storagePath = `${agent.id}/${Date.now()}_${fileName}`;
+            const { data: uploadData, error: uploadError } = await supabase.storage
+                .from("outcomes")
+                .upload(storagePath, buffer, {
+                    contentType: contentType || "image/png",
+                    upsert: true
+                });
+
+            if (uploadError) {
+                return res.status(500).json({ 
+                    success: false, 
+                    error: `Storage 업로드 실패: ${uploadError.message}`,
+                    hint: "Supabase에 'outcomes' 퍼블릭 버킷이 생성되어 있는지 확인하세요."
+                });
+            }
+
+            // Public URL
+            const { data: { publicUrl } } = supabase.storage.from("outcomes").getPublicUrl(storagePath);
+
+            // DB 기록
+            const { data: dbData, error: dbError } = await supabase
+                .from("agent_outcomes")
+                .insert({
+                    agent_id: agent.id,
+                    image_url: publicUrl,
+                    storage_path: storagePath,
+                    description: description || null
+                })
+                .select()
+                .single();
+
+            if (dbError) {
+                // DB 기록 실패 시 Storage 파일 삭제 시도
+                await supabase.storage.from("outcomes").remove([storagePath]);
+                return res.status(500).json({ success: false, error: `DB 저장 실패: ${dbError.message}` });
+            }
+
+            return res.status(201).json({ success: true, outcome: dbData });
+        }
+
+        // --- DELETE: 결과물 삭제 ---
+        if (req.method === "DELETE") {
+            const { id } = req.body || {};
+            if (!id) return res.status(400).json({ success: false, error: "삭제할 outcome id가 필요합니다." });
+
+            // 해당 항목 조회 및 소유권 확인
+            const { data: outcome, error: fetchError } = await supabase
+                .from("agent_outcomes")
+                .select("*")
+                .eq("id", id)
+                .eq("agent_id", agent.id)
+                .single();
+
+            if (fetchError || !outcome) {
+                return res.status(404).json({ success: false, error: "해당 결과물을 찾을 수 없거나 권한이 없습니다." });
+            }
+
+            // Storage에서 삭제
+            const { error: storageDeleteError } = await supabase.storage
+                .from("outcomes")
+                .remove([outcome.storage_path]);
+
+            // DB에서 삭제
+            const { error: dbDeleteError } = await supabase
+                .from("agent_outcomes")
+                .delete()
+                .eq("id", id);
+
+            if (dbDeleteError) return res.status(500).json({ success: false, error: dbDeleteError.message });
+
+            return res.status(200).json({ success: true, message: "결과물 이미지가 삭제되었습니다." });
+        }
+
+        return res.status(405).json({ success: false, error: "Method not allowed" });
+
+    } catch (err) {
+        console.error("outcomes handler error:", err);
+        return res.status(500).json({
+            success: false,
+            error: err instanceof Error ? err.message : "Internal server error",
+        });
+    }
+}

package/api/v1/agents/register.ts

@@ -43,7 +43,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
         if (req.method === "POST") {
             const supabase = getSupabase();
 
-            const { name, description, skills, image_url, solana_wallet, manager_phone, ethics_agreed, price_per_task, monthly_price, monthly_task_limit } = req.body || {};
+            const { name, description, skills, image_url, solana_wallet, manager_phone, input_schema, webhook_url, youtube_url, ethics_agreed, price_per_task, monthly_price, monthly_task_limit } = req.body || {};
             if (!name || !description || !image_url || !solana_wallet || !manager_phone) {
                 return res.status(400).json({
                     success: false,
@@ -82,6 +82,9 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
                     api_key,
                     claim_token,
                     verification_code,
+                    input_schema: input_schema || null,
+                    webhook_url: webhook_url || null,
+                    youtube_url: youtube_url || null,
                 })
                 .select()
                 .single();

package/api/v1/jobs/create.ts

@@ -51,7 +51,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
             });
         }
 
-        const { title, description, jobType, category, price, priceType, location, requiredSkills } = req.body || {};
+        const { title, description, jobType, category, price, priceType, location, requiredSkills, metadata } = req.body || {};
 
         if (!title || !description || price === undefined) {
             return res.status(400).json({
@@ -71,6 +71,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
                 price_type: priceType || "per_task",
                 location: location || "remote",
                 required_skills: requiredSkills || [],
+                metadata: metadata || null,
                 client_id: agent.id,
             })
             .select()
@@ -80,6 +81,43 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
             return res.status(500).json({ success: false, error: insertError.message });
         }
 
+        // --- Webhook 알림 전송 (배경) ---
+        // 봇 타입이고 webhook_url이 있는 에이전트 조회
+        const { data: bots } = await supabase
+            .from("agents")
+            .select("name, webhook_url")
+            .eq("agent_type", "bot")
+            .not("webhook_url", "is", null);
+
+        if (bots && bots.length > 0) {
+            const payload = {
+                event: "job.created",
+                job: {
+                    id: job.id,
+                    title: job.title,
+                    description: job.description,
+                    job_type: job.job_type,
+                    category: job.category,
+                    price: job.price,
+                    price_type: job.price_type,
+                    location: job.location,
+                    required_skills: job.required_skills,
+                    metadata: job.metadata,
+                    created_at: job.created_at,
+                },
+                source: "AlbaBot central",
+            };
+
+            // 모든 봇에게 알림 전송 (실패해도 응답에는 영향 없음)
+            Promise.allSettled(bots.map(bot => 
+                fetch(bot.webhook_url as string, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(payload),
+                }).catch(err => console.error(`Webhook failed for ${bot.name}:`, err))
+            )).catch(err => console.error("Webhook promise error:", err));
+        }
+
         return res.status(201).json({
             success: true,
             message: "작업이 등록되었습니다. 에스크로 결제 후 구인이 시작됩니다.",
@@ -93,6 +131,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
                 price_type: job.price_type,
                 location: job.location,
                 required_skills: job.required_skills,
+                metadata: job.metadata,
                 status: job.status,
                 created_at: job.created_at,
             },

package/api/v1/jobs/deliver.ts

@@ -0,0 +1,114 @@
+import { createClient } from "@supabase/supabase-js";
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+
+function getSupabase() {
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!url || !key) throw new Error("Supabase 환경변수가 설정되지 않았습니다.");
+    return createClient(url, key);
+}
+
+function extractApiKey(req: VercelRequest): string | null {
+    const auth = req.headers.authorization;
+    if (!auth?.startsWith("Bearer ")) return null;
+    return auth.slice(7).trim();
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") return res.status(200).end();
+
+    if (req.method !== "POST") {
+        return res.status(405).json({ success: false, error: "Method not allowed" });
+    }
+
+    try {
+        const apiKey = extractApiKey(req);
+        if (!apiKey) {
+            return res.status(401).json({
+                success: false,
+                error: "Authorization 헤더가 필요합니다.",
+                hint: "Authorization: Bearer YOUR_API_KEY",
+            });
+        }
+
+        const supabase = getSupabase();
+
+        // API 키 유효성 확인
+        const { data: agent, error: authError } = await supabase
+            .from("agents")
+            .select("id")
+            .eq("api_key", apiKey)
+            .single();
+
+        if (authError || !agent) {
+            return res.status(404).json({
+                success: false,
+                error: "유효하지 않은 API 키입니다.",
+            });
+        }
+
+        const { jobId, resultUrl, resultMessage } = req.body || {};
+
+        if (!jobId || (!resultUrl && !resultMessage)) {
+            return res.status(400).json({
+                success: false,
+                error: "jobId와 (resultUrl 또는 resultMessage)가 필요합니다.",
+            });
+        }
+
+        // 작업 권한 및 상태 확인
+        const { data: job, error: jobError } = await supabase
+            .from("jobs")
+            .select("worker_id, status")
+            .eq("id", jobId)
+            .single();
+
+        if (jobError || !job) {
+            return res.status(404).json({ success: false, error: "작업을 찾을 수 없습니다." });
+        }
+
+        if (job.worker_id !== agent.id) {
+            return res.status(403).json({
+                success: false,
+                error: "작업 수행자만 결과를 전달할 수 있습니다.",
+            });
+        }
+
+        // 결과 업데이트 및 상태 완료 변경
+        const { data: updated, error: updateError } = await supabase
+            .from("jobs")
+            .update({
+                status: "completed",
+                result_url: resultUrl || null,
+                result_message: resultMessage || null,
+                completed_at: new Date().toISOString(),
+            })
+            .eq("id", jobId)
+            .select()
+            .single();
+
+        if (updateError) {
+            return res.status(500).json({ success: false, error: updateError.message });
+        }
+
+        return res.status(200).json({
+            success: true,
+            message: "작업 결과가 전달되었으며 작업이 완료되었습니다.",
+            job: {
+                id: updated.id,
+                status: updated.status,
+                result_url: updated.result_url,
+                result_message: updated.result_message,
+            },
+        });
+    } catch (err) {
+        console.error("jobs/deliver handler error:", err);
+        return res.status(500).json({
+            success: false,
+            error: err instanceof Error ? err.message : "Internal server error",
+        });
+    }
+}

package/api/v1/jobs/status.ts

@@ -16,14 +16,10 @@ function extractApiKey(req: VercelRequest): string | null {
 
 export default async function handler(req: VercelRequest, res: VercelResponse) {
     res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
     if (req.method === "OPTIONS") return res.status(200).end();
 
-    if (req.method !== "GET") {
-        return res.status(405).json({ success: false, error: "Method not allowed" });
-    }
-
     try {
         const apiKey = extractApiKey(req);
         if (!apiKey) {
@@ -51,52 +47,104 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
             });
         }
 
-        const jobId = req.query.jobId as string;
+        const jobId = (req.query.jobId as string) || (req.body?.jobId as string);
         if (!jobId) {
             return res.status(400).json({
                 success: false,
-                error: "jobId 쿼리 파라미터가 필요합니다.",
+                error: "jobId가 필요합니다. (query 또는 body)",
             });
         }
 
-        // 작업 상세 조회
-        const { data: job, error: jobError } = await supabase
-            .from("jobs")
-            .select("*")
-            .eq("id", jobId)
-            .single();
+        // --- GET: 작업 상세 조회 ---
+        if (req.method === "GET") {
+            const { data: job, error: jobError } = await supabase
+                .from("jobs")
+                .select("*")
+                .eq("id", jobId)
+                .single();
 
-        if (jobError || !job) {
-            return res.status(404).json({
-                success: false,
-                error: "작업을 찾을 수 없습니다.",
+            if (jobError || !job) {
+                return res.status(404).json({
+                    success: false,
+                    error: "작업을 찾을 수 없습니다.",
+                });
+            }
+
+            const { data: applications } = await supabase
+                .from("applications")
+                .select("id, applicant_id, message, proposed_rate, status, created_at")
+                .eq("job_id", jobId)
+                .order("created_at", { ascending: false });
+
+            return res.status(200).json({
+                success: true,
+                job: {
+                    id: job.id,
+                    title: job.title,
+                    description: job.description,
+                    job_type: job.job_type,
+                    category: job.category,
+                    price: job.price,
+                    status: job.status,
+                    metadata: job.metadata || null,
+                    result_url: job.result_url || null,
+                    result_message: job.result_message || null,
+                    client_id: job.client_id,
+                    worker_id: job.worker_id,
+                    created_at: job.created_at,
+                },
+                applications: applications || [],
+                applicationCount: applications?.length || 0,
             });
         }
 
-        // 해당 작업의 지원 목록 조회
-        const { data: applications } = await supabase
-            .from("applications")
-            .select("id, applicant_id, message, proposed_rate, status, created_at")
-            .eq("job_id", jobId)
-            .order("created_at", { ascending: false });
-
-        return res.status(200).json({
-            success: true,
-            job: {
-                id: job.id,
-                title: job.title,
-                description: job.description,
-                job_type: job.job_type,
-                category: job.category,
-                price: job.price,
-                status: job.status,
-                client_id: job.client_id,
-                worker_id: job.worker_id,
-                created_at: job.created_at,
-            },
-            applications: applications || [],
-            applicationCount: applications?.length || 0,
-        });
+        // --- PUT: 작업 상태 변경 ---
+        if (req.method === "PUT") {
+            const { status } = req.body || {};
+            if (!status) {
+                return res.status(400).json({
+                    success: false,
+                    error: "변경할 status가 필요합니다.",
+                });
+            }
+
+            // 작업 권한 확인 (해당 작업의 수행자만 변경 가능)
+            const { data: job, error: jobError } = await supabase
+                .from("jobs")
+                .select("worker_id, status")
+                .eq("id", jobId)
+                .single();
+
+            if (jobError || !job) {
+                return res.status(404).json({ success: false, error: "작업을 찾을 수 없습니다." });
+            }
+
+            if (job.worker_id !== agent.id) {
+                return res.status(403).json({
+                    success: false,
+                    error: "작업 수행자만 상태를 변경할 수 있습니다.",
+                });
+            }
+
+            const { data: updated, error: updateError } = await supabase
+                .from("jobs")
+                .update({ status })
+                .eq("id", jobId)
+                .select()
+                .single();
+
+            if (updateError) {
+                return res.status(500).json({ success: false, error: updateError.message });
+            }
+
+            return res.status(200).json({
+                success: true,
+                message: "작업 상태가 업데이트되었습니다.",
+                status: updated.status,
+            });
+        }
+
+        return res.status(405).json({ success: false, error: "Method not allowed" });
     } catch (err) {
         console.error("jobs/status handler error:", err);
         return res.status(500).json({