App Store レビューを AI が自動返信 — App Store Connect API × Gemini でレビュー管理を半自動化する実践ガイド

// src/googleplay/auth.ts
// Google Play API 用アクセストークン取得（RS256 JWT → OAuth2 交換）
 
interface GoogleServiceAccount {
  client_email: string;
  private_key: string;
}
 
async function generateGoogleAccessToken(
  serviceAccount: GoogleServiceAccount
): Promise<string> {
  const now = Math.floor(Date.now() / 1000);
 
  const header = { alg: "RS256", typ: "JWT" };
  const payload = {
    iss: serviceAccount.client_email,
    scope: "https://www.googleapis.com/auth/androidpublisher",
    aud: "https://oauth2.googleapis.com/token",
    iat: now,
    exp: now + 3600, // 1時間
  };
 
  const encodeBase64Url = (obj: object): string =>
    btoa(JSON.stringify(obj))
      .replace(/\+/g, "-")
      .replace(/\//g, "_")
      .replace(/=/g, "");
 
  const header64 = encodeBase64Url(header);
  const payload64 = encodeBase64Url(payload);
  const signingInput = `${header64}.${payload64}`;
 
  // RSA-SHA256 署名（Cloudflare Workers の SubtleCrypto を使用）
  const keyBuffer = pemRsaToBuffer(serviceAccount.private_key);
  const cryptoKey = await crypto.subtle.importKey(
    "pkcs8",
    keyBuffer,
    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
    false,
    ["sign"]
  );
 
  const encoder = new TextEncoder();
  const signature = await crypto.subtle.sign(
    "RSASSA-PKCS1-v1_5",
    cryptoKey,
    encoder.encode(signingInput)
  );
 
  const sig64 = btoa(String.fromCharCode(...new Uint8Array(signature)))
    .replace(/\+/g, "-")
    .replace(/\//g, "_")
    .replace(/=/g, "");
 
  const jwtAssertion = `${signingInput}.${sig64}`;
 
  // JWTをOAuth2アクセストークンと交換
  const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwtAssertion}`,
  });
 
  if (\!tokenResponse.ok) {
    const err = await tokenResponse.text();
    throw new Error(`Google OAuth2 token exchange failed: ${err}`);
  }
 
  const tokenData = (await tokenResponse.json()) as { access_token: string };
  return tokenData.access_token;
}
 
function pemRsaToBuffer(pem: string): ArrayBuffer {
  const base64 = pem
    .replace(/-----BEGIN PRIVATE KEY-----/g, "")
    .replace(/-----END PRIVATE KEY-----/g, "")
    .replace(/\n/g, "");
 
  const binary = atob(base64);
  const buffer = new ArrayBuffer(binary.length);
  const view = new Uint8Array(buffer);
  for (let i = 0; i < binary.length; i++) {
    view[i] = binary.charCodeAt(i);
  }
  return buffer;
}
 
export { generateGoogleAccessToken };

// src/ai/reviewResponder.ts
// Gemini API を使ったレビュー感情分析と返信文生成
 
interface ReviewAnalysis {
  sentiment: "positive" | "negative" | "neutral" | "mixed";
  mainIssue: string | null;
  suggestedResponse: string;
  confidence: number;    // 0.0〜1.0（生成した返信の適切さへの自信度）
  shouldAutoSend: boolean; // confidence が高く安全な内容の場合のみ true
}
 
async function analyzeAndRespond(
  review: {
    rating: number;
    title: string;
    body: string;
    territory: string;
  },
  appContext: {
    name: string;
    category: string;
    recentUpdates: string[];
    knownIssues: string[];
  },
  geminiApiKey: string
): Promise<ReviewAnalysis> {
  const responseLanguage = getResponseLanguage(review.territory);
 
  const prompt = `
あなたは「${appContext.name}」というアプリの開発者として、ユーザーレビューに返信します。
 
## アプリ情報
- アプリ名: ${appContext.name}
- カテゴリ: ${appContext.category}
- 最近のアップデート: ${appContext.recentUpdates.join(", ") || "なし"}
- 既知の問題: ${appContext.knownIssues.length > 0 ? appContext.knownIssues.join(", ") : "なし"}
 
## 受信レビュー
- 評価: ${review.rating}星
- タイトル: ${review.title || "（タイトルなし）"}
- 本文: ${review.body}
- 地域コード: ${review.territory}
 
## 返信作成の指示
1. レビューの感情（positive/negative/neutral/mixed）を判断すること
2. 主な問題点があれば1文で要約すること（なければ null）
3. 返信文を以下の原則で作成すること:
   - 使用言語: ${responseLanguage}
   - 文字数: 100〜200文字（短すぎず長すぎず）
   - トーン: 誠実で温かみがあり、押しつけがましくない開発者の声
   - ポジティブなレビュー → 感謝を述べ、継続的なサポートを約束する
   - バグ報告 → 問題を真摯に受け止め、サポート連絡先（support@appname.com）を案内する
   - 機能要望 → 検討を約束し、フィードバックへの感謝を述べる
   - 感情的なレビュー → 防御的にならず、ユーザーの体験を受け止める姿勢を示す
4. confidence（0.0〜1.0）: 返信の適切さへの自信度を設定すること
5. shouldAutoSend: confidence が 0.85 以上かつ誤解を招く表現がない場合のみ true にすること
 
以下の JSON 形式で返すこと:
{
  "sentiment": "positive" | "negative" | "neutral" | "mixed",
  "mainIssue": "問題の要約（なければ null）",
  "suggestedResponse": "返信文本文",
  "confidence": 0.0〜1.0,
  "shouldAutoSend": true | false
}
`;
 
  const response = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${geminiApiKey}`,
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        contents: [{ parts: [{ text: prompt }] }],
        generationConfig: {
          responseMimeType: "application/json",
          temperature: 0.3, // 低めで一貫性を確保
          maxOutputTokens: 512,
        },
      }),
    }
  );
 
  if (\!response.ok) {
    throw new Error(`Gemini API error: ${response.status}`);
  }
 
  const data = (await response.json()) as {
    candidates: Array<{
      content: { parts: Array<{ text: string }> };
    }>;
  };
 
  const text = data.candidates[0]?.content.parts[0]?.text;
  if (\!text) throw new Error("Gemini API returned empty response");
 
  // JSON パース失敗時のフォールバック（後述）
  try {
    return JSON.parse(text) as ReviewAnalysis;
  } catch {
    return {
      sentiment: "neutral",
      mainIssue: null,
      suggestedResponse:
        "ご意見をお寄せいただき、ありがとうございます。より良いアプリになるよう改善を続けてまいります。引き続きよろしくお願いいたします。",
      confidence: 0.3,
      shouldAutoSend: false, // 不確かな場合は必ず手動確認
    };
  }
}
 
