@yoonion/mimi-seed-mcp 0.3.24 → 0.3.26

package/dist/auth/bigquery-auth.d.ts

@@ -0,0 +1,32 @@
+import { JWT } from 'google-auth-library';
+import type { OAuth2Client } from 'google-auth-library';
+export interface ServiceAccountKey {
+    type?: string;
+    client_email?: string;
+    private_key?: string;
+    project_id?: string;
+}
+/** 서비스 계정 키 JSON 문자열을 검증 후 저장. 형식이 아니면 throw. */
+export declare function saveBigQueryServiceAccountJson(json: string): ServiceAccountKey;
+/** 저장된 BigQuery 서비스 계정 키. 없거나 형식 오류면 null. */
+export declare function getBigQueryServiceAccountKey(): ServiceAccountKey | null;
+/** 저장된 BigQuery 서비스 계정 키 삭제. 없으면 false. */
+export declare function deleteBigQueryServiceAccountJson(): boolean;
+export type BigQueryAuthSource = 'service-account' | 'user-oauth';
+export interface BigQueryAuth {
+    client: OAuth2Client | JWT;
+    source: BigQueryAuthSource;
+    /** 서비스 계정이면 client_email, 사용자 OAuth면 null. */
+    clientEmail: string | null;
+    /** 서비스 계정 키의 project_id (있으면). */
+    projectId: string | null;
+}
+/**
+ * BigQuery 인증 클라이언트 해석. 우선순위:
+ *  1. BigQuery 서비스 계정 (~/.mimi-seed/bigquery-service-account.json)
+ *  2. 사용자 OAuth (~/.mimi-seed/tokens.json)
+ * 둘 다 없으면 null.
+ */
+export declare function resolveBigQueryAuth(): BigQueryAuth | null;
+/** BigQuery 인증을 강제. 없으면 안내 메시지와 함께 throw. */
+export declare function requireBigQueryAuth(): BigQueryAuth;

package/dist/auth/bigquery-auth.js

