@yoonion/mimi-seed-mcp 0.3.23 → 0.3.25

package/dist/facebook/api.d.ts

@@ -0,0 +1,16 @@
+import type { FacebookConfig } from './config.js';
+export interface FacebookPage {
+    id: string;
+    name: string;
+    category?: string;
+    followers_count?: number;
+    fan_count?: number;
+}
+export interface PostResult {
+    id: string;
+    permalink?: string;
+}
+export declare function getPage(cfg: FacebookConfig): Promise<FacebookPage>;
+export declare function postPhoto(cfg: FacebookConfig, imageUrl: string, caption: string): Promise<PostResult>;
+export declare function postMultiPhoto(cfg: FacebookConfig, imageUrls: string[], caption: string): Promise<PostResult>;
+export declare function listAccessiblePages(userAccessToken: string): Promise<FacebookPage[]>;

package/dist/facebook/api.js

@@ -0,0 +1,98 @@
+const BASE = 'https://graph.facebook.com/v21.0';
+async function fbPost(pageAccessToken, endpoint, params) {
+    const body = new URLSearchParams({ ...params, access_token: pageAccessToken });
+    const res = await fetch(`${BASE}${endpoint}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    const text = await res.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    if (json.error) {
+        const err = json.error;
+        throw new Error(`${err.message} (code ${err.code})`);
+    }
+    return json;
+}
+async function fbGet(pageAccessToken, endpoint, params = {}) {
+    const qs = new URLSearchParams({ ...params, access_token: pageAccessToken });
+    const res = await fetch(`${BASE}${endpoint}?${qs}`);
+    const json = await res.json();
+    if (json.error) {
+        const err = json.error;
+        throw new Error(`${err.message} (code ${err.code})`);
+    }
+    return json;
+}
+export async function getPage(cfg) {
+    const data = await fbGet(cfg.pageAccessToken, `/${cfg.pageId}`, {
+        fields: 'id,name,category,followers_count,fan_count',
+    });
+    return data;
+}
+// Step 1: upload photo as unpublished, returns photo ID
+async function uploadUnpublishedPhoto(cfg, imageUrl) {
+    const result = await fbPost(cfg.pageAccessToken, `/${cfg.pageId}/photos`, {
+        url: imageUrl,
+        published: 'false',
+    });
+    return result.id;
+}
+export async function postPhoto(cfg, imageUrl, caption) {
+    const result = await fbPost(cfg.pageAccessToken, `/${cfg.pageId}/photos`, {
+        url: imageUrl,
+        message: caption,
+        published: 'true',
+    });
+    const postId = result.post_id ?? result.id;
+    let permalink;
+    try {
+        const info = await fbGet(cfg.pageAccessToken, `/${postId}`, { fields: 'permalink_url' });
+        permalink = info.permalink_url;
+    }
+    catch { /* best-effort */ }
+    return { id: postId, permalink };
+}
+export async function postMultiPhoto(cfg, imageUrls, caption) {
+    if (imageUrls.length < 2 || imageUrls.length > 10) {
+        throw new Error('이미지는 2~10장이어야 합니다.');
+    }
+    // Step 1: upload each as unpublished photo
+    const photoIds = [];
+    for (const url of imageUrls) {
+        const id = await uploadUnpublishedPhoto(cfg, url);
+        photoIds.push(id);
+    }
+    // Step 2: create feed post with all photos attached
+    const attachedMedia = photoIds.map(id => JSON.stringify({ media_fbid: id }));
+    const result = await fbPost(cfg.pageAccessToken, `/${cfg.pageId}/feed`, {
+        message: caption,
+        attached_media: `[${attachedMedia.join(',')}]`,
+    });
+    const postId = result.id;
+    let permalink;
+    try {
+        const info = await fbGet(cfg.pageAccessToken, `/${postId}`, { fields: 'permalink_url' });
+        permalink = info.permalink_url;
+    }
+    catch { /* best-effort */ }
+    return { id: postId, permalink };
+}
+// Fetch all pages accessible with a User Access Token
+export async function listAccessiblePages(userAccessToken) {
+    const qs = new URLSearchParams({
+        fields: 'id,name,category',
+        access_token: userAccessToken,
+    });
+    const res = await fetch(`${BASE}/me/accounts?${qs}`);
+    const json = await res.json();
+    if (json.error)
+        throw new Error(`${json.error.message} (code ${json.error.code})`);
+    return json.data ?? [];
+}

package/dist/facebook/config.d.ts

@@ -0,0 +1,9 @@
+export interface FacebookConfig {
+    pageAccessToken: string;
+    pageId: string;
+    pageName?: string;
+    expiresAt?: string;
+}
+export declare function loadFacebookConfig(): FacebookConfig | null;
+export declare function saveFacebookConfig(cfg: FacebookConfig): void;
+export declare function requireFacebookConfig(): FacebookConfig;

package/dist/facebook/config.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const CONFIG_PATH = path.join(os.homedir(), '.mimi-seed', 'facebook.json');
+export function loadFacebookConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveFacebookConfig(cfg) {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+    if (process.platform !== 'win32') {
+        fs.chmodSync(CONFIG_PATH, 0o600);
+    }
+}
+export function requireFacebookConfig() {
+    const cfg = loadFacebookConfig();
+    if (!cfg) {
+        throw new Error('Facebook 설정이 없습니다.\n' +
+            'facebook_save_config 도구로 먼저 설정해주세요.\n' +
+            '예: facebook_save_config(pageAccessToken="EAA...", pageId="...")');
+    }
+    return cfg;
+}

package/dist/index.js

@@ -12,6 +12,7 @@ import { registerBigqueryTools } from './registers/bigquery.js';
 import { registerAuthTools } from './registers/auth.js';
 import { registerCiTools } from './registers/ci.js';
 import { registerInstagramTools } from './registers/instagram.js';
+import { registerFacebookTools } from './registers/facebook.js';
 import { registerPrompts } from './prompts.js';
 import { registerResources } from './resources.js';
 const server = new McpServer({
@@ -29,6 +30,7 @@ registerBigqueryTools(server);
 registerAuthTools(server);
 registerCiTools(server);
 registerInstagramTools(server);
+registerFacebookTools(server);
 registerPrompts(server);
 registerResources(server);
 // `npx -y @yoonion/mimi-seed-mcp <subcommand>` 처리.

package/dist/instagram/api.d.ts

@@ -1,4 +1,5 @@
 import type { InstagramConfig } from './config.js';
+export declare function apiBaseFor(token: string): string;
 export interface InstagramAccount {
     id: string;
     username: string;
@@ -9,6 +10,7 @@ export interface InstagramAccount {
     media_count?: number;
 }
 export declare function getAccount(cfg: InstagramConfig): Promise<InstagramAccount>;
+export declare function fetchUserId(accessToken: string): Promise<string>;
 export interface PublishResult {
     id: string;
     permalink?: string;

package/dist/instagram/api.js

@@ -1,6 +1,14 @@
-const BASE = 'https://graph.facebook.com/v21.0';
-async function igFetch(endpoint, params, method = 'GET') {
-    const url = new URL(`${BASE}${endpoint}`);
+// 두 가지 Meta API:
+//   IGAA... = Instagram API with Instagram Login (2024 신규) — graph.instagram.com
+//   EAA...  = Instagram Graph API via Facebook Login                — graph.facebook.com
+// 토큰 prefix로 자동 분기. 엔드포인트 path는 둘 다 동일.
+export function apiBaseFor(token) {
+    if (token.startsWith('IGAA'))
+        return 'https://graph.instagram.com/v21.0';
+    return 'https://graph.facebook.com/v21.0';
+}
+async function igFetch(token, endpoint, params, method = 'GET') {
+    const url = new URL(`${apiBaseFor(token)}${endpoint}`);
     let body;
     if (method === 'GET') {
         Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
@@ -28,17 +36,36 @@ async function igFetch(endpoint, params, method = 'GET') {
     return JSON.parse(text);
 }
 export async function getAccount(cfg) {
-    return igFetch(`/${cfg.userId}`, {
-        fields: 'id,username,name,profile_picture_url,account_type,followers_count,media_count',
+    // graph.instagram.com 은 name/profile_picture_url 필드를 받지 않을 수 있어
+    // 두 API 공통으로 안전한 필드만 요청
+    const fields = cfg.accessToken.startsWith('IGAA')
+        ? 'id,username,account_type,followers_count,media_count'
+        : 'id,username,name,profile_picture_url,account_type,followers_count,media_count';
+    return igFetch(cfg.accessToken, `/${cfg.userId}`, {
+        fields,
         access_token: cfg.accessToken,
     });
 }
+// 토큰만으로 user ID 자동 조회 (양쪽 API 지원)
+export async function fetchUserId(accessToken) {
+    if (accessToken.startsWith('IGAA')) {
+        // Instagram Login: GET /me?fields=user_id,username
+        const res = await igFetch(accessToken, '/me', { fields: 'user_id,username', access_token: accessToken });
+        // graph.instagram.com 은 v21.0에서 user_id 또는 id 둘 중 하나 반환
+        return res.user_id ?? res.id;
+    }
+    // Facebook Login: GET /me/accounts → instagram_business_account.id
+    const res = await igFetch(accessToken, '/me/accounts', { fields: 'instagram_business_account', access_token: accessToken });
+    const id = res.data?.[0]?.instagram_business_account?.id;
+    if (!id) {
+        throw new Error('Facebook Page에 연결된 Instagram Business Account를 찾지 못했습니다.\n' +
+            'Facebook Page → Settings → Linked Accounts에서 IG 계정을 연결하세요.');
+    }
+    return id;
+}
 async function fetchPermalink(cfg, mediaId) {
     try {
-        const meta = await igFetch(`/${mediaId}`, {
-            fields: 'permalink',
-            access_token: cfg.accessToken,
-        });
+        const meta = await igFetch(cfg.accessToken, `/${mediaId}`, { fields: 'permalink', access_token: cfg.accessToken });
         return meta.permalink;
     }
     catch {
@@ -47,9 +74,9 @@ async function fetchPermalink(cfg, mediaId) {
 }
 export async function postImage(cfg, imageUrl, caption) {
     // Step 1: image container 생성
-    const container = await igFetch(`/${cfg.userId}/media`, { image_url: imageUrl, caption, access_token: cfg.accessToken }, 'POST');
+    const container = await igFetch(cfg.accessToken, `/${cfg.userId}/media`, { image_url: imageUrl, caption, access_token: cfg.accessToken }, 'POST');
     // Step 2: publish
-    const published = await igFetch(`/${cfg.userId}/media_publish`, { creation_id: container.id, access_token: cfg.accessToken }, 'POST');
+    const published = await igFetch(cfg.accessToken, `/${cfg.userId}/media_publish`, { creation_id: container.id, access_token: cfg.accessToken }, 'POST');
     return {
         id: published.id,
         permalink: await fetchPermalink(cfg, published.id),
@@ -62,18 +89,18 @@ export async function postCarousel(cfg, imageUrls, caption) {
     // Step 1: 각 이미지를 children container로 생성 (sequential — 일부 실패 시 부분 결과 명확)
     const childIds = [];
     for (const url of imageUrls) {
-        const child = await igFetch(`/${cfg.userId}/media`, { image_url: url, is_carousel_item: 'true', access_token: cfg.accessToken }, 'POST');
+        const child = await igFetch(cfg.accessToken, `/${cfg.userId}/media`, { image_url: url, is_carousel_item: 'true', access_token: cfg.accessToken }, 'POST');
         childIds.push(child.id);
     }
     // Step 2: carousel container 생성
-    const carousel = await igFetch(`/${cfg.userId}/media`, {
+    const carousel = await igFetch(cfg.accessToken, `/${cfg.userId}/media`, {
         media_type: 'CAROUSEL',
         children: childIds.join(','),
         caption,
         access_token: cfg.accessToken,
     }, 'POST');
     // Step 3: publish
-    const published = await igFetch(`/${cfg.userId}/media_publish`, { creation_id: carousel.id, access_token: cfg.accessToken }, 'POST');
+    const published = await igFetch(cfg.accessToken, `/${cfg.userId}/media_publish`, { creation_id: carousel.id, access_token: cfg.accessToken }, 'POST');
     return {
         id: published.id,
         permalink: await fetchPermalink(cfg, published.id),

package/dist/registers/facebook.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerFacebookTools(server: McpServer): void;

package/dist/registers/facebook.js

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+import { loadFacebookConfig, requireFacebookConfig, saveFacebookConfig } from '../facebook/config.js';
+import * as api from '../facebook/api.js';
+export function registerFacebookTools(server) {
+    server.tool('facebook_save_config', [
+        'Facebook 페이지 액세스 토큰을 ~/.mimi-seed/facebook.json (mode 0600)에 저장합니다.',
+        'pageAccessToken: Graph API Explorer 또는 /me/accounts로 발급한 Page Access Token (EAA...).',
+        'pageId 미입력 시 토큰으로 자동 조회 (/me → id 필드).',
+        '저장 직후 페이지 정보를 조회해 토큰 유효성도 자동 검증.',
+    ].join(' '), {
+        pageAccessToken: z.string().describe('Facebook Page Access Token (EAA..., long-lived 권장)'),
+        pageId: z.string().optional().describe('Facebook Page ID (생략 시 토큰에서 자동 조회)'),
+    }, async ({ pageAccessToken, pageId }) => {
+        // Resolve pageId
+        let resolvedPageId = pageId;
+        if (!resolvedPageId) {
+            try {
+                const me = await api.listAccessiblePages(pageAccessToken);
+                if (me.length === 0) {
+                    // Try /me directly (already a Page Access Token)
+                    const res = await fetch(`https://graph.facebook.com/v21.0/me?fields=id,name&access_token=${pageAccessToken}`);
+                    const data = await res.json();
+                    if (data.error)
+                        throw new Error(`${data.error.message} (code ${data.error.code})`);
+                    resolvedPageId = data.id;
+                }
+                else if (me.length === 1) {
+                    resolvedPageId = me[0].id;
+                }
+                else {
+                    const list = me.map(p => `  • ${p.name} (${p.id})`).join('\n');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: [
+                                    '여러 페이지에 접근 가능합니다. pageId를 명시해주세요:',
+                                    list,
+                                ].join('\n'),
+                            }],
+                    };
+                }
+            }
+            catch (err) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ pageId 자동 조회 실패: ${err.message}`,
+                        }],
+                };
+            }
+        }
+        try {
+            const cfg = { pageAccessToken, pageId: resolvedPageId };
+            const page = await api.getPage(cfg);
+            saveFacebookConfig({
+                pageAccessToken,
+                pageId: resolvedPageId,
+                pageName: page.name,
+                expiresAt: new Date(Date.now() + 60 * 24 * 60 * 60 * 1000).toISOString(),
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            `✅ Facebook 페이지 연결 완료`,
+                            `   페이지: ${page.name}`,
+                            `   ID: ${page.id}`,
+                            page.category ? `   카테고리: ${page.category}` : '',
+                            page.followers_count !== undefined ? `   팔로워: ${page.followers_count.toLocaleString()}` : '',
+                            page.fan_count !== undefined ? `   좋아요: ${page.fan_count.toLocaleString()}` : '',
+                        ].filter(Boolean).join('\n'),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            `❌ 토큰 검증 실패`,
+                            `   ${err.message}`,
+                            ``,
+                            `Page Access Token을 다시 확인하거나 facebook_list_pages로 페이지 목록을 조회하세요.`,
+                        ].join('\n'),
+                    }],
+            };
+        }
+    });
+    server.tool('facebook_list_pages', 'User Access Token으로 접근 가능한 Facebook 페이지 목록을 조회합니다. 페이지별 Page Access Token도 함께 반환.', {
+        userAccessToken: z.string().describe('Facebook User Access Token (EAA...)'),
+    }, async ({ userAccessToken }) => {
+        const pages = await api.listAccessiblePages(userAccessToken);
+        if (pages.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: '접근 가능한 페이지가 없습니다. pages_show_list 권한이 있는 토큰인지 확인하세요.',
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `접근 가능한 페이지 ${pages.length}개:`,
+                        ...pages.map(p => `  • ${p.name} (ID: ${p.id})${p.category ? ` — ${p.category}` : ''}`),
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('facebook_get_page', 'Facebook 페이지 정보 조회 + 저장된 토큰 유효성 검증.', {}, async () => {
+        const cfg = requireFacebookConfig();
+        const page = await api.getPage(cfg);
+        const remainingDays = cfg.expiresAt
+            ? Math.round((new Date(cfg.expiresAt).getTime() - Date.now()) / (24 * 60 * 60 * 1000))
+            : null;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `${page.name} (ID: ${page.id})`,
+                        page.category ? `   카테고리: ${page.category}` : '',
+                        page.followers_count !== undefined ? `   팔로워: ${page.followers_count.toLocaleString()}` : '',
+                        page.fan_count !== undefined ? `   좋아요: ${page.fan_count.toLocaleString()}` : '',
+                        remainingDays !== null
+                            ? remainingDays > 7
+                                ? `   토큰: ${remainingDays}일 남음`
+                                : remainingDays > 0
+                                    ? `   ⚠️ 토큰 ${remainingDays}일 남음 — 갱신 필요`
+                                    : `   ❌ 토큰 만료 — facebook_save_config로 재저장`
+                            : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('facebook_post_photo', [
+        '단일 이미지를 Facebook 페이지에 게시합니다.',
+        'imageUrl은 public URL이어야 합니다.',
+    ].join(' '), {
+        imageUrl: z.string().url().describe('이미지의 public URL (HTTPS 권장)'),
+        caption: z.string().describe('게시글 본문'),
+    }, async ({ imageUrl, caption }) => {
+        const cfg = requireFacebookConfig();
+        const result = await api.postPhoto(cfg, imageUrl, caption);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ 게시 완료`,
+                        `   post_id: ${result.id}`,
+                        result.permalink ? `   URL: ${result.permalink}` : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('facebook_post_multi_photo', [
+        '여러 이미지를 하나의 게시물로 Facebook 페이지에 게시합니다. 2~10장.',
+        '모든 이미지는 public URL이어야 합니다.',
+        '각 이미지를 unpublished photo로 업로드한 뒤 하나의 feed 게시물로 묶습니다.',
+    ].join(' '), {
+        imageUrls: z.array(z.string().url()).min(2).max(10).describe('이미지 URL 배열 (2~10장)'),
+        caption: z.string().describe('게시글 본문'),
+    }, async ({ imageUrls, caption }) => {
+        const cfg = requireFacebookConfig();
+        const result = await api.postMultiPhoto(cfg, imageUrls, caption);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ ${imageUrls.length}장 게시 완료`,
+                        `   post_id: ${result.id}`,
+                        result.permalink ? `   URL: ${result.permalink}` : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    // Config load helper
+    server.tool('facebook_current_config', '현재 저장된 Facebook 페이지 설정을 확인합니다.', {}, async () => {
+        const cfg = loadFacebookConfig();
+        if (!cfg) {
+            return {
+                content: [{ type: 'text', text: '저장된 Facebook 설정 없음. facebook_save_config로 등록하세요.' }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `페이지: ${cfg.pageName ?? '(미확인)'} (${cfg.pageId})`,
+                        cfg.expiresAt ? `토큰 만료(추정): ${cfg.expiresAt.slice(0, 10)}` : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+}

package/dist/registers/instagram.js

@@ -3,49 +3,77 @@ import { requireInstagramConfig, saveInstagramConfig } from '../instagram/config
 import * as api from '../instagram/api.js';
 export function registerInstagramTools(server) {
     server.tool('instagram_save_config', [
-        'Instagram Graph API 토큰을 ~/.mimi-seed/instagram.json (mode 0600)에 저장합니다.',
-        'accessToken: long-lived (60일) — developers.facebook.com → Graph API Explorer에서 발급.',
-        'userId: Instagram Business Account ID — GET /me/accounts → instagram_business_account.id 로 조회.',
-        '권한: instagram_basic + instagram_content_publish 필수.',
-        '저장 후 instagram_get_account 로 토큰 검증 권장.',
+        'Instagram 토큰을 ~/.mimi-seed/instagram.json (mode 0600)에 저장합니다.',
+        'accessToken은 두 형식 모두 자동 감지:',
+        '  IGAA... = Instagram API with Instagram Login (Meta 신규, FB Page 불필요)',
+        '  EAA...  = Instagram Graph API via Facebook Login (FB Page+IG Business 연결 필요)',
+        'userId 미입력 시 토큰으로 자동 조회 (/me 또는 /me/accounts).',
+        '저장 직후 토큰 유효성도 자동 검증.',
     ].join(' '), {
-        accessToken: z.string().describe('Long-lived access token (60일 유효)'),
-        userId: z.string().describe('Instagram Business Account ID'),
-        assumeIssuedNow: z.boolean().default(true).describe('issuedAt을 지금으로 가정하고 expiresAt = +60일 자동 계산'),
+        accessToken: z.string().describe('Long-lived access token (60일)'),
+        userId: z.string().optional().describe('Instagram Business Account ID (생략 시 자동 조회)'),
+        assumeIssuedNow: z.boolean().default(true).describe('expiresAt = 지금 + 60일 자동 계산'),
     }, async ({ accessToken, userId, assumeIssuedNow }) => {
+        const apiType = accessToken.startsWith('IGAA') ? 'Instagram Login' : 'Facebook Login';
+        // userId 자동 조회
+        let resolvedUserId = userId;
+        if (!resolvedUserId) {
+            try {
+                resolvedUserId = await api.fetchUserId(accessToken);
+            }
+            catch (err) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                `❌ userId 자동 조회 실패 (${apiType})`,
+                                `   ${err.message}`,
+                                ``,
+                                `userId를 명시적으로 전달하거나 토큰을 다시 확인하세요.`,
+                            ].join('\n'),
+                        }],
+                };
+            }
+        }
         const expiresAt = assumeIssuedNow
             ? new Date(Date.now() + 60 * 24 * 60 * 60 * 1000).toISOString()
             : undefined;
-        saveInstagramConfig({ accessToken, userId, expiresAt });
         // 검증 — 잘못된 토큰이면 즉시 알림
         try {
-            const account = await api.getAccount({ accessToken, userId });
-            // 검증 성공 시 username 추가 저장
-            saveInstagramConfig({ accessToken, userId, expiresAt, username: account.username });
+            const account = await api.getAccount({ accessToken, userId: resolvedUserId });
+            // 검증 성공 → 최종 저장
+            saveInstagramConfig({
+                accessToken,
+                userId: resolvedUserId,
+                expiresAt,
+                username: account.username,
+            });
             return {
                 content: [{
                         type: 'text',
                         text: [
-                            `✅ Instagram 연결 확인 완료`,
+                            `✅ Instagram 연결 확인 완료 (${apiType})`,
                             `   계정: @${account.username}${account.name ? ` (${account.name})` : ''}`,
                             `   ID: ${account.id}`,
                             account.account_type ? `   타입: ${account.account_type}` : '',
                             account.followers_count !== undefined ? `   팔로워: ${account.followers_count.toLocaleString()}` : '',
+                            account.media_count !== undefined ? `   게시물: ${account.media_count}` : '',
                             expiresAt ? `   토큰 만료(추정): ${expiresAt.slice(0, 10)}` : '',
                         ].filter(Boolean).join('\n'),
                     }],
             };
         }
         catch (err) {
+            // 검증 실패 — 저장은 하지 않고 사용자에게 알림
             return {
                 content: [{
                         type: 'text',
                         text: [
-                            `⚠️ 설정은 저장됐지만 토큰 검증 실패`,
+                            `❌ 토큰 검증 실패 (${apiType})`,
+                            `   userId: ${resolvedUserId}`,
                             `   ${err.message}`,
                             ``,
-                            `토큰/userId를 다시 확인하세요.`,
-                            `instagram_save_config 로 재저장 가능.`,
+                            `토큰을 다시 발급받거나 userId를 직접 지정해보세요.`,
                         ].join('\n'),
                     }],
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.3.23",
+  "version": "0.3.25",
   "description": "Mimi Seed MCP server — Firebase + AdMob + Google Play + App Store management for Claude Code / Cursor / any MCP client.",
   "type": "module",
   "bin": {