function getResponseLanguage(territory: string): string {
  const map: Record<string, string> = {
    JPN: "日本語",
    USA: "English",
    GBR: "English",
    AUS: "English",
    CAN: "English",
    DEU: "Deutsch",
    FRA: "Français",
    KOR: "한국어",
    CHN: "中文（簡体）",
    TWN: "中文（繁體）",
  };
  return map[territory] ?? "English";
}
 
export { analyzeAndRespond };

// src/worker.ts
// Cloudflare Workers エントリポイント — レビュー自動処理システム
 
interface Env {
  APPSTORE_ISSUER_ID: string;
  APPSTORE_KEY_ID: string;
  APPSTORE_PRIVATE_KEY: string;
  GOOGLE_SERVICE_ACCOUNT_JSON: string; // サービスアカウントJSONを文字列化
  GEMINI_API_KEY: string;
  APP_ID_IOS: string;           // App Store の数値 ID（例: "123456789"）
  PACKAGE_NAME_ANDROID: string; // com.example.myapp
  APP_NAME: string;             // 表示用アプリ名
  APP_CATEGORY: string;         // Productivity / Health / etc.
  KV_REVIEWS: KVNamespace;      // 処理状態のキャッシュ
}
 
export default {
  // Cron トリガー（wrangler.toml で "0 * * * *" に設定 = 毎時実行）
  async scheduled(_event: ScheduledEvent, env: Env, ctx: ExecutionContext) {
    ctx.waitUntil(processNewReviews(env));
  },
 
  // REST API（Rork ダッシュボードからの呼び出し）
  async fetch(request: Request, env: Env, _ctx: ExecutionContext) {
    const url = new URL(request.url);
    const corsHeaders = {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type, Authorization",
    };
 
    if (request.method === "OPTIONS") {
      return new Response(null, { headers: corsHeaders });
    }
 
    // 未処理レビュー一覧を返す
    if (url.pathname === "/api/reviews" && request.method === "GET") {
      const reviews = await getPendingReviews(env);
      return Response.json(reviews, { headers: corsHeaders });
    }
 
    // ダッシュボードからの承認アクション
    if (url.pathname === "/api/approve" && request.method === "POST") {
      const { reviewId, platform, response: responseText } =
        (await request.json()) as {
          reviewId: string;
          platform: "ios" | "android";
          response: string;
        };
 
      await sendReviewResponse(reviewId, platform, responseText, env);
      await env.KV_REVIEWS.delete(`pending:${reviewId}`);
      await env.KV_REVIEWS.put(`approved:${reviewId}`, "1", {
        expirationTtl: 60 * 60 * 24 * 30, // 30日
      });
 
      return Response.json({ success: true }, { headers: corsHeaders });
    }
 
    // 破棄アクション（返信しない選択）
    if (url.pathname === "/api/dismiss" && request.method === "POST") {
      const { reviewId } = (await request.json()) as { reviewId: string };
      await env.KV_REVIEWS.delete(`pending:${reviewId}`);
      await env.KV_REVIEWS.put(`dismissed:${reviewId}`, "1", {
        expirationTtl: 60 * 60 * 24 * 30,
      });
      return Response.json({ success: true }, { headers: corsHeaders });
    }
 
    return new Response("Not Found", { status: 404 });
  },
};
 
