AdMob API MCP 서버 만들기 - Part 2: AdMob API 호출을 위한 인증 기능 추가하기

// src/auth.ts
import * as fs from "fs";
import * as path from "path";
import * as http from "http";
import * as url from "url";
import open from "open";
import { google } from "googleapis";
import { OAuth2Client } from "google-auth-library";

const CREDENTIALS_DIR = process.env.CREDENTIALS_DIR || path.join(process.cwd(), "credentials");

const CLIENT_SECERT_PATH = path.join(CREDENTIALS_DIR, "client_secret.json");
const TOKEN_PATH = path.join(CREDENTIALS_DIR, "token.json");

const SCOPES = [
  "https://www.googleapis.com/auth/admob.readonly",
  "https://www.googleapis.com/auth/admob.report",
];

interface ClientSecret {
  installed?: {
    client_id: string;
    project_id: string;
    auth_uri: string;
    token_uri: string;
    auth_provider_x509_cert_url: string;
    client_secret: string;
    redirect_uris: string[];
  };
  web?: {
    client_id: string;
    project_id: string;
    auth_uri: string;
    token_uri: string;
    auth_provider_x509_cert_url: string;
    client_secret: string;
    redirect_uris: string[];
    javascript_origins: string[];
  };
}

interface Token {
  type: string;
  client_id: string;
  client_secret: string;
  refresh_token: string;
}

export async function authorize(): Promise<OAuth2Client> {
  let client = await loadSavedCredentialsIfExist();
  if (client) {
    return client;
  }
  client = await authenticate({
    scopes: SCOPES,
    tokenPath: TOKEN_PATH,
  });
  if (client) {
    await saveCredentials(client);
    return client;
  }
  throw new Error("Authentication failed.");
}

export async function loadSavedCredentialsIfExist(): Promise<OAuth2Client | null> {
  try {
    const content: string = fs.readFileSync(TOKEN_PATH, "utf-8");
    const credentials = JSON.parse(content) as Token;
    return google.auth.fromJSON(credentials) as OAuth2Client;
  } catch {
    return null;
  }
}

async function saveCredentials(client: OAuth2Client): Promise<void> {
  const content: string = fs.readFileSync(CLIENT_SECERT_PATH, "utf-8");
  const keys = JSON.parse(content) as ClientSecret;
  const key = keys.installed || keys.web;
  if (!key) {
    throw new Error("No client secrets found in client_secret.json");
  }
  const payload: string = JSON.stringify({
    type: "authorized_user",
    client_id: key.client_id,
    client_secret: key.client_secret,
    refresh_token: client.credentials.refresh_token,
  });
  fs.writeFileSync(TOKEN_PATH, payload);
}

function authenticate(options: { scopes: string[]; tokenPath: string }): Promise<OAuth2Client> {
  return new Promise((resolve, reject) => {
    const content: string = fs.readFileSync(CLIENT_SECERT_PATH, "utf-8");
    const keys = JSON.parse(content) as ClientSecret;
    const key = keys.installed || keys.web;
    if (!key) {
      return reject(new Error("No client secrets found in client_secret.json"));
    }

    const oAuth2Client = new google.auth.OAuth2(
      key.client_id,
      key.client_secret,
      `http://localhost:3000/oauth2callback`
    );

    const authorizeUrl: string = oAuth2Client.generateAuthUrl({
      access_type: "offline",
      scope: options.scopes.join(" "),
    });

    const httpServer = http
      .createServer(async (req, res) => {
        try {
          if (req.url && req.url.includes("/oauth2callback")) {
            const qs = new url.URL(req.url, "http://localhost:3000").searchParams;
            res.end("Authentication successful! Please return to the console.");
            httpServer.close();
            const code = qs.get("code");
            if (code) {
              const { tokens } = await oAuth2Client.getToken(code);
              oAuth2Client.setCredentials(tokens);
              resolve(oAuth2Client);
            } else {
              reject(new Error("No code found in callback URL"));
            }
          }
        } catch (e) {
          reject(e);
        }
      })
      .listen(3000, () => {
        open(authorizeUrl, { wait: false }).then(cp => cp.unref());
      });
  });
}

// src/index.ts

// ... main() 함수는 그대로 둡니다 ...

if (process.argv.includes("auth")) {
  authorize().then(() => {
    console.log("Authentication successful! 🎉");
    process.exit(0);
  });
} else {
  main().catch(error => {
    console.error(`Fatal error in main(): ${error}`);
    process.exit(1);
  });
}