@@ -0,0 +1,100 @@
+import { JWT } from 'google-auth-library';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getAuthenticatedClient } from './google-auth.js';
+// BigQuery 전용 서비스 계정 키 저장 위치.
+// 서비스 계정 인증은 Google Workspace 의 재인증(reauth) 정책에서 면제되므로,
+// 사용자 OAuth 가 `invalid_rapt` 로 갱신 거부되는 환경에서도 안정적으로 동작한다.
+const CONFIG_DIR = path.join(os.homedir(), '.mimi-seed');
+const BQ_SA_PATH = path.join(CONFIG_DIR, 'bigquery-service-account.json');
+// jobs.create(쿼리 작업 생성) + 데이터셋 읽기에 필요한 최소 스코프.
+const BQ_SCOPES = [
+    'https://www.googleapis.com/auth/bigquery.readonly',
+    'https://www.googleapis.com/auth/cloud-platform',
+];
+function safeReadSa(p) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (parsed.type === 'service_account' && parsed.client_email && parsed.private_key) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 서비스 계정 키 JSON 문자열을 검증 후 저장. 형식이 아니면 throw. */
+export function saveBigQueryServiceAccountJson(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new Error('JSON 파싱 실패 — 올바른 서비스 계정 키 파일이 아닙니다.');
+    }
+    if (parsed.type !== 'service_account' || !parsed.client_email || !parsed.private_key) {
+        throw new Error('서비스 계정 키 형식이 아닙니다 (type="service_account", client_email, private_key 필요).');
+    }
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(BQ_SA_PATH, json, { mode: 0o600 });
+    return parsed;
+}
+/** 저장된 BigQuery 서비스 계정 키. 없거나 형식 오류면 null. */
+export function getBigQueryServiceAccountKey() {
+    if (!fs.existsSync(BQ_SA_PATH))
+        return null;
+    return safeReadSa(BQ_SA_PATH);
+}
+/** 저장된 BigQuery 서비스 계정 키 삭제. 없으면 false. */
+export function deleteBigQueryServiceAccountJson() {
+    if (!fs.existsSync(BQ_SA_PATH))
+        return false;
+    fs.unlinkSync(BQ_SA_PATH);
+    return true;
+}
+function makeJwt(sa) {
+    return new JWT({ email: sa.client_email, key: sa.private_key, scopes: BQ_SCOPES });
+}
+/**
+ * BigQuery 인증 클라이언트 해석. 우선순위:
+ *  1. BigQuery 서비스 계정 (~/.mimi-seed/bigquery-service-account.json)
+ *  2. 사용자 OAuth (~/.mimi-seed/tokens.json)
+ * 둘 다 없으면 null.
+ */
+export function resolveBigQueryAuth() {
+    const sa = getBigQueryServiceAccountKey();
+    if (sa) {
+        return {
+            client: makeJwt(sa),
+            source: 'service-account',
+            clientEmail: sa.client_email ?? null,
+            projectId: sa.project_id ?? null,
+        };
+    }
+    const oauth = getAuthenticatedClient();
+    if (oauth) {
+        return { client: oauth, source: 'user-oauth', clientEmail: null, projectId: null };
+    }
+    return null;
+}
+const BQ_AUTH_HINT = [
+    '❌ BigQuery 인증이 설정되지 않았어.',
+    '',
+    '방법 1 — 서비스 계정 (권장: Google Workspace 재인증 정책의 영향을 받지 않음):',
+    '  npx -y @yoonion/mimi-seed-mcp mimi-seed-bigquery-auth',
+    '',
+    '방법 2 — Google 계정 OAuth:',
+    '  npx -y @yoonion/mimi-seed-mcp mimi-seed-auth',
+    '',
+    '그 다음에 다시 물어봐줘.',
+].join('\n');
+/** BigQuery 인증을 강제. 없으면 안내 메시지와 함께 throw. */
+export function requireBigQueryAuth() {
+    const auth = resolveBigQueryAuth();
+    if (!auth)
+        throw new Error(BQ_AUTH_HINT);
+    return auth;
+}