async function processNewReviews(env: Env) {
  const { generateAppStoreToken } = await import("./appstore/auth");
  const { fetchReviews } = await import("./appstore/reviews");
  const { analyzeAndRespond } = await import("./ai/reviewResponder");
 
  const iosToken = await generateAppStoreToken({
    issuerId: env.APPSTORE_ISSUER_ID,
    keyId: env.APPSTORE_KEY_ID,
    privateKey: env.APPSTORE_PRIVATE_KEY,
  });
 
  const iosReviews = await fetchReviews(env.APP_ID_IOS, iosToken, 30);
 
  const appContext = {
    name: env.APP_NAME,
    category: env.APP_CATEGORY,
    recentUpdates: ["最新のパフォーマンス改善", "UIデザインの刷新"],
    knownIssues: [], // 既知の問題があればここに記述
  };
 
  // JWT の有効期限（19分）内に収まるよう10件ごとにトークンを更新
  let currentToken = iosToken;
  let count = 0;
 
  for (const review of iosReviews) {
    // 既に処理済みのレビューはスキップ
    const [processed, approved, dismissed] = await Promise.all([
      env.KV_REVIEWS.get(`pending:${review.id}`),
      env.KV_REVIEWS.get(`approved:${review.id}`),
      env.KV_REVIEWS.get(`dismissed:${review.id}`),
    ]);
    if (processed || approved || dismissed) continue;
 
    // 10件ごとにトークンを更新（有効期限切れ防止）
    if (count > 0 && count % 10 === 0) {
      currentToken = await generateAppStoreToken({
        issuerId: env.APPSTORE_ISSUER_ID,
        keyId: env.APPSTORE_KEY_ID,
        privateKey: env.APPSTORE_PRIVATE_KEY,
      });
    }
 
    try {
      const analysis = await analyzeAndRespond(
        review,
        appContext,
        env.GEMINI_API_KEY
      );
 
      // 分析結果を KV に保存（ダッシュボードから参照可能）
      await env.KV_REVIEWS.put(
        `pending:${review.id}`,
        JSON.stringify({ review, analysis, platform: "ios" }),
        { expirationTtl: 60 * 60 * 24 * 7 } // 7日間保持
      );
 
      // confidence が高く安全な内容は自動送信
      if (analysis.shouldAutoSend && analysis.confidence >= 0.85) {
        await sendReviewResponse(
          review.id,
          "ios",
          analysis.suggestedResponse,
          env
        );
        await env.KV_REVIEWS.delete(`pending:${review.id}`);
        await env.KV_REVIEWS.put(`approved:${review.id}`, "auto", {
          expirationTtl: 60 * 60 * 24 * 30,
        });
      }
 
      count++;
    } catch (error) {
      console.error(`Failed to process review ${review.id}:`, error);
      // エラーは記録するが処理を継続する（1件のエラーで全体が止まらないように）
    }
  }
}
 
