addashboard-cli 0.9.1 → 0.9.3

package/skills/ad-ops/scripts/plan_lint.py

@@ -4,8 +4,10 @@
 `adops.sh plan` から呼ばれる。単体でも動く:
 
     python3 plan_lint.py [<入稿計画.json>]
+    python3 plan_lint.py --wait [--timeout 7200]
 
 引数を省略すると ~/Downloads と 入稿計画/ の中で最も新しい入稿計画を拾う。
+`--wait` は、プランナーの入稿ボタンで新しい計画が書き出されるまで待ってから同じ処理を行う。
 Downloads にあったものは 入稿計画/ へリネームして移動する。
 
 やること:
@@ -13,18 +15,34 @@ Downloads にあったものは 入稿計画/ へリネームして移動する
   2. 要約 — CP > 広告グループ > 広告 を1画面の表で出す
   3. lint — dry-run が検出しない不備（相対finalUrl・paramCode衝突など）を拾う
   4. 差分 — サンプルプラン.json（＝合意した内容の正）と突き合わせ、違う項目だけ出す
+
+計画の特定はファイル名ではなく**中身**で行う。ブラウザがダウンロード名を勝手に
+整形するため、名前は当てにならない（実測: プランナーが指定した
+`TikTok入稿API検証_TikTok入稿計画_20260827-010101.json` が
+`TikTok 入稿 API 検証 2026年8月27日.json` / `YDA 入稿プラン 2026年8月27日.json`
+として保存された。「入稿計画」という連続文字列すら残らない）。
 """
+import argparse
 import glob
 import json
 import os
 import re
 import shutil
 import sys
+import time
 import urllib.parse
 
-SKILL_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-PLAN_DIR = os.path.join(SKILL_DIR, "入稿計画")
-DOWNLOADS = os.path.expanduser("~/Downloads")
+SKILL_DIR = os.environ.get("ADOPS_SKILL_DIR") or os.path.dirname(
+    os.path.dirname(os.path.abspath(__file__))
+)
+# テストが実ユーザーの Downloads を触らずに済むよう、探索先は env で差し替えられる
+PLAN_DIR = os.environ.get("ADOPS_PLAN_DIR") or os.path.join(SKILL_DIR, "入稿計画")
+DOWNLOADS = os.environ.get("ADOPS_DOWNLOADS") or os.path.expanduser("~/Downloads")
+
+WAIT_INTERVAL_SEC = 2.0
+WAIT_TIMEOUT_SEC = 7200.0
+EXIT_CONTEXT_MISMATCH = 3
+EXIT_TIMEOUT = 124
 
 # 新規モードの既定 12,000円 / 既存ASC の 5〜10万円 を包含するレンジ。
 # 外れたら桁間違いを疑う（エラーではなく確認を促す）。
@@ -44,9 +62,65 @@ def warn(msg: str) -> None:
 
 
 # --------------------------------------------------------------- 1. 回収
-def newest(pattern: str) -> str | None:
-    hits = glob.glob(pattern)
-    return max(hits, key=os.path.getmtime) if hits else None
+def scan_dir(directory: str) -> dict[str, tuple[float, int]]:
+    """直下の .json を {path: (mtime, size)} で返す。
+
+    サブディレクトリは見ない。E2E が 入稿計画/<timestamp>_<テスト名>/ 配下に
+    書き出すので、再帰するとテスト成果物を計画として拾ってしまう。
+    """
+    found: dict[str, tuple[float, int]] = {}
+    try:
+        names = os.listdir(directory)
+    except OSError:
+        return found  # 未作成でも探索は続ける（zip 展開直後は 入稿計画/ が無い）
+    for name in names:
+        if not name.endswith(".json"):
+            continue
+        path = os.path.join(directory, name)
+        try:
+            st = os.stat(path)
+        except OSError:
+            continue
+        if os.path.isfile(path):
+            found[path] = (st.st_mtime, st.st_size)
+    return found
+
+
+def read_plan(path: str) -> dict | None:
+    """入稿計画JSONとして読めれば返す。読めなければ None。
+
+    ファイル名では判定しない（ブラウザが改変するため。冒頭の docstring 参照）。
+    parse 失敗は「壊れている」だけでなく「書き込み途中」でも起きる。
+    """
+    try:
+        with open(path, encoding="utf-8") as f:
+            plan = json.load(f)
+    except (OSError, ValueError):
+        return None
+    if not isinstance(plan, dict) or plan.get("planVersion") != 1:
+        return None
+    campaigns = plan.get("campaigns")
+    if not isinstance(campaigns, list) or not campaigns:
+        return None
+    return plan
+
+
+def ad_count(plan: dict) -> int:
+    return sum(len(g.get("ads") or []) for c in plan["campaigns"] for g in ad_groups(c))
+
+
+def newest_plan(directories: list[str]) -> str | None:
+    """指定ディレクトリ直下から、中身が入稿計画である最新のファイルを返す。
+
+    mtime が同着なら先頭のディレクトリを優先する。呼び出し側が Downloads を先に
+    渡すので、未回収のものが 入稿計画/ の既存ファイルに負けない。
+    """
+    found: list[tuple[float, int, str]] = []
+    for rank, directory in enumerate(directories):
+        for path, (mtime, _size) in scan_dir(directory).items():
+            if read_plan(path) is not None:
+                found.append((mtime, -rank, path))
+    return max(found)[2] if found else None
 
 
 def load_account(platform: str, account_id: str) -> dict:
@@ -80,12 +154,26 @@ def collect(path: str, plan: dict) -> str:
     project = account.get("name") or plan.get("accountId", "plan")
     campaigns = plan.get("campaigns") or []
     cp = (campaigns[0].get("name") if campaigns else "") or "no-campaign"
-    stamp = re.search(r"(\d{8}-\d{6})", os.path.basename(path))
-    stamp = stamp.group(1) if stamp else "unknown"
+    # ブラウザがダウンロード名から timestamp を落とすことがある。その場合はファイルの
+    # mtime（＝保存時刻）から作る。以前は "unknown" 固定だったため、同じ案件・同じCPで
+    # 書き出すたびに同名になり、黙って上書きされていた。
+    matched = re.search(r"(\d{8}-\d{6})", os.path.basename(path))
+    stamp = matched.group(1) if matched else time.strftime(
+        "%Y%m%d-%H%M%S", time.localtime(os.path.getmtime(path))
+    )
 
     safe = lambda s: re.sub(r"[/\\:\s]+", "_", str(s)).strip("_")
-    dest = os.path.join(PLAN_DIR, f"{safe(project)}_{safe(cp)}_入稿計画_{stamp}.json")
     os.makedirs(PLAN_DIR, exist_ok=True)
+    # 連番は CP 名側に付ける。末尾の _<timestamp>.json はプランナーの履歴ビューが
+    # 保存日時の抽出に使っているので崩さない。
+    dest = os.path.join(PLAN_DIR, f"{safe(project)}_{safe(cp)}_入稿計画_{stamp}.json")
+    seq = 2
+    while os.path.exists(dest):
+        dest = os.path.join(
+            PLAN_DIR, f"{safe(project)}_{safe(cp)}_{seq}_入稿計画_{stamp}.json"
+        )
+        seq += 1
+
     shutil.move(path, dest)
     print(f"📥 回収: ~/Downloads → 入稿計画/{os.path.basename(dest)}")
     return dest
@@ -96,17 +184,122 @@ def pick_plan(argv: list[str]) -> str:
         if not os.path.exists(argv[0]):
             sys.exit(f"✗ ファイルが見つかりません: {argv[0]}")
         return argv[0]
-    candidates = [
-        p
-        for p in (
-            newest(os.path.join(DOWNLOADS, "*入稿計画*.json")),
-            newest(os.path.join(PLAN_DIR, "*.json")),
-        )
-        if p
-    ]
-    if not candidates:
+    path = newest_plan([DOWNLOADS, PLAN_DIR])
+    if not path:
         sys.exit("✗ 入稿計画JSONが見つかりません（~/Downloads にも 入稿計画/ にも）")
-    return max(candidates, key=os.path.getmtime)
+    return path
+
+
+# ------------------------------------------------------------- 1b. 待機
+def active_context() -> tuple[str, str] | None:
+    """アクティブプラン.json から (platform, accountId) を解決する。
+
+    `adops.sh planner --platform <pf> --account <名前>` が書く唯一の口。
+    待機中に読み直さない — 別タブ・別セッションで作業対象が変わったときに、
+    待っている相手が黙ってすり替わるのを避ける。
+    """
+    try:
+        with open(os.path.join(SKILL_DIR, "アクティブプラン.json"), encoding="utf-8") as f:
+            active = json.load(f)
+    except (OSError, ValueError):
+        return None
+    platform, name = active.get("platform"), active.get("accountName")
+    if not platform or not name:
+        return None
+    try:
+        with open(
+            os.path.join(SKILL_DIR, "アカウント", platform, f"{name}.json"), encoding="utf-8"
+        ) as f:
+            account = json.load(f)
+    except (OSError, ValueError):
+        return None
+    account_id = str(account.get("accountId") or "").strip()
+    return (platform, account_id) if account_id else None
+
+
+def wait_for_plan(since: float, timeout: float) -> str:
+    """プランナーが新しい計画を書き出すまで待ち、そのパスを返す。
+
+    保存先は接続状態で変わる（フォルダ接続済みなら 入稿計画/、未接続ならブラウザの
+    ダウンロード先）ため両方を見る。接続はブラウザを開き直すと切れることがあるので、
+    どちらか一方に決め打ちできない。
+    """
+    expected = active_context()
+    if not expected:
+        sys.exit(
+            "✗ 作業中の案件を特定できません"
+            "（adops.sh planner --platform <媒体> --account <案件名> で開き直してください）"
+        )
+    want_platform, want_account = expected
+    print(
+        f"▸ 入稿ボタンを待っています（{want_platform} / {want_account}"
+        f" / 最大 {int(timeout / 60)} 分）",
+        file=sys.stderr,
+    )
+
+    stable: dict[str, tuple[float, int]] = {}
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        time.sleep(WAIT_INTERVAL_SEC)
+        for path, stat in sorted(
+            {**scan_dir(PLAN_DIR), **scan_dir(DOWNLOADS)}.items(),
+            key=lambda kv: kv[1][0],
+            reverse=True,
+        ):
+            if stat[0] <= since:
+                continue  # 待機を張る前からあったもの
+            # 書き込み途中を掴まないよう、mtime と size が据わってから読む
+            if stable.get(path) != stat:
+                stable[path] = stat
+                continue
+            plan = read_plan(path)
+            if plan is None or ad_count(plan) == 0:
+                continue
+
+            got_platform = str(plan.get("platform") or "yda")
+            got_account = str(plan.get("accountId") or "")
+            if (got_platform, got_account) != (want_platform, want_account):
+                # 「押したのに無反応」を避けるため、待ち続けずここで知らせる
+                print(
+                    json.dumps(
+                        {
+                            "error": "context_mismatch",
+                            "expected": {"platform": want_platform, "accountId": want_account},
+                            "actual": {"platform": got_platform, "accountId": got_account},
+                            "planFile": path,
+                        },
+                        ensure_ascii=False,
+                    )
+                )
+                print(
+                    "\n✗ 作業中の案件と違う計画が書き出されました。"
+                    "プランナーのアカウント選択を確認してください",
+                    file=sys.stderr,
+                )
+                sys.exit(EXIT_CONTEXT_MISMATCH)
+
+            print(
+                "WEBGRAM_PLAN_DETECTED "
+                + json.dumps(
+                    {
+                        "planFile": path,
+                        "platform": got_platform,
+                        "accountId": got_account,
+                        "campaignCount": len(plan["campaigns"]),
+                        "adCount": ad_count(plan),
+                        "location": "入稿計画" if path.startswith(PLAN_DIR) else "downloads",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return path
+
+    print(
+        "\n✗ 時間内に入稿計画が書き出されませんでした。"
+        "プランナーで「完成 → 保存して入稿」を押したか確認してください",
+        file=sys.stderr,
+    )
+    sys.exit(EXIT_TIMEOUT)
 
 
 # ------------------------------------------------------- 共通: 値の取り出し
@@ -138,6 +331,11 @@ ON_STATUSES = ("ACTIVE", "ENABLED", "ENABLE")
 UNVERIFIED_PLATFORMS = ("google", "bytedance")
 
 
+def is_existing_campaign(campaign: dict) -> bool:
+    """既存キャンペーンへの広告追加か（campaignId 指定）。予算・入札は送らない。"""
+    return bool(str(campaign.get("campaignId") or "").strip())
+
+
 def budget_of(campaign: dict) -> int:
     """日予算。キー名がファイル種別で違い、**予算を持つ階層も媒体で違う**。
 
