@iducky/media-agent 1.1.0

package/src/media_agent/platforms/douyin/douyin_publish.py

@@ -0,0 +1,1135 @@
+#!/usr/bin/env python3
+"""
+Douyin Creator Center 发布脚本 — 五阶段发布流水线。
+
+Phases:
+  --dry-run          检查素材 SHA-256 去重，不执行实际操作
+  --prepare <path>   上传素材、配置元数据、定时发布，写账本后保持浏览器
+  --confirm-submit   确认提交（点击发布按钮）
+  --status           查询发布状态
+  --close            关闭浏览器并释放锁
+
+Ledger: tasks/douyin_publish/publish-ledger.jsonl
+State machine: discovered → reserved → uploading → scheduled → submitted → reviewing → published/rejected/indeterminate/failed
+SHA-256 dedup: submitted / scheduled / reviewing / published 永久阻止重复提交。
+"""
+from media_agent.runtime.paths import runtime_home
+
+import argparse
+import hashlib
+import json
+import os
+import signal
+import sys
+import time
+import uuid
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+
+# ─── Paths ───────────────────────────────────────────────────────────────────
+BASE = runtime_home()
+DEFAULT_PROFILE_ID = 'douyin_creator_mengjun_ecommerce'
+LOCKS_DIR = BASE / 'locks'
+LEDGER_DIR = BASE / 'tasks' / 'douyin_publish'
+LEDGER_FILE = LEDGER_DIR / 'publish-ledger.jsonl'
+UPLOAD_URL = 'https://creator.douyin.com/creator-micro/content/upload'
+SIGNAL_DIR = BASE / 'signals'
+
+
+def _profile_dir(profile_id):
+    return BASE / 'profiles' / profile_id
+
+
+def _browser_data(profile_id):
+    return str(_profile_dir(profile_id) / 'browser_data')
+
+
+def _lock_file(profile_id):
+    return LOCKS_DIR / f'{profile_id}.lock'
+
+
+def _confirm_file(profile_id):
+    return SIGNAL_DIR / f'{profile_id}.confirm'
+
+
+def _close_file(profile_id):
+    return SIGNAL_DIR / f'{profile_id}.close'
+
+
+# ─── Constants ───────────────────────────────────────────────────────────────
+DEDUP_STATES = {'submitted', 'scheduled', 'reviewing', 'published'}
+SUPPORTED_VIDEO_FORMATS = {'.mp4', '.mov', '.avi', '.wmv', '.flv', '.mkv', '.webm', '.m4v', '.3gp'}
+SUPPORTED_IMAGE_FORMATS = {'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.gif'}
+SUPPORTED_FORMATS = SUPPORTED_VIDEO_FORMATS | SUPPORTED_IMAGE_FORMATS
+DEFAULT_SCHEDULED_AT = '2026-08-04T23:50:00+08:00'
+TZ_SHANGHAI = timezone(timedelta(hours=8))
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def sha256_file(path):
+    """Compute SHA-256 digest of a file."""
+    h = hashlib.sha256()
+    with open(path, 'rb') as f:
+        while True:
+            chunk = f.read(65536)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def load_ledger():
+    """Load all ledger entries as a list of dicts."""
+    LEDGER_DIR.mkdir(parents=True, exist_ok=True)
+    if not LEDGER_FILE.exists():
+        return []
+    entries = []
+    for line in LEDGER_FILE.read_text().splitlines():
+        line = line.strip()
+        if line:
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                pass
+    return entries
+
+
+def find_ledger_entry(sha256):
+    """Return the most recent ledger entry matching a SHA-256 (or None)."""
+    entries = load_ledger()
+    for entry in reversed(entries):
+        if entry.get('sha256') == sha256:
+            return entry
+    return None
+
+
+def check_duplicate(sha256):
+    """Return (is_blocked, existing_entry) — True if SHA-256 is in a terminal dedup state."""
+    entry = find_ledger_entry(sha256)
+    if entry and entry.get('state') in DEDUP_STATES:
+        return True, entry
+    return False, entry
+
+
+def append_ledger(entry):
+    """Atomically append a JSON line to the ledger."""
+    LEDGER_DIR.mkdir(parents=True, exist_ok=True)
+    with open(LEDGER_FILE, 'a') as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+
+
+def acquire_lock(profile_id, task_id):
+    """Acquire the profile lock. Returns (ok, existing_owner)."""
+    lf = _lock_file(profile_id)
+    LOCKS_DIR.mkdir(parents=True, exist_ok=True)
+    if lf.exists():
+        try:
+            old = json.loads(lf.read_text())
+            os.kill(old.get('pid', 0), 0)
+            return False, old
+        except (OSError, json.JSONDecodeError):
+            lf.unlink()
+    lf.write_text(json.dumps({
+        'task_id': task_id,
+        'pid': os.getpid(),
+        'time': datetime.now().isoformat(),
+        'phase': 'publish',
+    }, indent=2))
+    return True, None
+
+
+def release_lock(profile_id):
+    """Release the profile lock."""
+    lf = _lock_file(profile_id)
+    if lf.exists():
+        lf.unlink(missing_ok=True)
+
+
+def now_iso():
+    """Return current time in Asia/Shanghai ISO format."""
+    return datetime.now(TZ_SHANGHAI).isoformat()
+
+
+def log(msg):
+    """Print a structured log line to stdout."""
+    print(json.dumps({'ts': now_iso(), **msg}, ensure_ascii=False), flush=True)
+
+
+def die(code, msg):
+    """Print error and exit."""
+    log({'level': 'ERROR', 'exit_code': code, **msg})
+    sys.exit(code)
+
+
+def _kwargs(**kw):
+    """Helper to return a dict of kwargs — for readability."""
+    return kw
+
+
+# ─── Browser ─────────────────────────────────────────────────────────────────
+
+def launch_browser(profile_id):
+    """Launch a CloakBrowser persistent context for the profile."""
+    from media_agent.runtime.browser import launch_persistent_context
+
+    pdir = _profile_dir(profile_id)
+    cfg = json.loads((pdir / 'config.json').read_text())
+    fp = cfg.get('fingerprint', {})
+
+    ctx = launch_persistent_context(
+        user_data_dir=_browser_data(profile_id),
+        headless=False,
+        stealth_args=True,
+        viewport=fp.get('viewport', {'width': 1440, 'height': 900}),
+        locale=fp.get('locale', 'zh-CN'),
+        timezone=fp.get('timezone', 'Asia/Shanghai'),
+        humanize=False,
+        geoip=False,
+    )
+    return ctx, cfg
+
+
+# ─── Phase: dry-run ──────────────────────────────────────────────────────────
+
+def phase_dry_run(profile_id, media_path, scheduled_at=None):
+    """Check media file validity and SHA-256 dedup status."""
+    path = Path(media_path).resolve()
+
+    if not path.exists():
+        die(1, _kwargs(phase='dry-run', error='FILE_NOT_FOUND', path=str(path)))
+
+    if not path.is_file():
+        die(1, _kwargs(phase='dry-run', error='NOT_A_FILE', path=str(path)))
+
+    ext = path.suffix.lower()
+    if ext not in SUPPORTED_FORMATS:
+        die(1, _kwargs(
+            phase='dry-run', error='UNSUPPORTED_FORMAT',
+            format=ext, supported=sorted(SUPPORTED_FORMATS),
+        ))
+
+    file_size = path.stat().st_size
+    sha = sha256_file(str(path))
+    blocked, existing = check_duplicate(sha)
+
+    schedule = scheduled_at or DEFAULT_SCHEDULED_AT
+
+    result = _kwargs(
+        phase='dry-run',
+        media_path=str(path),
+        file_size=file_size,
+        file_size_mb=round(file_size / 1024 / 1024, 2),
+        sha256=sha,
+        format=ext,
+        scheduled_at=schedule,
+        duplicate_blocked=blocked,
+        profile_id=profile_id,
+    )
+
+    if blocked:
+        result['existing_state'] = existing.get('state')
+        result['existing_task_id'] = existing.get('task_id')
+        result['existing_timestamp'] = existing.get('timestamp')
+        log(result)
+        sys.exit(8)  # DUPLICATE_BLOCKED
+
+    log(result)
+    return sha, str(path), schedule
+
+
+# ─── Phase: prepare ──────────────────────────────────────────────────────────
+
+def _wait_for_upload_complete(page, timeout=300):
+    """Wait for the video upload/processing to complete."""
+    start = time.time()
+    while time.time() - start < timeout:
+        # Check multiple indicators
+        status = page.evaluate('''() => {
+            const body = document.body.textContent || '';
+            // Check if upload area is still showing
+            const uploadArea = document.querySelector('input[type="file"]');
+            const uploadVisible = uploadArea && uploadArea.offsetParent !== null;
+            // Check for processing indicators
+            const processing = body.includes('上传中') || body.includes('处理中') || body.includes('转码中');
+            // Check for edit form (title/description)
+            const hasTitle = document.querySelector('input[placeholder*="标题"]') || 
+                           document.querySelector('textarea[placeholder*="简介"]') ||
+                           document.querySelector('[class*="title"] input');
+            // Check for cover/settings area
+            const hasCover = body.includes('封面') || body.includes('选择封面');
+            if (hasTitle && hasCover && !uploadVisible) {
+                return 'done';
+            }
+            if (processing) {
+                return 'processing';
+            }
+            return 'waiting';
+        }''')
+        if status == 'done':
+            return True
+        if status == 'processing':
+            log(_kwargs(step='upload_progress', status='processing', elapsed=round(time.time() - start)))
+        time.sleep(3)
+    return False
+
+
+def _dismiss_location_permission(page):
+    """Dismiss the location permission popup by choosing '一律不允许'."""
+    time.sleep(2)
+    dismissed = page.evaluate('''() => {
+        const keywords = ['一律不允许', '不允许', '禁止', '拒绝', "Don't Allow", 'Block', 'Deny'];
+        for (const kw of keywords) {
+            for (const el of document.querySelectorAll('button, span, div, a')) {
+                const text = (el.textContent || '').trim();
+                if (text === kw || text.includes(kw)) {
+                    if (el.offsetParent !== null) {
+                        el.click();
+                        return 'clicked:' + kw;
+                    }
+                }
+            }
+        }
+        return 'not_found';
+    }''')
+    log(_kwargs(step='location_permission', result=dismissed))
+    time.sleep(1)
+
+
+def _set_cover_natural_frame(page):
+    """Select a natural frame as cover, avoiding AI-text overlays."""
+    time.sleep(3)
+    result = page.evaluate('''() => {
+        const coverAreas = document.querySelectorAll('[class*="cover"], [class*="poster"], [class*="thumbnail"]');
+        const info = [];
+        for (const el of coverAreas) {
+            if (el.offsetParent === null) continue;
+            const rect = el.getBoundingClientRect();
+            info.push({
+                tag: el.tagName,
+                class: (el.className || '').substring(0, 40),
+                text: (el.textContent || '').trim().substring(0, 30),
+                bounds: {x: Math.round(rect.x), y: Math.round(rect.y),
+                         w: Math.round(rect.width), h: Math.round(rect.height)},
+            });
+        }
+        return {found: info.length, covers: info.slice(0, 5)};
+    }''')
+    log(_kwargs(step='cover_inspection', **result))
+
+    picked = page.evaluate('''() => {
+        for (const el of document.querySelectorAll('div, span, button')) {
+            const text = (el.textContent || '').trim();
+            if ((text.includes('选择封面') || text.includes('推荐封面') || text.includes('默认封面')) &&
+                el.offsetParent !== null) {
+                el.click();
+                return 'clicked:' + text.substring(0, 20);
+            }
+        }
+        return 'no_cover_ui';
+    }''')
+    log(_kwargs(step='cover_selection', result=picked))
+    time.sleep(2)
+
+
+def _configure_default_settings(page):
+    """Set default publish settings: public, allow save, no collection, no location, no hotspot, no event, no music."""
+    settings_log = []
+
+    # Ensure visibility is public
+    r = page.evaluate('''() => {
+        const results = [];
+        for (const el of document.querySelectorAll('div, span, label')) {
+            const text = (el.textContent || '').trim();
+            if ((text === '公开' || text === '私密' || text === '好友可见') && el.offsetParent !== null) {
+                results.push({text: text, tag: el.tagName});
+            }
+        }
+        return results;
+    }''')
+    settings_log.append({'visibility_options': r})
+
+    # Uncheck: 原创声明, 营销声明, 广告声明
+    r = page.evaluate('''() => {
+        const unchecked = [];
+        const declKeywords = ['原创', '营销', '广告', '声明', '品牌'];
+        const checkboxes = document.querySelectorAll('input[type="checkbox"]');
+        for (const cb of checkboxes) {
+            const label = cb.closest('label') || cb.parentElement;
+            const text = (label?.textContent || '').trim();
+            for (const kw of declKeywords) {
+                if (text.includes(kw) && cb.checked && cb.offsetParent !== null) {
+                    cb.click();
+                    unchecked.push(kw);
+                    break;
+                }
+            }
+        }
+        return unchecked;
+    }''')
+    settings_log.append({'declarations_unchecked': r})
+
+    # Disable: 加入合集, 添加位置, 关联热点, 参加活动, 添加音乐
+    r = page.evaluate('''() => {
+        const actions = [];
+        const disableKeywords = ['加入合集', '添加位置', '关联热点', '参加活动', '添加音乐', '位置', '合集', '活动', '音乐', '热点'];
+        for (const kw of disableKeywords) {
+            for (const el of document.querySelectorAll('div, span, button')) {
+                const text = (el.textContent || '').trim();
+                if (text === kw && el.offsetParent !== null) {
+                    const parent = el.closest('div, label, section') || el.parentElement;
+                    if (parent) {
+                        const cb = parent.querySelector('input[type="checkbox"]');
+                        if (cb && cb.checked) {
+                            cb.click();
+                            actions.push('unchecked:' + kw);
+                        } else {
+                            actions.push('found:' + kw + '(already_off)');
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        return actions;
+    }''')
+    settings_log.append({'extras_disabled': r})
+
+    log(_kwargs(step='configure_settings', settings=settings_log))
+
+
+def _fill_title_description(page, title, description):
+    """Fill in the video title and description."""
+    if not title and not description:
+        return
+    if title:
+        r = page.evaluate(f'''(t) => {{
+            const selectors = ['input[placeholder*="标题"]', 'input[placeholder*="title"]',
+                'textarea[placeholder*="标题"]', '[class*="title"] input', '[class*="title"] textarea'];
+            for (const sel of selectors) {{
+                for (const inp of document.querySelectorAll(sel)) {{
+                    if (inp.offsetParent !== null) {{
+                        const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set ||
+                                     Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
+                        setter.call(inp, t);
+                        inp.dispatchEvent(new Event('input', {{ bubbles: true }}));
+                        inp.dispatchEvent(new Event('change', {{ bubbles: true }}));
+                        return 'title_set';
+                    }}
+                }}
+            }}
+            return 'no_title_input';
+        }}''', title)
+        log(_kwargs(step='fill_title', result=r))
+    if description:
+        r = page.evaluate(f'''(d) => {{
+            // Try standard textarea first
+            for (const ta of document.querySelectorAll('textarea')) {{
+                if (ta.offsetParent !== null) {{
+                    const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
+                    setter.call(ta, d);
+                    ta.dispatchEvent(new Event('input', {{ bubbles: true }}));
+                    ta.dispatchEvent(new Event('change', {{ bubbles: true }}));
+                    return ta.placeholder || 'textarea_set';
+                }}
+            }}
+            // Try contenteditable div (editor-kit-container)
+            for (const el of document.querySelectorAll('[class*="editor-kit"], [class*="zone-container"], [contenteditable="true"]')) {{
+                if (el.offsetParent !== null) {{
+                    el.textContent = d;
+                    el.dispatchEvent(new Event('input', {{ bubbles: true }}));
+                    el.dispatchEvent(new Event('change', {{ bubbles: true }}));
+                    return 'editor_set';
+                }}
+            }}
+            return 'no_desc_input';
+        }}''', description)
+        log(_kwargs(step='fill_desc', result=r))
+
+
+def _set_scheduled_publish(page, scheduled_at):
+    """Select scheduled publish and set the datetime by typing directly."""
+    dt_obj = datetime.fromisoformat(scheduled_at)
+    datetime_str = dt_obj.strftime('%Y-%m-%d %H:%M')
+    
+    # 1. Scroll to bottom to reveal publish settings
+    page.evaluate('window.scrollTo(0, document.documentElement.scrollHeight)')
+    time.sleep(1)
+    
+    # 2. Click "定时发布"
+    r = page.evaluate('''() => {
+        for (const el of document.querySelectorAll('div, span, label, button')) {
+            const text = (el.textContent || '').trim();
+            if (text === '定时发布' && el.offsetParent !== null) {
+                el.click();
+                return 'clicked';
+            }
+        }
+        return 'not_found';
+    }''')
+    log(_kwargs(step='scheduled_publish_option', click_result=r))
+    time.sleep(2)
+    
+    # 3. After clicking "定时发布", find the datetime input field next to it
+    # The Semi Design DateTimePicker renders as an input-like element
+    datetime_str = dt_obj.strftime('%Y-%m-%d %H:%M')
+    result = page.evaluate(f'''(datetimeVal) => {{
+        // Dump all inputs and text near "定时发布"
+        const dump = [];
+        for (const el of document.querySelectorAll('input, textarea, [contenteditable="true"]')) {{
+            if (el.offsetParent) {{
+                dump.push({{tag: el.tagName, type: el.type, value: el.value, placeholder: el.placeholder, className: (el.className||'').substring(0,40)}});
+            }}
+        }}
+        return {{all_inputs: dump, count: dump.length}};
+    }}''', datetime_str)
+    log(_kwargs(step='datetime_inputs', **result))
+    
+    # 4. Try to find and set the datetime via the input that appears next to "定时发布"
+    set_result = page.evaluate(f'''(datetimeVal) => {{
+        // Strategy: find the last visible input element that's near the bottom of the page
+        // This should be the datetime picker's input field
+        const allInputs = [...document.querySelectorAll('input')].filter(el => el.offsetParent);
+        // Try inputs near the bottom (y > 800)
+        for (const inp of allInputs) {{
+            const rect = inp.getBoundingClientRect();
+            if (rect.y > 600 && inp.type === 'text') {{
+                inp.focus();
+                inp.value = '';
+                inp.value = datetimeVal;
+                inp.dispatchEvent(new Event('input', {{bubbles: true}}));
+                inp.dispatchEvent(new Event('change', {{bubbles: true}}));
+                inp.dispatchEvent(new Event('blur', {{bubbles: true}}));
+                return {{set: true, tag: inp.tagName, rect: rect, value: inp.value}};
+            }}
+        }}
+        // Fallback: try all text inputs
+        for (const inp of allInputs) {{
+            if (inp.type === 'text' && inp.placeholder !== '填写作品标题') {{
+                inp.focus();
+                inp.value = '';
+                inp.value = datetimeVal;
+                inp.dispatchEvent(new Event('input', {{bubbles: true}}));
+                inp.dispatchEvent(new Event('change', {{bubbles: true}}));
+                inp.dispatchEvent(new Event('blur', {{bubbles: true}}));
+                return {{set: true, tag: inp.tagName, fallback: true, value: inp.value}};
+            }}
+        }}
+        return {{set: false, reason: 'no_suitable_input'}};
+    }}''', datetime_str)
+    log(_kwargs(step='datetime_set', **set_result))
+    
+    time.sleep(1)
+    
+    # 5. Read back
+    readback = page.evaluate('''() => {
+        const re = /\\d{4}-\\d{2}-\\d{2}\\s+\\d{2}:\\d{2}/;
+        for (const el of document.querySelectorAll('span, div, input')) {
+            const text = (el.textContent || el.value || '').trim();
+            if (re.test(text) && el.offsetParent) {
+                return {value: text, tag: el.tagName};
+            }
+        }
+        return null;
+    }''')
+    log(_kwargs(step='datetime_readback', value=readback))
+
+    # Read back the trigger box value
+    readback_dt = page.evaluate('''() => {
+        const re = /\\d{4}-\\d{2}-\\d{2}\\s+\\d{2}:\\d{2}/;
+        for (const el of document.querySelectorAll('div, span, input')) {
+            const text = (el.textContent || '').trim();
+            if (re.test(text) && el.offsetParent) {
+                return text;
+            }
+        }
+        return null;
+    }''')
+    log(_kwargs(step='datetime_readback', value=readback_dt))
+    time.sleep(1)
+
+
+def _readback_title_and_time(page):
+    """Read back the video title and scheduled time from the page."""
+    info = page.evaluate('''() => {
+        const result = {};
+
+        const titleInputs = document.querySelectorAll('input[placeholder*="标题"], input[placeholder*="title"], textarea[placeholder*="标题"], input[class*="title"]');
+        for (const inp of titleInputs) {
+            if (inp.offsetParent !== null) {
+                result.title = inp.value || inp.placeholder || '';
+                result.title_tag = inp.tagName;
+                break;
+            }
+        }
+
+        const timeElements = document.querySelectorAll('div, span');
+        for (const el of timeElements) {
+            const text = (el.textContent || '').trim();
+            if (text.includes('定时') && text.includes(':') && el.offsetParent !== null) {
+                result.scheduled_display = text.substring(0, 60);
+                break;
+            }
+        }
+
+        for (const el of document.querySelectorAll('button, div, span')) {
+            const text = (el.textContent || '').trim();
+            if ((text === '发布' || text.includes('发布')) && el.offsetParent !== null) {
+                result.publish_button = text.substring(0, 20);
+                result.publish_button_visible = true;
+                break;
+            }
+        }
+
+        return result;
+    }''')
+    log(_kwargs(step='readback', **info))
+    return info
+
+
+def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=None):
+    """Upload media, configure settings, schedule publish, write ledger, keep browser alive."""
+    schedule = scheduled_at or DEFAULT_SCHEDULED_AT
+    path = Path(media_path).resolve()
+    sha = sha256_file(str(path))
+
+    blocked, existing = check_duplicate(sha)
+    if blocked:
+        die(8, _kwargs(
+            phase='prepare', error='DUPLICATE_BLOCKED', sha256=sha,
+            existing_state=existing.get('state'),
+            existing_task_id=existing.get('task_id'),
+        ))
+
+    task_id = f'publish_{profile_id}_{datetime.now().strftime("%Y%m%d_%H%M%S")}'
+
+    ok, owner = acquire_lock(profile_id, task_id)
+    if not ok:
+        die(3, _kwargs(phase='prepare', error='PROFILE_LOCKED', owner=owner))
+
+    log(_kwargs(phase='prepare', step='launch_browser', task_id=task_id))
+
+    try:
+        ctx, cfg = launch_browser(profile_id)
+        page = ctx.pages[0] if ctx.pages else ctx.new_page()
+    except Exception as e:
+        release_lock(profile_id)
+        die(1, _kwargs(phase='prepare', error='BROWSER_LAUNCH_FAILED', detail=str(e)[:200]))
+
+    try:
+        # ── Navigate to upload page ──
+        log(_kwargs(step='navigate', url=UPLOAD_URL))
+        page.goto(UPLOAD_URL, wait_until='load', timeout=60000)
+        time.sleep(5)
+
+        current_url = page.url
+        if 'login' in current_url.lower() or 'passport' in current_url.lower():
+            ctx.close()
+            release_lock(profile_id)
+            die(2, _kwargs(phase='prepare', error='LOGIN_REQUIRED', current_url=current_url[:120]))
+
+        log(_kwargs(step='landed', url=current_url[:120], title=page.title()))
+
+        # ── Upload file ──
+        log(_kwargs(step='upload', path=str(path)))
+        try:
+            file_input = page.locator('input[type="file"]').first
+            file_input.set_input_files(str(path))
+            log(_kwargs(step='file_set', result='ok'))
+        except Exception as e:
+            log(_kwargs(step='file_set', result='locator_failed', error=str(e)[:100]))
+            # Make inputs visible and retry
+            page.evaluate('''() => {
+                const inputs = document.querySelectorAll('input[type="file"]');
+                for (const inp of inputs) {
+                    inp.style.display = 'block';
+                    inp.style.visibility = 'visible';
+                    inp.style.position = 'static';
+                }
+                return inputs.length;
+            }''')
+            try:
+                file_input = page.locator('input[type="file"]').first
+                file_input.set_input_files(str(path))
+            except Exception as e2:
+                ctx.close()
+                release_lock(profile_id)
+                die(1, _kwargs(phase='prepare', error='UPLOAD_FAILED', detail=str(e2)[:200]))
+
+        time.sleep(3)
+
+        # ── Wait for upload complete ──
+        if not _wait_for_upload_complete(page):
+            log(_kwargs(step='upload_wait', warning='timeout — proceeding anyway'))
+
+        # ── Fill title and description ──
+        _fill_title_description(page, title, description)
+
+        # ── Dismiss location permission ──
+        _dismiss_location_permission(page)
+
+        # ── Set cover ──
+        _set_cover_natural_frame(page)
+
+        # ── Configure default settings ──
+        _configure_default_settings(page)
+
+        # ── Set scheduled publish ──
+        if scheduled_at:
+            _set_scheduled_publish(page, schedule)
+
+        # ── Readback ──
+        readback = _readback_title_and_time(page)
+
+        # ── Write ledger entry ──
+        ledger_entry = _kwargs(
+            task_id=task_id,
+            sha256=sha,
+            path=str(path),
+            state='prepared',
+            timestamp=now_iso(),
+            scheduled_at=schedule,
+            profile_id=profile_id,
+            file_size=path.stat().st_size,
+            readback=readback,
+            pid=os.getpid(),
+        )
+        append_ledger(ledger_entry)
+        log(_kwargs(phase='prepare', step='ledger_written', state='prepared', task_id=task_id))
+
+        # ── Wait for confirm or close signal ──
+        SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
+        cf = _confirm_file(profile_id)
+        clf = _close_file(profile_id)
+        for f in [cf, clf]:
+            if f.exists():
+                f.unlink(missing_ok=True)
+
+        log(_kwargs(
+            phase='prepare', step='awaiting_confirm', task_id=task_id,
+            hint='Run publish-confirm to submit, or publish-close to abort',
+        ))
+
+        while True:
+            if cf.exists():
+                cf.unlink(missing_ok=True)
+                log(_kwargs(phase='prepare', step='confirm_received'))
+
+                clicked = page.evaluate('''() => {
+                    for (const el of document.querySelectorAll('button')) {
+                        const text = (el.textContent || '').trim();
+                        if (text === '发布' && el.offsetParent !== null) {
+                            // Dispatch full mouse event sequence for React button
+                            el.dispatchEvent(new MouseEvent('mousedown', {bubbles: true, cancelable: true}));
+                            el.dispatchEvent(new MouseEvent('mouseup', {bubbles: true, cancelable: true}));
+                            el.dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true}));
+                            return 'clicked:button:' + text;
+                        }
+                    }
+                    for (const el of document.querySelectorAll('div, span')) {
+                        const text = (el.textContent || '').trim();
+                        if (text === '发布' && el.offsetParent !== null) {
+                            el.dispatchEvent(new MouseEvent('mousedown', {bubbles: true, cancelable: true}));
+                            el.dispatchEvent(new MouseEvent('mouseup', {bubbles: true, cancelable: true}));
+                            el.dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true}));
+                            return 'clicked:' + el.tagName + ':' + text;
+                        }
+                    }
+                    return 'not_found';
+                }''')
+                log(_kwargs(step='publish_click', result=clicked))
+                time.sleep(5)
+
+                # Wait for platform auto-navigation (up to 3 minutes)
+                # Don't manually navigate - wait for platform to redirect
+                url_after = page.url
+                log(_kwargs(step='post_click_wait', url=url_after[:120], title=page.title()))
+                
+                # Wait for auto-navigation or platform response
+                max_wait = 180  # 3 minutes
+                start_wait = time.time()
+                navigated = False
+                while time.time() - start_wait < max_wait:
+                    current_url = page.url
+                    if 'content/manage' in current_url:
+                        navigated = True
+                        log(_kwargs(step='auto_navigated', url=current_url[:120], elapsed=time.time()-start_wait))
+                        break
+                    # Check for error messages or submit confirmation
+                    page_text = page.evaluate('() => document.body.innerText.substring(0,500)')
+                    if '发布成功' in page_text or '提交成功' in page_text or '审核中' in page_text:
+                        log(_kwargs(step='platform_success_hint', text=page_text[:200]))
+                    if '失败' in page_text or '错误' in page_text or 'error' in page_text.lower():
+                        log(_kwargs(step='platform_error_hint', text=page_text[:200]))
+                    time.sleep(5)
+                
+                if not navigated:
+                    # Still not navigated - check if page shows any result
+                    url_after = page.url
+                    page_text = page.evaluate('() => document.body.innerText.substring(0,1000)')
+                    log(_kwargs(step='no_navigation', url=url_after[:120], page_text=page_text[:300]))
+                    # Write indeterminate - keep browser for manual inspection
+                    ledger_entry['state'] = 'indeterminate'
+                    ledger_entry['indeterminate_at'] = now_iso()
+                    ledger_entry['indeterminate_reason'] = 'no_auto_navigation_after_click'
+                    ledger_entry['post_click_url'] = url_after[:200]
+                    append_ledger(ledger_entry)
+                    log(_kwargs(phase='prepare', step='indeterminate', task_id=task_id))
+                    # Keep browser open - don't break/close
+                    continue  # Stay in loop waiting for close signal
+                
+                # Navigated to content management - always wait and refresh
+                time.sleep(10)
+                log(_kwargs(step='manage_landed', url=page.url[:120]))
+                
+                # Always refresh once after waiting
+                page.reload(timeout=15000)
+                time.sleep(5)
+                log(_kwargs(step='post_refresh', url=page.url[:120]))
+                
+                # Search for target title
+                title_to_find = title
+                found = page.evaluate(f'''(targetTitle) => {{
+                    for (const el of document.querySelectorAll('div, span, a')) {{
+                        const text = (el.textContent || '').trim();
+                        if (text.includes(targetTitle)) {{
+                            return {{found: true, element: text.substring(0, 80)}};
+                        }}
+                    }}
+                    return {{found: false}};
+                }}''', title_to_find)
+                log(_kwargs(step='verify_work', **found))
+                
+                if found.get('found'):
+                    ledger_entry['state'] = 'submitted'
+                    ledger_entry['submitted_at'] = now_iso()
+                    append_ledger(ledger_entry)
+                    log(_kwargs(phase='prepare', step='submitted', task_id=task_id))
+                else:
+                    # Poll up to 5 minutes
+                    start_poll = time.time()
+                    poll_found = False
+                    while time.time() - start_poll < 300:
+                        time.sleep(15)
+                        page.reload(timeout=15000)
+                        time.sleep(3)
+                        found = page.evaluate(f'''(targetTitle) => {{
+                            for (const el of document.querySelectorAll('div, span, a')) {{
+                                const text = (el.textContent || '').trim();
+                                if (text.includes(targetTitle)) {{
+                                    return {{found: true, element: text.substring(0, 80)}};
+                                }}
+                            }}
+                            return {{found: false}};
+                        }}''', title_to_find)
+                        log(_kwargs(step='poll_check', **found, elapsed=time.time()-start_poll))
+                        if found.get('found'):
+                            poll_found = True
+                            break
+                    
+                    if poll_found:
+                        ledger_entry['state'] = 'submitted'
+                        ledger_entry['submitted_at'] = now_iso()
+                        append_ledger(ledger_entry)
+                        log(_kwargs(phase='prepare', step='submitted_after_poll', task_id=task_id))
+                    else:
+                        ledger_entry['state'] = 'failed'
+                        ledger_entry['failed_at'] = now_iso()
+                        ledger_entry['failed_reason'] = 'work_not_found_in_manage'
+                        append_ledger(ledger_entry)
+                        log(_kwargs(phase='prepare', step='submit_failed', task_id=task_id, reason='work_not_found'))
+                break
+
+            if clf.exists():
+                clf.unlink(missing_ok=True)
+                log(_kwargs(phase='prepare', step='close_received', task_id=task_id))
+                ledger_entry['state'] = 'indeterminate'
+                ledger_entry['closed_at'] = now_iso()
+                append_ledger(ledger_entry)
+                break
+
+            time.sleep(2)
+
+    except Exception as e:
+        log(_kwargs(phase='prepare', error=str(e)[:300]))
+        try:
+            append_ledger(_kwargs(
+                task_id=task_id, sha256=sha, path=str(path),
+                state='failed', timestamp=now_iso(),
+                error=str(e)[:200], profile_id=profile_id,
+            ))
+        except Exception:
+            pass
+    finally:
+        try:
+            ctx.close()
+        except Exception:
+            pass
+        release_lock(profile_id)
+        log(_kwargs(phase='prepare', step='browser_closed', task_id=task_id))
+
+
+# ─── Phase: confirm-submit ───────────────────────────────────────────────────
+
+def phase_confirm_submit(profile_id):
+    """Send confirm signal to a running prepare process, or launch browser and click submit."""
+    SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
+    lf = _lock_file(profile_id)
+    cf = _confirm_file(profile_id)
+
+    if lf.exists():
+        try:
+            lock_data = json.loads(lf.read_text())
+            pid = lock_data.get('pid')
+            if pid:
+                os.kill(pid, 0)
+                cf.write_text(json.dumps({
+                    'action': 'confirm',
+                    'timestamp': now_iso(),
+                }))
+                log(_kwargs(phase='confirm-submit', step='signal_sent', target_pid=pid))
+                time.sleep(10)
+                if not cf.exists():
+                    log(_kwargs(phase='confirm-submit', step='signal_consumed', status='ok'))
+                else:
+                    log(_kwargs(phase='confirm-submit', step='signal_pending', status='waiting'))
+                return
+        except (OSError, json.JSONDecodeError):
+            log(_kwargs(phase='confirm-submit', step='process_dead', action='launch_new'))
+
+    log(_kwargs(phase='confirm-submit', step='launch_browser'))
+
+    try:
+        ctx, cfg = launch_browser(profile_id)
+        page = ctx.pages[0] if ctx.pages else ctx.new_page()
+    except Exception as e:
+        die(1, _kwargs(phase='confirm-submit', error='BROWSER_LAUNCH_FAILED', detail=str(e)[:200]))
+
+    try:
+        page.goto(UPLOAD_URL, wait_until='load', timeout=60000)
+        time.sleep(5)
+
+        current_url = page.url
+        if 'login' in current_url.lower() or 'passport' in current_url.lower():
+            ctx.close()
+            die(2, _kwargs(phase='confirm-submit', error='LOGIN_REQUIRED', current_url=current_url[:120]))
+
+        time.sleep(3)
+        inspect = page.evaluate('''() => {
+            const buttons = [];
+            for (const el of document.querySelectorAll('button, div[role="button"], span')) {
+                const text = (el.textContent || '').trim();
+                if ((text === '发布' || text.includes('发布') || text === '提交') && el.offsetParent !== null) {
+                    const rect = el.getBoundingClientRect();
+                    buttons.push({
+                        text: text.substring(0, 20),
+                        tag: el.tagName,
+                        bounds: {x: Math.round(rect.x), y: Math.round(rect.y),
+                                 w: Math.round(rect.width), h: Math.round(rect.height)},
+                    });
+                }
+            }
+            return {button_count: buttons.length, buttons: buttons.slice(0, 5)};
+        }''')
+        log(_kwargs(step='inspect', **inspect))
+
+        if inspect.get('button_count', 0) == 0:
+            log(_kwargs(step='no_publish_button', warning='Upload page may not have a prepared video. Run prepare first.'))
+
+        clicked = page.evaluate('''() => {
+            for (const el of document.querySelectorAll('button, div, span')) {
+                const text = (el.textContent || '').trim();
+                if ((text === '发布' || text === '确认发布' || text === '提交') &&
+                    el.offsetParent !== null) {
+                    el.click();
+                    return 'clicked:' + text;
+                }
+            }
+            return 'not_found';
+        }''')
+        log(_kwargs(step='publish_click', result=clicked))
+        time.sleep(5)
+
+        url_after = page.url
+        log(_kwargs(step='post_submit', url=url_after[:120], title=page.title()))
+
+        entries = load_ledger()
+        if entries:
+            latest = entries[-1]
+            latest['state'] = 'submitted'
+            latest['submitted_at'] = now_iso()
+            append_ledger(latest)
+            log(_kwargs(step='ledger_updated', task_id=latest.get('task_id')))
+
+    except Exception as e:
+        log(_kwargs(phase='confirm-submit', error=str(e)[:300]))
+    finally:
+        try:
+            ctx.close()
+        except Exception:
+            pass
+        release_lock(profile_id)
+        log(_kwargs(phase='confirm-submit', step='browser_closed'))
+
+
+# ─── Phase: status ───────────────────────────────────────────────────────────
+
+def phase_status(profile_id, task_id=None):
+    """Query publish status from the ledger."""
+    entries = load_ledger()
+
+    if task_id:
+        matching = [e for e in entries if e.get('task_id') == task_id]
+    else:
+        matching = entries[-10:]
+
+    if not matching:
+        log(_kwargs(phase='status', entries=[], count=0))
+        return
+
+    states = {}
+    for e in matching:
+        s = e.get('state', 'unknown')
+        states[s] = states.get(s, 0) + 1
+
+    result = _kwargs(
+        phase='status',
+        total_entries=len(entries),
+        shown=len(matching),
+        state_summary=states,
+        entries=matching,
+    )
+
+    lf = _lock_file(profile_id)
+    if lf.exists():
+        try:
+            lock_data = json.loads(lf.read_text())
+            pid = lock_data.get('pid')
+            os.kill(pid, 0)
+            result['browser_running'] = True
+            result['browser_pid'] = pid
+        except (OSError, json.JSONDecodeError):
+            result['browser_running'] = False
+
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    sys.exit(0)
+
+
+# ─── Phase: close ────────────────────────────────────────────────────────────
+
+def phase_close(profile_id):
+    """Close the browser and release the lock."""
+    SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
+    lf = _lock_file(profile_id)
+    clf = _close_file(profile_id)
+
+    result = _kwargs(phase='close', action='none')
+
+    if lf.exists():
+        try:
+            lock_data = json.loads(lf.read_text())
+            pid = lock_data.get('pid')
+            if pid:
+                try:
+                    os.kill(pid, 0)
+                    clf.write_text(json.dumps({
+                        'action': 'close',
+                        'timestamp': now_iso(),
+                    }))
+                    result['action'] = 'signal_sent'
+                    result['pid'] = pid
+                    log(result)
+
+                    for _ in range(15):
+                        time.sleep(2)
+                        if not lf.exists():
+                            result['lock_released'] = True
+                            break
+                        try:
+                            os.kill(pid, 0)
+                        except OSError:
+                            result['lock_released'] = True
+                            release_lock(profile_id)
+                            break
+
+                    if not result.get('lock_released'):
+                        try:
+                            os.kill(pid, signal.SIGTERM)
+                            time.sleep(2)
+                        except OSError:
+                            pass
+                        release_lock(profile_id)
+                        result['action'] = 'force_killed'
+                        result['lock_released'] = True
+
+                    log(result)
+                    return
+                except OSError:
+                    pass
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+    release_lock(profile_id)
+    result['action'] = 'lock_released'
+    result['lock_released'] = True
+    log(result)
+
+
+# ─── CLI ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Douyin Creator Center Publish — 五阶段发布流水线',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  python3 douyin_publish.py --dry-run --media-path /path/to/video.mp4
+  python3 douyin_publish.py --prepare --media-path /path/to/video.mp4 --scheduled-at 2026-08-04T23:50:00+08:00
+  python3 douyin_publish.py --confirm-submit
+  python3 douyin_publish.py --status
+  python3 douyin_publish.py --status --task-id publish_xxx
+  python3 douyin_publish.py --close
+        ''',
+    )
+
+    parser.add_argument('--dry-run', action='store_true', help='Check media without executing')
+    parser.add_argument('--prepare', action='store_true', help='Upload and configure media')
+    parser.add_argument('--confirm-submit', action='store_true', help='Confirm final submission')
+    parser.add_argument('--status', action='store_true', help='Query publish status')
+    parser.add_argument('--close', action='store_true', help='Close browser')
+    parser.add_argument('--media-path', help='Path to media file (required for --dry-run, --prepare)')
+    parser.add_argument('--scheduled-at', help=f'Scheduled publish time (default: {DEFAULT_SCHEDULED_AT})')
+    parser.add_argument('--task-id', default=None, help='Task ID for status query')
+    parser.add_argument('--profile-id', default=DEFAULT_PROFILE_ID, help='Profile ID')
+    parser.add_argument('--title', default=None, help='Video title')
+    parser.add_argument('--description', default=None, help='Video description')
+    args = parser.parse_args()
+    profile_id = args.profile_id
+
+    if args.dry_run:
+        if not args.media_path:
+            die(1, _kwargs(error='--media-path required for --dry-run'))
+        phase_dry_run(profile_id, args.media_path, args.scheduled_at)
+
+    elif args.prepare:
+        if not args.media_path:
+            die(1, _kwargs(error='--media-path required for --prepare'))
+        phase_prepare(profile_id, args.media_path, args.scheduled_at, args.title, args.description)
+
+    elif args.confirm_submit:
+        phase_confirm_submit(profile_id)
+
+    elif args.status:
+        phase_status(profile_id, args.task_id)
+
+    elif args.close:
+        phase_close(profile_id)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()