async function getPendingReviews(env: Env) {
  const list = await env.KV_REVIEWS.list({ prefix: "pending:" });
  const reviews = await Promise.all(
    list.keys.map((key) => env.KV_REVIEWS.get(key.name, "json"))
  );
  return reviews.filter(Boolean);
}
 
async function sendReviewResponse(
  reviewId: string,
  platform: "ios" | "android",
  responseText: string,
  env: Env
) {
  if (platform === "ios") {
    const { generateAppStoreToken } = await import("./appstore/auth");
    const token = await generateAppStoreToken({
      issuerId: env.APPSTORE_ISSUER_ID,
      keyId: env.APPSTORE_KEY_ID,
      privateKey: env.APPSTORE_PRIVATE_KEY,
    });
 
    const res = await fetch(
      "https://api.appstoreconnect.apple.com/v1/customerReviewResponses",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          data: {
            type: "customerReviewResponses",
            attributes: { responseBody: responseText },
            relationships: {
              review: {
                data: { type: "customerReviews", id: reviewId },
              },
            },
          },
        }),
      }
    );
 
    if (\!res.ok) {
      const errText = await res.text();
      throw new Error(`App Store response send failed: ${res.status} ${errText}`);
    }
  }
 
  if (platform === "android") {
    const { generateGoogleAccessToken } = await import("./googleplay/auth");
    const serviceAccount = JSON.parse(env.GOOGLE_SERVICE_ACCOUNT_JSON);
    const accessToken = await generateGoogleAccessToken(serviceAccount);
 
    // Google Play Reviews API でレビューに返信
    const res = await fetch(
      `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${env.PACKAGE_NAME_ANDROID}/reviews/${reviewId}:reply`,
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${accessToken}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ replyText: responseText }),
      }
    );
 
    if (\!res.ok) {
      const errText = await res.text();
      throw new Error(`Google Play response send failed: ${res.status} ${errText}`);
    }
  }
}

// ❌ 悪い例：1度生成したトークンを無限に使い回す
const token = await generateAppStoreToken(config);
for (const review of manyReviews) {
  await processReview(review, token); // 途中でトークン切れ → 401エラー
}
 
// ✅ 良い例：10件ごとにトークンを更新する
let token = await generateAppStoreToken(config);
for (let i = 0; i < reviews.length; i++) {
  if (i > 0 && i % 10 === 0) {
    token = await generateAppStoreToken(config); // 期限前に更新
  }
  await processReview(reviews[i], token);
}

// フォールバックの原則：不確かなものは必ず手動確認へ
catch {
  return {
    confidence: 0.3,
    shouldAutoSend: false, // ← ここを絶対に true にしない
    suggestedResponse: "ご意見ありがとうございます。...",
    // ...
  };
}