@yoonion/mimi-seed-mcp 0.3.2 → 0.3.4

package/README.md

@@ -172,7 +172,7 @@ Claude가 연쇄 호출:
 
 ## 레거시 호환성
 
-패키지 이름이 `@preseed/mcp-server` / `preseed-mcp` 시절의 데이터는 자동으로 이어받음:
+Preseed 시절(`~/.preseed/`) 데이터는 자동으로 이어받음:
 
 - `~/.preseed/tokens.json` 있으면 읽음 (재인증 불필요)
 - `~/.preseed/appstore.json`도 동일

package/dist/appstore/screenshots.js

@@ -21,8 +21,7 @@ function authHeadersOrThrow() {
             '❌ App Store Connect 인증이 필요해.',
             '',
             '터미널에서 실행:',
-            '  cd c:/users/turbo08/app-gen/packages/mcp-server',
-            '  npx tsx src/appstore/setup-cli.ts',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
         ].join('\n'));
     }
     return headers;

package/dist/appstore/tools.d.ts

@@ -20,3 +20,38 @@ export declare function updateVersionWhatsNew(versionId: string, locale: string,
 export declare function listBuilds(appId: string): Promise<any>;
 export declare function listBetaGroups(appId: string): Promise<any>;
 export declare function getAppInfo(appId: string): Promise<any>;
+export interface AppInfoLocalizationFields {
+    name?: string;
+    subtitle?: string;
+    privacyPolicyUrl?: string;
+    privacyPolicyText?: string;
+}
+export declare function listAppInfoLocalizations(appId: string, locale?: string): Promise<{
+    appInfoId: string;
+    appInfoState: string;
+    localizations: {
+        id: any;
+        locale: any;
+        name: any;
+        subtitle: any;
+        privacyPolicyUrl: any;
+        privacyPolicyText: any;
+    }[];
+}>;
+export declare function updateAppInfoLocalization(localizationId: string, fields: AppInfoLocalizationFields): Promise<any>;
+export interface ListCustomerReviewsOptions {
+    limit?: number;
+    territory?: string;
+    rating?: 1 | 2 | 3 | 4 | 5;
+}
+export declare function listCustomerReviews(appId: string, opts?: ListCustomerReviewsOptions): Promise<any>;
+export declare function createReviewResponse(reviewId: string, responseBody: string): Promise<any>;
+export declare function submitVersionForReview(versionId: string): Promise<{
+    submissionId: string;
+    appId: string;
+    platform: string;
+    versionId: string;
+    reusedSubmission: boolean;
+    itemAttached: boolean;
+    state: any;
+}>;

package/dist/appstore/tools.js

@@ -11,8 +11,7 @@ export async function apiGet(path, params) {
             '❌ App Store Connect 인증이 필요해.',
             '',
             '터미널에서 실행:',
-            '  cd c:/users/turbo08/app-gen/packages/mcp-server',
-            '  npx tsx src/appstore/setup-cli.ts',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
             '',
             'API Key가 필요해:',
             '  App Store Connect > Users and Access > Integrations > Keys',
@@ -36,8 +35,7 @@ async function apiPatch(path, body) {
             '❌ App Store Connect 인증이 필요해.',
             '',
             '터미널에서 실행:',
-            '  cd c:/users/turbo08/app-gen/packages/mcp-server',
-            '  npx tsx src/appstore/setup-cli.ts',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
         ].join('\n'));
     const res = await fetch(`${BASE}${path}`, {
         method: 'PATCH',
@@ -52,6 +50,28 @@ async function apiPatch(path, body) {
     const text = await res.text();
     return text ? JSON.parse(text) : { ok: true };
 }
+async function apiPost(path, body) {
+    const headers = getAuthHeaders();
+    if (!headers)
+        throw new Error([
+            '❌ App Store Connect 인증이 필요해.',
+            '',
+            '터미널에서 실행:',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
+        ].join('\n'));
+    const res = await fetch(`${BASE}${path}`, {
+        method: 'POST',
+        headers: { ...headers, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`App Store API ${res.status}: ${text}`);
+    }
+    // 201 Created — 본문에 created entity. 일부 엔드포인트는 204
+    const text = await res.text();
+    return text ? JSON.parse(text) : { ok: true };
+}
 // ─── 앱 ───
 export async function listApps() {
     const data = await apiGet('/apps', {
@@ -154,13 +174,203 @@ export async function listBetaGroups(appId) {
     }));
 }
 // ─── 앱 정보 (카테고리 등) ───
+// AppInfoState — READY_FOR_DISTRIBUTION이 라이브 버전, 그 외(PREPARE_FOR_SUBMISSION /
+// DEVELOPER_REJECTED 등)가 편집 가능한 appInfo.
+const APP_INFO_LIVE_STATE = 'READY_FOR_DISTRIBUTION';
 export async function getAppInfo(appId) {
     const data = await apiGet(`/apps/${appId}/appInfos`, {
-        'fields[appInfos]': 'appStoreState,appStoreAgeRating,brazilAgeRating',
+        'fields[appInfos]': 'state,appStoreAgeRating,brazilAgeRating',
     });
     return (data.data ?? []).map((i) => ({
         id: i.id,
-        state: i.attributes?.appStoreState,
+        // 새 필드명 state, 옛 필드명 appStoreState 모두 케어
+        state: i.attributes?.state ?? i.attributes?.appStoreState,
         ageRating: i.attributes?.appStoreAgeRating,
     }));
 }
+async function findEditableAppInfoId(appId) {
+    const data = await apiGet(`/apps/${appId}/appInfos`, {
+        'fields[appInfos]': 'state',
+        'limit': '10',
+    });
+    const infos = (data?.data ?? []);
+    if (infos.length === 0) {
+        throw new Error(`앱 ${appId}에 appInfos가 없어. 앱 ID 확인 필요.`);
+    }
+    const stateOf = (i) => i.attributes?.state ?? i.attributes?.appStoreState ?? '';
+    const editable = infos.find((i) => stateOf(i) !== APP_INFO_LIVE_STATE);
+    const target = editable ?? infos[0];
+    return { appInfoId: target.id, state: stateOf(target) };
+}
+export async function listAppInfoLocalizations(appId, locale) {
+    const { appInfoId, state } = await findEditableAppInfoId(appId);
+    const data = await apiGet(`/appInfos/${appInfoId}/appInfoLocalizations`, {
+        'fields[appInfoLocalizations]': 'locale,name,subtitle,privacyPolicyUrl,privacyPolicyText',
+        'limit': '200',
+    });
+    const all = (data?.data ?? []).map((l) => ({
+        id: l.id,
+        locale: l.attributes?.locale,
+        name: l.attributes?.name,
+        subtitle: l.attributes?.subtitle,
+        privacyPolicyUrl: l.attributes?.privacyPolicyUrl,
+        privacyPolicyText: l.attributes?.privacyPolicyText,
+    }));
+    const filtered = locale ? all.filter((l) => l.locale === locale) : all;
+    return { appInfoId, appInfoState: state, localizations: filtered };
+}
+export async function updateAppInfoLocalization(localizationId, fields) {
+    const attributes = Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== undefined));
+    if (Object.keys(attributes).length === 0) {
+        throw new Error('수정할 필드가 없어 (name / subtitle / privacyPolicyUrl / privacyPolicyText 중 하나 이상).');
+    }
+    return apiPatch(`/appInfoLocalizations/${localizationId}`, {
+        data: {
+            type: 'appInfoLocalizations',
+            id: localizationId,
+            attributes,
+        },
+    });
+}
+export async function listCustomerReviews(appId, opts = {}) {
+    const params = {
+        'sort': '-createdDate',
+        'limit': String(opts.limit ?? 50),
+        'fields[customerReviews]': 'rating,title,body,reviewerNickname,createdDate,territory',
+        'include': 'response',
+        'fields[customerReviewResponses]': 'responseBody,lastModifiedDate,state',
+    };
+    if (opts.territory)
+        params['filter[territory]'] = opts.territory;
+    if (opts.rating != null)
+        params['filter[rating]'] = String(opts.rating);
+    const data = await apiGet(`/apps/${appId}/customerReviews`, params);
+    // include로 가져온 답변 매핑
+    const responses = new Map();
+    for (const inc of data.included ?? []) {
+        if (inc.type === 'customerReviewResponses') {
+            responses.set(inc.id, inc.attributes);
+        }
+    }
+    return (data.data ?? []).map((r) => {
+        const respId = r.relationships?.response?.data?.id;
+        const resp = respId ? responses.get(respId) : null;
+        return {
+            id: r.id,
+            rating: r.attributes?.rating,
+            title: r.attributes?.title,
+            body: r.attributes?.body,
+            nickname: r.attributes?.reviewerNickname,
+            createdDate: r.attributes?.createdDate,
+            territory: r.attributes?.territory,
+            response: resp
+                ? {
+                    body: resp.responseBody,
+                    lastModifiedDate: resp.lastModifiedDate,
+                    state: resp.state,
+                }
+                : null,
+        };
+    });
+}
+export async function createReviewResponse(reviewId, responseBody) {
+    return apiPost('/customerReviewResponses', {
+        data: {
+            type: 'customerReviewResponses',
+            attributes: { responseBody },
+            relationships: {
+                review: { data: { type: 'customerReviews', id: reviewId } },
+            },
+        },
+    });
+}
+// ─── 심사 제출 (Submit for Review) ───
+// 2024년 1월부터 옛 /appStoreVersionSubmissions가 deprecated 됐고,
+// 새 모델은 /reviewSubmissions + /reviewSubmissionItems 2단계 + PATCH submitted=true.
+// 참고: https://developer.apple.com/documentation/appstoreconnectapi/submit-an-app-for-review
+async function getVersionAppAndPlatform(versionId) {
+    const data = await apiGet(`/appStoreVersions/${versionId}`, {
+        'fields[appStoreVersions]': 'platform,app',
+        'include': 'app',
+    });
+    const platform = data?.data?.attributes?.platform;
+    const appId = data?.data?.relationships?.app?.data?.id;
+    if (!platform || !appId) {
+        throw new Error(`appStoreVersion ${versionId}에서 app 또는 platform을 찾지 못했어. 버전 ID 확인 필요.`);
+    }
+    return { appId, platform };
+}
+async function findOpenReviewSubmission(appId, platform) {
+    const data = await apiGet('/reviewSubmissions', {
+        'filter[app]': appId,
+        'filter[platform]': platform,
+        'filter[state]': 'READY_FOR_REVIEW,COMPLETING,UNRESOLVED_ISSUES',
+        'limit': '1',
+    });
+    // CREATED 상태(아직 제출 안 된)도 별도 조회해서 우선 재사용
+    const created = await apiGet('/reviewSubmissions', {
+        'filter[app]': appId,
+        'filter[platform]': platform,
+        'filter[state]': 'CREATED',
+        'limit': '1',
+    });
+    return created?.data?.[0]?.id ?? data?.data?.[0]?.id ?? null;
+}
+async function isVersionAttached(submissionId, versionId) {
+    const data = await apiGet(`/reviewSubmissions/${submissionId}/items`, {
+        'limit': '50',
+    });
+    const items = (data?.data ?? []);
+    return items.some((it) => it?.relationships?.appStoreVersion?.data?.id === versionId);
+}
+export async function submitVersionForReview(versionId) {
+    const { appId, platform } = await getVersionAppAndPlatform(versionId);
+    // 1. CREATED 상태의 reviewSubmission이 있으면 재사용, 없으면 새로 생성
+    let submissionId = await findOpenReviewSubmission(appId, platform);
+    const reusedSubmission = Boolean(submissionId);
+    if (!submissionId) {
+        const created = await apiPost('/reviewSubmissions', {
+            data: {
+                type: 'reviewSubmissions',
+                attributes: { platform },
+                relationships: {
+                    app: { data: { type: 'apps', id: appId } },
+                },
+            },
+        });
+        submissionId = created?.data?.id;
+        if (!submissionId) {
+            throw new Error(`reviewSubmission 생성 응답에 id가 없어: ${JSON.stringify(created)}`);
+        }
+    }
+    // 2. 버전을 reviewSubmissionItems로 attach (이미 붙어있으면 skip)
+    const alreadyAttached = reusedSubmission ? await isVersionAttached(submissionId, versionId) : false;
+    if (!alreadyAttached) {
+        await apiPost('/reviewSubmissionItems', {
+            data: {
+                type: 'reviewSubmissionItems',
+                relationships: {
+                    reviewSubmission: { data: { type: 'reviewSubmissions', id: submissionId } },
+                    appStoreVersion: { data: { type: 'appStoreVersions', id: versionId } },
+                },
+            },
+        });
+    }
+    // 3. PATCH submitted=true → state: CREATED → WAITING_FOR_REVIEW
+    const submitted = await apiPatch(`/reviewSubmissions/${submissionId}`, {
+        data: {
+            type: 'reviewSubmissions',
+            id: submissionId,
+            attributes: { submitted: true },
+        },
+    });
+    return {
+        submissionId,
+        appId,
+        platform,
+        versionId,
+        reusedSubmission,
+        itemAttached: !alreadyAttached,
+        state: submitted?.data?.attributes?.state ?? 'WAITING_FOR_REVIEW',
+    };
+}

package/dist/index.js

@@ -631,10 +631,93 @@ server.tool('appstore_list_beta_groups', 'TestFlight 베타 그룹 목록', { ap
     const groups = await appstore.listBetaGroups(appId);
     return { content: [{ type: 'text', text: JSON.stringify(groups, null, 2) }] };
 });
-server.tool('appstore_get_app_info', 'App Store 앱 정보 (카테고리, 연령 등급)', { appId: z.string().describe('앱 ID') }, async ({ appId }) => {
+server.tool('appstore_get_app_info', 'App Store 앱 정보 (카테고리, 연령 등급, state). state=READY_FOR_DISTRIBUTION이 라이브, 그 외가 편집 가능 appInfo.', { appId: z.string().describe('앱 ID') }, async ({ appId }) => {
     const info = await appstore.getAppInfo(appId);
     return { content: [{ type: 'text', text: JSON.stringify(info, null, 2) }] };
 });
+server.tool('appstore_list_app_info_localizations', [
+    '편집 가능한 appInfo의 로컬라이제이션 목록 조회 — 앱 이름(name), 부제(subtitle), 개인정보 URL/텍스트.',
+    'appInfo.relationships.appInfoLocalizations가 빈 배열로 오는 케이스를 우회하려고 /appInfos/{id}/appInfoLocalizations 직접 호출.',
+    'locale을 주면 해당 언어만 반환 (예: "ko", "en-US").',
+    '※ versionLocalization(설명/키워드/whatsNew)과 다름 — 그건 appstore_get_metadata 사용.',
+].join(' '), {
+    appId: z.string().describe('앱 ID (appstore_list_apps 결과)'),
+    locale: z.string().optional().describe('언어 필터 (예: "ko", "en-US"). 생략 시 전체 반환.'),
+}, async ({ appId, locale }) => {
+    const result = await appstore.listAppInfoLocalizations(appId, locale);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('appstore_update_app_info_localization', [
+    'appInfo 로컬라이제이션(앱 이름/부제/개인정보 URL/텍스트) 수정 — PATCH /appInfoLocalizations/{id}.',
+    'localizationId는 appstore_list_app_info_localizations 결과의 id.',
+    '편집 가능 상태(PREPARE_FOR_SUBMISSION / DEVELOPER_REJECTED 등)에서만 반영됨.',
+    '제한: name 30자, subtitle 30자.',
+].join(' '), {
+    localizationId: z.string().describe('appInfoLocalization ID'),
+    name: z.string().optional().describe('앱 이름 (30자 이내)'),
+    subtitle: z.string().optional().describe('부제 (30자 이내)'),
+    privacyPolicyUrl: z.string().url().optional().describe('개인정보 처리방침 URL'),
+    privacyPolicyText: z.string().optional().describe('개인정보 처리방침 텍스트'),
+}, async ({ localizationId, ...fields }) => {
+    const result = await appstore.updateAppInfoLocalization(localizationId, fields);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+// --- App Store 고객 리뷰 ---
+server.tool('appstore_list_reviews', [
+    'App Store 받은 고객 리뷰 조회 (최신순).',
+    'response 필드에 개발자 답변 존재 여부와 내용이 함께 포함됨 (없으면 null).',
+    'territory(예: KOR/USA — ISO 3166 alpha-3) / rating(1~5)으로 필터 가능.',
+].join(' '), {
+    appId: z.string().describe('App Store 앱 ID (appstore_list_apps 결과)'),
+    limit: z.number().int().positive().max(200).optional().describe('가져올 개수 (기본 50, 최대 200)'),
+    territory: z.string().optional().describe("국가 코드 (예: 'KOR', 'USA' — alpha-3)"),
+    rating: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5)]).optional().describe('별점 필터 (1~5)'),
+}, async ({ appId, limit, territory, rating }) => {
+    const reviews = await appstore.listCustomerReviews(appId, { limit, territory, rating });
+    return { content: [{ type: 'text', text: JSON.stringify(reviews, null, 2) }] };
+});
+server.tool('appstore_reply_review', [
+    'App Store 고객 리뷰에 개발자 답변을 등록 (또는 갱신).',
+    '동일 리뷰에 한 번만 답변 가능 — 기존 답변이 있으면 Apple이 새 응답으로 대체함.',
+    'reviewId는 appstore_list_reviews 결과의 id.',
+    '답변 본문은 5970자 이내.',
+].join(' '), {
+    reviewId: z.string().describe('리뷰 ID (appstore_list_reviews 결과)'),
+    responseBody: z.string().describe('답변 본문 (5970자 이내)'),
+}, async ({ reviewId, responseBody }) => {
+    const result = await appstore.createReviewResponse(reviewId, responseBody);
+    return { content: [{ type: 'text', text: `✅ 리뷰 ${reviewId}에 답변 등록됐어.\n\n${JSON.stringify(result, null, 2)}` }] };
+});
+// --- App Store 심사 제출 (Submit for Review) ---
+server.tool('appstore_submit_for_review', [
+    'App Store 버전을 심사에 제출 — 새 reviewSubmissions API 사용 (옛 /appStoreVersionSubmissions는 2024-01 deprecated).',
+    '내부 흐름: POST /reviewSubmissions(또는 CREATED 상태 재사용) → POST /reviewSubmissionItems(version attach) → PATCH submitted=true.',
+    'appId와 platform은 versionId에서 자동 조회 — 별도 입력 불필요.',
+    '⚠️ 비가역 작업: 제출 후엔 Apple 심사가 시작되며, 메타데이터/스크린샷/빌드를 더 못 바꿈 (REJECTED/METADATA_REJECTED 시 다시 편집 가능).',
+    '사전 조건: 버전이 PREPARE_FOR_SUBMISSION 또는 DEVELOPER_REJECTED 상태, 빌드 attached, 모든 필수 메타데이터 채워짐.',
+    'appstore_check_submission_risks로 사전 점검 권장.',
+].join(' '), {
+    versionId: z.string().describe('App Store 버전 ID (appstore_list_versions 결과)'),
+}, async ({ versionId }) => {
+    const result = await appstore.submitVersionForReview(versionId);
+    return { content: [{ type: 'text', text: `✅ 버전 ${versionId} 심사 제출 완료 (state: ${result.state}). App Store Connect에서 진행 상태 확인 가능.\n\n${JSON.stringify(result, null, 2)}` }] };
+});
+// --- Play Store 심사 제출 / release status 변경 ---
+server.tool('playstore_submit_release', [
+    'Google Play 트랙의 release status를 변경 — 일반적으로 draft → completed로 바꿔 검토/배포 큐에 진입시킬 때 사용.',
+    '⚠️ status="completed"는 비가역에 가까움 (전체 출시 또는 Google 검토 시작). halted로 일시 중단은 가능하나 한 번 라이브된 release는 되돌리기 어려움.',
+    'status 옵션: draft(검토 미시작) / inProgress(단계 출시) / completed(전체 출시) / halted(중단).',
+    'playstore_check_submission_risks로 사전 점검 권장.',
+].join(' '), {
+    packageName: z.string().describe('패키지명 (예: gg.pryzm.coffee)'),
+    track: z.enum(['production', 'beta', 'alpha', 'internal']).describe('릴리스 트랙'),
+    versionCode: z.string().describe('대상 versionCode (문자열)'),
+    status: z.enum(['draft', 'inProgress', 'completed', 'halted']).optional().describe('새 status (기본: completed)'),
+}, async ({ packageName, track, versionCode, status }) => {
+    const auth = requireAuth();
+    const result = await playstore.submitRelease(auth, packageName, track, versionCode, status);
+    return { content: [{ type: 'text', text: `✅ ${packageName} ${track} v${versionCode}: ${result.previousStatus} → ${result.newStatus}\n\n${JSON.stringify(result, null, 2)}` }] };
+});
 // --- 인증 상태 ---
 server.tool('mimi_seed_auth_start', [
     'Google OAuth 로그인 링크를 발급하고 백그라운드 콜백 서버를 시작.',

package/dist/playstore/tools.d.ts

@@ -54,6 +54,14 @@ export declare function replaceImages(auth: OAuth2Client, packageName: string, l
         sha256?: string | null;
     }[];
 }>;
+export declare function submitRelease(auth: OAuth2Client, packageName: string, track: string, versionCode: string, status?: 'completed' | 'draft' | 'inProgress' | 'halted'): Promise<{
+    track: string;
+    versionCode: string;
+    previousStatus: string | null | undefined;
+    newStatus: "completed" | "draft" | "inProgress" | "halted";
+    committed: boolean;
+    result: import("googleapis").androidpublisher_v3.Schema$Track;
+}>;
 export declare function listReviews(auth: OAuth2Client, packageName: string): Promise<{
     reviewId: string | null | undefined;
     authorName: string | null | undefined;

package/dist/playstore/tools.js

@@ -221,6 +221,47 @@ export async function replaceImages(auth, packageName, language, imageType, file
     }, true);
 }
 // ─── 리뷰 조회 ───
+// ─── 릴리스 상태 변경 / 심사 제출 ───
+//
+// Play Store는 명시적 "Submit for Review" 버튼이 없고, track의 release
+// status를 "completed"로 바꾸면 자동으로 심사 큐에 들어감 (또는 즉시 publish).
+// status: draft → 검토 미시작, inProgress → 단계적 출시, completed → 전체 출시
+//        halted → 일시 중단
+// 신중히 사용해야 함 — completed로 바꾸면 되돌리기 어려움.
+export async function submitRelease(auth, packageName, track, versionCode, status = 'completed') {
+    return withEdit(auth, packageName, async (editId) => {
+        const current = await publisher().edits.tracks.get({
+            auth, packageName, editId, track,
+        });
+        const releases = current.data.releases ?? [];
+        if (releases.length === 0) {
+            throw new Error(`${track} 트랙에 릴리스가 없어.`);
+        }
+        const target = releases.find((r) => (r.versionCodes ?? []).some((v) => String(v) === String(versionCode)));
+        if (!target) {
+            const available = releases.map((r) => ({
+                name: r.name,
+                versionCodes: r.versionCodes,
+                status: r.status,
+            }));
+            throw new Error(`versionCode "${versionCode}"를 ${track} 트랙에서 찾을 수 없어. 가능한 릴리스: ${JSON.stringify(available)}`);
+        }
+        const previousStatus = target.status;
+        target.status = status;
+        const updated = await publisher().edits.tracks.update({
+            auth, packageName, editId, track,
+            requestBody: { track, releases },
+        });
+        return {
+            track,
+            versionCode,
+            previousStatus,
+            newStatus: status,
+            committed: true,
+            result: updated.data,
+        };
+    }, true);
+}
 export async function listReviews(auth, packageName) {
     const res = await publisher().reviews.list({ auth, packageName });
     return (res.data.reviews ?? []).map((r) => ({

package/package.json

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