aimakeall-mcp 0.2.0 → 0.3.0

package/README.md

@@ -16,7 +16,7 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
   "mcpServers": {
     "aimakeall": {
       "command": "npx",
-      "args": ["-y", "aimakeall-mcp@0.2.0"],
+      "args": ["-y", "aimakeall-mcp@0.3.0"],
       "env": { "AIMAKEALL_PAT": "aio_pat_..." }
     }
   }

package/lib/api-client.mjs

@@ -139,5 +139,77 @@ export function createApiClient({ apiBase, pat }) {
     return payload;
   }
 
-  return { request, requestBinary, requestStreamUpload };
+  // SSE(text/event-stream) 라우트 — `data: {json}` 프레임을 순서대로 파싱한다.
+  // 서버는 게이트(인증/플랜/기계정책) 실패는 SSE 이전 일반 JSON 으로, 그 이후의
+  // 실패는 HTTP 200 스트림 안 {type:"error"} 프레임으로 보낸다. 둘 다 예외로 변환.
+  async function requestSse(pathName, { body, timeoutMs = DEFAULT_TIMEOUT_MS, onEvent } = {}) {
+    const response = await fetch(`${apiBase}${pathName}`, {
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      headers: {
+        Authorization: `Bearer ${pat}`,
+        "X-AImakeAll-MCP-Version": MCP_PROXY_VERSION,
+        ...(body !== undefined ? { "Content-Type": "application/json" } : {}),
+      },
+      method: "POST",
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    const contentType = String(response.headers.get("content-type") || "");
+    if (!contentType.includes("text/event-stream")) {
+      const text = await response.text();
+      let payload = null;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch {
+        payload = null;
+      }
+      throw new AimakeallApiError(describeApiFailure(response.status, payload), {
+        errorCode: String(payload?.error || ""),
+        retryAfterSeconds: Number(payload?.retryAfterSeconds) || 0,
+        status: response.status,
+      });
+    }
+    const events = [];
+    let result = null;
+    let buffer = "";
+    const decoder = new TextDecoder();
+    try {
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let frameEnd;
+      while ((frameEnd = buffer.indexOf("\n\n")) >= 0) {
+        const frame = buffer.slice(0, frameEnd);
+        buffer = buffer.slice(frameEnd + 2);
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data:")) continue;
+          let payload = null;
+          try {
+            payload = JSON.parse(line.slice(5).trim());
+          } catch {
+            continue;
+          }
+          if (!payload || typeof payload !== "object") continue;
+          if (payload.type === "error") {
+            throw new AimakeallApiError(String(payload.message || payload.error || "스트리밍 생성 중 오류가 발생했습니다."), {
+              errorCode: "SSE_ERROR",
+              status: 200,
+            });
+          }
+          events.push(payload);
+          if (payload.type === "result") result = payload.result;
+          onEvent?.(payload);
+        }
+      }
+    }
+    } catch (error) {
+      if (error instanceof AimakeallApiError) throw error;
+      // 스트림 중단(idle timeout·네트워크) — 서버에서는 생성이 계속 완료·과금됐을 수 있다.
+      throw new AimakeallApiError(
+        "스트리밍 수신이 중단되었습니다. 서버에서는 생성이 계속 완료되어 과금됐을 수 있으니, 무작정 재시도하지 말고 계정 사용량/결과를 먼저 확인하세요.",
+        { errorCode: "SSE_INTERRUPTED", status: 0 },
+      );
+    }
+    return { events, result };
+  }
+
+  return { request, requestBinary, requestSse, requestStreamUpload };
 }

package/lib/cloud-tools.mjs

@@ -13,6 +13,7 @@ import {
   encodedDataUrlBytes,
   fileToDataUrl,
   fileToImagePayload,
+  guessMimeType,
   saveMediaBuffer,
   savePayloadHandle,
   SERVER_JSON_BODY_LIMIT_BYTES,
@@ -999,4 +1000,284 @@ export function registerCloudTools(server, config, api) {
       return jsonResult({ count: voices.length, provider, voices });
     }),
   );