package/dist/auth/bigquery-setup-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/auth/bigquery-setup-cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import readline from 'node:readline';
+import fs from 'node:fs';
+import { saveBigQueryServiceAccountJson, getBigQueryServiceAccountKey, } from './bigquery-auth.js';
+import * as bigquery from '../bigquery/tools.js';
+import { JWT } from 'google-auth-library';
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q) => new Promise((r) => rl.question(q, r));
+async function main() {
+    console.log('');
+    console.log('  🤖 Mimi Seed — BigQuery 서비스 계정 연결');
+    console.log('');
+    console.log('  서비스 계정 인증은 Google Workspace 의 재인증(reauth) 정책에서');
+    console.log('  면제되므로, OAuth 가 invalid_rapt 로 막히는 환경에서도 동작해.');
+    console.log('');
+    const existing = getBigQueryServiceAccountKey();
+    if (existing) {
+        console.log(`  ✅ 이미 연결됨 (${existing.client_email})`);
+        const answer = await ask('  다시 설정할래? (y/N): ');
+        if (answer.toLowerCase() !== 'y') {
+            rl.close();
+            return;
+        }
+    }
+    console.log('  BigQuery 를 읽을 수 있는 서비스 계정 키 JSON 이 필요해:');
+    console.log('  1. GCP Console → IAM & Admin → Service Accounts');
+    console.log('  2. 서비스 계정 선택(또는 생성) → Keys → Add Key → JSON');
+    console.log('  3. 그 서비스 계정에 프로젝트 IAM 역할 부여:');
+    console.log('     • roles/bigquery.jobUser    (쿼리 작업 생성)');
+    console.log('     • roles/bigquery.dataViewer (데이터셋 읽기)');
+    console.log('  4. 다운로드한 JSON 파일 경로를 입력해');
+    console.log('');
+    const jsonPath = await ask('  서비스 계정 JSON 파일 경로: ');
+    const trimmedPath = jsonPath.trim().replace(/^["']|["']$/g, '');
+    if (!fs.existsSync(trimmedPath)) {
+        console.log(`  ❌ 파일 없음: ${trimmedPath}`);
+        rl.close();
+        process.exit(1);
+    }
+    const json = fs.readFileSync(trimmedPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = saveBigQueryServiceAccountJson(json);
+    }
+    catch (e) {
+        console.log(`  ❌ ${e instanceof Error ? e.message : String(e)}`);
+        rl.close();
+        process.exit(1);
+    }
+    console.log('');
+    console.log(`  ✅ 저장 완료! (${parsed.client_email})`);
+    if (parsed.project_id)
+        console.log(`     서비스 계정 프로젝트: ${parsed.project_id}`);
+    console.log('');
+    // 선택적 연결 테스트 — projectId 를 입력하면 datasets.list 로 권한 확인.
+    const testProject = await ask(`  연결 테스트할 GCP 프로젝트 ID (엔터 시 건너뜀${parsed.project_id ? `, 기본 ${parsed.project_id}` : ''}): `);
+    const projectId = testProject.trim() || parsed.project_id || '';
+    if (projectId) {
+        console.log(`  🔎 ${projectId} 데이터셋 조회 중...`);
+        try {
+            const jwt = new JWT({
+                email: parsed.client_email,
+                key: parsed.private_key,
+                scopes: [
+                    'https://www.googleapis.com/auth/bigquery.readonly',
+                    'https://www.googleapis.com/auth/cloud-platform',
+                ],
+            });
+            const datasets = await bigquery.listDatasets(jwt, projectId);
+            console.log(`  ✅ 접근 OK — 데이터셋 ${datasets.length}개`);
+            for (const d of datasets.slice(0, 10))
+                console.log(`     • ${d.datasetId} (${d.location})`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(`  ⚠️  접근 실패: ${msg}`);
+            console.log('');
+            console.log('  IAM 역할이 없으면 아래를 실행해 (프로젝트 소유자 계정에서):');
+            console.log(`    gcloud projects add-iam-policy-binding ${projectId} \\`);
+            console.log(`      --member="serviceAccount:${parsed.client_email}" --role="roles/bigquery.jobUser"`);
+            console.log(`    gcloud projects add-iam-policy-binding ${projectId} \\`);
+            console.log(`      --member="serviceAccount:${parsed.client_email}" --role="roles/bigquery.dataViewer"`);
+        }
+    }
+    console.log('');
+    console.log('  이제 Claude Code 에서:');
+    console.log('    "BigQuery 로 GA4 트래픽 분석해줘"');
+    console.log('');
+    rl.close();
+}
+main();

package/dist/auth/errors.d.ts

@@ -1,4 +1,4 @@
-export type AuthErrorCode = 'UNAUTHENTICATED' | 'NO_REFRESH_TOKEN' | 'INVALID_GRANT' | 'INVALID_CLIENT' | 'UNAUTHORIZED_CLIENT' | 'REFRESH_NETWORK_ERROR' | 'REFRESH_UNKNOWN' | 'CALLBACK_PORT_IN_USE' | 'CALLBACK_TIMEOUT' | 'BROWSER_OPEN_FAILED' | 'USER_DENIED' | 'CODE_EXCHANGE_FAILED' | 'TOKEN_RESPONSE_INVALID';
+export type AuthErrorCode = 'UNAUTHENTICATED' | 'NO_REFRESH_TOKEN' | 'INVALID_GRANT' | 'RAPT_REQUIRED' | 'INVALID_CLIENT' | 'UNAUTHORIZED_CLIENT' | 'REFRESH_NETWORK_ERROR' | 'REFRESH_UNKNOWN' | 'CALLBACK_PORT_IN_USE' | 'CALLBACK_TIMEOUT' | 'BROWSER_OPEN_FAILED' | 'USER_DENIED' | 'CODE_EXCHANGE_FAILED' | 'TOKEN_RESPONSE_INVALID';
 export interface AuthErrorPayload {
     code: AuthErrorCode;
     message: string;

package/dist/auth/errors.js

@@ -28,6 +28,17 @@ export function classifyError(e, ctx) {
             cause: raw,
         };
     }
+    if (oauthCode === 'invalid_rapt' || oauthCode === 'rapt_required') {
+        return {
+            code: 'RAPT_REQUIRED',
+            message: 'Google Workspace 재인증(reauth) 정책으로 토큰 갱신이 거부되었습니다 (invalid_rapt).',
+            hint: 'mimi-seed-auth 로 재로그인하거나, 재인증 정책의 영향을 받지 않는 서비스 계정 인증을 사용하세요 ' +
+                '(BigQuery: mimi-seed-bigquery-auth).',
+            retriable: false,
+            needsReauth: true,
+            cause: raw,
+        };
+    }
     if (oauthCode === 'invalid_client') {
         return {
             code: 'INVALID_CLIENT',
@@ -128,7 +139,7 @@ function extractOAuthErrorCode(e, raw) {
             return dataErr;
     }
     // message에 'invalid_grant' 같은 표준 코드가 박혀 있는 경우
-    const m = raw.match(/\b(invalid_grant|invalid_client|invalid_request|unauthorized_client|access_denied|unsupported_grant_type)\b/);
+    const m = raw.match(/\b(invalid_grant|invalid_client|invalid_request|unauthorized_client|access_denied|unsupported_grant_type|invalid_rapt|rapt_required)\b/);
     return m?.[1];
 }
 function isNetworkError(e, raw) {

package/dist/bigquery/tools.d.ts

@@ -1,5 +1,7 @@
-import type { OAuth2Client } from 'google-auth-library';
-export declare function runQuery(auth: OAuth2Client, projectId: string, query: string, maxResults?: number): Promise<{
+import type { OAuth2Client, JWT } from 'google-auth-library';
+/** BigQuery 호출에 쓰이는 인증 클라이언트 — 사용자 OAuth 또는 서비스 계정 JWT. */
+export type BigQueryAuthClient = OAuth2Client | JWT;
+export declare function runQuery(auth: BigQueryAuthClient, projectId: string, query: string, maxResults?: number): Promise<{
     jobComplete: boolean | null | undefined;
     totalRows: string | null | undefined;
     schema: {
@@ -10,15 +12,15 @@ export declare function runQuery(auth: OAuth2Client, projectId: string, query: s
         [k: string]: any;
     }[];
 }>;
-export declare function listDatasets(auth: OAuth2Client, projectId: string): Promise<{
+export declare function listDatasets(auth: BigQueryAuthClient, projectId: string): Promise<{
     datasetId: string | null | undefined;
     location: string | undefined;
 }[]>;
-export declare function listTables(auth: OAuth2Client, projectId: string, datasetId: string): Promise<{
+export declare function listTables(auth: BigQueryAuthClient, projectId: string, datasetId: string): Promise<{
     tableId: string | null | undefined;
     type: string | undefined;
 }[]>;
-export declare function getTableSchema(auth: OAuth2Client, projectId: string, datasetId: string, tableId: string): Promise<{
+export declare function getTableSchema(auth: BigQueryAuthClient, projectId: string, datasetId: string, tableId: string): Promise<{
     tableId: string;
     schema: {
         name: string | null | undefined;

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>` 처리.
@@ -39,6 +41,7 @@ const SUBCOMMANDS = {
     'mimi-seed-auth': () => import('./auth/cli.js'),
     'mimi-seed-playstore-auth': () => import('./auth/playstore-setup-cli.js'),
     'mimi-seed-appstore-auth': () => import('./appstore/setup-cli.js'),
+    'mimi-seed-bigquery-auth': () => import('./auth/bigquery-setup-cli.js'),
 };
 async function main() {
     const sub = process.argv[2];

package/dist/registers/bigquery.js

@@ -1,38 +1,130 @@
 import { z } from 'zod';
 import * as bigquery from '../bigquery/tools.js';
-import { requireAuth } from '../helpers.js';
+import { requireBigQueryAuth, resolveBigQueryAuth } from '../auth/bigquery-auth.js';
+/**
+ * BigQuery 에러를 사람이 읽을 수 있게 가공.
+ * 403(accessDenied)은 인증 자체는 됐으나 IAM 역할이 없는 경우 — 어떤 역할을
+ * 어디에 부여해야 하는지 정확히 안내한다.
+ */
+function describeBqError(e, auth, projectId) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const obj = (e && typeof e === 'object' ? e : {});
+    const status = (obj.code ?? obj.status);
+    const is403 = status === 403 || status === '403' || /accessDenied|does not have|permission/i.test(msg);
+    if (is403) {
+        const who = auth.clientEmail
+            ? `서비스 계정 ${auth.clientEmail}`
+            : '현재 OAuth 사용자 계정';
+        const lines = [
+            `❌ BigQuery 접근 거부 (project: ${projectId})`,
+            `   ${msg}`,
+            '',
+            `${who}에 다음 IAM 역할이 필요해 — 프로젝트 ${projectId}에 부여:`,
+            '  • roles/bigquery.jobUser    (쿼리 작업 생성)',
+            '  • roles/bigquery.dataViewer (데이터셋 읽기)',
+        ];
+        if (auth.clientEmail) {
+            lines.push('', 'gcloud 로 부여 (프로젝트 소유자 계정에서 1회):', `  gcloud projects add-iam-policy-binding ${projectId} \\`, `    --member="serviceAccount:${auth.clientEmail}" --role="roles/bigquery.jobUser"`, `  gcloud projects add-iam-policy-binding ${projectId} \\`, `    --member="serviceAccount:${auth.clientEmail}" --role="roles/bigquery.dataViewer"`);
+        }
+        return lines.join('\n');
+    }
+    // 토큰 만료/재인증 류 — 서비스 계정 등록 권유
+    if (/invalid_rapt|rapt_required|invalid_grant|reauth/i.test(msg)) {
+        return [
+            `❌ BigQuery 인증 갱신 실패: ${msg}`,
+            '',
+            'Google Workspace 재인증 정책으로 OAuth 토큰 갱신이 막힌 상태일 수 있어.',
+            '서비스 계정은 이 정책의 영향을 받지 않아 — 등록 권장:',
+            '  npx -y @yoonion/mimi-seed-mcp mimi-seed-bigquery-auth',
+        ].join('\n');
+    }
+    return `❌ BigQuery 오류: ${msg}`;
+}
+function errResult(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
 export function registerBigqueryTools(server) {
-    server.tool('bigquery_run_query', 'BigQuery SQL 쿼리 실행 (SELECT). GA4 analytics_* 테이블 분석에 사용.', {
+    server.tool('bigquery_run_query', 'BigQuery SQL 쿼리 실행 (SELECT). GA4 analytics_* 테이블 분석에 사용. ' +
+        '서비스 계정(권장) 또는 사용자 OAuth 로 인증.', {
         projectId: z.string().describe('GCP 프로젝트 ID (예: ads-coffee)'),
         query: z.string().describe('실행할 StandardSQL 쿼리'),
         maxResults: z.number().optional().describe('최대 행 수 (기본 1000)'),
     }, async ({ projectId, query, maxResults }) => {
-        const auth = requireAuth();
-        const result = await bigquery.runQuery(auth, projectId, query, maxResults ?? 1000);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        const auth = requireBigQueryAuth();
+        try {
+            const result = await bigquery.runQuery(auth.client, projectId, query, maxResults ?? 1000);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return errResult(describeBqError(e, auth, projectId));
+        }
     });
     server.tool('bigquery_list_datasets', 'BigQuery 프로젝트의 데이터셋 목록 조회', {
         projectId: z.string().describe('GCP 프로젝트 ID'),
     }, async ({ projectId }) => {
-        const auth = requireAuth();
-        const datasets = await bigquery.listDatasets(auth, projectId);
-        return { content: [{ type: 'text', text: JSON.stringify(datasets, null, 2) }] };
+        const auth = requireBigQueryAuth();
+        try {
+            const datasets = await bigquery.listDatasets(auth.client, projectId);
+            return { content: [{ type: 'text', text: JSON.stringify(datasets, null, 2) }] };
+        }
+        catch (e) {
+            return errResult(describeBqError(e, auth, projectId));
+        }
     });
     server.tool('bigquery_list_tables', 'BigQuery 데이터셋의 테이블 목록 조회', {
         projectId: z.string().describe('GCP 프로젝트 ID'),
         datasetId: z.string().describe('데이터셋 ID (예: analytics_530080532)'),
     }, async ({ projectId, datasetId }) => {
-        const auth = requireAuth();
-        const tables = await bigquery.listTables(auth, projectId, datasetId);
-        return { content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }] };
+        const auth = requireBigQueryAuth();
+        try {
+            const tables = await bigquery.listTables(auth.client, projectId, datasetId);
+            return { content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }] };
+        }
+        catch (e) {
+            return errResult(describeBqError(e, auth, projectId));
+        }
     });
     server.tool('bigquery_get_table_schema', 'BigQuery 테이블 스키마(컬럼 정보) 조회', {
         projectId: z.string().describe('GCP 프로젝트 ID'),
         datasetId: z.string().describe('데이터셋 ID'),
         tableId: z.string().describe('테이블 ID'),
     }, async ({ projectId, datasetId, tableId }) => {
-        const auth = requireAuth();
-        const schema = await bigquery.getTableSchema(auth, projectId, datasetId, tableId);
-        return { content: [{ type: 'text', text: JSON.stringify(schema, null, 2) }] };
+        const auth = requireBigQueryAuth();
+        try {
+            const schema = await bigquery.getTableSchema(auth.client, projectId, datasetId, tableId);
+            return { content: [{ type: 'text', text: JSON.stringify(schema, null, 2) }] };
+        }
+        catch (e) {
+            return errResult(describeBqError(e, auth, projectId));
+        }
+    });
+    server.tool('bigquery_auth_status', '현재 BigQuery 인증 상태 조회 — 어떤 인증(서비스 계정/OAuth)이 사용되는지 확인', {}, async () => {
+        const auth = resolveBigQueryAuth();
+        if (!auth) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            authenticated: false,
+                            hint: 'mimi-seed-bigquery-auth (서비스 계정) 또는 mimi-seed-auth (OAuth) 로 인증 필요',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        authenticated: true,
+                        source: auth.source,
+                        clientEmail: auth.clientEmail,
+                        serviceAccountProjectId: auth.projectId,
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }

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/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "Mimi Seed MCP server — Firebase + AdMob + Google Play + App Store management for Claude Code / Cursor / any MCP client.",
   "type": "module",
   "bin": {
     "mimi-seed-mcp": "dist/index.js",
     "mimi-seed-auth": "dist/auth/cli.js",
     "mimi-seed-appstore-auth": "dist/appstore/setup-cli.js",
-    "mimi-seed-playstore-auth": "dist/auth/playstore-setup-cli.js"
+    "mimi-seed-playstore-auth": "dist/auth/playstore-setup-cli.js",
+    "mimi-seed-bigquery-auth": "dist/auth/bigquery-setup-cli.js"
   },
   "files": [
     "dist",