@yoonion/mimi-seed-mcp 0.19.13 → 0.19.17

package/dist/auth/google-auth.js

@@ -1,12 +1,14 @@
 import { google } from '../lib/googleapis-lite.js';
 import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { verifyYouTubeChannel, YOUTUBE_CHANNEL_ID } from './youtube-channel.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { getMcpOAuthClient } from './constants.js';
 import { AuthError, classifyError } from './errors.js';
 // 스코프 목록의 SSOT 는 scopes.ts (도메인 → 스코프 매핑). 여기서는 로그인 요청 조립만 한다.
-import { scopesForDomains, mergeScopeStrings } from './scopes.js';
+import { scopesForDomains } from './scopes.js';
 import { writeCredentialJson } from '../lib/atomic-write.js';
 // Primary config dir. Legacy `~/.preseed` is read as a fallback during the
 // rebrand so existing auth sessions don't force a re-login; new writes go to
@@ -16,7 +18,36 @@ const LEGACY_TOKEN_DIR = path.join(os.homedir(), '.preseed');
 const TOKEN_PATH = path.join(TOKEN_DIR, 'tokens.json');
 const LEGACY_TOKEN_PATH = path.join(LEGACY_TOKEN_DIR, 'tokens.json');
 const CREDENTIALS_PATH = path.join(TOKEN_DIR, 'credentials.json');