+
+  // ── 인플루언서(소울) 스튜디오 ────────────────────────────────────────────────
+  server.tool(
+    "create_influencer_character",
+    "참조 사진으로 인플루언서(소울) 캐릭터를 학습 등록합니다. 학습 비용 $2.50(1회성) — 실패 시 자동 재시도 금지(중복 과금). 등록 후 influencer_character_status로 completed까지 10초 간격 폴링하세요 (수 분 소요).",
+    {
+      name: z.string().min(1).describe("캐릭터 이름"),
+      photoPaths: z.array(z.string()).min(5).max(18).describe("동일 인물 사진 로컬 경로 5~18장 (jpg/png/webp)"),
+    },
+    wrapCloudHandler(config, async ({ name, photoPaths }) => {
+      for (const filePath of photoPaths) assertAllowedInputFile(filePath, ALLOWED_IMAGE_EXTS, { kind: "참조 사진" });
+      const publicUrls = [];
+      // 업로드 URL 발급은 사진 수만큼 쓰기 슬롯(20/분)을 쓰므로, 분당 한도에 걸리면
+      // retryAfterSeconds 만큼 대기 후 이어서 진행한다(발급된 URL 은 보존).
+      const issueUploadUrl = async (mime) => {
+        for (let attempt = 0; ; attempt += 1) {
+          try {
+            return await api.request("/api/tracker/higgsfield/files/generate-upload-url", {
+              body: { content_type: mime },
+              method: "POST",
+              timeoutMs: 30_000,
+            });
+          } catch (error) {
+            if (error instanceof AimakeallApiError && error.errorCode === "MACHINE_RATE_LIMITED" && attempt < 3) {
+              await new Promise((resolve) => setTimeout(resolve, Math.max(1, error.retryAfterSeconds || 10) * 1000));
+              continue;
+            }
+            throw error;
+          }
+        }
+      };
+      // presigned PUT(직접) — 컴패니언 불필요.
+      for (const filePath of photoPaths) {
+        const mime = guessMimeType(filePath, "image/jpeg");
+        const issued = await issueUploadUrl(mime);
+        const uploadUrl = String(issued?.upload_url || "");
+        const publicUrl = String(issued?.public_url || "");
+        if (!uploadUrl || !publicUrl) {
+          return textResult("업로드 URL 발급에 실패했습니다. Higgsfield API 키 연결을 확인하세요.", { isError: true });
+        }
+        const put = await fetch(uploadUrl, {
+          body: readFileSync(filePath),
+          headers: { "Content-Type": mime },
+          method: "PUT",
+          signal: AbortSignal.timeout(120_000),
+        });
+        if (!put.ok) {
+          return textResult(`사진 업로드 실패 (HTTP ${put.status}): ${path.basename(filePath)}`, { isError: true });
+        }
+        publicUrls.push(publicUrl);
+      }
+      let payload;
+      try {
+        // 서버의 업스트림 창(90s)보다 길게 잡아, 클라이언트가 먼저 끊어 "성공했는데
+        // 실패로 오인 → 재시도 → 중복 과금($2.50)" 되는 상황을 방지한다.
+        payload = await api.request("/api/tracker/higgsfield/v1/custom-references", {
+          body: { input_images: publicUrls.map((url) => ({ image_url: url, type: "image_url" })), name },
+          method: "POST",
+          timeoutMs: 120_000,
+        });
+      } catch (error) {
+        const reason = String(error?.message || error);
+        return textResult(
+          `캐릭터 학습 등록 요청이 실패했습니다: ${reason}\n재시도 전에 반드시 list_influencer_characters로 캐릭터가 이미 생성됐는지 확인하세요 — 생성돼 있다면 재시도는 중복 과금($2.50)입니다.`,
+          { isError: true },
+        );
+      }
+      const referenceId = String(payload?.id || payload?.reference_id || "");
+      if (!referenceId) return textResult("캐릭터 학습 등록 응답에 ID가 없습니다. list_influencer_characters로 생성 여부를 확인하세요.", { isError: true });
+      return jsonResult({
+        costUsd: payload?.costUsd,
+        next: "influencer_character_status를 10초 간격으로 폴링해 completed를 기다리세요. 이 호출을 재시도하면 중복 과금됩니다.",
+        photoCount: publicUrls.length,
+        referenceId,
+        status: payload?.status,
+      });
+    }),
+  );
+
+  server.tool(
+    "influencer_character_status",
+    "소울 캐릭터 학습 상태를 조회합니다 (terminal: completed | failed).",
+    { referenceId: z.string().min(1) },
+    wrapCloudHandler(config, async ({ referenceId }) => {
+      const payload = await api.request(`/api/tracker/higgsfield/v1/custom-references/${encodeURIComponent(referenceId)}`, {
+        method: "GET",
+        timeoutMs: 30_000,
+      });
+      return jsonResult({
+        name: payload?.name,
+        referenceId,
+        status: payload?.status,
+        thumbnailUrl: payload?.thumbnail_url,
+      });
+    }),
+  );
+
+  server.tool(
+    "list_influencer_characters",
+    "등록된 소울 캐릭터 목록을 조회합니다. (machine 토큰은 서버 경유로 만든 캐릭터만 상세 조회·생성에 사용 가능)",
+    { page: z.number().int().min(1).optional().describe("기본 1") },
+    wrapCloudHandler(config, async ({ page = 1 }) => {
+      const payload = await api.request(`/api/tracker/higgsfield/v1/custom-references/list?page=${page}&page_size=50`, {
+        method: "GET",
+        timeoutMs: 30_000,
+      });
+      return jsonResult({
+        characters: (Array.isArray(payload?.items) ? payload.items : []).map((item) => ({
+          id: item?.id,
+          name: item?.name,
+          status: item?.status,
+        })),
+        page,
+        totalPages: payload?.total_pages,
+      });
+    }),
+  );
+
+  server.tool(
+    "suggest_influencer_prompts",
+    "소울 이미지용 연출·프롬프트 10종을 추천받습니다. 반환 prompt는 부정규칙까지 완성형이므로 generate_influencer_image에 그대로 쓰세요.",
+    {
+      gender: z.enum(["여자", "남자"]),
+      ageRange: z.enum(["10대", "20대", "30대", "40대", "50대", "60대"]),
+      keyword: z.string().min(1).describe("장면 키워드 (예: 카페에서 책 읽는 모습)"),
+    },
+    wrapCloudHandler(config, async ({ gender, ageRange, keyword }) => {
+      const { events } = await api.requestSse("/api/tracker/gemini/soul-prompts", {
+        body: { ageRange, gender, imageModel: "soul", keyword },
+        timeoutMs: 180_000,
+      });
+      const items = events
+        .filter((event) => event?.type === "item" && event.item)
+        .map((event) => ({ directing: event.item.directing, id: event.item.id, prompt: event.item.prompt }));
+      if (!items.length) return textResult("프롬프트 추천 결과가 비어 있습니다.", { isError: true });
+      return jsonResult({ count: items.length, items });
+    }),
+  );
+
+  server.tool(
+    "generate_influencer_image",
+    "학습 완료(completed)된 소울 캐릭터로 인플루언서 이미지를 생성합니다 (720p $0.094/장, 1080p $0.19/장). 반환 requestId를 influencer_image_status로 폴링하세요 (~30초).",
+    {
+      prompt: z.string().min(1).describe("영문 프롬프트 (suggest_influencer_prompts 결과 그대로 권장)"),
+      referenceId: z.string().min(1).describe("completed 상태의 캐릭터 referenceId"),
+      aspectRatio: z.enum(["9:16", "16:9", "4:3", "3:4", "1:1", "2:3", "3:2"]).optional().describe("기본 4:3"),
+      resolution: z.enum(["720p", "1080p"]).optional().describe("기본 720p"),
+      imageReferenceUrl: z.string().optional().describe("구도/씬 참조 이미지 URL (선택)"),
+      seed: z.number().int().optional().describe("재현용 시드 (선택)"),
+    },
+    wrapCloudHandler(config, async ({ prompt, referenceId, aspectRatio = "4:3", resolution = "720p", imageReferenceUrl = "", seed }) => {
+      const payload = await api.request("/api/tracker/higgsfield/higgsfield-ai/soul/character", {
+        body: {
+          aspect_ratio: aspectRatio,
+          batch_size: 1,
+          custom_reference_id: referenceId,
+          custom_reference_strength: 1,
+          enhance_prompt: false,
+          ...(imageReferenceUrl ? { image_reference_url: imageReferenceUrl } : {}),
+          prompt,
+          resolution,
+          ...(seed !== undefined ? { seed } : {}),
+        },
+        method: "POST",
+        timeoutMs: 60_000,
+      });
+      const requestId = String(payload?.request_id || payload?.id || "");
+      if (!requestId) return textResult("이미지 생성 요청 응답에 request_id가 없습니다.", { isError: true });
+      return jsonResult({ costUsd: payload?.costUsd, requestId, status: payload?.status });
+    }),
+  );
+
+  server.tool(
+    "influencer_image_status",
+    "소울 이미지 생성 상태를 조회합니다 (terminal: completed | failed | nsfw | canceled). 결과 이미지는 만료 없는 공개 URL입니다.",
+    { requestId: z.string().min(1) },
+    wrapCloudHandler(config, async ({ requestId }) => {
+      const payload = await api.request(`/api/tracker/higgsfield/requests/${encodeURIComponent(requestId)}/status`, {
+        method: "GET",
+        timeoutMs: 30_000,
+      });
+      return jsonResult({
+        error: payload?.error || payload?.message || undefined,
+        imageUrls: (Array.isArray(payload?.images) ? payload.images : []).map((image) => image?.url).filter(Boolean),
+        progress: payload?.progress,
+        requestId,
+        status: payload?.status,
+      });
+    }),
+  );
+
+  // ── 상세페이지(PDP) ─────────────────────────────────────────────────────────
+  server.tool(
+    "generate_pdp",
+    "상품 사진으로 상세페이지(PDP) HTML을 생성합니다. 분석→카피→라이프스타일 컷 8장→조립까지 서버가 한 번에 처리하며 3~6분 걸립니다. 결과는 HTML 파일 경로로 반환됩니다 (Pro 스튜디오 기능).",
+    {
+      productName: z.string().min(1).describe("상품명"),
+      productImagePaths: z.array(z.string()).min(2).max(5).describe("상품 사진 로컬 경로 2~5장 (첫 장이 메인)"),
+      modelImagePath: z.string().optional().describe("모델 사진 로컬 경로 (선택 — 사용 장면 컷 레퍼런스)"),
+      description: z.string().optional().describe("부가 설명"),
+      targetCustomer: z.string().optional(),
+      priceRange: z.enum(["~1만원", "1~5만원", "5~10만원", "10~30만원", "30~100만원", "100만원~"]).optional(),
+      coreUsp: z.string().optional().describe("핵심 USP — 한 줄씩 줄바꿈 구분"),
+      tone: z.enum(["자동 추천", "프리미엄·럭셔리", "친근·일상적", "전문적·신뢰", "감성·스토리", "트렌디·MZ"]).optional().describe("기본 자동 추천"),
+      usePersonaReviews: z.boolean().optional().describe("기본 false. true면 한국인 페르소나 후기 5건으로 대체 (+30초)"),
+      downloadImages: z.boolean().optional().describe("기본 true — 라이프스타일 컷을 로컬 저장하고 HTML src를 로컬 경로로 재작성(원격 URL 만료 대비)"),
+    },
+    wrapCloudHandler(config, async ({
+      productName,
+      productImagePaths,
+      modelImagePath = "",
+      description = "",
+      targetCustomer = "",
+      priceRange = "",
+      coreUsp = "",
+      tone = "자동 추천",
+      usePersonaReviews = false,
+      downloadImages = true,
+    }) => {
+      for (const filePath of productImagePaths) assertAllowedInputFile(filePath, ALLOWED_IMAGE_EXTS, { kind: "상품 사진" });
+      if (modelImagePath) assertAllowedInputFile(modelImagePath, ALLOWED_IMAGE_EXTS, { kind: "모델 사진" });
+      assertEncodedBudget([...productImagePaths, modelImagePath], { context: "상품/모델 사진" });
+
+      const { result } = await api.requestSse("/api/tracker/pdp/generate", {
+        body: {
+          coreUsp,
+          description,
+          modelImage: modelImagePath ? fileToImagePayload(modelImagePath) : null,
+          priceRange,
+          productImages: productImagePaths.map((filePath) => fileToImagePayload(filePath)),
+          productName,
+          targetCustomer,
+          tone,
+          usePersonaReviews,
+        },
+        timeoutMs: 900_000,
+      });
+      if (!result?.html) return textResult("PDP 생성 결과가 비어 있습니다. 잠시 후 다시 시도하세요.", { isError: true });
+
+      let html = String(result.html);
+      const savedImages = [];
+      if (downloadImages) {
+        // 렌더러가 URL 을 HTML 이스케이프(&→&amp; 등)해 넣었을 수 있으므로 두 형태 모두 치환.
+        const escapeHtml = (value) => value
+          .replaceAll("&", "&amp;")
+          .replaceAll("<", "&lt;")
+          .replaceAll(">", "&gt;")
+          .replaceAll('"', "&quot;")
+          .replaceAll("'", "&#39;");
+        for (const image of Array.isArray(result.lifestyleImages) ? result.lifestyleImages : []) {
+          const url = String(image?.url || "");
+          if (!url) continue;
+          try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(60_000) });
+            if (!res.ok) continue;
+            const buf = Buffer.from(await res.arrayBuffer());
+            const ext = String(res.headers.get("content-type") || "").includes("png") ? "png" : "jpg";
+            const saved = saveMediaBuffer(config.stateDir, `pdp-image-${image?.idx ?? savedImages.length + 1}.${ext}`, buf);
+            // HTML 은 같은 디렉터리에 저장되므로 상대경로 치환으로 자립형 유지.
+            const local = `./${path.basename(saved.filePath)}`;
+            const before = html;
+            html = html.split(url).join(local).split(escapeHtml(url)).join(local);
+            if (html !== before) savedImages.push(saved.filePath);
+          } catch {
+            // 다운로드 실패한 컷은 원격 URL 유지
+          }
+        }
+      }
+      const savedHtml = saveMediaBuffer(config.stateDir, "pdp.html", Buffer.from(html, "utf8"), { contentType: "text/html" });
+      return jsonResult({
+        analysis: trimAnalysis(result.analysis),
+        heroHeadline: result?.copy?.heroHeadline,
+        htmlPath: savedHtml.filePath,
+        imageCount: (Array.isArray(result.lifestyleImages) ? result.lifestyleImages : []).filter((image) => image?.url).length,
+        localImages: savedImages.length,
+        note: "htmlPath와 로컬 이미지들은 48시간 뒤 자동 정리되는 스테이징 폴더에 있습니다. 보존하려면 같은 폴더의 이미지들과 함께 원하는 위치로 복사하세요.",
+        tagline: result?.copy?.tagline,
+      });
+    }),
+  );
 }

package/lib/config.mjs

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 // 프록시 버전 — 서버가 X-AImakeAll-MCP-Version 으로 하한을 강제(426)할 수 있다.
-export const MCP_PROXY_VERSION = "0.2.0";
+export const MCP_PROXY_VERSION = "0.3.0";
 
 export const DEFAULT_API_BASE = "https://aimakeall.com";
 export const DEFAULT_COMPANION_URL = "http://127.0.0.1:9876";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimakeall-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AImakeAll MCP 서버 — Claude Code/Codex에서 자연어로 영상 기획·생성·렌더·퍼블리시 (렌더는 로컬 컴패니언)",
   "type": "module",
   "bin": {