@appsyogi/adsense-mcp-server 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1927 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as readline from "readline";
+import { OAuth2Client } from "google-auth-library";
+
+// src/auth/tokenStore.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import envPaths from "env-paths";
+var paths = envPaths("adsense-mcp");
+var KEYTAR_SERVICE = "adsense-mcp";
+var KEYTAR_ACCOUNT = "tokens";
+async function ensureConfigDir() {
+  await fs.mkdir(paths.config, { recursive: true });
+}
+async function loadConfig() {
+  await ensureConfigDir();
+  const configPath = path.join(paths.config, "config.json");
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      authType: "oauth",
+      scope: "readonly"
+    };
+  }
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  const configPath = path.join(paths.config, "config.json");
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function loadTokens() {
+  try {
+    const keytar = await import("keytar");
+    const stored = await keytar.getPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+    if (stored) {
+      return JSON.parse(stored);
+    }
+  } catch {
+  }
+  await ensureConfigDir();
+  const tokensPath = path.join(paths.config, "tokens.json");
+  try {
+    const content = await fs.readFile(tokensPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveTokens(tokens) {
+  const tokenString = JSON.stringify(tokens);
+  try {
+    const keytar = await import("keytar");
+    await keytar.setPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT, tokenString);
+    return;
+  } catch {
+  }
+  await ensureConfigDir();
+  const tokensPath = path.join(paths.config, "tokens.json");
+  await fs.writeFile(tokensPath, tokenString, { mode: 384 });
+}
+function getCachePath() {
+  return path.join(paths.config, "cache.sqlite");
+}
+
+// src/types.ts
+var ADSENSE_SCOPES = {
+  readonly: ["https://www.googleapis.com/auth/adsense.readonly"]
+  // Full scope available but NOT recommended for MCP use:
+  // full: ['https://www.googleapis.com/auth/adsense'],
+};
+
+// src/cli/init.ts
+async function runInit(options) {
+  console.log("\u{1F680} AdSense MCP Server Setup\n");
+  if (options.serviceAccount) {
+    await setupServiceAccount(options.serviceAccount);
+    return;
+  }
+  const clientId = options.clientId || await prompt("Enter your OAuth Client ID: ");
+  const clientSecret = options.clientSecret || await prompt("Enter your OAuth Client Secret: ");
+  if (!clientId || !clientSecret) {
+    console.error("\u274C Client ID and Client Secret are required");
+    console.log("\nTo create OAuth credentials:");
+    console.log("1. Go to https://console.cloud.google.com/apis/credentials");
+    console.log("2. Create an OAuth 2.0 Client ID (Desktop app)");
+    console.log("3. Enable the AdSense Management API");
+    process.exit(1);
+  }
+  const configDir = path2.join(process.env.HOME || "", ".config", "adsense-mcp");
+  fs2.mkdirSync(configDir, { recursive: true });
+  const credentialsPath = path2.join(configDir, "credentials.json");
+  fs2.writeFileSync(credentialsPath, JSON.stringify({
+    installed: {
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uris: ["http://localhost:3000/oauth/callback", "urn:ietf:wg:oauth:2.0:oob"]
+    }
+  }, null, 2));
+  console.log(`\u2705 Credentials saved to ${credentialsPath}
+`);
+  await performOAuthFlow(clientId, clientSecret);
+}
+async function setupServiceAccount(keyPath) {
+  console.log("Setting up service account authentication...\n");
+  if (!fs2.existsSync(keyPath)) {
+    console.error(`\u274C Service account key file not found: ${keyPath}`);
+    process.exit(1);
+  }
+  try {
+    const keyContent = JSON.parse(fs2.readFileSync(keyPath, "utf-8"));
+    if (!keyContent.client_email || !keyContent.private_key) {
+      throw new Error("Invalid service account key file");
+    }
+    const configDir = path2.join(process.env.HOME || "", ".config", "adsense-mcp");
+    fs2.mkdirSync(configDir, { recursive: true });
+    const destPath = path2.join(configDir, "service-account.json");
+    fs2.copyFileSync(keyPath, destPath);
+    console.log(`\u2705 Service account key saved to ${destPath}`);
+    console.log(`\u{1F4E7} Service account: ${keyContent.client_email}
+`);
+    console.log("\u26A0\uFE0F  Important: Make sure this service account has been granted");
+    console.log("   access to your AdSense account via domain-wide delegation.\n");
+    console.log("Run `adsense-mcp doctor` to verify the setup.");
+  } catch (error) {
+    console.error(`\u274C Failed to setup service account: ${error.message}`);
+    process.exit(1);
+  }
+}
+async function performOAuthFlow(clientId, clientSecret) {
+  const oauth2Client = new OAuth2Client(
+    clientId,
+    clientSecret,
+    "urn:ietf:wg:oauth:2.0:oob"
+  );
+  const authUrl = oauth2Client.generateAuthUrl({
+    access_type: "offline",
+    scope: ADSENSE_SCOPES.readonly,
+    prompt: "consent"
+  });
+  console.log("\u{1F4CB} Open this URL in your browser to authorize:\n");
+  console.log(authUrl);
+  console.log("\n");
+  const code = await prompt("Enter the authorization code: ");
+  try {
+    const { tokens } = await oauth2Client.getToken(code);
+    if (!tokens.access_token) {
+      throw new Error("No access token received");
+    }
+    await saveConfig({
+      authType: "oauth",
+      clientId,
+      clientSecret,
+      scope: "readonly"
+    });
+    await saveTokens({
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token ?? void 0,
+      expiryDate: tokens.expiry_date ?? void 0
+    });
+    console.log("\n\u2705 Authentication successful!");
+    console.log("\u{1F510} Tokens saved securely\n");
+    console.log("Run `adsense-mcp doctor` to verify the setup.");
+  } catch (error) {
+    console.error(`
+\u274C Authentication failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// src/cli/doctor.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+
+// src/auth/oauth.ts
+import { OAuth2Client as OAuth2Client2 } from "google-auth-library";
+async function createOAuthClient() {
+  const config = await loadConfig();
+  if (config.authType !== "oauth") {
+    throw new Error("OAuth not configured. Run `adsense-mcp init` to set up OAuth.");
+  }
+  const oauth2Client = new OAuth2Client2({
+    clientId: config.clientId,
+    clientSecret: config.clientSecret
+  });
+  const tokens = await loadTokens();
+  if (!tokens) {
+    throw new Error("No tokens found. Run `adsense-mcp init` to authenticate.");
+  }
+  oauth2Client.setCredentials({
+    access_token: tokens.accessToken,
+    refresh_token: tokens.refreshToken,
+    expiry_date: tokens.expiryDate
+  });
+  oauth2Client.on("tokens", async (newTokens) => {
+    await saveTokens({
+      accessToken: newTokens.access_token || tokens.accessToken,
+      refreshToken: newTokens.refresh_token || tokens.refreshToken,
+      expiryDate: newTokens.expiry_date || Date.now() + 36e5
+    });
+  });
+  return oauth2Client;
+}
+
+// src/auth/serviceAccount.ts
+import { google } from "googleapis";
+import * as fs3 from "fs/promises";
+async function createServiceAccountClient() {
+  const config = await loadConfig();
+  if (config.authType !== "service-account") {
+    throw new Error("Service account not configured. Run `adsense-mcp init --service-account <path>` to set up.");
+  }
+  if (!config.serviceAccountPath) {
+    throw new Error("Service account path not configured.");
+  }
+  const keyFileContent = await fs3.readFile(config.serviceAccountPath, "utf-8");
+  const keyFile = JSON.parse(keyFileContent);
+  const auth = new google.auth.JWT({
+    email: keyFile.client_email,
+    key: keyFile.private_key,
+    scopes: ADSENSE_SCOPES[config.scope]
+  });
+  return auth;
+}
+
+// src/adsense/client.ts
+import { google as google2 } from "googleapis";
+
+// src/adsense/rateLimiter.ts
+var MAX_REQUESTS_PER_MINUTE = 100;
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 32e3;
+var RateLimiter = class {
+  requestTimestamps = [];
+  /**
+   * Wait if necessary to stay under rate limit
+   */
+  async throttle() {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    this.requestTimestamps = this.requestTimestamps.filter(
+      (ts) => ts > oneMinuteAgo
+    );
+    if (this.requestTimestamps.length >= MAX_REQUESTS_PER_MINUTE) {
+      const oldestInWindow = this.requestTimestamps[0];
+      const waitTime = oldestInWindow + 6e4 - now + 100;
+      if (waitTime > 0) {
+        await sleep(waitTime);
+      }
+    }
+    this.requestTimestamps.push(Date.now());
+  }
+  /**
+   * Get current request count in the last minute
+   */
+  getRequestCount() {
+    const oneMinuteAgo = Date.now() - 6e4;
+    return this.requestTimestamps.filter((ts) => ts > oneMinuteAgo).length;
+  }
+  /**
+   * Check if we're close to the rate limit
+   */
+  isNearLimit() {
+    return this.getRequestCount() >= MAX_REQUESTS_PER_MINUTE * 0.8;
+  }
+};
+async function withRetry(operation, retries = MAX_RETRIES) {
+  let lastError;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      const isRateLimited = error.code === 429 || error.status === 429 || error.message?.includes("quota") || error.message?.includes("rate limit") || error.message?.includes("RATE_LIMIT_EXCEEDED");
+      const isRetryable = isRateLimited || error.code === 503 || error.code === 500 || error.status === 503 || error.status === 500 || error.code === "ECONNRESET" || error.code === "ETIMEDOUT";
+      if (!isRetryable || attempt === retries - 1) {
+        throw error;
+      }
+      const delay = Math.min(
+        BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 1e3,
+        MAX_DELAY_MS
+      );
+      console.error(
+        `Request failed (attempt ${attempt + 1}/${retries}), retrying in ${Math.round(delay)}ms...`
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var rateLimiter = new RateLimiter();
+
+// src/adsense/cache.ts
+import Database from "better-sqlite3";
+import * as crypto from "crypto";
+var CacheTTL = {
+  TODAY_EARNINGS: 5 * 60 * 1e3,
+  // 5 minutes
+  YESTERDAY_EARNINGS: 60 * 60 * 1e3,
+  // 1 hour
+  HISTORICAL_REPORT: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  ACCOUNTS: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  SITES: 60 * 60 * 1e3,
+  // 1 hour
+  ALERTS: 15 * 60 * 1e3,
+  // 15 minutes
+  POLICY_ISSUES: 30 * 60 * 1e3,
+  // 30 minutes
+  PAYMENTS: 6 * 60 * 60 * 1e3,
+  // 6 hours
+  AD_UNITS: 60 * 60 * 1e3
+  // 1 hour
+};
+var CacheManager = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath || getCachePath());
+    this.initSchema();
+  }
+  /**
+   * Initialize database schema
+   */
+  initSchema() {
+    this.db.exec(`
+            -- Report cache with TTL
+            CREATE TABLE IF NOT EXISTS report_cache (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                cache_key TEXT UNIQUE NOT NULL,
+                account_id TEXT NOT NULL,
+                query_hash TEXT NOT NULL,
+                response_data TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                expires_at INTEGER NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_report_cache_key ON report_cache(cache_key);
+            CREATE INDEX IF NOT EXISTS idx_report_cache_expires ON report_cache(expires_at);
+
+            -- Account info cache
+            CREATE TABLE IF NOT EXISTS accounts_cache (
+                account_id TEXT PRIMARY KEY,
+                account_data TEXT NOT NULL,
+                updated_at INTEGER NOT NULL
+            );
+
+            -- Query history for analytics
+            CREATE TABLE IF NOT EXISTS query_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                account_id TEXT NOT NULL,
+                tool_name TEXT NOT NULL,
+                query_params TEXT,
+                executed_at INTEGER NOT NULL,
+                response_time_ms INTEGER
+            );
+        `);
+  }
+  /**
+   * Generate a cache key from query parameters
+   */
+  generateCacheKey(prefix, params) {
+    const hash = crypto.createHash("md5").update(JSON.stringify(params)).digest("hex");
+    return `${prefix}:${hash}`;
+  }
+  /**
+   * Get cached data if not expired
+   */
+  get(prefix, params) {
+    const cacheKey = this.generateCacheKey(prefix, params);
+    const now = Date.now();
+    const row = this.db.prepare("SELECT response_data, expires_at FROM report_cache WHERE cache_key = ?").get(cacheKey);
+    if (row && row.expires_at > now) {
+      return JSON.parse(row.response_data);
+    }
+    return null;
+  }
+  /**
+   * Store data in cache
+   */
+  set(prefix, params, data, ttl, accountId) {
+    const cacheKey = this.generateCacheKey(prefix, params);
+    const queryHash = crypto.createHash("md5").update(JSON.stringify(params)).digest("hex");
+    const now = Date.now();
+    this.db.prepare(`
+                INSERT OR REPLACE INTO report_cache 
+                (cache_key, account_id, query_hash, response_data, created_at, expires_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `).run(cacheKey, accountId, queryHash, JSON.stringify(data), now, now + ttl);
+  }
+  /**
+   * Clear expired cache entries
+   */
+  clearExpired() {
+    const result = this.db.prepare("DELETE FROM report_cache WHERE expires_at < ?").run(Date.now());
+    return result.changes;
+  }
+  /**
+   * Clear all cache for an account
+   */
+  clearAccount(accountId) {
+    const result = this.db.prepare("DELETE FROM report_cache WHERE account_id = ?").run(accountId);
+    return result.changes;
+  }
+  /**
+   * Clear all cache
+   */
+  clearAll() {
+    this.db.exec("DELETE FROM report_cache");
+    this.db.exec("DELETE FROM accounts_cache");
+  }
+  /**
+   * Record a query for analytics
+   */
+  recordQuery(accountId, toolName, params, responseTimeMs) {
+    this.db.prepare(`
+                INSERT INTO query_history (account_id, tool_name, query_params, executed_at, response_time_ms)
+                VALUES (?, ?, ?, ?, ?)
+            `).run(accountId, toolName, JSON.stringify(params), Date.now(), responseTimeMs);
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const totalEntries = this.db.prepare("SELECT COUNT(*) as count FROM report_cache").get().count;
+    const expiredCount = this.db.prepare("SELECT COUNT(*) as count FROM report_cache WHERE expires_at < ?").get(now).count;
+    const sizeResult = this.db.prepare("SELECT SUM(LENGTH(response_data)) as size FROM report_cache").get();
+    return {
+      totalEntries,
+      totalSize: sizeResult.size || 0,
+      expiredCount
+    };
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+};
+var cacheInstance = null;
+function getCache() {
+  if (!cacheInstance) {
+    cacheInstance = new CacheManager();
+  }
+  return cacheInstance;
+}
+
+// src/adsense/client.ts
+var AdSenseClient = class _AdSenseClient {
+  adsense;
+  defaultAccountId;
+  constructor(adsense, defaultAccountId) {
+    this.adsense = adsense;
+    this.defaultAccountId = defaultAccountId;
+  }
+  /**
+   * Create an authenticated AdSense client
+   */
+  static async create(accountIdOverride) {
+    const config = await loadConfig();
+    let auth;
+    if (config.authType === "service-account") {
+      auth = await createServiceAccountClient();
+    } else {
+      auth = await createOAuthClient();
+    }
+    const adsense = google2.adsense({
+      version: "v2",
+      auth
+    });
+    const accountId = accountIdOverride || config.defaultAccountId;
+    return new _AdSenseClient(adsense, accountId);
+  }
+  /**
+   * Get the account ID to use (explicit > default > first available)
+   */
+  async resolveAccountId(explicitId) {
+    if (explicitId) {
+      return explicitId.startsWith("accounts/") ? explicitId : `accounts/${explicitId}`;
+    }
+    if (this.defaultAccountId) {
+      return this.defaultAccountId.startsWith("accounts/") ? this.defaultAccountId : `accounts/${this.defaultAccountId}`;
+    }
+    const accounts = await this.listAccounts();
+    if (accounts.length === 0) {
+      throw new Error("No AdSense accounts found");
+    }
+    return accounts[0].name;
+  }
+  /**
+   * Extract publisher ID from account name
+   */
+  extractPubId(accountName) {
+    return accountName.replace("accounts/", "");
+  }
+  // ==================== Account Operations ====================
+  /**
+   * List all AdSense accounts
+   */
+  async listAccounts() {
+    const cache = getCache();
+    const cacheKey = "accounts";
+    const cached = cache.get(cacheKey, {});
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.list()
+    );
+    const accounts = response.data.accounts || [];
+    cache.set(cacheKey, {}, accounts, CacheTTL.ACCOUNTS, "global");
+    return accounts;
+  }
+  /**
+   * Get a specific account
+   */
+  async getAccount(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    await rateLimiter.throttle();
+    try {
+      const response = await withRetry(
+        () => this.adsense.accounts.get({ name: resolvedId })
+      );
+      return response.data;
+    } catch {
+      return null;
+    }
+  }
+  // ==================== Sites Operations ====================
+  /**
+   * List all sites for an account
+   */
+  async listSites(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const cache = getCache();
+    const params = { accountId: resolvedId };
+    const cached = cache.get("sites", params);
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.sites.list({ parent: resolvedId })
+    );
+    const sites = response.data.sites || [];
+    cache.set("sites", params, sites, CacheTTL.SITES, this.extractPubId(resolvedId));
+    return sites;
+  }
+  // ==================== Alerts Operations ====================
+  /**
+   * List alerts for an account
+   */
+  async listAlerts(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const cache = getCache();
+    const params = { accountId: resolvedId };
+    const cached = cache.get("alerts", params);
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.alerts.list({ parent: resolvedId })
+    );
+    const alerts = response.data.alerts || [];
+    cache.set("alerts", params, alerts, CacheTTL.ALERTS, this.extractPubId(resolvedId));
+    return alerts;
+  }
+  // ==================== Policy Issues Operations ====================
+  /**
+   * List policy issues for an account
+   */
+  async listPolicyIssues(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const cache = getCache();
+    const params = { accountId: resolvedId };
+    const cached = cache.get("policyIssues", params);
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.policyIssues.list({ parent: resolvedId })
+    );
+    const issues = response.data.policyIssues || [];
+    cache.set("policyIssues", params, issues, CacheTTL.POLICY_ISSUES, this.extractPubId(resolvedId));
+    return issues;
+  }
+  // ==================== Payments Operations ====================
+  /**
+   * List payments for an account
+   */
+  async listPayments(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const cache = getCache();
+    const params = { accountId: resolvedId };
+    const cached = cache.get("payments", params);
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.payments.list({ parent: resolvedId })
+    );
+    const payments = response.data.payments || [];
+    cache.set("payments", params, payments, CacheTTL.PAYMENTS, this.extractPubId(resolvedId));
+    return payments;
+  }
+  // ==================== Ad Client Operations ====================
+  /**
+   * List ad clients for an account
+   */
+  async listAdClients(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.adclients.list({ parent: resolvedId })
+    );
+    return response.data.adClients || [];
+  }
+  // ==================== Ad Unit Operations ====================
+  /**
+   * List ad units for an account (across all ad clients)
+   */
+  async listAdUnits(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const cache = getCache();
+    const params = { accountId: resolvedId };
+    const cached = cache.get("adUnits", params);
+    if (cached) {
+      return cached;
+    }
+    const adClients = await this.listAdClients(accountId);
+    const allAdUnits = [];
+    for (const client of adClients) {
+      await rateLimiter.throttle();
+      const response = await withRetry(
+        () => this.adsense.accounts.adclients.adunits.list({ parent: client.name })
+      );
+      allAdUnits.push(...response.data.adUnits || []);
+    }
+    cache.set("adUnits", params, allAdUnits, CacheTTL.AD_UNITS, this.extractPubId(resolvedId));
+    return allAdUnits;
+  }
+  /**
+   * Get ad code for an ad unit
+   */
+  async getAdCode(adClientId, adUnitId, accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const adUnitName = `${resolvedId}/adclients/${adClientId}/adunits/${adUnitId}`;
+    await rateLimiter.throttle();
+    const response = await withRetry(
+      () => this.adsense.accounts.adclients.adunits.getAdcode({ name: adUnitName })
+    );
+    return response.data.adCode || "";
+  }
+  // ==================== Report Operations ====================
+  /**
+   * Generate a report
+   */
+  async generateReport(query) {
+    const resolvedId = await this.resolveAccountId(query.accountId);
+    const cache = getCache();
+    const ttl = this.getReportTTL(query.startDate, query.endDate);
+    const cached = cache.get("report", { ...query, accountId: resolvedId });
+    if (cached) {
+      return cached;
+    }
+    await rateLimiter.throttle();
+    const params = {
+      account: resolvedId,
+      "dateRange": query.dateRange || "CUSTOM",
+      "startDate.year": parseInt(query.startDate.split("-")[0]),
+      "startDate.month": parseInt(query.startDate.split("-")[1]),
+      "startDate.day": parseInt(query.startDate.split("-")[2]),
+      "endDate.year": parseInt(query.endDate.split("-")[0]),
+      "endDate.month": parseInt(query.endDate.split("-")[1]),
+      "endDate.day": parseInt(query.endDate.split("-")[2])
+    };
+    if (query.dimensions && query.dimensions.length > 0) {
+      params.dimensions = query.dimensions;
+    }
+    params.metrics = query.metrics || [
+      "ESTIMATED_EARNINGS",
+      "IMPRESSIONS",
+      "CLICKS",
+      "PAGE_VIEWS",
+      "PAGE_VIEWS_CTR",
+      "PAGE_VIEWS_RPM"
+    ];
+    if (query.orderBy) {
+      params.orderBy = query.orderBy.startsWith("-") ? `${query.orderBy.slice(1)} DESC` : `${query.orderBy} ASC`;
+    }
+    if (query.limit) {
+      params.limit = Math.min(query.limit, 1e5);
+    }
+    const response = await withRetry(
+      () => this.adsense.accounts.reports.generate(params)
+    );
+    const report = response.data;
+    cache.set("report", { ...query, accountId: resolvedId }, report, ttl, this.extractPubId(resolvedId));
+    return report;
+  }
+  /**
+   * Generate a CSV report
+   */
+  async generateCsvReport(query) {
+    const resolvedId = await this.resolveAccountId(query.accountId);
+    await rateLimiter.throttle();
+    const params = {
+      account: resolvedId,
+      "dateRange": query.dateRange || "CUSTOM",
+      "startDate.year": parseInt(query.startDate.split("-")[0]),
+      "startDate.month": parseInt(query.startDate.split("-")[1]),
+      "startDate.day": parseInt(query.startDate.split("-")[2]),
+      "endDate.year": parseInt(query.endDate.split("-")[0]),
+      "endDate.month": parseInt(query.endDate.split("-")[1]),
+      "endDate.day": parseInt(query.endDate.split("-")[2])
+    };
+    if (query.dimensions) {
+      params.dimensions = query.dimensions;
+    }
+    params.metrics = query.metrics || [
+      "ESTIMATED_EARNINGS",
+      "IMPRESSIONS",
+      "CLICKS",
+      "PAGE_VIEWS"
+    ];
+    const response = await withRetry(
+      () => this.adsense.accounts.reports.generateCsv(params)
+    );
+    return response.data;
+  }
+  /**
+   * Get earnings summary (today, yesterday, last 7 days, this month, last month)
+   */
+  async getEarningsSummary(accountId) {
+    const resolvedId = await this.resolveAccountId(accountId);
+    const today = /* @__PURE__ */ new Date();
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    const formatDate = (d) => d.toISOString().split("T")[0];
+    const todayStr = formatDate(today);
+    const yesterdayStr = formatDate(yesterday);
+    const last7DaysStart = new Date(today);
+    last7DaysStart.setDate(last7DaysStart.getDate() - 6);
+    const thisMonthStart = new Date(today.getFullYear(), today.getMonth(), 1);
+    const lastMonthStart = new Date(today.getFullYear(), today.getMonth() - 1, 1);
+    const lastMonthEnd = new Date(today.getFullYear(), today.getMonth(), 0);
+    const [todayReport, yesterdayReport, last7DaysReport, thisMonthReport, lastMonthReport] = await Promise.all([
+      this.generateReport({
+        accountId: resolvedId,
+        startDate: todayStr,
+        endDate: todayStr
+      }),
+      this.generateReport({
+        accountId: resolvedId,
+        startDate: yesterdayStr,
+        endDate: yesterdayStr
+      }),
+      this.generateReport({
+        accountId: resolvedId,
+        startDate: formatDate(last7DaysStart),
+        endDate: todayStr
+      }),
+      this.generateReport({
+        accountId: resolvedId,
+        startDate: formatDate(thisMonthStart),
+        endDate: todayStr
+      }),
+      this.generateReport({
+        accountId: resolvedId,
+        startDate: formatDate(lastMonthStart),
+        endDate: formatDate(lastMonthEnd)
+      })
+    ]);
+    return {
+      today: this.extractEarningsPeriod(todayReport),
+      yesterday: this.extractEarningsPeriod(yesterdayReport),
+      last7Days: this.extractEarningsPeriod(last7DaysReport),
+      thisMonth: this.extractEarningsPeriod(thisMonthReport),
+      lastMonth: this.extractEarningsPeriod(lastMonthReport)
+    };
+  }
+  /**
+   * Extract earnings data from a report response
+   */
+  extractEarningsPeriod(report) {
+    const totals = report.totals?.cells || report.rows?.[0]?.cells || [];
+    const headers = report.headers || [];
+    const getValue = (metricName) => {
+      const index = headers.findIndex((h) => h.name === metricName);
+      if (index >= 0 && totals[index]) {
+        return parseFloat(totals[index].value) || 0;
+      }
+      return 0;
+    };
+    return {
+      earnings: getValue("ESTIMATED_EARNINGS"),
+      impressions: getValue("IMPRESSIONS"),
+      clicks: getValue("CLICKS"),
+      ctr: getValue("PAGE_VIEWS_CTR") || getValue("IMPRESSIONS_CTR"),
+      rpm: getValue("PAGE_VIEWS_RPM") || getValue("IMPRESSIONS_RPM"),
+      pageViews: getValue("PAGE_VIEWS")
+    };
+  }
+  /**
+   * Determine appropriate cache TTL based on date range
+   */
+  getReportTTL(startDate, endDate) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const yesterday = /* @__PURE__ */ new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStr = yesterday.toISOString().split("T")[0];
+    if (endDate === today || startDate === today) {
+      return CacheTTL.TODAY_EARNINGS;
+    }
+    if (endDate === yesterdayStr) {
+      return CacheTTL.YESTERDAY_EARNINGS;
+    }
+    return CacheTTL.HISTORICAL_REPORT;
+  }
+};
+
+// src/cli/doctor.ts
+async function runDoctor() {
+  console.log("\u{1FA7A} AdSense MCP Server Health Check\n");
+  const results = [];
+  const configDir = path3.join(process.env.HOME || "", ".config", "adsense-mcp");
+  if (fs4.existsSync(configDir)) {
+    results.push({
+      name: "Config Directory",
+      status: "pass",
+      message: configDir
+    });
+  } else {
+    results.push({
+      name: "Config Directory",
+      status: "fail",
+      message: "Not found. Run `adsense-mcp init` first."
+    });
+  }
+  const credentialsPath = path3.join(configDir, "credentials.json");
+  const serviceAccountPath = path3.join(configDir, "service-account.json");
+  if (fs4.existsSync(serviceAccountPath)) {
+    results.push({
+      name: "Authentication",
+      status: "pass",
+      message: "Service account configured"
+    });
+  } else if (fs4.existsSync(credentialsPath)) {
+    results.push({
+      name: "Authentication",
+      status: "pass",
+      message: "OAuth credentials configured"
+    });
+  } else {
+    results.push({
+      name: "Authentication",
+      status: "fail",
+      message: "No credentials found. Run `adsense-mcp init` first."
+    });
+  }
+  try {
+    const config = await loadConfig();
+    let authClient;
+    if (config.authType === "service-account") {
+      authClient = await createServiceAccountClient();
+    } else {
+      authClient = await createOAuthClient();
+    }
+    if (authClient) {
+      results.push({
+        name: "Auth Client",
+        status: "pass",
+        message: "Successfully created auth client"
+      });
+    } else {
+      throw new Error("Auth client is null");
+    }
+  } catch (error) {
+    results.push({
+      name: "Auth Client",
+      status: "fail",
+      message: `Failed: ${error.message}`
+    });
+  }
+  try {
+    const client = await AdSenseClient.create();
+    const accounts = await client.listAccounts();
+    if (accounts.length > 0) {
+      results.push({
+        name: "AdSense API",
+        status: "pass",
+        message: `Found ${accounts.length} account(s)`
+      });
+      console.log("\n\u{1F4CA} AdSense Accounts:");
+      for (const account of accounts) {
+        const id = account.name.replace("accounts/", "");
+        console.log(`   \u2022 ${id} - ${account.displayName || "Unnamed"}`);
+      }
+    } else {
+      results.push({
+        name: "AdSense API",
+        status: "warn",
+        message: "No accounts found"
+      });
+    }
+  } catch (error) {
+    results.push({
+      name: "AdSense API",
+      status: "fail",
+      message: `Failed: ${error.message}`
+    });
+  }
+  const cacheDir = path3.join(configDir, "cache");
+  if (fs4.existsSync(cacheDir)) {
+    const cacheFiles = fs4.readdirSync(cacheDir);
+    results.push({
+      name: "Cache",
+      status: "pass",
+      message: `${cacheFiles.length} cache file(s)`
+    });
+  } else {
+    results.push({
+      name: "Cache",
+      status: "pass",
+      message: "Not yet created (will be created on first use)"
+    });
+  }
+  console.log("\n\u{1F4CB} Health Check Results:\n");
+  let hasFailures = false;
+  for (const result of results) {
+    const icon = result.status === "pass" ? "\u2705" : result.status === "warn" ? "\u26A0\uFE0F" : "\u274C";
+    console.log(`${icon} ${result.name}: ${result.message}`);
+    if (result.status === "fail") {
+      hasFailures = true;
+    }
+  }
+  console.log("");
+  if (hasFailures) {
+    console.log("\u274C Some checks failed. Please fix the issues above.\n");
+    process.exit(1);
+  } else {
+    console.log("\u2705 All checks passed! Server is ready to use.\n");
+    console.log("Add to Claude Desktop config:");
+    console.log("");
+    console.log(JSON.stringify({
+      "mcpServers": {
+        "adsense": {
+          "command": "npx",
+          "args": ["-y", "adsense-mcp", "run"]
+        }
+      }
+    }, null, 2));
+  }
+}
+
+// src/server/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/server/tools/accounts.ts
+async function handleListAccounts() {
+  const client = await AdSenseClient.create();
+  const accounts = await client.listAccounts();
+  return {
+    accounts: accounts.map((account) => ({
+      id: account.name.replace("accounts/", ""),
+      name: account.name,
+      displayName: account.displayName || "Unnamed Account",
+      timeZone: account.timeZone?.id || "Unknown",
+      createTime: account.createTime,
+      premium: account.premium || false
+    })),
+    total: accounts.length
+  };
+}
+
+// src/server/tools/reports.ts
+async function handleEarningsSummary(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const summary = await client.getEarningsSummary(accountId);
+  const formatCurrency = (value) => `$${value.toFixed(2)}`;
+  const formatNumber = (value) => value.toLocaleString();
+  const formatPercent = (value) => `${(value * 100).toFixed(2)}%`;
+  return {
+    summary: {
+      today: {
+        earnings: formatCurrency(summary.today.earnings),
+        impressions: formatNumber(summary.today.impressions),
+        clicks: formatNumber(summary.today.clicks),
+        ctr: formatPercent(summary.today.ctr),
+        rpm: formatCurrency(summary.today.rpm),
+        pageViews: formatNumber(summary.today.pageViews)
+      },
+      yesterday: {
+        earnings: formatCurrency(summary.yesterday.earnings),
+        impressions: formatNumber(summary.yesterday.impressions),
+        clicks: formatNumber(summary.yesterday.clicks),
+        ctr: formatPercent(summary.yesterday.ctr),
+        rpm: formatCurrency(summary.yesterday.rpm),
+        pageViews: formatNumber(summary.yesterday.pageViews)
+      },
+      last7Days: {
+        earnings: formatCurrency(summary.last7Days.earnings),
+        impressions: formatNumber(summary.last7Days.impressions),
+        clicks: formatNumber(summary.last7Days.clicks),
+        ctr: formatPercent(summary.last7Days.ctr),
+        rpm: formatCurrency(summary.last7Days.rpm),
+        pageViews: formatNumber(summary.last7Days.pageViews)
+      },
+      thisMonth: {
+        earnings: formatCurrency(summary.thisMonth.earnings),
+        impressions: formatNumber(summary.thisMonth.impressions),
+        clicks: formatNumber(summary.thisMonth.clicks),
+        ctr: formatPercent(summary.thisMonth.ctr),
+        rpm: formatCurrency(summary.thisMonth.rpm),
+        pageViews: formatNumber(summary.thisMonth.pageViews)
+      },
+      lastMonth: {
+        earnings: formatCurrency(summary.lastMonth.earnings),
+        impressions: formatNumber(summary.lastMonth.impressions),
+        clicks: formatNumber(summary.lastMonth.clicks),
+        ctr: formatPercent(summary.lastMonth.ctr),
+        rpm: formatCurrency(summary.lastMonth.rpm),
+        pageViews: formatNumber(summary.lastMonth.pageViews)
+      }
+    },
+    raw: summary,
+    comparison: {
+      vsYesterday: summary.yesterday.earnings > 0 ? ((summary.today.earnings - summary.yesterday.earnings) / summary.yesterday.earnings * 100).toFixed(1) + "%" : "N/A",
+      vsLastMonth: summary.lastMonth.earnings > 0 ? ((summary.thisMonth.earnings - summary.lastMonth.earnings) / summary.lastMonth.earnings * 100).toFixed(1) + "%" : "N/A"
+    }
+  };
+}
+async function handleGenerateReport(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const endDate = args.endDate || getYesterday();
+  const startDate = args.startDate || get7DaysAgo();
+  const report = await client.generateReport({
+    accountId: accountId || "",
+    startDate,
+    endDate,
+    dimensions: args.dimensions || void 0,
+    metrics: args.metrics || void 0,
+    orderBy: args.orderBy || void 0,
+    limit: args.limit || 100
+  });
+  const headers = report.headers?.map((h) => h.name) || [];
+  const rows = report.rows?.map(
+    (row) => row.cells.reduce((acc, cell, i) => {
+      acc[headers[i]] = cell.value;
+      return acc;
+    }, {})
+  ) || [];
+  return {
+    dateRange: {
+      start: startDate,
+      end: endDate
+    },
+    headers,
+    rows,
+    totals: report.totals?.cells.reduce((acc, cell, i) => {
+      acc[headers[i]] = cell.value;
+      return acc;
+    }, {}),
+    totalRows: report.totalMatchedRows || rows.length.toString()
+  };
+}
+async function handleComparePeriods(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const period1Start = args.period1Start;
+  const period1End = args.period1End;
+  const period2Start = args.period2Start;
+  const period2End = args.period2End;
+  if (!period1Start || !period1End || !period2Start || !period2End) {
+    throw new Error("All period dates are required");
+  }
+  const dimensions = args.dimensions || void 0;
+  const [report1, report2] = await Promise.all([
+    client.generateReport({
+      accountId: accountId || "",
+      startDate: period1Start,
+      endDate: period1End,
+      dimensions
+    }),
+    client.generateReport({
+      accountId: accountId || "",
+      startDate: period2Start,
+      endDate: period2End,
+      dimensions
+    })
+  ]);
+  const extractTotals = (report) => {
+    const headers = report.headers?.map((h) => h.name) || [];
+    const totals = report.totals?.cells || report.rows?.[0]?.cells || [];
+    return headers.reduce((acc, header, i) => {
+      acc[header] = parseFloat(totals[i]?.value) || 0;
+      return acc;
+    }, {});
+  };
+  const period1Totals = extractTotals(report1);
+  const period2Totals = extractTotals(report2);
+  const changes = {};
+  for (const key of Object.keys(period1Totals)) {
+    const val1 = period1Totals[key];
+    const val2 = period2Totals[key] || 0;
+    const diff = val1 - val2;
+    const percent = val2 !== 0 ? diff / val2 * 100 : 0;
+    changes[key] = {
+      period1: val1,
+      period2: val2,
+      change: diff >= 0 ? `+${diff.toFixed(2)}` : diff.toFixed(2),
+      changePercent: percent >= 0 ? `+${percent.toFixed(1)}%` : `${percent.toFixed(1)}%`
+    };
+  }
+  return {
+    period1: {
+      start: period1Start,
+      end: period1End,
+      totals: period1Totals
+    },
+    period2: {
+      start: period2Start,
+      end: period2End,
+      totals: period2Totals
+    },
+    changes
+  };
+}
+function getYesterday() {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - 1);
+  return d.toISOString().split("T")[0];
+}
+function get7DaysAgo() {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - 7);
+  return d.toISOString().split("T")[0];
+}
+
+// src/server/tools/sites.ts
+async function handleListSites(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const sites = await client.listSites(accountId);
+  const byStatus = {
+    ready: sites.filter((s) => s.state === "READY"),
+    gettingReady: sites.filter((s) => s.state === "GETTING_READY"),
+    needsAttention: sites.filter((s) => s.state === "NEEDS_ATTENTION"),
+    requiresReview: sites.filter((s) => s.state === "REQUIRES_REVIEW")
+  };
+  const formatSite = (site) => {
+    const statusEmojiMap = {
+      "READY": "\u2705",
+      "GETTING_READY": "\u23F3",
+      "NEEDS_ATTENTION": "\u26A0\uFE0F",
+      "REQUIRES_REVIEW": "\u{1F4DD}",
+      "STATE_UNSPECIFIED": "\u2753"
+    };
+    const statusEmoji = statusEmojiMap[site.state] || "\u2753";
+    return {
+      domain: site.domain,
+      status: site.state,
+      statusEmoji,
+      autoAdsEnabled: site.autoAdsEnabled || false,
+      name: site.name
+    };
+  };
+  return {
+    sites: sites.map(formatSite),
+    summary: {
+      total: sites.length,
+      ready: byStatus.ready.length,
+      gettingReady: byStatus.gettingReady.length,
+      needsAttention: byStatus.needsAttention.length,
+      requiresReview: byStatus.requiresReview.length
+    },
+    statusDescriptions: {
+      READY: "Approved and serving ads",
+      GETTING_READY: "Under review by Google (may take 1-2 weeks)",
+      NEEDS_ATTENTION: "Issues to fix before approval",
+      REQUIRES_REVIEW: "Site needs review or is inactive"
+    }
+  };
+}
+
+// src/server/tools/alerts.ts
+async function handleListAlerts(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const alerts = await client.listAlerts(accountId);
+  const bySeverity = {
+    severe: alerts.filter((a) => a.severity === "SEVERE"),
+    warning: alerts.filter((a) => a.severity === "WARNING"),
+    info: alerts.filter((a) => a.severity === "INFO")
+  };
+  const formatAlert = (alert) => {
+    const severityEmojiMap = {
+      "SEVERE": "\u{1F534}",
+      "WARNING": "\u{1F7E1}",
+      "INFO": "\u{1F535}",
+      "SEVERITY_UNSPECIFIED": "\u26AA"
+    };
+    const severityEmoji = severityEmojiMap[alert.severity] || "\u26AA";
+    return {
+      message: alert.message,
+      severity: alert.severity,
+      severityEmoji,
+      type: alert.type,
+      name: alert.name
+    };
+  };
+  return {
+    alerts: alerts.map(formatAlert),
+    summary: {
+      total: alerts.length,
+      severe: bySeverity.severe.length,
+      warning: bySeverity.warning.length,
+      info: bySeverity.info.length
+    },
+    hasIssues: bySeverity.severe.length > 0 || bySeverity.warning.length > 0,
+    severityDescriptions: {
+      SEVERE: "Immediate action required (payment holds, violations)",
+      WARNING: "Action recommended",
+      INFO: "General notifications"
+    }
+  };
+}
+async function handleListPolicyIssues(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const issues = await client.listPolicyIssues(accountId);
+  const formatIssue = (issue) => {
+    const actionEmojiMap = {
+      "WARNED": "\u26A0\uFE0F",
+      "AD_SERVING_RESTRICTED": "\u{1F536}",
+      "AD_SERVING_DISABLED": "\u{1F534}",
+      "AD_SERVED_WITH_CLICK_CONFIRMATION": "\u{1F7E1}",
+      "AD_PERSONALIZATION_RESTRICTED": "\u{1F7E0}",
+      "ENFORCEMENT_ACTION_UNSPECIFIED": "\u26AA"
+    };
+    const actionEmoji = actionEmojiMap[issue.action] || "\u26AA";
+    return {
+      site: issue.site,
+      siteSection: issue.siteSection,
+      uri: issue.uri,
+      entityType: issue.entityType,
+      action: issue.action,
+      actionEmoji,
+      adRequestCount: issue.adRequestCount,
+      warningEscalationDate: issue.warningEscalationDate ? `${issue.warningEscalationDate.year}-${String(issue.warningEscalationDate.month).padStart(2, "0")}-${String(issue.warningEscalationDate.day).padStart(2, "0")}` : null,
+      name: issue.name
+    };
+  };
+  const byAction = {
+    warned: issues.filter((i) => i.action === "WARNED"),
+    restricted: issues.filter((i) => i.action === "AD_SERVING_RESTRICTED"),
+    disabled: issues.filter((i) => i.action === "AD_SERVING_DISABLED"),
+    clickConfirmation: issues.filter((i) => i.action === "AD_SERVED_WITH_CLICK_CONFIRMATION"),
+    personalizationRestricted: issues.filter((i) => i.action === "AD_PERSONALIZATION_RESTRICTED")
+  };
+  return {
+    issues: issues.map(formatIssue),
+    summary: {
+      total: issues.length,
+      warned: byAction.warned.length,
+      restricted: byAction.restricted.length,
+      disabled: byAction.disabled.length,
+      clickConfirmation: byAction.clickConfirmation.length,
+      personalizationRestricted: byAction.personalizationRestricted.length
+    },
+    hasIssues: issues.length > 0,
+    actionDescriptions: {
+      WARNED: "Pending enforcement with deadline - fix before escalation",
+      AD_SERVING_RESTRICTED: "Reduced ad demand on affected pages",
+      AD_SERVING_DISABLED: "Ads completely stopped on affected pages",
+      AD_SERVED_WITH_CLICK_CONFIRMATION: "Extra click verification required",
+      AD_PERSONALIZATION_RESTRICTED: "Limited to basic (non-personalized) ads"
+    }
+  };
+}
+
+// src/server/tools/payments.ts
+async function handleListPayments(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const payments = await client.listPayments(accountId);
+  const formatPayment = (payment) => {
+    const date = payment.date ? `${payment.date.year}-${String(payment.date.month).padStart(2, "0")}-${String(payment.date.day).padStart(2, "0")}` : null;
+    const name = payment.name || "";
+    let type = "payment";
+    if (name.includes("unpaid")) {
+      type = "unpaid";
+    } else if (name.includes("youtube")) {
+      type = "youtube";
+    }
+    return {
+      amount: payment.amount || "N/A",
+      date,
+      type,
+      name: payment.name
+    };
+  };
+  const unpaid = payments.filter((p) => p.name?.includes("unpaid"));
+  const paid = payments.filter((p) => !p.name?.includes("unpaid"));
+  const totalPaid = paid.reduce((sum, p) => {
+    const match = p.amount?.match(/[\d.]+/);
+    return sum + (match ? parseFloat(match[0]) : 0);
+  }, 0);
+  return {
+    payments: payments.map(formatPayment),
+    summary: {
+      totalPayments: paid.length,
+      unpaidBalance: unpaid.length > 0 ? unpaid[0].amount : "N/A",
+      totalPaidAllTime: `$${totalPaid.toFixed(2)}`
+    },
+    unpaid: unpaid.map(formatPayment),
+    paid: paid.map(formatPayment)
+  };
+}
+
+// src/server/tools/adUnits.ts
+async function handleListAdUnits(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const client = await AdSenseClient.create(accountId);
+  const adUnits = await client.listAdUnits(accountId);
+  const formatAdUnit = (unit) => {
+    const stateEmojiMap = {
+      "ACTIVE": "\u2705",
+      "ARCHIVED": "\u{1F4E6}",
+      "STATE_UNSPECIFIED": "\u2753"
+    };
+    const stateEmoji = stateEmojiMap[unit.state] || "\u2753";
+    const nameParts = unit.name.split("/");
+    const adClientId = nameParts[3] || "";
+    const adUnitId = nameParts[5] || "";
+    return {
+      displayName: unit.displayName,
+      state: unit.state,
+      stateEmoji,
+      type: unit.contentAdsSettings?.type || "UNKNOWN",
+      size: unit.contentAdsSettings?.size || "Auto",
+      adClientId,
+      adUnitId,
+      name: unit.name,
+      reportingDimensionId: unit.reportingDimensionId
+    };
+  };
+  const byState = {
+    active: adUnits.filter((u) => u.state === "ACTIVE"),
+    archived: adUnits.filter((u) => u.state === "ARCHIVED")
+  };
+  const byType = {};
+  for (const unit of adUnits) {
+    const type = unit.contentAdsSettings?.type || "UNKNOWN";
+    if (!byType[type]) {
+      byType[type] = [];
+    }
+    byType[type].push(unit);
+  }
+  return {
+    adUnits: adUnits.map(formatAdUnit),
+    summary: {
+      total: adUnits.length,
+      active: byState.active.length,
+      archived: byState.archived.length,
+      byType: Object.fromEntries(
+        Object.entries(byType).map(([type, units]) => [type, units.length])
+      )
+    },
+    typeDescriptions: {
+      DISPLAY: "Standard display ads (image, text, rich media)",
+      FEED: "In-feed ads that match your content style",
+      ARTICLE: "In-article ads for between paragraphs",
+      MATCHED_CONTENT: "Content recommendations with ads",
+      LINK: "Contextual link unit ads"
+    }
+  };
+}
+async function handleGetAdCode(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const adClientId = args.adClientId;
+  const adUnitId = args.adUnitId;
+  if (!adClientId || !adUnitId) {
+    throw new Error("adClientId and adUnitId are required");
+  }
+  const client = await AdSenseClient.create(accountId);
+  const adCode = await client.getAdCode(adClientId, adUnitId, accountId);
+  return {
+    adCode,
+    adClientId,
+    adUnitId,
+    instructions: [
+      "Copy the ad code above",
+      "Paste it into your website HTML where you want the ad to appear",
+      "The ad code should be placed within the <body> tags",
+      "Make sure to test the ad placement before publishing"
+    ]
+  };
+}
+
+// src/server/tools/export.ts
+async function handleExportCsv(args) {
+  const accountId = args.accountId || process.env.ADSENSE_ACCOUNT_ID;
+  const startDate = args.startDate;
+  const endDate = args.endDate;
+  if (!startDate || !endDate) {
+    throw new Error("startDate and endDate are required");
+  }
+  const client = await AdSenseClient.create(accountId);
+  try {
+    const csvData = await client.generateCsvReport({
+      accountId: accountId || "",
+      startDate,
+      endDate,
+      dimensions: args.dimensions || void 0,
+      metrics: args.metrics || void 0
+    });
+    return {
+      format: "csv",
+      dateRange: { start: startDate, end: endDate },
+      data: csvData
+    };
+  } catch {
+    const report = await client.generateReport({
+      accountId: accountId || "",
+      startDate,
+      endDate,
+      dimensions: args.dimensions || void 0,
+      metrics: args.metrics || void 0,
+      limit: 1e4
+    });
+    const headers = report.headers?.map((h) => h.name) || [];
+    const rows = report.rows || [];
+    const csvLines = [
+      headers.join(","),
+      ...rows.map(
+        (row) => row.cells.map((cell) => {
+          const value = cell.value;
+          if (value.includes(",") || value.includes('"')) {
+            return `"${value.replace(/"/g, '""')}"`;
+          }
+          return value;
+        }).join(",")
+      )
+    ];
+    return {
+      format: "csv",
+      dateRange: { start: startDate, end: endDate },
+      data: csvLines.join("\n"),
+      rowCount: rows.length
+    };
+  }
+}
+
+// src/server/tools/index.ts
+function registerTools() {
+  return [
+    // Account tools
+    {
+      name: "adsense_list_accounts",
+      description: "List all AdSense accounts you have access to",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    },
+    // Report tools
+    {
+      name: "adsense_earnings_summary",
+      description: "Get a quick earnings summary (today, yesterday, last 7 days, this month, last month)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID (e.g., pub-1234567890123456). Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "adsense_generate_report",
+      description: "Generate a detailed AdSense performance report with custom dimensions and metrics",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          },
+          startDate: {
+            type: "string",
+            description: "Start date (YYYY-MM-DD). Defaults to 7 days ago."
+          },
+          endDate: {
+            type: "string",
+            description: "End date (YYYY-MM-DD). Defaults to yesterday."
+          },
+          dimensions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Dimensions to group by: DATE, WEEK, MONTH, DOMAIN_NAME, PAGE_URL, AD_UNIT_NAME, COUNTRY_NAME, PLATFORM_TYPE_CODE, TRAFFIC_SOURCE_CODE"
+          },
+          metrics: {
+            type: "array",
+            items: { type: "string" },
+            description: "Metrics to include: ESTIMATED_EARNINGS, IMPRESSIONS, CLICKS, PAGE_VIEWS, PAGE_VIEWS_CTR, PAGE_VIEWS_RPM, AD_REQUESTS, AD_REQUESTS_COVERAGE"
+          },
+          orderBy: {
+            type: "string",
+            description: "Metric to sort by (prefix with - for descending, e.g., -ESTIMATED_EARNINGS)"
+          },
+          limit: {
+            type: "number",
+            description: "Max rows to return (default: 100, max: 10000)"
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "adsense_compare_periods",
+      description: "Compare AdSense performance between two time periods",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          },
+          period1Start: {
+            type: "string",
+            description: "First period start date (YYYY-MM-DD)"
+          },
+          period1End: {
+            type: "string",
+            description: "First period end date (YYYY-MM-DD)"
+          },
+          period2Start: {
+            type: "string",
+            description: "Second period start date (YYYY-MM-DD)"
+          },
+          period2End: {
+            type: "string",
+            description: "Second period end date (YYYY-MM-DD)"
+          },
+          dimensions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Dimensions to group by for comparison"
+          }
+        },
+        required: ["period1Start", "period1End", "period2Start", "period2End"]
+      }
+    },
+    // Sites tools
+    {
+      name: "adsense_list_sites",
+      description: "List all sites and their AdSense approval status (READY, GETTING_READY, NEEDS_ATTENTION, REQUIRES_REVIEW)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    // Alerts tools
+    {
+      name: "adsense_list_alerts",
+      description: "List AdSense account alerts and warnings (INFO, WARNING, SEVERE)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "adsense_list_policy_issues",
+      description: "List policy issues and violations affecting your account (WARNED, AD_SERVING_RESTRICTED, AD_SERVING_DISABLED)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    // Payments tools
+    {
+      name: "adsense_list_payments",
+      description: "List payment history and pending earnings",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    // Ad units tools
+    {
+      name: "adsense_list_ad_units",
+      description: "List all ad units across your ad clients",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "adsense_get_ad_code",
+      description: "Get the HTML embed code for an ad unit",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          },
+          adClientId: {
+            type: "string",
+            description: "Ad client ID (e.g., ca-pub-1234567890123456)"
+          },
+          adUnitId: {
+            type: "string",
+            description: "Ad unit ID"
+          }
+        },
+        required: ["adClientId", "adUnitId"]
+      }
+    },
+    // Export tools
+    {
+      name: "adsense_export_csv",
+      description: "Export AdSense report data as CSV format",
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountId: {
+            type: "string",
+            description: "AdSense account ID. Uses default if not specified."
+          },
+          startDate: {
+            type: "string",
+            description: "Start date (YYYY-MM-DD)"
+          },
+          endDate: {
+            type: "string",
+            description: "End date (YYYY-MM-DD)"
+          },
+          dimensions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Dimensions to include"
+          },
+          metrics: {
+            type: "array",
+            items: { type: "string" },
+            description: "Metrics to include"
+          }
+        },
+        required: ["startDate", "endDate"]
+      }
+    }
+  ];
+}
+async function handleToolCall(name, args) {
+  try {
+    let result;
+    switch (name) {
+      case "adsense_list_accounts":
+        result = await handleListAccounts();
+        break;
+      case "adsense_earnings_summary":
+        result = await handleEarningsSummary(args);
+        break;
+      case "adsense_generate_report":
+        result = await handleGenerateReport(args);
+        break;
+      case "adsense_compare_periods":
+        result = await handleComparePeriods(args);
+        break;
+      case "adsense_list_sites":
+        result = await handleListSites(args);
+        break;
+      case "adsense_list_alerts":
+        result = await handleListAlerts(args);
+        break;
+      case "adsense_list_policy_issues":
+        result = await handleListPolicyIssues(args);
+        break;
+      case "adsense_list_payments":
+        result = await handleListPayments(args);
+        break;
+      case "adsense_list_ad_units":
+        result = await handleListAdUnits(args);
+        break;
+      case "adsense_get_ad_code":
+        result = await handleGetAdCode(args);
+        break;
+      case "adsense_export_csv":
+        result = await handleExportCsv(args);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error.message}`
+        }
+      ]
+    };
+  }
+}
+
+// src/server/resources/index.ts
+async function handleListResources() {
+  return {
+    resources: [
+      {
+        uri: "adsense://accounts",
+        name: "AdSense Accounts",
+        description: "List of all AdSense accounts you have access to",
+        mimeType: "application/json"
+      }
+    ]
+  };
+}
+async function handleReadResource(uri) {
+  const url = new URL(uri);
+  if (url.protocol !== "adsense:") {
+    throw new Error(`Unsupported protocol: ${url.protocol}`);
+  }
+  const path4 = url.pathname.replace(/^\/\//, "");
+  if (path4 === "accounts") {
+    const client = await AdSenseClient.create();
+    const accounts = await client.listAccounts();
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(accounts, null, 2)
+        }
+      ]
+    };
+  }
+  const sitesMatch = path4.match(/^accounts\/([^/]+)\/sites$/);
+  if (sitesMatch) {
+    const accountId = sitesMatch[1];
+    const client = await AdSenseClient.create(accountId);
+    const sites = await client.listSites(accountId);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(sites, null, 2)
+        }
+      ]
+    };
+  }
+  const adUnitsMatch = path4.match(/^accounts\/([^/]+)\/adunits$/);
+  if (adUnitsMatch) {
+    const accountId = adUnitsMatch[1];
+    const client = await AdSenseClient.create(accountId);
+    const adUnits = await client.listAdUnits(accountId);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(adUnits, null, 2)
+        }
+      ]
+    };
+  }
+  throw new Error(`Unknown resource: ${uri}`);
+}
+
+// src/server/index.ts
+function createServer() {
+  const server = new Server(
+    {
+      name: "adsense-mcp-server",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: registerTools()
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return handleToolCall(request.params.name, request.params.arguments || {});
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return handleListResources();
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    return handleReadResource(request.params.uri);
+  });
+  return server;
+}
+async function startServer(accountId) {
+  if (accountId) {
+    process.env.ADSENSE_ACCOUNT_ID = accountId;
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await server.close();
+    process.exit(0);
+  });
+}
+
+// src/cli/run.ts
+async function runServer(options) {
+  if (options.account) {
+    process.stderr.write(`Using account: ${options.account}
+`);
+  }
+  await startServer(options.account);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("adsense-mcp").description("AdSense MCP Server - Query earnings, reports, alerts via Claude").version("0.1.0");
+program.command("init").description("Initialize OAuth authentication with Google AdSense").option("--client-id <id>", "OAuth Client ID").option("--client-secret <secret>", "OAuth Client Secret").option("--service-account <path>", "Path to service account JSON key file").action(async (options) => {
+  await runInit(options);
+});
+program.command("doctor").description("Check authentication and API access").action(async () => {
+  await runDoctor();
+});
+program.command("run").description("Start the MCP server").option("--account <id>", "Default AdSense account ID to use").action(async (options) => {
+  await runServer(options);
+});
+program.argument("[command]", "Command to run").action(async (cmd) => {
+  if (!cmd) {
+    await runServer({});
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map