@yoonion/mimi-seed-mcp 0.19.13 → 0.19.17

package/dist/googleads/tools.js

@@ -1,9 +1,34 @@
 import { fetchWithTimeout } from '../lib/http.js';
+import { googleAdsError } from './errors.js';
 // Google Ads API는 ~13개월 주기로 sunset (항상 최신 3개 major만 유지).
 // v24 = 2026-06 기준 현행 major. 새 major 출시 시 갱신 필요.
 // https://developers.google.com/google-ads/api/docs/sunset-dates
 const API_VERSION = 'v24';
 const BASE = `https://googleads.googleapis.com/${API_VERSION}`;
+export const REPORT_METRIC_NOTE = 'cost is in account currency, not micros. conversions are Google Ads conversions, not necessarily installs. Legacy installs/cpi aliases do not establish install CPI or cohort D7 ROAS.';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function metricNumber(value) {
+    // Protobuf JSON can omit zero-valued scalars, but explicit malformed values are not zero.
+    if (value === undefined)
+        return 0;
+    if ((typeof value !== 'number' && typeof value !== 'string') ||
+        (typeof value === 'string' && !/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)) ||
+        !Number.isFinite(Number(value)))
+        throw new Error('Google Ads returned an invalid numeric metric.');
+    return Number(value);
+}
+function validateDateRange(range) {
+    for (const value of [range.startDate, range.endDate]) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(value) ||
+            !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) {
+            throw new Error('Google Ads dates must be valid YYYY-MM-DD calendar dates.');
+        }
+    }
+    if (range.startDate > range.endDate)
+        throw new Error('Google Ads startDate must not exceed endDate.');
+}
 // ─── 내부 헬퍼 ───────────────────────────────────────────────
 async function getAccessToken(auth) {
     const token = await auth.getAccessToken();
@@ -28,8 +53,10 @@ async function search(auth, cfg, query) {
     const url = `${BASE}/customers/${cfg.customerId}/googleAds:search`;
     const all = [];
     let pageToken;
+    const seenTokens = new Set();
     do {
-        const body = { query, pageSize: 1000 };
+        // Google Ads controls page size; sending pageSize is rejected by current APIs.
+        const body = { query };
         if (pageToken)
             body.pageToken = pageToken;
         const res = await fetchWithTimeout(url, {
@@ -39,27 +66,36 @@ async function search(auth, cfg, query) {
         });
         const text = await res.text();
         if (!res.ok) {
-            let msg = `Google Ads API ${res.status}`;
-            try {
-                const err = JSON.parse(text);
-                const detail = err?.error?.message ?? err?.[0]?.error?.message ?? text;
-                msg += `: ${detail}`;
-            }
-            catch {
-                msg += `: ${text.slice(0, 300)}`;
-            }
-            throw new Error(msg);
+            throw googleAdsError(res.status, text, [accessToken, cfg.developerToken]);
+        }
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            throw new Error('Google Ads returned invalid JSON.');
+        }
+        if (!isRecord(json) || 'error' in json ||
+            (json.results !== undefined && !Array.isArray(json.results)) ||
+            (json.nextPageToken !== undefined && typeof json.nextPageToken !== 'string') ||
+            (json.results ?? []).some((row) => !isRecord(row) || !isRecord(row.campaign))) {
+            throw new Error('Google Ads returned an invalid search response.');
         }
-        const json = JSON.parse(text);
         all.push(...(json.results ?? []));
         pageToken = json.nextPageToken ?? undefined;
+        if (pageToken) {
+            if (seenTokens.has(pageToken))
+                throw new Error('Google Ads repeated a page token; refusing partial totals.');
+            seenTokens.add(pageToken);
+        }
     } while (pageToken);
     return all;
 }
 function microsToCurrency(micros) {
-    if (micros == null)
-        return 0;
-    return Number(micros) / 1_000_000;
+    const value = metricNumber(micros);
+    if (!Number.isSafeInteger(value))
+        throw new Error('Google Ads returned unsafe or fractional currency micros.');
+    return value / 1_000_000;
 }
 // ─── 접근 가능한 고객 목록 (API 연결 확인용) ─────────────────────
 export async function listAccessibleCustomers(auth, cfg) {
@@ -71,15 +107,7 @@ export async function listAccessibleCustomers(auth, cfg) {
     });
     const text = await res.text();
     if (!res.ok) {
-        let msg = `Google Ads API ${res.status}`;
-        try {
-            const err = JSON.parse(text);
-            msg += `: ${err?.error?.message ?? text.slice(0, 300)}`;
-        }
-        catch {
-            msg += `: ${text.slice(0, 300)}`;
-        }
-        throw new Error(msg);
+        throw googleAdsError(res.status, text, [accessToken, cfg.developerToken]);
     }
     return JSON.parse(text);
 }
