@iducky/media-agent 1.1.0 → 1.1.1

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_publish.py

@@ -62,7 +62,7 @@ def _close_file(profile_id):
 
 
 # ─── Constants ───────────────────────────────────────────────────────────────
-DEDUP_STATES = {'submitted', 'reviewing', 'published'}
+DEDUP_STATES = {'submitted', 'reviewing', 'published', 'indeterminate', 'confirming'}
 SUPPORTED_VIDEO_FORMATS = {'.mp4', '.mov', '.avi', '.wmv', '.flv', '.mkv', '.webm', '.m4v', '.3gp'}
 TZ_SHANGHAI = timezone(timedelta(hours=8))
 NOTE_POLL_INTERVAL = 18  # 交接文档要求 15–20 秒间隔只读检查
@@ -86,7 +86,6 @@ def sha256_file(path):
 
 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 = []
@@ -96,7 +95,7 @@ def load_ledger():
             try:
                 entries.append(json.loads(line))
             except json.JSONDecodeError:
-                pass
+                die(1, _kwargs(error='INVALID_LEDGER', path=str(LEDGER_FILE)))
     return entries
 
 
@@ -110,10 +109,11 @@ def find_ledger_entry(sha256):
 
 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
+    matching = [e for e in load_ledger() if e.get('sha256') == sha256]
+    for entry in reversed(matching):
+        if entry.get('state') in DEDUP_STATES:
+            return True, entry
+    return False, matching[-1] if matching else None
 
 
 def append_ledger(entry):
@@ -123,31 +123,24 @@ def append_ledger(entry):
         f.write(json.dumps(entry, ensure_ascii=False) + '\n')
 
 
+_owned_locks = {}
+
+
 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
+    from media_agent.runtime.locking import acquire
+    def initialize():
+        for signal_file in (_confirm_file(profile_id), _close_file(profile_id)):
+            signal_file.unlink(missing_ok=True)
+    ok = acquire(_lock_file(profile_id), task_id, initialize=initialize, phase='publish')
+    if ok:
+        _owned_locks[profile_id] = task_id
+    return ok, None
 
 
 def release_lock(profile_id):
-    """Release the profile lock."""
-    lf = _lock_file(profile_id)
-    if lf.exists():
-        lf.unlink(missing_ok=True)
+    from media_agent.runtime.locking import release
+    task_id = _owned_locks.get(profile_id)
+    return release(_lock_file(profile_id), task_id) if task_id else False
 
 
 def now_iso():
@@ -429,6 +422,7 @@ def phase_prepare(profile_id, media_path, title):
     if not ok:
         die(3, _kwargs(phase='prepare', error='PROFILE_LOCKED', owner=owner))
 
+    confirmation_used = False
     log(_kwargs(phase='prepare', step='launch_browser', task_id=task_id))
 
     try:
@@ -518,9 +512,6 @@ def phase_prepare(profile_id, media_path, title):
         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,
@@ -529,29 +520,35 @@ def phase_prepare(profile_id, media_path, title):
 
         while True:
             if cf.exists():
-                cf.unlink(missing_ok=True)
+                from media_agent.runtime.publish_control import consume_confirmation
+                valid = consume_confirmation(cf, profile_id, task_id, sha)
+                if not valid or confirmation_used:
+                    log(_kwargs(step='confirmation_rejected', task_id=task_id))
+                    continue
+                confirmation_used = True
+                ledger_entry['state'] = 'confirming'
+                append_ledger(ledger_entry)
                 log(_kwargs(phase='prepare', step='confirm_received'))
 
                 # 门禁：按钮必须唯一、可见且启用，否则不点击继续等待
                 if not _inspect_publish_button(page):
                     log(_kwargs(step='publish_button_not_ready', warning='waiting, no click performed'))
+                    confirmation_used = False
+                    ledger_entry['state'] = 'prepared'
+                    append_ledger(ledger_entry)
                     continue
 
                 # 单次真实点击"发布"
-                clicked = page.evaluate('''() => {
-                    for (const el of document.querySelectorAll('button, [role="button"], 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';
-                }''')
+                from media_agent.runtime.publish_control import click_publish_once
+                clicked = click_publish_once(page)
+                if not clicked:
+                    confirmation_used = False
+                    ledger_entry['state'] = 'prepared'
+                    append_ledger(ledger_entry)
+                    log(_kwargs(step='publish_button_not_ready', task_id=task_id))
+                    continue
                 ledger_entry['click_count'] = 1
-                log(_kwargs(step='publish_click', result=clicked, click_count=1))
+                log(_kwargs(step='publish_click', result='clicked', click_count=1))
                 time.sleep(5)
 
                 # ── 等待发布成功页（最长 180 秒）──
@@ -653,9 +650,11 @@ def phase_prepare(profile_id, media_path, title):
                 break
 
             if clf.exists():
