openmd-cli 0.1.0__py3-none-any.whl

openmd/backends/youtube_transcript.py

@@ -0,0 +1,213 @@
+"""youtube-transcript-api backend provider.
+
+This provider is intentionally opt-in because it performs network requests when
+enabled. The default CLI keeps using skeleton providers unless the operator
+explicitly enables real network backends.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from collections.abc import Callable, Iterable
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from openmd.core.models import ContentItem, TranscriptResult
+from openmd.core.secrets import sanitize_error_summary
+
+from .base import BackendCapability, BackendDescriptor, BackendExtractRequest, BackendHealth
+
+
+YOUTUBE_TRANSCRIPT_BACKEND = "youtube-transcript-api"
+DEFAULT_LANGUAGES: tuple[str, ...] = ("zh-Hans", "zh-CN", "zh", "en")
+
+
+def extract_youtube_video_id(input_value: str) -> str | None:
+    """Extract a YouTube video id from common URL forms or a raw id."""
+    value = input_value.strip()
+    if not value:
+        return None
+    if "://" not in value and "/" not in value and "?" not in value:
+        return value
+
+    parsed = urlparse(value if "://" in value else f"https://{value}")
+    host = parsed.netloc.lower()
+    path_parts = [part for part in parsed.path.split("/") if part]
+
+    if host.endswith("youtu.be") and path_parts:
+        return path_parts[0]
+
+    query_video_id = parse_qs(parsed.query).get("v")
+    if query_video_id and query_video_id[0]:
+        return query_video_id[0]
+
+    if path_parts and path_parts[0] in {"embed", "shorts", "live"} and len(path_parts) >= 2:
+        return path_parts[1]
+
+    return None
+
+
+class YouTubeTranscriptApiProvider:
+    """Fetch YouTube-native transcripts through youtube-transcript-api."""
+
+    name = YOUTUBE_TRANSCRIPT_BACKEND
+
+    def __init__(
+        self,
+        *,
+        languages: tuple[str, ...] = DEFAULT_LANGUAGES,
+        api_factory: Callable[[], Any] | None = None,
+    ) -> None:
+        self.languages = languages
+        self._api_factory = api_factory
+
+    def descriptor(self) -> BackendDescriptor:
+        capability = BackendCapability(
+            platforms=("youtube",),
+            source_types=("video",),
+            input_types=("single",),
+            source_levels=("native_caption", "auto_caption"),
+            requires_network=True,
+            requires_credentials=False,
+            optional_config=("languages",),
+        )
+        return BackendDescriptor(
+            name=self.name,
+            layer="L1 specialized extractor",
+            capabilities=(capability,),
+            description="Fetch existing YouTube manual or generated transcripts.",
+            provider="youtube-transcript-api",
+        )
+
+    def health(self) -> BackendHealth:
+        if self._api_factory is not None:
+            return BackendHealth(ok=True, dependencies={"youtube-transcript-api": "injected"})
+        if importlib.util.find_spec("youtube_transcript_api") is None:
+            return BackendHealth(
+                ok=False,
+                dependencies={"youtube-transcript-api": "missing"},
+                error_code="backend_dependency_missing",
+                error_summary="youtube-transcript-api is not installed.",
+            )
+        return BackendHealth(ok=True, dependencies={"youtube-transcript-api": "available"})
+
+    def extract(self, request: BackendExtractRequest) -> TranscriptResult:
+        item = request.item
+        if item.platform != "youtube":
+            return _failed(
+                item,
+                "unsupported_platform",
+                f"youtube-transcript-api only supports youtube, got {item.platform}.",
+            )
+
+        video_id = item.id or extract_youtube_video_id(item.url)
+        if not video_id:
+            return _failed(item, "invalid_input", "Could not extract a YouTube video id.")
+
+        try:
+            api = self._create_api()
+            fetched_transcript = api.fetch(video_id, languages=list(self.languages))
+        except ImportError as exc:
+            return _failed(item, "backend_dependency_missing", exc, video_id=video_id)
+        except Exception as exc:
+            return _failed(item, _error_code_for_exception(exc), exc, video_id=video_id)
+
+        text = _format_transcript(fetched_transcript)
+        if not text.strip():
+            return _failed(item, "empty_result", "youtube-transcript-api returned no transcript text.", video_id=video_id)
+
+        is_generated = bool(getattr(fetched_transcript, "is_generated", False))
+        language = getattr(fetched_transcript, "language", None)
+        language_code = getattr(fetched_transcript, "language_code", None)
+        source_level = "auto_caption" if is_generated else "native_caption"
+        notes = [
+            "youtube-transcript-api fetched an existing YouTube transcript.",
+            f"language_code: {language_code or 'unknown'}",
+            "caption_type: generated" if is_generated else "caption_type: manual_or_official",
+        ]
+        return TranscriptResult(
+            text=text,
+            status="verified",
+            source_level=source_level,
+            backend=self.name,
+            source_notes=notes,
+            metadata={
+                "video_id": video_id,
+                "language": language,
+                "language_code": language_code,
+                "is_generated": is_generated,
+            },
+        )
+
+    def _create_api(self) -> Any:
+        if self._api_factory is not None:
+            return self._api_factory()
+        try:
+            from youtube_transcript_api import YouTubeTranscriptApi
+        except ImportError as exc:
+            raise ImportError("youtube-transcript-api is not installed.") from exc
+        return YouTubeTranscriptApi()
+
+
+def _format_transcript(fetched_transcript: Iterable[Any]) -> str:
+    lines: list[str] = []
+    for snippet in fetched_transcript:
+        text = str(_snippet_value(snippet, "text", "")).replace("\r", " ").replace("\n", " ").strip()
+        if not text:
+            continue
+        start = _snippet_value(snippet, "start", 0.0)
+        lines.append(f"[{_format_timestamp(start)}] {text}")
+    return "\n".join(lines) + ("\n" if lines else "")
+
+
+def _snippet_value(snippet: Any, key: str, default: Any) -> Any:
+    if isinstance(snippet, dict):
+        return snippet.get(key, default)
+    return getattr(snippet, key, default)
+
+
+def _format_timestamp(start_seconds: Any) -> str:
+    try:
+        total_seconds = max(0, int(float(start_seconds)))
+    except (TypeError, ValueError):
+        total_seconds = 0
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def _error_code_for_exception(exc: Exception) -> str:
+    name = exc.__class__.__name__.lower()
+    if "requestblocked" in name:
+        return "youtube_request_blocked"
+    if "ipblocked" in name:
+        return "youtube_ip_blocked"
+    if "transcriptsdisabled" in name:
+        return "youtube_transcripts_disabled"
+    if "notranscriptfound" in name:
+        return "youtube_transcript_not_found"
+    if "videounavailable" in name:
+        return "youtube_video_unavailable"
+    return "youtube_transcript_api_error"
+
+
+def _failed(
+    item: ContentItem,
+    code: str,
+    error: object,
+    *,
+    video_id: str | None = None,
+) -> TranscriptResult:
+    metadata = {"platform": item.platform}
+    if video_id:
+        metadata["video_id"] = video_id
+    return TranscriptResult(
+        text="",
+        status="failed",
+        source_level="partial_extraction",
+        backend=YOUTUBE_TRANSCRIPT_BACKEND,
+        source_notes=["youtube-transcript-api returned structured failure"],
+        error_code=code,
+        error_summary=sanitize_error_summary(error),
+        metadata=metadata,
+    )

openmd/browser_extension/background.js

@@ -0,0 +1,231 @@
+// Built-in OpenCLI Browser Bridge (Apache-2.0): lets the bundled opencli read pages
+// through this browser, so users install one extension. See vendor/opencli-bridge/VENDOR.md.
+import "./vendor/opencli-bridge/background.js";
+
+// Openmd extension service worker.
+// Daily flow: click the toolbar icon -> save the current page (or every highlighted tab) to the
+// default location. Right-click a selection -> save every link inside it. Jobs run one by one.
+const HOST = "com.openmd.host";
+const POLL_MS = 2000;
+const SETUP_HINT = "还没连上本机 openmd：请在终端运行 openmd browser-setup，然后重新加载插件。";
+
+function native(message) {
+  return new Promise((resolve) => {
+    chrome.runtime.sendNativeMessage(HOST, message, (reply) => {
+      const err = chrome.runtime.lastError;
+      if (err) resolve({ ok: false, error: /not found|forbidden/i.test(err.message) ? SETUP_HINT : err.message });
+      else resolve(reply || { ok: false, error: "本机 openmd 没有回应" });
+    });
+  });
+}
+
+const isWeb = (url) => /^https?:\/\//.test(url || "");
+
+async function getSettings() {
+  const { settings } = await chrome.storage.local.get("settings");
+  return { videoMode: "note", ...(settings || { locations: [], defaultId: null, clickMode: "auto" }) };
+}
+
+async function applyClickMode() {
+  const { clickMode, locations } = await getSettings();
+  // Without a popup, a click fires action.onClicked and saves directly.
+  const direct = clickMode === "auto" && locations.length > 0;
+  await chrome.action.setPopup({ popup: direct ? "" : "popup.html" });
+  await chrome.action.setTitle({ title: direct ? "保存到 Openmd（默认位置）。按住 Ctrl 多选标签页可一次保存多个" : "保存到 Openmd" });
+}
+
+async function seedSettings() {
+  const current = await getSettings();
+  if (current.locations.length) return;
+  const ping = await native({ type: "ping" });
+  if (!ping.ok || !ping.save_to) return;
+  const id = crypto.randomUUID();
+  await chrome.storage.local.set({ settings: { locations: [{ id, name: "默认", path: ping.save_to }], defaultId: id, clickMode: "auto" } });
+}
+
+// ---------------------------------------------------------------- tracking
+
+async function tracked() {
+  const { jobs = {}, batches = {} } = await chrome.storage.local.get(["jobs", "batches"]);
+  return { jobs, batches };
+}
+
+async function showRunning(jobs) {
+  const n = Object.keys(jobs).length;
+  await chrome.action.setBadgeBackgroundColor({ color: "#1d5c49" });
+  await chrome.action.setBadgeText({ text: n > 1 ? String(n) : n ? "…" : "" });
+}
+
+async function flash(text, color) {
+  await chrome.action.setBadgeBackgroundColor({ color });
+  await chrome.action.setBadgeText({ text });
+  setTimeout(async () => showRunning((await tracked()).jobs), 6000);
+}
+
+function notify(title, message) {
+  chrome.notifications.create(`openmd:${Date.now()}`, {
+    type: "basic", iconUrl: "icons/icon-128.png", title, message: String(message || "").slice(0, 300),
+  });
+}
+
+function fail(title, message) {
+  flash("!", "#b3261e");
+  notify(title, message);
+}
+
+async function locationFor(locationId) {
+  const settings = await getSettings();
+  return settings.locations.find((l) => l.id === (locationId || settings.defaultId)) || settings.locations[0];
+}
+
+async function track(jobs, batch, location) {
+  const state = await tracked();
+  for (const job of jobs) state.jobs[job.id] = { title: job.title || job.url, batch };
+  state.batches[batch] = { total: jobs.length, failed: [], location };
+  await chrome.storage.local.set(state);
+  await showRunning(state.jobs);
+  poll();
+}
+
+// ---------------------------------------------------------------- saving
+
+// video: "note" (just mention the video), "text" (+ local transcript), "file" (+ the video file).
+async function saveMany(items, locationId, video) {
+  const web = items.filter((item) => isWeb(item.url));
+  if (!web.length) return fail("没法保存", "只能保存普通网页（http / https）。");
+  const location = await locationFor(locationId);
+  if (!location) {
+    chrome.runtime.openOptionsPage();
+    return fail("先设置一个保存位置", "已打开设置页。");
+  }
+  video = video || (await getSettings()).videoMode || "note";
+  const titles = Object.fromEntries(web.map((item) => [item.url, item.title]));
+  const reply = web.length === 1
+    ? await native({ type: "save", url: web[0].url, save_to: location.path, video })
+    : await native({ type: "save_many", urls: web.map((item) => item.url), save_to: location.path, video });
+  if (!reply.ok) return fail("没能开始保存", reply.error);
+  const jobs = (reply.jobs || [reply.job]).map((job) => ({ ...job, title: titles[job.url] }));
+  await track(jobs, reply.batch || jobs[0].id, location.name);
+  return { ok: true, count: jobs.length, location: location.name };
+}
+
+async function highlightedTabs(tab) {
+  const tabs = await chrome.tabs.query({ highlighted: true, windowId: tab.windowId });
+  // Clicking the icon on a tab outside the highlighted set saves just that tab.
+  return tabs.length > 1 && tabs.some((t) => t.id === tab.id) ? tabs : [tab];
+}
+
+async function linksInSelection(tabId) {
+  const [{ result } = {}] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: () => {
+      const selection = window.getSelection();
+      const found = [];
+      for (let i = 0; i < selection.rangeCount; i += 1) {
+        const range = selection.getRangeAt(i);
+        const root = range.commonAncestorContainer.nodeType === 1 ? range.commonAncestorContainer : range.commonAncestorContainer.parentElement;
+        const anchors = root.closest("a[href]") ? [root.closest("a[href]")] : [...root.querySelectorAll("a[href]")];
+        for (const a of anchors) if (range.intersectsNode(a)) found.push({ url: a.href, title: (a.innerText || a.title || a.href).trim().slice(0, 120) });
+      }
+      return found;
+    },
+  });
+  const seen = new Set();
+  return (result || []).filter((item) => /^https?:\/\//.test(item.url) && !seen.has(item.url) && seen.add(item.url));
+}
+
+// ---------------------------------------------------------------- polling
+
+let polling = false;
+async function poll() {
+  if (polling) return;
+  polling = true;
+  try {
+    for (;;) {
+      const state = await tracked();
+      const ids = Object.keys(state.jobs);
+      if (!ids.length) break;
+      const reply = await native({ type: "statuses", ids });
+      if (reply.ok) {
+        for (const id of ids) {
+          const job = reply.jobs[id] || { state: "unknown" };
+          if (!["done", "failed", "cancelled", "unknown"].includes(job.state)) continue;
+          const meta = state.jobs[id];
+          delete state.jobs[id];
+          const batch = state.batches[meta.batch];
+          if (batch && job.state !== "done" && job.state !== "cancelled") batch.failed.push(`${meta.title}：${job.error || "状态未知"}`);
+          const remaining = Object.values(state.jobs).some((m) => m.batch === meta.batch);
+          if (batch && !remaining) {
+            delete state.batches[meta.batch];
+            if (batch.failed.length) {
+              const head = batch.total > 1 ? `${batch.total} 个里有 ${batch.failed.length} 个没保存成功` : "没能保存";
+              fail(head, batch.failed.slice(0, 3).join("\n"));
+            } else {
+              await flash("✓", "#2c8a5f");
+            }
+          }
+        }
+        await chrome.storage.local.set(state);
+        await showRunning(state.jobs);
+      }
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+  } finally {
+    polling = false;
+  }
+}
+
+// ---------------------------------------------------------------- entry points
+
+chrome.action.onClicked.addListener(async (tab) => {
+  const tabs = await highlightedTabs(tab);
+  saveMany(tabs.map((t) => ({ url: t.url, title: t.title })));
+});
+
+chrome.runtime.onInstalled.addListener(async () => {
+  chrome.contextMenus.removeAll(() => {
+    chrome.contextMenus.create({ id: "save-page", title: "用 Openmd 保存此页", contexts: ["page"] });
+    chrome.contextMenus.create({ id: "save-link", title: "用 Openmd 保存此链接", contexts: ["link"] });
+    chrome.contextMenus.create({ id: "save-selection", title: "用 Openmd 保存选中的链接", contexts: ["selection"] });
+    // Posts with an attached video (X for now): opt in per save, so a plain click stays fast.
+    const posts = ["*://x.com/*", "*://*.x.com/*", "*://twitter.com/*", "*://*.twitter.com/*"];
+    chrome.contextMenus.create({ id: "save-video-text", title: "用 Openmd 保存（含视频文字版）", contexts: ["page", "link", "video"], documentUrlPatterns: posts });
+    chrome.contextMenus.create({ id: "save-video-file", title: "用 Openmd 保存（含视频文字版和视频文件）", contexts: ["page", "link", "video"], documentUrlPatterns: posts });
+  });
+  await seedSettings();
+  await applyClickMode();
+  if (!(await getSettings()).locations.length) chrome.runtime.openOptionsPage();
+});
+
+chrome.contextMenus.onClicked.addListener(async (info, tab) => {
+  if (info.menuItemId === "save-link" && info.linkUrl) return saveMany([{ url: info.linkUrl, title: info.linkUrl }]);
+  if (info.menuItemId === "save-page" && tab?.url) return saveMany([{ url: tab.url, title: tab.title }]);
+  if (info.menuItemId === "save-video-text" || info.menuItemId === "save-video-file") {
+    const url = info.linkUrl || info.pageUrl || tab?.url;
+    const video = info.menuItemId === "save-video-file" ? "file" : "text";
+    return saveMany([{ url, title: info.linkUrl ? url : tab?.title }], null, video);
+  }
+  if (info.menuItemId === "save-selection" && tab?.id) {
+    try {
+      const links = await linksInSelection(tab.id);
+      if (!links.length) return fail("选中的区域里没有链接", "拖选一段包含链接的内容（比如课程目录、合集列表）再试。");
+      return saveMany(links);
+    } catch (err) {
+      return fail("读不到这个页面的选中内容", String(err?.message || err));
+    }
+  }
+});
+
+chrome.storage.onChanged.addListener((changes) => {
+  if (changes.settings) applyClickMode();
+});
+
+chrome.runtime.onMessage.addListener((msg, _sender, reply) => {
+  if (msg?.cmd === "save") { saveMany(msg.items, msg.locationId).then(reply); return true; }
+  if (msg?.cmd === "native") { native(msg.message).then(reply); return true; }
+  return false;
+});
+
+chrome.runtime.onStartup.addListener(async () => { await applyClickMode(); poll(); });
+applyClickMode();
+poll();

openmd/browser_extension/idle.html

@@ -0,0 +1,6 @@
+<!doctype html>
+<html lang="zh-CN">
+<head><meta charset="utf-8"><title>Openmd</title>
+<style>body{font:15px/1.6 system-ui,sans-serif;color:#555;background:#fafafa;display:grid;place-items:center;height:100vh;margin:0}</style></head>
+<body><p>这是 Openmd 的后台读取窗口，可以忽略；关掉也不影响使用。</p></body>
+</html>

openmd/browser_extension/manifest.json

@@ -0,0 +1,43 @@
+{
+  "manifest_version": 3,
+  "name": "Openmd",
+  "version": "1.3.0",
+  "description": "一键把当前网页、视频或播客保存成干净的 Markdown 原文 / 逐字稿（由本机 openmd 处理）；内置 OpenCLI 浏览器桥接，借用你已登录的浏览器读取 B 站、公众号等。",
+  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0voJuuFdrQiqZFKlcfFdjc9xcD8zMtD8JH4fmNAuO2Fl6swv1qINbzy6QiUX2SGMyEZTg/r6tFLiCHGuFHZ1b3LFW1ytCzQS/OuwTs3tRG4y07AQk+9ZWAtMVy02+Njo4lSuORh/ODwQb1o5JkgH1DJbdGwNyfWFgA3KljYEYBh4GvJScDfqFt25l079hyF2y/zTHVmq7EhFj+mO9SFRZp8K2tpaUCdtS9TGA40RLw77P209kJSsa0Ii0/CMgXawb/305FMmWif438vUoKiGbte9HQBy51ouwpQxeTi3zsszpV/KSFFejPDMpr0RfF/YrInSnEo9tMcxQRb/ltlJgQIDAQAB",
+  "icons": {
+    "16": "icons/icon-16.png",
+    "32": "icons/icon-32.png",
+    "48": "icons/icon-48.png",
+    "128": "icons/icon-128.png"
+  },
+  "action": {
+    "default_title": "保存到 Openmd",
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "icons/icon-16.png",
+      "32": "icons/icon-32.png"
+    }
+  },
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "permissions": [
+    "nativeMessaging",
+    "activeTab",
+    "contextMenus",
+    "notifications",
+    "storage",
+    "scripting",
+    "debugger",
+    "tabs",
+    "cookies",
+    "alarms",
+    "tabGroups",
+    "downloads"
+  ],
+  "options_page": "options.html",
+  "host_permissions": [
+    "<all_urls>"
+  ]
+}

openmd/browser_extension/options.html

@@ -0,0 +1,42 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<title>Openmd 设置</title>
+<link rel="stylesheet" href="popup.css">
+</head>
+<body class="options">
+  <main>
+    <header class="opt-head">
+      <img src="icons/icon-48.png" width="36" height="36" alt="">
+      <div>
+        <h1>Openmd 设置</h1>
+        <p class="host" id="host">正在连接本机 openmd…</p>
+      </div>
+    </header>
+
+    <section>
+      <h2>点击图标时</h2>
+      <label class="choice"><input type="radio" name="mode" value="auto"> 直接保存到默认位置</label>
+      <label class="choice"><input type="radio" name="mode" value="choose"> 先选择保存位置</label>
+    </section>
+
+    <section>
+      <h2>帖子里带视频时（目前 X）</h2>
+      <label class="choice"><input type="radio" name="video" value="note"> 只注明有视频（最快）</label>
+      <label class="choice"><input type="radio" name="video" value="text"> 附上视频逐字稿（本机转写，较慢）</label>
+      <p class="hint">不论选哪个，在 X 页面右键都可以单独选“含视频文字版”或“含视频文字版和视频文件”。</p>
+    </section>
+
+    <section>
+      <h2>保存位置</h2>
+      <p class="hint">名字随便起，比如“笔记收件箱”“D 盘资料”。圆点选中的是默认位置。</p>
+      <ul id="rows" class="rows"></ul>
+      <button id="add" type="button" class="secondary">＋ 添加位置</button>
+    </section>
+
+    <p class="saved" id="saved" role="status" aria-live="polite"></p>
+  </main>
+  <script src="options.js"></script>
+</body>
+</html>

openmd/browser_extension/options.js

@@ -0,0 +1,117 @@
+const $ = (id) => document.getElementById(id);
+let settings = { locations: [], defaultId: null, clickMode: "auto", videoMode: "note" };
+
+function native(message) {
+  return chrome.runtime.sendMessage({ cmd: "native", message });
+}
+
+function isAbsoluteWindowsPath(p) {
+  return /^[A-Za-z]:[\\/]/.test(p) || /^\\\\/.test(p);
+}
+
+let savedTimer;
+async function persist() {
+  settings.locations = settings.locations.filter((l) => l.name.trim() || l.path.trim());
+  if (!settings.locations.some((l) => l.id === settings.defaultId)) settings.defaultId = settings.locations[0]?.id || null;
+  await chrome.storage.local.set({ settings });
+  $("saved").textContent = "已保存设置";
+  clearTimeout(savedTimer);
+  savedTimer = setTimeout(() => { $("saved").textContent = ""; }, 1500);
+}
+
+function row(loc) {
+  const li = document.createElement("li");
+  li.className = "row";
+
+  const radio = document.createElement("input");
+  radio.type = "radio";
+  radio.name = "default";
+  radio.id = `def-${loc.id}`;
+  radio.title = "设为默认";
+  radio.checked = loc.id === settings.defaultId;
+  radio.onchange = () => { settings.defaultId = loc.id; persist(); };
+
+  const name = document.createElement("input");
+  name.type = "text";
+  name.id = `name-${loc.id}`;
+  name.className = "name";
+  name.placeholder = "名字";
+  name.value = loc.name;
+  name.onchange = () => { loc.name = name.value.trim() || "未命名"; name.value = loc.name; persist(); };
+
+  const path = document.createElement("input");
+  path.type = "text";
+  path.id = `path-${loc.id}`;
+  path.className = "path";
+  path.placeholder = "例如 D:\\资料\\收件箱";
+  path.spellcheck = false;
+  path.value = loc.path;
+  const check = () => path.classList.toggle("invalid", !!path.value && !isAbsoluteWindowsPath(path.value));
+  path.onchange = () => { loc.path = path.value.trim(); check(); persist(); };
+  check();
+
+  const pick = document.createElement("button");
+  pick.type = "button";
+  pick.className = "secondary";
+  pick.textContent = "选择…";
+  pick.onclick = async () => {
+    pick.disabled = true;
+    const reply = await native({ type: "pick_folder", initial: loc.path });
+    pick.disabled = false;
+    if (reply?.ok && reply.path) { loc.path = reply.path; path.value = reply.path; check(); persist(); }
+  };
+
+  const remove = document.createElement("button");
+  remove.type = "button";
+  remove.className = "remove";
+  remove.textContent = "删除";
+  remove.onclick = () => {
+    settings.locations = settings.locations.filter((l) => l.id !== loc.id);
+    persist();
+    render();
+  };
+
+  li.append(radio, name, path, pick, remove);
+  return li;
+}
+
+function render() {
+  const rows = $("rows");
+  rows.textContent = "";
+  for (const loc of settings.locations) rows.append(row(loc));
+  document.querySelectorAll('input[name="mode"]').forEach((r) => { r.checked = r.value === settings.clickMode; });
+  document.querySelectorAll('input[name="video"]').forEach((r) => { r.checked = r.value === (settings.videoMode || "note"); });
+}
+
+async function init() {
+  const stored = (await chrome.storage.local.get("settings")).settings;
+  if (stored) settings = { videoMode: "note", ...stored };
+  const ping = await native({ type: "ping" });
+  const host = $("host");
+  host.textContent = ping?.ok ? "本机 openmd 已连接" : (ping?.error || "未连接本机 openmd");
+  host.className = `host ${ping?.ok ? "ok" : "bad"}`;
+  if (!settings.locations.length && ping?.ok && ping.save_to) {
+    const id = crypto.randomUUID();
+    settings = { locations: [{ id, name: "默认", path: ping.save_to }], defaultId: id, clickMode: "auto", videoMode: "note" };
+    await persist();
+  }
+  render();
+}
+
+$("add").addEventListener("click", () => {
+  const loc = { id: crypto.randomUUID(), name: `位置 ${settings.locations.length + 1}`, path: "" };
+  settings.locations.push(loc);
+  if (!settings.defaultId) settings.defaultId = loc.id;
+  render();
+  document.getElementById(`path-${loc.id}`).focus();
+});
+
+document.querySelectorAll('input[name="mode"]').forEach((r) => {
+  r.addEventListener("change", () => { settings.clickMode = r.value; persist(); });
+});
+
+init();
+
+document.querySelectorAll('input[name="video"]').forEach((r) => {
+  r.addEventListener("change", () => { settings.videoMode = r.value; persist(); });
+});