@@ -92,8 +120,8 @@ export async function listCampaigns(auth, cfg) {
       campaign.status,
       campaign.advertising_channel_type,
       campaign.advertising_channel_sub_type,
-      campaign.start_date,
-      campaign.end_date,
+      campaign.start_date_time,
+      campaign.end_date_time,
       campaign_budget.amount_micros
     FROM campaign
     WHERE campaign.status != 'REMOVED'
@@ -107,15 +135,19 @@ export async function listCampaigns(auth, cfg) {
         status: r.campaign?.status,
         channelType: r.campaign?.advertisingChannelType,
         channelSubType: r.campaign?.advertisingChannelSubType,
-        startDate: r.campaign?.startDate,
-        endDate: r.campaign?.endDate,
+        // Keep date-only response fields compatible while querying the supported schema.
+        startDate: r.campaign?.startDateTime?.slice(0, 10),
+        endDate: r.campaign?.endDateTime?.slice(0, 10),
         dailyBudget: microsToCurrency(r.campaignBudget?.amountMicros),
     }));
 }
 // ─── 캠페인 성과 리포트 ────────────────────────────────────────
 export async function getCampaignReport(auth, cfg, range) {
+    validateDateRange(range);
     const query = `
     SELECT
+      customer.currency_code,
+      customer.time_zone,
       campaign.id,
       campaign.name,
       campaign.status,
@@ -130,30 +162,37 @@ export async function getCampaignReport(auth, cfg, range) {
       metrics.ctr,
       metrics.average_cpc
     FROM campaign
-    WHERE campaign.status != 'REMOVED'
-      AND segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'
+    WHERE segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'
     ORDER BY metrics.cost_micros DESC
-    LIMIT 500
   `;
     const rows = await search(auth, cfg, query);
+    for (const row of rows) {
+        if (!isRecord(row.metrics))
+            throw new Error('Google Ads report row is missing metrics.');
+    }
     return rows.map((r) => ({
+        currencyCode: r.customer?.currencyCode,
+        timeZone: r.customer?.timeZone,
         id: r.campaign?.id,
         name: r.campaign?.name,
         status: r.campaign?.status,
         channelType: r.campaign?.advertisingChannelType,
         channelSubType: r.campaign?.advertisingChannelSubType,
-        clicks: Number(r.metrics?.clicks ?? 0),
-        impressions: Number(r.metrics?.impressions ?? 0),
+        clicks: metricNumber(r.metrics?.clicks),
+        impressions: metricNumber(r.metrics?.impressions),
         cost: microsToCurrency(r.metrics?.costMicros),
-        conversions: Number(r.metrics?.conversions ?? 0),
-        conversionsValue: Number(r.metrics?.conversionsValue ?? 0),
-        cpi: microsToCurrency(r.metrics?.costPerConversion),
-        ctr: Number(r.metrics?.ctr ?? 0),
-        avgCpc: microsToCurrency(r.metrics?.averageCpc),
+        conversions: metricNumber(r.metrics?.conversions),
+        conversionsValue: metricNumber(r.metrics?.conversionsValue),
+        costPerConversion: metricNumber(r.metrics?.conversions) > 0
+            ? metricNumber(r.metrics?.costPerConversion) / 1_000_000 : null,
+        cpi: metricNumber(r.metrics?.costPerConversion) / 1_000_000,
+        ctr: metricNumber(r.metrics?.ctr),
+        avgCpc: metricNumber(r.metrics?.averageCpc) / 1_000_000,
     }));
 }
 // ─── UAC(앱 캠페인) 리포트 ─────────────────────────────────────
 export async function getUacReport(auth, cfg, range) {
+    validateDateRange(range);
     const query = `
     SELECT
       campaign.id,
@@ -173,21 +212,22 @@ export async function getUacReport(auth, cfg, range) {
       AND campaign.advertising_channel_sub_type IN ('APP_CAMPAIGN', 'APP_CAMPAIGN_FOR_ENGAGEMENT', 'APP_CAMPAIGN_FOR_PRE_REGISTRATION')
       AND segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'
     ORDER BY segments.date DESC, metrics.cost_micros DESC
-    LIMIT 500
   `;
     const rows = await search(auth, cfg, query);
     const byId = new Map();
     for (const r of rows) {
+        if (!isRecord(r.metrics) || !r.campaign?.id)
+            throw new Error('Google Ads UAC row is missing campaign or metrics.');
         const id = String(r.campaign?.id ?? '');
         const existing = byId.get(id);
         const cost = microsToCurrency(r.metrics?.costMicros);
-        const installs = Number(r.metrics?.conversions ?? 0);
+        const installs = metricNumber(r.metrics?.conversions);
         if (existing) {
-            existing.clicks += Number(r.metrics?.clicks ?? 0);
-            existing.impressions += Number(r.metrics?.impressions ?? 0);
+            existing.clicks += metricNumber(r.metrics?.clicks);
+            existing.impressions += metricNumber(r.metrics?.impressions);
             existing.cost += cost;
             existing.installs += installs;
-            existing.installsValue += Number(r.metrics?.conversionsValue ?? 0);
+            existing.installsValue += metricNumber(r.metrics?.conversionsValue);
             if (r.segments?.date)
                 existing.dates.push(r.segments.date);
         }
@@ -197,11 +237,11 @@ export async function getUacReport(auth, cfg, range) {
                 name: r.campaign?.name ?? '',
                 status: r.campaign?.status ?? '',
                 subType: r.campaign?.advertisingChannelSubType ?? '',
-                clicks: Number(r.metrics?.clicks ?? 0),
-                impressions: Number(r.metrics?.impressions ?? 0),
+                clicks: metricNumber(r.metrics?.clicks),
+                impressions: metricNumber(r.metrics?.impressions),
                 cost,
                 installs,
-                installsValue: Number(r.metrics?.conversionsValue ?? 0),
+                installsValue: metricNumber(r.metrics?.conversionsValue),
                 dates: r.segments?.date ? [r.segments.date] : [],
             });
         }