-export function getStoredCredentials() {
+export const GOOGLE_PROFILE_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+export function googleProfilePath(profile) {
+    if (!GOOGLE_PROFILE_ID.test(profile))
+        throw new Error('Invalid Google profile ID: use lowercase letters, digits, _ or - (1–64 characters).');
+    return path.join(TOKEN_DIR, 'google-profiles', `${profile}.json`);
+}
+function readProfile(profile) {
+    const file = googleProfilePath(profile);
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Only safe metadata; never return tokens or OAuth client secrets to MCP callers. */
+export function listGoogleProfiles() {
+    const dir = path.join(TOKEN_DIR, 'google-profiles');
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((file) => file.endsWith('.json') && GOOGLE_PROFILE_ID.test(file.slice(0, -5)))
+        .sort().map((file) => {
+        const profile = file.slice(0, -5);
+        const tokens = readProfile(profile)?.tokens;
+        return { profile, connected: !!tokens?.refresh_token, youtubeChannel: tokens?.youtubeChannel ?? null };
+    });
+}
+export function getStoredCredentials(profile) {
+    if (profile !== undefined)
+        return readProfile(profile)?.credentials ?? null;
     if (!fs.existsSync(CREDENTIALS_PATH))
         return null;
     try {
@@ -30,7 +61,9 @@ export function getStoredCredentials() {
 export function saveCredentials(clientId, clientSecret) {
     writeCredentialJson(CREDENTIALS_PATH, { clientId, clientSecret });
 }
-export function getStoredTokens() {
+export function getStoredTokens(profile) {
+    if (profile !== undefined)
+        return readProfile(profile)?.tokens ?? null;
     // Prefer new dir; fall back to legacy ~/.preseed during the rebrand window.
     const pathToRead = fs.existsSync(TOKEN_PATH)
         ? TOKEN_PATH
@@ -52,7 +85,16 @@ export function getStoredTokens() {
  * Google refresh_token 은 7일(미인증 앱) ~ 6개월(인증 앱) 미사용 시 revoke 됨.
  * auth_status 응답 enrichment 에 사용.
  */
-export function getTokensLastRefreshMs() {
+export function getTokensLastRefreshMs(profile) {
+    if (profile !== undefined) {
+        const file = googleProfilePath(profile);
+        try {
+            return fs.statSync(file).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
     const pathToRead = fs.existsSync(TOKEN_PATH)
         ? TOKEN_PATH
         : fs.existsSync(LEGACY_TOKEN_PATH)
@@ -69,8 +111,19 @@ export function getTokensLastRefreshMs() {
 }
 // 원자적 교체가 특히 중요한 지점 — 이 함수는 access_token 만료 5분 전마다 다시 불리고,
 // MCP 서버 인스턴스 여러 개와 CLI 가 같은 tokens.json 을 동시에 노린다.
-function saveTokens(tokens) {
-    writeCredentialJson(TOKEN_PATH, tokens);
+function saveTokens(tokens, profile, credentials) {
+    if (profile !== undefined) {
+        const creds = credentials ?? getStoredCredentials(profile);
+        if (!creds)
+            throw new Error(`Missing OAuth credentials for profile ${profile}. Sign in again.`);
+        // Client credentials and tokens belong to one grant and commit together.
+        writeCredentialJson(googleProfilePath(profile), { credentials: creds, tokens });
+    }
+    else {
+        if (credentials)
+            saveCredentials(credentials.clientId, credentials.clientSecret);
+        writeCredentialJson(TOKEN_PATH, tokens);
+    }
 }
 export function createOAuth2Client(clientId, clientSecret) {
     return new google.auth.OAuth2(clientId, clientSecret, 'http://localhost:9876/callback');
@@ -79,32 +132,34 @@ export function createOAuth2Client(clientId, clientSecret) {
  * Get authenticated OAuth2 client.
  * Returns null if not authenticated yet.
  */
-export function getAuthenticatedClient() {
-    const creds = getStoredCredentials();
+export function getAuthenticatedClient(profile) {
+    const creds = getStoredCredentials(profile);
     if (!creds)
         return null;
-    const tokens = getStoredTokens();
+    const tokens = getStoredTokens(profile);
     if (!tokens)
         return null;
     const client = createOAuth2Client(creds.clientId, creds.clientSecret);
     client.setCredentials(tokens);
     // Auto-refresh
     client.on('tokens', (newTokens) => {
-        const stored = getStoredTokens();
-        if (stored) {
+        const stored = getStoredTokens(profile);
+        if (stored && stored.refresh_token === tokens.refresh_token) {
             saveTokens({
                 ...stored,
                 ...(newTokens.access_token && { access_token: newTokens.access_token }),
                 ...(newTokens.refresh_token && { refresh_token: newTokens.refresh_token }),
                 ...(newTokens.expiry_date && { expiry_date: newTokens.expiry_date }),
                 ...(newTokens.scope && { scope: newTokens.scope }),
-            });
+            }, profile);
         }
     });
     return client;
 }
 // 동시 실행 방지용 — 활성 콜백 서버 참조
-let activeAuthServer = null;
+let cancelActiveAuth = null;
+const authAttempts = new Map();
+export function getGoogleAuthAttempt(profile) { return authAttempts.get(profile ?? '') ?? null; }
 /**
  * OAuth 플로우 시작.
  * URL과 대기 Promise를 즉시 반환. localhost:9876 콜백 서버는 백그라운드로 실행.
@@ -117,17 +172,22 @@ let activeAuthServer = null;
  * 얹는다(incremental authorization) — 토큰 응답의 scope 필드에도 누적 전체가 온다.
  */
 export function startAuth(clientId, clientSecret, options = {}) {
-    if (activeAuthServer) {
-        try {
-            activeAuthServer.close();
-        }
-        catch { /* noop */ }
-        activeAuthServer = null;
+    const { profile, expectedChannelId } = options;
+    if (profile !== undefined)
+        googleProfilePath(profile);
+    if (expectedChannelId !== undefined && (!profile || !YOUTUBE_CHANNEL_ID.test(expectedChannelId))) {
+        throw new Error('expectedChannelId requires a named profile and a valid YouTube channel ID.');
     }
-    saveCredentials(clientId, clientSecret);
+    if (cancelActiveAuth)
+        cancelActiveAuth();
+    const attempt = { status: 'pending', expectedChannelId };
+    authAttempts.set(profile ?? '', attempt);
     const oauth2Client = createOAuth2Client(clientId, clientSecret);
-    const requestedScopes = scopesForDomains(options.domains);
+    const needsYouTubeDomain = expectedChannelId && options.domains && !options.domains.some((id) => id === 'youtube' || id === 'youtube_analytics');
+    const requestedScopes = scopesForDomains(needsYouTubeDomain ? [...new Set([...options.domains, 'youtube'])] : options.domains);
+    const state = randomUUID();
     const authUrl = oauth2Client.generateAuthUrl({
+        state,
         access_type: 'offline',
         scope: requestedScopes,
         // Private windows can still share cookies with an already-running private session.
@@ -136,8 +196,12 @@ export function startAuth(clientId, clientSecret, options = {}) {
         prompt: 'consent select_account',
         include_granted_scopes: true,
     });
+    let exchanging = false;
     const wait = new Promise((resolve, reject) => {
-        const rejectAuth = (e) => reject(new AuthError(classifyError(e, { phase: 'login' })));
+        const rejectAuth = (e) => {
+            attempt.status = 'failed';
+            reject(new AuthError(classifyError(e, { phase: 'login' })));
+        };
         // 핸들러 전체가 try/catch 로 감싸여 있고 모든 경로가 응답 후 rejectAuth 로 끝난다 —
         // createServer 가 void 를 기대하지만 여기서 새어 나갈 rejection 은 없다.
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -149,16 +213,20 @@ export function startAuth(clientId, clientSecret, options = {}) {
                     res.end();
                     return;
                 }
+                if (url.searchParams.get('state') !== state) {
+                    res.writeHead(400);
+                    res.end('Invalid OAuth state');
+                    return;
+                }
                 // Google이 동의 거부 시 ?error=access_denied 로 콜백
                 const errParam = url.searchParams.get('error');
                 if (errParam) {
-                    res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end(`<html><body><h2>❌ 인증 거부됨 (${errParam})</h2></body></html>`);
+                    res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end('Google authentication was denied.');
                     try {
                         server.close();
                     }
                     catch { /* noop */ }
-                    activeAuthServer = null;
                     rejectAuth(new Error(errParam));
                     return;
                 }
@@ -168,6 +236,12 @@ export function startAuth(clientId, clientSecret, options = {}) {
                     res.end('No code');
                     return;
                 }
+                if (attempt.status !== 'pending' || exchanging) {
+                    res.writeHead(409);
+                    res.end('Login is no longer accepting callbacks.');
+                    return;
+                }
+                exchanging = true;
                 let tokenResponse;
                 try {
                     tokenResponse = await oauth2Client.getToken(code);
@@ -179,7 +253,6 @@ export function startAuth(clientId, clientSecret, options = {}) {
                         server.close();
                     }
                     catch { /* noop */ }
-                    activeAuthServer = null;
                     rejectAuth(e);
                     return;
                 }
@@ -191,7 +264,7 @@ export function startAuth(clientId, clientSecret, options = {}) {
                         server.close();
                     }
                     catch { /* noop */ }
-                    activeAuthServer = null;
+                    attempt.status = 'failed';
                     reject(new AuthError({
                         code: 'TOKEN_RESPONSE_INVALID',
                         message: 'Google 응답에 access_token 또는 refresh_token이 누락되었습니다.',
@@ -202,22 +275,22 @@ export function startAuth(clientId, clientSecret, options = {}) {
                     }));
                     return;
                 }
-                // scope 는 항상 기록한다 — 그리고 누적(monotonic)으로 저장한다.
-                //   1) include_granted_scopes 로 Google 측 grant 는 (기존 부여분 ∪ 이번 요청분)이다.
-                //   2) 응답의 tokens.scope 는 그 합집합이어야 하지만, 만약 Google 이 좁혀서 주거나
-                //      생략하면(빈 값) 여기서 기존 기록 + 이번 요청 스코프로 보정한다.
-                // 이렇게 해야 "scope 미기록 = 추적 이전 legacy 토큰" 불변식이 유지된다 — 도메인
-                // 선택형 로그인이 이를 깨서, 좁은 로그인이 legacy 로 오인돼 pre-flight 를 우회하는
-                // 것을 막는다. (기존엔 응답 scope 로 통째 덮어써서 이 두 위험에 모두 노출됐다.)
-                const priorScope = getStoredTokens()?.scope;
+                oauth2Client.setCredentials(tokens);
+                const youtubeChannel = (expectedChannelId || (profile && requestedScopes.some((scope) => scope.includes('/auth/youtube') || scope.includes('/auth/yt-analytics'))))
+                    ? await verifyYouTubeChannel(oauth2Client, expectedChannelId) : undefined;
+                // A fresh login may be another Google account. Never union its scopes with
+                // the previous account's grant; Google's response is authoritative.
                 const stored = {
                     access_token: tokens.access_token,
                     refresh_token: tokens.refresh_token,
                     token_type: tokens.token_type ?? 'Bearer',
                     expiry_date: tokens.expiry_date ?? Date.now() + 3600_000,
-                    scope: mergeScopeStrings(priorScope, tokens.scope ?? requestedScopes.join(' ')),
+                    scope: tokens.scope ?? requestedScopes.join(' '),
+                    ...(youtubeChannel && { youtubeChannel }),
                 };
-                saveTokens(stored);
+                if (attempt.status !== 'pending')
+                    throw new Error('Login cancelled or timed out; credentials were not saved.');
+                saveTokens(stored, profile, { clientId, clientSecret });
                 res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
                 res.end(`
           <html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0">
@@ -228,28 +301,36 @@ export function startAuth(clientId, clientSecret, options = {}) {
           </body></html>
         `);
                 server.close();
-                activeAuthServer = null;
+                attempt.status = 'succeeded';
                 resolve(stored);
             }
             catch (err) {
                 try {
                     res.writeHead(500);
-                    res.end('Auth error');
+                    res.end(err instanceof Error && err.message.startsWith('YouTube') ? err.message : 'Auth error. Check the MCP/CLI login status.');
                 }
                 catch { /* noop — already responded */ }
                 try {
                     server.close();
                 }
                 catch { /* noop */ }
-                activeAuthServer = null;
                 rejectAuth(err);
             }
         });
+        cancelActiveAuth = () => {
+            if (attempt.status !== 'pending')
+                return;
+            try {
+                server.close();
+            }
+            catch { /* noop */ }
+            rejectAuth(new Error('Login replaced by a new authentication request.'));
+        };
         server.on('error', (err) => {
             rejectAuth(err);
         });
         server.listen(9876, () => {
-            activeAuthServer = server;
+            // Callback server is ready.
         });
         const timeoutMs = options.timeoutMs ?? 10 * 60 * 1000;
         setTimeout(() => {
@@ -258,10 +339,9 @@ export function startAuth(clientId, clientSecret, options = {}) {
                     server.close();
                 }
                 catch { /* noop */ }
-                activeAuthServer = null;
                 rejectAuth(new Error(`Auth timeout (${Math.round(timeoutMs / 1000)}s).`));
             }
-        }, timeoutMs);
+        }, timeoutMs).unref();
     });
     return { url: authUrl, wait };
 }
@@ -278,8 +358,8 @@ export function startAuth(clientId, clientSecret, options = {}) {
  * 통상 lifetime 이 1h 이므로, 5분 마진으로 매 도구 호출 시 만료 임박 시 사전 갱신해
  * "토큰 만료 → 도구 fail → 재호출" 의 단절 마찰 제거. 5분 마진은 평균 도구 작업 시간을 흡수.
  */
-export async function ensureFreshAccessToken(marginMs = 300_000) {
-    const tokens = getStoredTokens();
+export async function ensureFreshAccessToken(marginMs = 300_000, profile) {
+    const tokens = getStoredTokens(profile);
     if (!tokens) {
         return {
             status: 'unauthenticated',
@@ -316,12 +396,14 @@ export async function ensureFreshAccessToken(marginMs = 300_000) {
     // 원격 의존을 최초 1회로 끝낸다. 조회 실패는 raw throw 가 아니라 분류된 에러로 반환.
     let clientId;
     let clientSecret;
-    const stored = getStoredCredentials();
+    const stored = getStoredCredentials(profile);
     if (stored?.clientId && stored?.clientSecret) {
         ({ clientId, clientSecret } = stored);
     }
     else {
         try {
+            if (profile !== undefined)
+                throw new Error(`Missing credentials for profile ${profile}. Sign in again.`);
             ({ clientId, clientSecret } = await getMcpOAuthClient());
             saveCredentials(clientId, clientSecret);
         }
@@ -338,6 +420,7 @@ export async function ensureFreshAccessToken(marginMs = 300_000) {
     try {
         const { credentials } = await client.refreshAccessToken();
         const refreshed = {
+            ...tokens,
             access_token: credentials.access_token ?? tokens.access_token,
             refresh_token: credentials.refresh_token ?? tokens.refresh_token,
             token_type: credentials.token_type ?? tokens.token_type ?? 'Bearer',
@@ -345,7 +428,10 @@ export async function ensureFreshAccessToken(marginMs = 300_000) {
             // refresh 응답은 scope 를 생략할 수 있으므로 기존 값을 보존(blank 방지).
             scope: credentials.scope ?? tokens.scope,
         };
-        saveTokens(refreshed);
+        if (getStoredTokens(profile)?.refresh_token !== tokens.refresh_token) {
+            throw new Error('Google login changed during refresh. Retry with the selected profile.');
+        }
+        saveTokens(refreshed, profile);
         return {
             status: 'refreshed',
             tokens: refreshed,

package/dist/auth/scopes.d.ts

@@ -64,6 +64,11 @@ export declare const AUTH_DOMAINS: {
         readonly scopes: readonly ["https://www.googleapis.com/auth/youtube.force-ssl"];
         readonly summary: "youtube_* — 영상 업로드·처리 상태 조회·공개 상태 변경";
     };
+    readonly youtube_analytics: {
+        readonly label: "YouTube Analytics (read-only)";
+        readonly scopes: readonly ["https://www.googleapis.com/auth/youtube.readonly", "https://www.googleapis.com/auth/yt-analytics.readonly"];
+        readonly summary: "youtube_get_channel·youtube_list_videos·youtube_get_analytics_report — 채널·영상·성과 읽기";
+    };
 };
 export type AuthDomainId = keyof typeof AUTH_DOMAINS;
 /** z.enum 등 튜플이 필요한 자리에 쓰는 도메인 id 목록 (선언 순서 유지). */

package/dist/auth/scopes.js

@@ -72,6 +72,14 @@ export const AUTH_DOMAINS = {
         scopes: ['https://www.googleapis.com/auth/youtube.force-ssl'],
         summary: 'youtube_* — 영상 업로드·처리 상태 조회·공개 상태 변경',
     },
+    youtube_analytics: {
+        label: 'YouTube Analytics (read-only)',
+        scopes: [
+            'https://www.googleapis.com/auth/youtube.readonly',
+            'https://www.googleapis.com/auth/yt-analytics.readonly',
+        ],
+        summary: 'youtube_get_channel·youtube_list_videos·youtube_get_analytics_report — 채널·영상·성과 읽기',
+    },
 };
 /** z.enum 등 튜플이 필요한 자리에 쓰는 도메인 id 목록 (선언 순서 유지). */
 export const DOMAIN_IDS = Object.keys(AUTH_DOMAINS);

package/dist/auth/youtube-channel.d.ts

@@ -0,0 +1,8 @@
+import type { OAuth2Client } from 'google-auth-library';
+export declare const YOUTUBE_CHANNEL_ID: RegExp;
+/** A channel ID is a guard, not a videos.insert routing parameter. Google selects
+ * the personal/Brand channel during OAuth; ambiguous or mismatched grants fail closed. */
+export declare function verifyYouTubeChannel(auth: OAuth2Client, expectedChannelId?: string): Promise<{
+    id: string;
+    title: string;
+}>;

package/dist/auth/youtube-channel.js

@@ -0,0 +1,26 @@
+import { google } from '../lib/googleapis-lite.js';
+import { friendlyGoogleError } from '../lib/google-errors.js';
+export const YOUTUBE_CHANNEL_ID = /^UC[\w-]{22}$/;
+/** A channel ID is a guard, not a videos.insert routing parameter. Google selects
+ * the personal/Brand channel during OAuth; ambiguous or mismatched grants fail closed. */
+export async function verifyYouTubeChannel(auth, expectedChannelId) {
+    if (expectedChannelId !== undefined && !YOUTUBE_CHANNEL_ID.test(expectedChannelId)) {
+        throw new Error('Invalid YouTube channel ID (expected UC + 22 characters).');
+    }
+    let response;
+    try {
+        response = await google.youtube({ version: 'v3', auth }).channels.list({ part: ['snippet'], mine: true, maxResults: 50 });
+    }
+    catch (error) {
+        throw friendlyGoogleError(error);
+    }
+    const channels = response.data.items ?? [];
+    if (channels.length !== 1 || !channels[0].id || response.data.nextPageToken) {
+        throw new Error('YouTube login must resolve to exactly one channel. Sign in again and select the intended personal/Brand channel.');
+    }
+    const channel = { id: channels[0].id, title: channels[0].snippet?.title ?? '' };
+    if (expectedChannelId && channel.id !== expectedChannelId) {
+        throw new Error(`YouTube channel mismatch: expected ${expectedChannelId}, authenticated ${channel.id} (${channel.title}). Sign in again with the intended channel. Nothing was uploaded.`);
+    }
+    return channel;
+}

package/dist/googleads/errors.d.ts

@@ -0,0 +1,2 @@
+/** Preserve provider diagnostics without exposing authentication material. */
+export declare function googleAdsError(status: number, body: string, secrets: string[]): Error;

package/dist/googleads/errors.js

@@ -0,0 +1,31 @@
+/** Preserve provider diagnostics without exposing authentication material. */
+export function googleAdsError(status, body, secrets) {
+    let message = `Google Ads API ${status}`;
+    try {
+        const parsed = JSON.parse(body);
+        const error = (Array.isArray(parsed) ? parsed[0] : parsed)?.error;
+        if (typeof error?.message === 'string')
+            message += `: ${error.message}`;
+        for (const detail of Array.isArray(error?.details) ? error.details : []) {
+            for (const item of Array.isArray(detail.errors) ? detail.errors : []) {
+                const codes = item.errorCode && typeof item.errorCode === 'object'
+                    ? Object.entries(item.errorCode).map(([key, value]) => `${key}=${String(value)}`).join(', ')
+                    : '';
+                message += `\n${codes}${typeof item.message === 'string' ? `: ${item.message}` : ''}`;
+            }
+            for (const item of Array.isArray(detail.fieldViolations) ? detail.fieldViolations : []) {
+                message += `\n${String(item.field ?? '')}: ${String(item.description ?? '')}`;
+            }
+            if (typeof detail.requestId === 'string')
+                message += `\nrequestId=${detail.requestId}`;
+        }
+    }
+    catch {
+        // HTML/proxy bodies can contain arbitrary data; do not echo them.
+        message += ': non-JSON response';
+    }
+    for (const secret of secrets.filter(Boolean).sort((a, b) => b.length - a.length)) {
+        message = message.split(secret).join('[REDACTED]');
+    }
+    return new Error(message.slice(0, 4000));
+}

package/dist/googleads/tools.d.ts

@@ -1,5 +1,6 @@
 import type { OAuth2Client } from 'google-auth-library';
 import type { GoogleAdsConfig } from './config.js';
+export declare 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.";
 export interface DateRange {
     startDate: string;
     endDate: string;
@@ -16,6 +17,8 @@ export declare function listCampaigns(auth: OAuth2Client, cfg: GoogleAdsConfig):
     dailyBudget: number;
 }[]>;
 export declare function getCampaignReport(auth: OAuth2Client, cfg: GoogleAdsConfig, range: DateRange): Promise<{
+    currencyCode: any;
+    timeZone: any;
     id: any;
     name: any;
     status: any;
@@ -26,6 +29,7 @@ export declare function getCampaignReport(auth: OAuth2Client, cfg: GoogleAdsConf
     cost: number;
     conversions: number;
     conversionsValue: number;
+    costPerConversion: number | null;
     cpi: number;
     ctr: number;
     avgCpc: number;
@@ -38,6 +42,9 @@ export declare function getUacReport(auth: OAuth2Client, cfg: GoogleAdsConfig, r
     clicks: number;
     impressions: number;
     cost: number;
+    conversions: number;
+    conversionsValue: number;
+    costPerConversion: number | null;
     installs: number;
     installsValue: number;
     cpi: number;