-                clf.unlink(missing_ok=True)
+                from media_agent.runtime.publish_control import consume_close
+                if not consume_close(clf, task_id):
+                    continue
                 log(_kwargs(phase='prepare', step='close_received', task_id=task_id))
-                ledger_entry['state'] = 'indeterminate'
+                ledger_entry['state'] = 'indeterminate' if confirmation_used else 'aborted'
                 ledger_entry['closed_at'] = now_iso()
                 append_ledger(ledger_entry)
                 break
@@ -667,7 +666,7 @@ def phase_prepare(profile_id, media_path, title):
         try:
             append_ledger(_kwargs(
                 task_id=task_id, sha256=sha, path=str(path),
-                state='failed', timestamp=now_iso(),
+                state='indeterminate' if confirmation_used else 'failed', timestamp=now_iso(),
                 error=str(e)[:200], profile_id=profile_id,
             ))
         except Exception:
@@ -683,91 +682,22 @@ def phase_prepare(profile_id, media_path, title):
 
 # ─── Phase: confirm-submit ───────────────────────────────────────────────────
 
-def phase_confirm_submit(profile_id):
-    """Send confirm signal to a running prepare process, or launch browser and click submit once."""
-    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'))
-
+def phase_confirm_submit(profile_id, task_id=None):
+    from media_agent.runtime.publish_control import send_confirmation
     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(PUBLISH_URL, wait_until='load', timeout=60000)