@@ -214,6 +254,9 @@ export async function getUacReport(auth, cfg, range) {
         clicks: c.clicks,
         impressions: c.impressions,
         cost: c.cost,
+        conversions: c.installs,
+        conversionsValue: c.installsValue,
+        costPerConversion: c.installs > 0 ? c.cost / c.installs : null,
         installs: c.installs,
         installsValue: c.installsValue,
         cpi: c.installs > 0 ? c.cost / c.installs : 0,

package/dist/helpers.d.ts

@@ -8,7 +8,7 @@ export { ensureFreshAccessToken };
  * 기존엔 만료 시 각 OAuth 도구(firebase/admob/iam/googleads/checks)가
  * googleapis GaxiosError 를 그대로 노출 → 사용자는 "재로그인하라"는 안내를 못 받았다.
  */
-export declare function requireAuth(requiredScope?: string): Promise<import("google-auth-library").OAuth2Client>;
+export declare function requireAuth(requiredScope?: string, profile?: string): Promise<import("google-auth-library").OAuth2Client>;
 export declare const PLAY_AUTH_HINT: string;
 export declare const APPSTORE_AUTH_HINT: string;
 /**

package/dist/helpers.js

@@ -4,13 +4,13 @@ import { getServiceAccountClient, getServiceAccountJson } from './auth/playstore
 import { getAppStoreCredentials } from './appstore/auth.js';
 export { ensureFreshAccessToken };
 const REAUTH_CMD = '  npx -y @yoonion/mimi-seed-mcp mimi-seed-auth';
-function formatAuthError(p) {
+function formatAuthError(p, profile) {
     // 재로그인 안내는 needsReauth 인 경우에만 — CONFIG_FETCH_FAILED 처럼 재로그인이
     // 해법이 아닌 에러에 무조건 붙이면 같은 실패를 반복하게 만든다.
     return [
         `❌ [${p.code}] ${p.message}`,
         p.hint ? `→ ${p.hint}` : '',
-        ...(p.needsReauth ? ['', '터미널에서 재로그인:', REAUTH_CMD] : []),
+        ...(p.needsReauth ? ['', '터미널에서 재로그인:', profile === undefined ? REAUTH_CMD : `${REAUTH_CMD} --profile ${profile}`] : []),
     ]
         .filter((l) => l !== '')
         .join('\n');
@@ -28,10 +28,10 @@ function formatAuthError(p) {
  *
  * OAuth 토큰에만 적용된다 — SA JWT 는 자체 scopes 로 토큰을 받으므로 이 검사 대상이 아니다.
  */
-function assertStoredScope(requiredScope) {
+function assertStoredScope(requiredScope, profile) {
     if (!requiredScope)
         return;
-    const scopeStr = getStoredTokens()?.scope;
+    const scopeStr = getStoredTokens(profile)?.scope;
     const missing = scopeStr === undefined
         ? !isPreTrackingScope(requiredScope)
         : !scopeStr.split(' ').filter(Boolean).includes(requiredScope);
@@ -42,7 +42,7 @@ function assertStoredScope(requiredScope) {
         code: 'INSUFFICIENT_SCOPE',
         message: `이 도구는 추가 권한이 필요해 (${requiredScope}). 현재 로그인에 그 권한이 없어.`,
         hint: domainArg
-            ? `mimi-seed-auth --domains ${domainArg} 로 재로그인하면 기존 권한은 유지한 채 이 권한만 추가돼.`
+            ? `mimi-seed-auth${profile === undefined ? '' : ` --profile ${profile}`} --domains ${domainArg} 로 재로그인하면 기존 권한은 유지한 채 이 권한만 추가돼.`
             : 'mimi-seed-auth 로 재로그인하면 새 권한이 부여돼.',
         retriable: false,
         needsReauth: true,
@@ -56,12 +56,12 @@ function assertStoredScope(requiredScope) {
  * 기존엔 만료 시 각 OAuth 도구(firebase/admob/iam/googleads/checks)가
  * googleapis GaxiosError 를 그대로 노출 → 사용자는 "재로그인하라"는 안내를 못 받았다.
  */
-export async function requireAuth(requiredScope) {
-    const result = await ensureFreshAccessToken();
+export async function requireAuth(requiredScope, profile) {
+    const result = await ensureFreshAccessToken(undefined, profile);
     if (result.status === 'unauthenticated' || result.status === 'expired_refresh_failed') {
-        throw new Error(formatAuthError(result.error));
+        throw new Error(formatAuthError(result.error, profile));
     }
-    const client = getAuthenticatedClient();
+    const client = getAuthenticatedClient(profile);
     if (!client) {
         throw new Error(formatAuthError({
             code: 'UNAUTHENTICATED',
@@ -71,7 +71,7 @@ export async function requireAuth(requiredScope) {
             needsReauth: true,
         }));
     }
-    assertStoredScope(requiredScope);
+    assertStoredScope(requiredScope, profile);
     return client;
 }
 export const PLAY_AUTH_HINT = [

package/dist/instagram/browser-login.d.ts

@@ -0,0 +1,13 @@
+import { type SocialConfigOptions } from '../social/profile-store.js';
+export declare class InstagramLoginError extends Error {
+    readonly code: 'configuration' | 'unavailable' | 'denied' | 'timeout' | 'exchange' | 'validation';
+    constructor(code: 'configuration' | 'unavailable' | 'denied' | 'timeout' | 'exchange' | 'validation');
+}
+export interface BrowserLoginOptions extends SocialConfigOptions {
+    webBase?: string;
+    timeoutMs?: number;
+    openBrowser?: (url: string) => Promise<void>;
+    onUrl?: (url: string) => void;
+}
+/** The broker keeps the Meta app secret server-side; no token is passed through browser URLs. */
+export declare function connectInstagramInBrowser(options?: BrowserLoginOptions): Promise<import("../facebook/setup.js").ConnectResult>;

package/dist/instagram/browser-login.js

@@ -0,0 +1,125 @@
+import { createServer } from 'node:http';
+import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
+import { fetchWithTimeout } from '../lib/http.js';
+import { openSystemBrowser } from '../auth/browser.js';
+import { connectInstagram } from './setup.js';
+import { resolveSocialConfigTarget } from '../social/profile-store.js';
+export class InstagramLoginError extends Error {
+    code;
+    constructor(code) {
+        super(`Instagram browser login: ${code}`);
+        this.code = code;
+    }
+}
+/** The broker keeps the Meta app secret server-side; no token is passed through browser URLs. */
+export async function connectInstagramInBrowser(options = {}) {
+    // Freeze the selected profile before any asynchronous work / directory changes.
+    const target = resolveSocialConfigTarget('instagram', options);
+    const saveOptions = { ...options, profile: target.profile ?? undefined, startDir: options.startDir ?? process.cwd() };
+    const base = new URL(options.webBase ?? process.env.MIMI_SEED_WEB_BASE ?? 'https://mimi-seed.pryzm.gg');
+    if (base.protocol !== 'https:' || base.username || base.password || base.search || base.hash || base.pathname !== '/') {
+        throw new InstagramLoginError('configuration');
+    }
+    const state = randomBytes(32).toString('hex');
+    const verifier = randomBytes(32).toString('base64url');
+    const codeChallenge = createHash('sha256').update(verifier).digest('base64url');
+    const timeoutMs = options.timeoutMs ?? 600_000;
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 600_000)
+        throw new InstagramLoginError('configuration');
+    let finish;
+    let fail;
+    let settled = false;
+    const callback = new Promise((resolve, reject) => { finish = resolve; fail = reject; });
+    // A denial/timeout can arrive while opening the browser. Attach a handler immediately.
+    void callback.catch(() => { });
+    const server = createServer((req, res) => {
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('Referrer-Policy', 'no-referrer');
+        res.setHeader('Content-Security-Policy', "default-src 'none'");
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        if (req.method !== 'GET' || url.pathname !== '/instagram/callback') {
+            res.writeHead(404).end();
+            return;
+        }
+        const actual = url.searchParams.get('state') ?? '';
+        if (!/^[a-f0-9]{64}$/.test(actual) || !timingSafeEqual(Buffer.from(actual), Buffer.from(state))) {
+            res.writeHead(400).end('Invalid login state.');
+            return;
+        }
+        if (settled) {
+            res.writeHead(409).end('Login already handled.');
+            return;
+        }
+        if (url.searchParams.has('error')) {
+            settled = true;
+            res.writeHead(400).end('Instagram login cancelled. Return to Mimi Seed.');
+            fail(new InstagramLoginError('denied'));
+            return;
+        }
+        const code = url.searchParams.get('code');
+        const ticket = url.searchParams.get('ticket');
+        if (!code || code.length > 4096 || !ticket || ticket.length > 8192) {
+            res.writeHead(400).end('Invalid callback.');
+            return;
+        }
+        settled = true;
+        res.end('Instagram approval received. Return to Mimi Seed to check the connection result.');
+        finish({ code, ticket });
+    });
+    let timer;
+    try {
+        await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new InstagramLoginError('configuration');
+        timer = setTimeout(() => { settled = true; fail(new InstagramLoginError('timeout')); }, timeoutMs);
+        const request = async (path, body) => {
+            try {
+                const response = await fetchWithTimeout(new URL(path, base), {
+                    method: 'POST', redirect: 'error', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+                }, 30_000);
+                if (!response.ok)
+                    throw new InstagramLoginError(response.status === 503 || response.status === 404 ? 'unavailable' : 'exchange');
+                return await response.json();
+            }
+            catch (error) {
+                if (error instanceof InstagramLoginError)
+                    throw error;
+                // Network/provider exceptions may contain codes or tokens. Do not echo them.
+                throw new InstagramLoginError('unavailable');
+            }
+        };
+        const start = await request('/api/instagram-auth/start', { state, codeChallenge, callbackPort: address.port });
+        if (typeof start.authorizationUrl !== 'string')
+            throw new InstagramLoginError('configuration');
+        const authorize = new URL(start.authorizationUrl);
+        if (authorize.origin !== base.origin || authorize.pathname !== '/api/instagram-auth/authorize' || authorize.username || authorize.password) {
+            throw new InstagramLoginError('configuration');
+        }
+        options.onUrl?.(authorize.href);
+        try {
+            await (options.openBrowser ?? openSystemBrowser)(authorize.href);
+        }
+        catch {
+            if (!options.onUrl)
+                throw new InstagramLoginError('unavailable');
+        }
+        const result = await callback;
+        const token = await request('/api/instagram-auth/exchange', { ...result, codeVerifier: verifier });
+        if (typeof token.accessToken !== 'string' || !token.accessToken || typeof token.userId !== 'string' || !token.userId ||
+            typeof token.expiresInSeconds !== 'number' || !Number.isFinite(token.expiresInSeconds) || token.expiresInSeconds <= 0 || token.expiresInSeconds > 60 * 24 * 3600) {
+            throw new InstagramLoginError('exchange');
+        }
+        // Resolve the canonical account ID from /me: numeric OAuth user_id values can lose precision.
+        const connected = await connectInstagram(token.accessToken, undefined, true, saveOptions, token.expiresInSeconds);
+        if (!connected.ok)
+            throw new InstagramLoginError('validation');
+        return connected;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        server.close();
+        server.closeAllConnections();
+    }
+}

package/dist/instagram/setup.d.ts

@@ -2,4 +2,4 @@ import type { ConnectResult } from '../facebook/setup.js';
 import type { SocialConfigOptions } from '../social/profile-store.js';
 /** IGAA… = Instagram Login(신규) · EAA… = Facebook Login(FB Page + IG Business 연결 필요) */
 export declare function detectApiType(accessToken: string): string;
-export declare function connectInstagram(accessToken: string, userId?: string, assumeIssuedNow?: boolean, options?: SocialConfigOptions): Promise<ConnectResult>;
+export declare function connectInstagram(accessToken: string, userId?: string, assumeIssuedNow?: boolean, options?: SocialConfigOptions, expiresInSeconds?: number): Promise<ConnectResult>;

package/dist/instagram/setup.js

@@ -8,7 +8,10 @@ const SIXTY_DAYS_MS = 60 * 24 * 60 * 60 * 1000;
 export function detectApiType(accessToken) {
     return accessToken.startsWith('IGAA') ? 'Instagram Login' : 'Facebook Login';
 }
-export async function connectInstagram(accessToken, userId, assumeIssuedNow = true, options = {}) {
+export async function connectInstagram(accessToken, userId, assumeIssuedNow = true, options = {}, expiresInSeconds) {
+    if (expiresInSeconds !== undefined && (!Number.isFinite(expiresInSeconds) || expiresInSeconds <= 0 || expiresInSeconds > 5_184_000)) {
+        return { ok: false, text: 'Invalid Instagram token lifetime; nothing was saved.' };
+    }
     // 프로필 ID를 네트워크 호출 전에 검증하고, 성공 응답에 실제 저장 대상을 남긴다.
     const target = resolveSocialConfigTarget('instagram', options);
     const apiType = detectApiType(accessToken);
@@ -30,7 +33,7 @@ export async function connectInstagram(accessToken, userId, assumeIssuedNow = tr
         }
     }
     const expiresAt = assumeIssuedNow
-        ? new Date(Date.now() + SIXTY_DAYS_MS).toISOString()
+        ? new Date(Date.now() + (expiresInSeconds === undefined ? SIXTY_DAYS_MS : expiresInSeconds * 1000)).toISOString()
         : undefined;
     try {
         const account = await api.getAccount({ accessToken, userId: resolvedUserId });

package/dist/lib/googleapis-lite.d.ts

@@ -1,4 +1,5 @@
 export type { youtube_v3 } from 'googleapis/build/src/apis/youtube/index.js';
+export type { youtubeAnalytics_v2 } from 'googleapis/build/src/apis/youtubeAnalytics/index.js';
 /**
  * 기존 `google.<api>(...)` 호출부와 100% 동일하게 동작하는 지연 로딩 네임스페이스.
  * 각 프로퍼티는 getter 라서, 실제로 그 API 를 쓰는 도구가 호출될 때까지 아무것도 로드하지 않는다.
@@ -19,4 +20,5 @@ export declare const google: {
     readonly searchconsole: typeof import("googleapis/build/src/apis/searchconsole/index.js").searchconsole;
     readonly serviceusage: typeof import("googleapis/build/src/apis/serviceusage/index.js").serviceusage;
     readonly youtube: typeof import("googleapis/build/src/apis/youtube/index.js").youtube;
+    readonly youtubeAnalytics: typeof import("googleapis/build/src/apis/youtubeAnalytics/index.js").youtubeAnalytics;
 };

package/dist/lib/googleapis-lite.js

@@ -91,4 +91,7 @@ export const google = {
     get youtube() {
         return sub('youtube').youtube;
     },
+    get youtubeAnalytics() {
+        return sub('youtubeAnalytics').youtubeAnalytics;
+    },
 };