@@ -215,8 +413,10 @@ def summarize(plan: dict) -> None:
         if tcpa:
             bid += f" (tCPA {tcpa:,})"
         budget = budget_of(c)
+        # 既存CPへの広告追加は予算・入札・開始日を送らない（媒体側の設定をそのまま使う）
+        budget_txt = "予算 既存CPのまま" if is_existing_campaign(c) else f"予算 {budget:,}/日"
         print(f"\n  CP[{ci}] {c.get('name')}")
-        print(f"        予算 {budget:,}/日 | {bid} | status {status_of(c) or '-'} "
+        print(f"        {budget_txt} | {bid} | status {status_of(c) or '-'} "
               f"| 開始 {c.get('startDate', '-')}")
         for g in ad_groups(c):
             tg = "/".join(filter(None, [
@@ -256,11 +456,15 @@ def lint(plan: dict, plan_path: str = "") -> None:
     }
     # Google は同名キャンペーンを拒否する（2026-08-23 実測。他媒体は未確認なので google 限定で見る）。
     # dry-run は実 API を叩かないので通ってしまい、本実行の campaign 作成で初めて落ちる。
-    known_cp_names = {
-        str(v.get("name"))
+    # stale = 媒体側から消えたCP。削除済みの名前は再利用できるので同名チェックから外す
+    known_cp_lower = {
+        str(v.get("name")).strip().lower()
         for v in (account.get("refs", {}).get("campaigns") or {}).values()
-        if v.get("name")
+        if v.get("name") and not v.get("stale")
     }
+    # 同じ計画の中での重複を見るための累積。既存との衝突と違い、
+    # refs の鮮度と無関係にローカルで確定する
+    plan_cp_names: set[str] = set()
 
     if not base:
         warn(f"アカウントJSONに baseArticleUrl がありません（{platform}/{plan.get('accountId')}）。"
@@ -270,7 +474,9 @@ def lint(plan: dict, plan_path: str = "") -> None:
     for c in plan.get("campaigns") or []:
         name = c.get("name", "")
         budget = budget_of(c)
-        if not (BUDGET_MIN <= budget <= BUDGET_MAX):
+        # 既存CP（campaignId 指定）は広告追加専用で、予算はプランに載らない。
+        # ここで 0 を見て警告すると「毎回出るので読み飛ばす警告」になる。
+        if not is_existing_campaign(c) and not (BUDGET_MIN <= budget <= BUDGET_MAX):
             warn(f"CP「{name}」の日予算 {budget:,} が想定レンジ外（{BUDGET_MIN:,}〜{BUDGET_MAX:,}）。桁を確認してください")
         # 配信オンを表す値は媒体で違う: yda / meta は ACTIVE、**google は ENABLED**。
         # ACTIVE だけ見ていると Google の配信オンが素通りする。
@@ -288,9 +494,19 @@ def lint(plan: dict, plan_path: str = "") -> None:
         # 同名 CP を拒否するのは **google だけ**（2026-08-23 実測。他媒体は未確認）。
         # YDA は `_2` サフィックスで自動リトライする先例があるので、全媒体で止めると
         # これまで通っていた計画をブロックしてしまう。
-        if platform == "google" and name in known_cp_names:
-            err(f"CP名「{name}」はアカウントの既存キャンペーンと同名です。"
-                " Google は同名キャンペーンを拒否するため、本実行の作成で落ちます")
+        if platform == "google":
+            # 大文字小文字だけ違う名前も同名として扱う（取りこぼすより安全側）
+            if name.strip().lower() in known_cp_lower:
+                err(f"CP名「{name}」はアカウントの既存キャンペーンと同名です。"
+                    " Google は同名キャンペーンを拒否するため、本実行の作成で落ちます")
+            # 既存との衝突とは別に、同じ計画の中での重複も落ちる。
+            # こちらは refs の鮮度と無関係にローカルで確定する
+            key = name.strip().lower()
+            if key and key in plan_cp_names:
+                err(f"CP名「{name}」がこの計画の中で重複しています。"
+                    " まとめて入稿すると2件目以降が落ちます")
+            if key:
+                plan_cp_names.add(key)
 
         for g in ad_groups(c):
             gname = g.get("name", "")
@@ -469,7 +685,25 @@ def diff_against_sample(plan: dict) -> None:
 
 # ---------------------------------------------------------------- main
 def main() -> int:
-    path = pick_plan(sys.argv[1:])
+    parser = argparse.ArgumentParser(add_help=True, description=__doc__)
+    parser.add_argument("plan_file", nargs="?", help="入稿計画JSON（省略時は最新を探す）")
+    parser.add_argument(
+        "--wait",
+        action="store_true",
+        help="プランナーが新しい計画を書き出すまで待ってから処理する",
+    )
+    parser.add_argument(
+        "--timeout", type=float, default=WAIT_TIMEOUT_SEC, help="--wait の上限秒数"
+    )
+    args = parser.parse_args()
+
+    if args.wait:
+        if args.plan_file:
+            sys.exit("✗ --wait とファイル指定は同時に使えません")
+        path = wait_for_plan(since=time.time(), timeout=args.timeout)
+    else:
+        path = pick_plan([args.plan_file] if args.plan_file else [])
+
     plan = json.load(open(path, encoding="utf-8"))
     path = collect(path, plan)
     print(f"📄 {path}")