-        time.sleep(5)
-
-        current_url = page.url
-        if _is_login_page(current_url):
-            ctx.close()
-            die(2, _kwargs(phase='confirm-submit', error='LOGIN_REQUIRED', current_url=current_url[:120]))
-
-        if not _inspect_publish_button(page):
-            log(_kwargs(step='no_publish_button',
-                        warning='Upload page may not have a prepared video. Run xhs-publish-prepare first.'))
-
-        clicked = page.evaluate('''() => {
-            for (const el of document.querySelectorAll('button, [role="button"], div, span')) {
-                const text = (el.textContent || '').trim();
-                if (text === '发布' && el.offsetParent !== null) {
-                    el.click();
-                    return 'clicked:' + text;
-                }
-            }
-            return 'not_found';
-        }''')
-        log(_kwargs(step='confirm_fallback_click', result=clicked, click_count=1 if clicked != 'not_found' else 0))
-        time.sleep(5)
-        log(_kwargs(step='post_submit', url=page.url[: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'))
+        send_confirmation(_lock_file(profile_id), _confirm_file(profile_id),
+                          load_ledger(), profile_id, task_id)
+    except ValueError as exc:
+        die(1, _kwargs(phase='confirm-submit', error=str(exc)))
+    log(_kwargs(phase='confirm-submit', step='signal_sent', task_id=task_id,
+                status='pending', hint='Query task status; a signal is not a publication result'))
 
 
 # ─── Phase: status ───────────────────────────────────────────────────────────
 
 def phase_status(profile_id, task_id=None):
     """Query publish status from the ledger."""
-    entries = load_ledger()
+    entries = [e for e in load_ledger() if e.get('profile_id') == profile_id]
 
     if task_id:
         matching = [e for e in entries if e.get('task_id') == task_id]
@@ -809,61 +739,12 @@ def phase_status(profile_id, task_id=None):
 # ─── 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)
+    from media_agent.runtime.publish_control import request_close
+    try:
+        request_close(_lock_file(profile_id), _close_file(profile_id))
+    except ValueError as exc:
+        die(1, _kwargs(phase='close', error=str(exc), lock_released=False))
+    log(_kwargs(phase='close', action='signal_sent', lock_released=False))
 
 
 # ─── CLI ─────────────────────────────────────────────────────────────────────
@@ -908,7 +789,7 @@ Examples:
         phase_prepare(profile_id, args.media_path, args.title)
 
     elif args.confirm_submit:
-        phase_confirm_submit(profile_id)
+        phase_confirm_submit(profile_id, args.task_id)
 
     elif args.status:
         phase_status(profile_id, args.task_id)

package/src/media_agent/runtime/account_manager.py

@@ -54,6 +54,7 @@ def save_accounts(accounts: list):
     """保存 accounts.yaml"""
     import yaml
     data = {"accounts": accounts}
+    ACCOUNTS_YAML.parent.mkdir(parents=True, exist_ok=True)
     with open(ACCOUNTS_YAML, "w", encoding="utf-8") as f:
         yaml.dump(data, f, allow_unicode=True, default_flow_style=False, sort_keys=False)
     print(f"✅ 已保存 {len(accounts)} 个账号到 {ACCOUNTS_YAML}")
@@ -153,6 +154,8 @@ def init_profile(alias: str, account: dict):
         },
         "account": {
             "alias": alias,
+            "account_type": account.get("account_type", "personal"),
+            "capabilities": account.get("capabilities", []),
             "platform": account.get("platform", "unknown"),
             "label": account.get("label", alias),
             "login_method": account.get("login_method", "unknown"),
@@ -205,94 +208,13 @@ def lock_path(alias: str) -> Path:
 
 
 def acquire_lock(alias: str, task_id: str) -> bool:
-    """
-    尝试获取 profile 锁。
-    返回 True 成功，False 失败（已被其他任务占用）。
-    """
-    lock_file = lock_path(alias)
-    lock_file.parent.mkdir(parents=True, exist_ok=True)
-
-    # 检查是否存在僵死锁
-    if lock_file.exists():
-        try:
-            data = json.loads(lock_file.read_text())
-            locked_at = data.get("locked_at", "")
-            locked_pid = data.get("pid", 0)
-            locked_task = data.get("task_id", "unknown")
-
-            # 检查进程是否还在运行
-            import subprocess
-            if locked_pid:
-                try:
-                    os.kill(locked_pid, 0)  # 信号 0 只检测进程存在
-                    process_alive = True
-                except (OSError, ProcessLookupError):
-                    process_alive = False
-            else:
-                process_alive = False
-
-            # 检查超时
-            if locked_at:
-                locked_dt = datetime.fromisoformat(locked_at)
-                elapsed = (datetime.now(timezone.utc) - locked_dt).total_seconds()
-                is_stale = elapsed > LOCK_STALE_TIMEOUT
-            else:
-                is_stale = False
-
-            if process_alive and not is_stale:
-                print(f"  ⛔ Profile [{alias}] 已被占用 (task: {locked_task}, pid: {locked_pid})")
-                return False
-            elif is_stale:
-                print(f"  ⚠️  检测到僵死锁 (task: {locked_task}, {elapsed:.0f}s 超时)，正在释放...")
-                release_lock(alias, locked_task)
-            else:
-                # 进程已死但尚未超时
-                print(f"  ⚠️  检测到过期锁 (task: {locked_task}, 进程已结束)，正在释放...")
-                release_lock(alias, locked_task)
-        except (json.JSONDecodeError, Exception) as e:
-            print(f"  ⚠️  锁文件异常 ({e})，覆盖...")
-            lock_file.unlink(missing_ok=True)
-
-    # 创建锁
-    lock_data = {
-        "task_id": task_id,
-        "locked_at": datetime.now(timezone.utc).isoformat(),
-        "pid": os.getpid(),
-        "hostname": os.uname().nodename,
-    }
-    try:
-        lock_file.write_text(json.dumps(lock_data, indent=2))
-        print(f"  🔒 已锁定 profile [{alias}] (task: {task_id})")
-        return True
-    except Exception as e:
-        print(f"  ❌ 锁写入失败: {e}")
-        return False
+    from media_agent.runtime.locking import acquire
+    return acquire(lock_path(alias), task_id)
 
 
 def release_lock(alias: str, task_id: str):
-    """释放 profile 锁"""
-    lock_file = lock_path(alias)
-    if not lock_file.exists():
-        print(f"  🔓 Profile [{alias}] 没有被锁定")
-        return True
-
-    try:
-        data = json.loads(lock_file.read_text())
-        if data.get("task_id") != task_id:
-            print(f"  ⚠️  锁不属于当前任务 ({data.get('task_id')} != {task_id})，跳过")
-            return False
-        lock_file.unlink()
-        print(f"  🔓 已释放 profile [{alias}] (task: {task_id})")
-        return True
-    except Exception as e:
-        print(f"  ❌ 解锁失败: {e}")
-        # 强制删除
-        try:
-            lock_file.unlink(missing_ok=True)
-            print(f"  🔓 强制释放 profile [{alias}]")
-            return True
-        except Exception:
-            return False
+    from media_agent.runtime.locking import release
+    return release(lock_path(alias), task_id)
 
 
 def list_locks() -> list[dict]:
@@ -394,9 +316,13 @@ def human_intervene(alias: str, reason: str, screenshot_path=None):
 # ═══════════════════════════════════════════════════════════════
 # CLI 入口
 # ═══════════════════════════════════════════════════════════════
-def cmd_init(alias: str, platform: str, label: str, login_method: str, notes: str = ""):
+def cmd_init(alias: str, platform: str, label: str, login_method: str, notes: str = "", account_type: str = "personal", capabilities=None):
     """初始化新账号: init_account <alias> --platform <p> --label <l> --login <m>"""
+    from media_agent.runtime.arguments import profile_id
+    profile_id(alias)
     account = {
+        "account_type": account_type,
+        "capabilities": capabilities or [],
         "alias": alias,
         "platform": platform,
         "label": label,
@@ -441,7 +367,7 @@ def cmd_status(alias: str):
 
     if not config:
         print(f"❌ Profile [{alias}] 不存在")
-        return
+        raise SystemExit(5)
 
     acct = find_account(alias) or config.get("account", {})
 
@@ -637,6 +563,8 @@ if __name__ == "__main__":
     p_init.add_argument("--label", required=True, help="中文备注")
     p_init.add_argument("--login", required=True, help="登录方式: phone_qr/phone_code/password/wechat")
     p_init.add_argument("--notes", default="", help="备注")
+    p_init.add_argument("--account-type", choices=["personal", "enterprise"], default="personal")
+    p_init.add_argument("--capability", action="append", default=[], choices=["creator_publish", "creator_index_collect", "leads_export", "leads_rankings", "leads_taxonomy"])
 
     # list
     sub.add_parser("list", help="列出所有账号")
@@ -659,7 +587,7 @@ if __name__ == "__main__":
     args = parser.parse_args()
 
     if args.command == "init":
-        cmd_init(args.alias, args.platform, args.label, args.login, args.notes)
+        cmd_init(args.alias, args.platform, args.label, args.login, args.notes, args.account_type, args.capability)
     elif args.command == "list":
         cmd_list()
     elif args.command == "open":

package/src/media_agent/runtime/arguments.py

@@ -0,0 +1,69 @@
+"""Validate public arguments before the legacy shell dispatcher can discard them."""
+import argparse
+import re
+
+
+def profile_id(value):
+    if not re.fullmatch(r'[A-Za-z0-9_-]+', value):
+        raise argparse.ArgumentTypeError('invalid profile_id')
+    return value
+
+
+def validate(argv):
+    if not argv or argv[0] in ('help', '--help', '-h', 'run-script'):
+        return argv
+    cmd = argv[0]
+    if cmd.startswith('validate-'):
+        return argv  # These validators have their own argparse contracts.
+    p = argparse.ArgumentParser(prog='media-agent ' + cmd, allow_abbrev=False)
+    if cmd in ('list', 'ls', 'locks'):
+        p.parse_args(argv[1:])
+        return argv
+    known = {'init', 'status', 'st', 'close', 'enterprise-login', 'check-login',
+             'collect-douyin-index', 'collect-video-rankings', 'collect-industry-taxonomy', 'export-short-video'}
+    for prefix in ('', 'xhs-', 'toutiao-'):
+        known.update(prefix + 'login-' + x for x in ('start', 'status', 'scan-done', 'refresh-qr', 'close'))
+        known.add(prefix + 'check-login')
+    known.update(('login-submit-code', 'login-resend-code', 'toutiao-login-verify-account'))
+    known.update(prefix + 'publish-' + x for prefix in ('', 'xhs-')
+                 for x in ('dry-run', 'prepare', 'confirm', 'status', 'close'))
+    if cmd not in known:
+        p.error('unknown command')
+    p.add_argument('profile_id', type=profile_id)
+    if cmd == 'init':
+        for opt in ('platform', 'label', 'login'):
+            p.add_argument('--' + opt, required=True)
+        p.add_argument('--notes', default='')
+        p.add_argument('--account-type', choices=['personal', 'enterprise'], default='personal')
+        p.add_argument('--capability', action='append', default=[])
+    if cmd in ('check-login', 'enterprise-login'):
+        p.add_argument('--site', choices=['creator', 'leads', 'all'])
+    if cmd in ('toutiao-login-scan-done', 'toutiao-login-verify-account'):
+        p.add_argument('--expected-account-name', required=cmd.endswith('verify-account'))
+    if cmd.startswith('collect-') or cmd == 'export-short-video':
+        p.add_argument('--dry-run', action='store_true')
+        if cmd in ('export-short-video', 'collect-video-rankings'):
+            p.add_argument('--date')
+        if cmd in ('collect-douyin-index', 'collect-video-rankings'):
+            p.add_argument('--pages', type=int)
+        if cmd == 'collect-douyin-index':
+            p.add_argument('--lists')
+        if cmd == 'collect-video-rankings':
+            p.add_argument('--industry-l1')
+            p.add_argument('--industry-l2')
+    if 'publish-' in cmd:
+        if cmd.endswith(('dry-run', 'prepare')):
+            p.add_argument('--media-path', required=True)
+            if not cmd.startswith('xhs-'):
+                p.add_argument('--scheduled-at')
+            if cmd.endswith('prepare'):
+                p.add_argument('--title', required=cmd.startswith('xhs-'))
+                if not cmd.startswith('xhs-'):
+                    p.add_argument('--description')
+        elif cmd.endswith(('confirm', 'status')):
+            p.add_argument('--task-id', required=cmd.endswith('confirm'))
+    p.parse_args(argv[1:])
+    normalized = []
+    for value in argv:
+        normalized.extend(value.split('=', 1) if value.startswith('--') and '=' in value else [value])
+    return normalized