hunter-mate 0.1.2 → 0.1.4

package/dist/assets/extension/sidepanel/index.js

@@ -0,0 +1,926 @@
+"use strict";
+(() => {
+  // src/shared/messaging.ts
+  var SERVER_PORT = 34570;
+  var WS_URL = `ws://localhost:${SERVER_PORT}/ws`;
+  var SERVER_HTTP_URL = `http://localhost:${SERVER_PORT}`;
+  var WEB_APP_URL = SERVER_HTTP_URL;
+
+  // ../../node_modules/.pnpm/@chromepilot+logger-kit@0.1.3_@nestjs+common@10.4.22_class-transformer@0.5.1_class-validator@_v44hq6ikmqzoani6tawke4nway/node_modules/@chromepilot/logger-kit/dist/client/logger.js
+  function stringifyArg(arg) {
+    if (typeof arg === "string")
+      return arg;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }
+  var Logger = class {
+    opts;
+    buffer = [];
+    timer = null;
+    originalConsole = {};
+    maxBufferSize;
+    flushIntervalMs;
+    constructor(opts) {
+      this.opts = opts;
+      this.maxBufferSize = opts.maxBufferSize ?? 50;
+      this.flushIntervalMs = opts.flushIntervalMs ?? 1e3;
+    }
+    resolveSessionId() {
+      const sid = typeof this.opts.sessionId === "function" ? this.opts.sessionId() : this.opts.sessionId;
+      return sid || "none";
+    }
+    async resolveTabInfo() {
+      try {
+        return await this.opts.getTabInfo?.() ?? {};
+      } catch {
+        return {};
+      }
+    }
+    enqueue(level, message, meta) {
+      this.resolveTabInfo().then((info) => {
+        this.buffer.push({
+          sessionId: this.resolveSessionId(),
+          context: this.opts.context,
+          level,
+          message,
+          meta: meta ?? null,
+          tabId: info.tabId ?? null,
+          url: info.url ?? null,
+          timestamp: Date.now()
+        });
+        if (this.buffer.length >= this.maxBufferSize) {
+          this.flush().catch(() => {
+          });
+        } else {
+          this.scheduleFlush();
+        }
+      });
+    }
+    scheduleFlush() {
+      if (this.timer)
+        return;
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.flush().catch(() => {
+        });
+      }, this.flushIntervalMs);
+    }
+    async flush() {
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      if (!this.buffer.length)
+        return;
+      const batch = this.buffer.splice(0, this.buffer.length);
+      try {
+        await this.opts.send(batch);
+      } catch {
+        const queue = this.opts.persistentQueue;
+        if (queue) {
+          for (const entry of batch) {
+            await queue.enqueue(entry).catch(() => {
+            });
+          }
+        } else {
+          this.buffer.unshift(...batch);
+          if (this.buffer.length > this.maxBufferSize * 2) {
+            this.buffer.splice(0, this.buffer.length - this.maxBufferSize * 2);
+          }
+        }
+      }
+    }
+    /**
+     * Drain persistent queue by calling send. Returns counts of sent/remaining.
+     * Caller should invoke this when server is reachable again (e.g. on retry tick).
+     */
+    async drainPersistent() {
+      if (!this.opts.persistentQueue)
+        return null;
+      return this.opts.persistentQueue.drain(this.opts.send);
+    }
+    debug(message, meta) {
+      this.enqueue("debug", message, meta);
+    }
+    info(message, meta) {
+      this.enqueue("info", message, meta);
+    }
+    warn(message, meta) {
+      this.enqueue("warn", message, meta);
+    }
+    error(message, meta) {
+      this.enqueue("error", message, meta);
+    }
+    log(message, meta) {
+      this.info(message, meta);
+    }
+    patchConsole() {
+      const levels = ["debug", "info", "warn", "error"];
+      for (const level of levels) {
+        const original = console[level];
+        this.originalConsole[level] = original;
+        console[level] = (...args) => {
+          original.apply(console, args);
+          try {
+            const message = args.map(stringifyArg).join(" ");
+            this[level](message);
+          } catch {
+          }
+        };
+      }
+      const originalLog = console.log;
+      this.originalConsole.log = originalLog;
+      console.log = (...args) => {
+        originalLog.apply(console, args);
+        try {
+          const message = args.map(stringifyArg).join(" ");
+          this.info(message);
+        } catch {
+        }
+      };
+    }
+    patchProcessStreams() {
+      if (typeof process === "undefined")
+        return;
+      const wrap = (stream, label) => {
+        const original = stream.write.bind(stream);
+        stream.write = (chunk, encoding, cb) => {
+          const str = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
+          this.info(str.replace(/\n$/, ""), { stream: label });
+          return original(chunk, encoding, cb);
+        };
+      };
+      wrap(process.stdout, "stdout");
+      wrap(process.stderr, "stderr");
+    }
+  };
+
+  // src/shared/logger.ts
+  function createMessageLogger(options) {
+    return new Logger({
+      context: options.context,
+      sessionId: options.sessionId,
+      send: async (logs) => {
+        await chrome.runtime.sendMessage({ type: "hm:logs", logs });
+      },
+      flushIntervalMs: 1500,
+      maxBufferSize: 30
+    });
+  }
+
+  // src/sidepanel/index.ts
+  var state = {
+    tabId: -1,
+    url: "",
+    serverConnected: false,
+    wsConnected: false,
+    recordingSessionId: null,
+    eventCount: 0,
+    classification: null,
+    statusKnown: false,
+    serverVersion: null,
+    serverBuildTime: null
+  };
+  var prevServerConnected = false;
+  var prevWsConnected = false;
+  var statusIntervalId = null;
+  var currentStatusIntervalMs = 3e3;
+  var STATUS_INTERVAL_ONLINE_MS = 3e3;
+  var STATUS_INTERVAL_OFFLINE_MS = 1e4;
+  var sidepanelLogger = createMessageLogger({
+    context: "sidepanel",
+    sessionId: () => `sidepanel-${Date.now()}`
+  });
+  sidepanelLogger.patchConsole();
+  var autoParsedSessionIds = /* @__PURE__ */ new Set();
+  var currentEntity = null;
+  var parseStatus = "idle";
+  var parseError = "";
+  var autoParseTimer = null;
+  var detectingSessionId = null;
+  var lastParse = null;
+  var CLS_LABEL = {
+    talent: "\u4EBA\u624D",
+    job: "\u804C\u4F4D",
+    company: "\u516C\u53F8",
+    list: "\u5217\u8868",
+    unknown: "\u672A\u8BC6\u522B"
+  };
+  var els = {
+    currentUrl: document.getElementById("currentUrl"),
+    jumpInput: document.getElementById("jumpInput"),
+    jumpBtn: document.getElementById("jumpBtn"),
+    jumpMsg: document.getElementById("jumpMsg"),
+    jumpError: document.getElementById("jumpError"),
+    recordingIndicator: document.getElementById("recordingIndicator"),
+    recordingText: document.getElementById("recordingText"),
+    clsBadge: document.getElementById("clsBadge"),
+    clsDetail: document.getElementById("clsDetail"),
+    parseBtn: document.getElementById("parseBtn"),
+    copyBtn: document.getElementById("copyBtn"),
+    parseResult: document.getElementById("parseResult"),
+    parseStatus: document.getElementById("parseStatus"),
+    entityTags: document.getElementById("entityTags"),
+    entityTagList: document.getElementById("entityTagList"),
+    tagInput: document.getElementById("tagInput"),
+    tagAddBtn: document.getElementById("tagAddBtn"),
+    sitesCard: document.getElementById("sitesCard"),
+    sitesCount: document.getElementById("sitesCount"),
+    sitesList: document.getElementById("sitesList"),
+    entityList: document.getElementById("entityList"),
+    footerVersion: document.getElementById("footerVersion"),
+    dotExt: document.getElementById("dotExt"),
+    dotServer: document.getElementById("dotServer"),
+    dotWs: document.getElementById("dotWs"),
+    tabTag: document.getElementById("tabTag"),
+    groupTag: document.getElementById("groupTag")
+  };
+  var currentTabId = null;
+  var currentGroupId = null;
+  var currentUrl = "";
+  var currentTitle = "";
+  async function api(path, init) {
+    const res = await fetch(`${SERVER_HTTP_URL}${path}`, init);
+    if (!res.ok) throw new Error(`${path} \u2192 HTTP ${res.status}`);
+    return res.json();
+  }
+  async function withRetry(fn, opts = {}) {
+    const { maxAttempts = 4, baseDelayMs = 800, label = "retry" } = opts;
+    let lastErr;
+    for (let i = 1; i <= maxAttempts; i++) {
+      try {
+        return await fn();
+      } catch (e) {
+        lastErr = e;
+        if (i === maxAttempts) throw e;
+        const delay = baseDelayMs * Math.pow(2, i - 1);
+        sidepanelLogger.warn(`sidepanel:${label}:retry`, { attempt: i, delayMs: delay });
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastErr;
+  }
+  function adjustStatusPolling() {
+    const next = state.serverConnected ? STATUS_INTERVAL_ONLINE_MS : STATUS_INTERVAL_OFFLINE_MS;
+    if (next === currentStatusIntervalMs) return;
+    currentStatusIntervalMs = next;
+    if (statusIntervalId) clearInterval(statusIntervalId);
+    statusIntervalId = setInterval(requestStatus, next);
+  }
+  function onServerStateChanged() {
+    const serverCameOnline = !prevServerConnected && state.serverConnected;
+    const wsCameOnline = !prevWsConnected && state.wsConnected;
+    prevServerConnected = state.serverConnected;
+    prevWsConnected = state.wsConnected;
+    if (serverCameOnline || wsCameOnline) {
+      sidepanelLogger.info("sidepanel:server-back-online", {});
+      loadPendingSites();
+      renderEntities(currentType);
+    }
+    adjustStatusPolling();
+  }
+  async function loadCurrentUrlEntity() {
+    if (!currentUrl || isInternalUrl(currentUrl) || !state.serverConnected) return;
+    try {
+      const data = await withRetry(
+        () => api(`/entities/by-url?url=${encodeURIComponent(currentUrl)}`),
+        { label: "loadCurrentUrlEntity", maxAttempts: 2 }
+      );
+      if (data.found && data.entity && data.type) {
+        currentEntity = {
+          id: data.entity.id,
+          type: data.type,
+          isNew: false,
+          tags: data.entity.tags || []
+        };
+        lastParse = {
+          status: data.latestParse?.status || "ok",
+          sessionId: data.latestParse?.sessionId,
+          sourceUrl: data.entity.sourceUrl,
+          entity: { id: data.entity.id, type: data.type, isNew: false },
+          extracted: data.entity.extracted || {}
+        };
+        parseStatus = "parsed";
+        parseError = "";
+        const e = data.entity.extracted || {};
+        const fields = Object.entries(e).filter(([k, v]) => v != null && String(v).trim()).slice(0, 8).map(([k, v]) => `<b>${escapeHtml(k)}</b>: ${escapeHtml(String(v).slice(0, 120))}`).join("<br>");
+        els.parseResult.innerHTML = `\u5F53\u524D\u9875\u9762\u5DF2\u89E3\u6790: <b>${CLS_LABEL[data.type] || data.type} #${data.entity.id}</b><br>${fields || "(\u6682\u65E0\u5B57\u6BB5)"}`;
+        els.parseResult.className = "info";
+        renderEntities(currentType);
+        render();
+      }
+    } catch (err) {
+      sidepanelLogger.warn("sidepanel:loadCurrentUrlEntity:failed", { error: err.message });
+    }
+  }
+  async function loadCurrentTabInfo() {
+    try {
+      const tabs = await new Promise((resolve) => {
+        chrome.tabs.query({ active: true, currentWindow: true }, resolve);
+      });
+      const tab = tabs[0];
+      if (!tab?.id) {
+        resetTabInfo();
+        return;
+      }
+      currentTabId = tab.id;
+      currentGroupId = tab.groupId && tab.groupId !== -1 ? tab.groupId : null;
+      currentUrl = tab.url || tab.pendingUrl || "";
+      currentTitle = tab.title || "";
+      updateTabInfoUI();
+      await loadCurrentUrlEntity();
+    } catch {
+      resetTabInfo();
+    }
+  }
+  function updateTabInfoUI() {
+    els.currentUrl.textContent = currentUrl || currentTitle || "\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u9875\u9762";
+    els.currentUrl.title = currentTitle ? `${currentTitle}
+${currentUrl}` : currentUrl;
+    if (currentTabId != null) {
+      els.tabTag.style.display = "";
+      els.tabTag.textContent = `tab ${currentTabId}`;
+      els.tabTag.title = `\u70B9\u51FB\u590D\u5236: tab ${currentTabId}`;
+    } else {
+      els.tabTag.style.display = "none";
+    }
+    if (currentGroupId != null) {
+      els.groupTag.style.display = "";
+      els.groupTag.textContent = `group ${currentGroupId}`;
+      els.groupTag.title = `\u70B9\u51FB\u590D\u5236: group ${currentGroupId}`;
+    } else {
+      els.groupTag.style.display = "none";
+    }
+  }
+  function resetTabInfo() {
+    currentTabId = null;
+    currentGroupId = null;
+    currentUrl = "";
+    currentTitle = "";
+    updateTabInfoUI();
+  }
+  async function copyToClipboard(text) {
+    try {
+      await navigator.clipboard.writeText(text);
+    } catch {
+      const ta = document.createElement("textarea");
+      ta.value = text;
+      ta.style.position = "fixed";
+      ta.style.opacity = "0";
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand("copy");
+      document.body.removeChild(ta);
+    }
+  }
+  async function handleCopyTag(el, value, originalText) {
+    await copyToClipboard(value);
+    el.classList.add("hm-tag-copied");
+    el.textContent = "\u5DF2\u590D\u5236";
+    setTimeout(() => {
+      el.classList.remove("hm-tag-copied");
+      el.textContent = originalText;
+    }, 1500);
+  }
+  els.tabTag.addEventListener("click", () => {
+    if (currentTabId == null) return;
+    handleCopyTag(els.tabTag, `tab ${currentTabId}`, `tab ${currentTabId}`);
+  });
+  els.groupTag.addEventListener("click", () => {
+    if (currentGroupId == null) return;
+    handleCopyTag(els.groupTag, `group ${currentGroupId}`, `group ${currentGroupId}`);
+  });
+  function navigateToId(input) {
+    const trimmed = input.trim();
+    if (!trimmed) return null;
+    const groupMatch = trimmed.match(/^(?:group|g)[:\s-]+(\d+)$/i);
+    if (groupMatch) {
+      return { type: "group", id: parseInt(groupMatch[1], 10) };
+    }
+    const tabMatch = trimmed.match(/^(?:tab|t)[:\s-]+(\d+)$/i) || trimmed.match(/^(\d+)$/);
+    if (tabMatch) {
+      return { type: "tab", id: parseInt(tabMatch[1], 10) };
+    }
+    return null;
+  }
+  async function jumpToTab(tabId) {
+    return new Promise((resolve, reject) => {
+      chrome.tabs.get(tabId, (tab) => {
+        if (chrome.runtime.lastError || !tab) {
+          reject(new Error(`tab ${tabId} \u4E0D\u5B58\u5728`));
+          return;
+        }
+        chrome.windows.update(tab.windowId, { focused: true }, () => {
+          chrome.tabs.update(tabId, { active: true }, () => {
+            resolve(`\u5DF2\u8DF3\u8F6C\u5230 tab ${tabId}`);
+          });
+        });
+      });
+    });
+  }
+  async function jumpToGroup(groupId) {
+    return new Promise((resolve, reject) => {
+      chrome.tabGroups.get(groupId, (group) => {
+        if (chrome.runtime.lastError || !group) {
+          reject(new Error(`group ${groupId} \u4E0D\u5B58\u5728`));
+          return;
+        }
+        chrome.tabGroups.update(groupId, { collapsed: false }, () => {
+          chrome.tabs.query({ groupId }, (tabs) => {
+            if (!tabs || tabs.length === 0) {
+              reject(new Error(`group ${groupId} \u5185\u65E0 tab`));
+              return;
+            }
+            const firstTab = tabs[0];
+            const firstTabId = firstTab.id;
+            const firstWindowId = firstTab.windowId;
+            if (!firstTabId || !firstWindowId) return;
+            chrome.windows.update(firstWindowId, { focused: true }, () => {
+              chrome.tabs.update(firstTabId, { active: true }, () => {
+                resolve(`\u5DF2\u8DF3\u8F6C\u5230 group ${groupId}`);
+              });
+            });
+          });
+        });
+      });
+    });
+  }
+  async function handleJump() {
+    const parsed = navigateToId(els.jumpInput.value);
+    if (!parsed) {
+      showJumpError("\u683C\u5F0F: tab <ID> / group <ID> / \u7EAF\u6570\u5B57");
+      return;
+    }
+    els.jumpMsg.style.display = "none";
+    els.jumpError.style.display = "none";
+    try {
+      const msg = parsed.type === "tab" ? await jumpToTab(parsed.id) : await jumpToGroup(parsed.id);
+      showJumpMsg(msg);
+      els.jumpInput.value = "";
+      await loadCurrentTabInfo();
+    } catch (e) {
+      showJumpError(e.message || String(e));
+    }
+  }
+  function showJumpMsg(text) {
+    els.jumpMsg.textContent = text;
+    els.jumpMsg.style.display = "";
+    els.jumpError.style.display = "none";
+  }
+  function showJumpError(text) {
+    els.jumpError.textContent = text;
+    els.jumpError.style.display = "";
+    els.jumpMsg.style.display = "none";
+  }
+  els.jumpInput.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") handleJump();
+  });
+  els.jumpBtn.addEventListener("click", handleJump);
+  function isInternalUrl(url) {
+    if (!url) return true;
+    return url.startsWith("chrome://") || url.startsWith("chrome-extension://") || url.startsWith("about:") || url.startsWith("file://") || url.startsWith("edge://");
+  }
+  function render() {
+    renderStatusDots();
+    if (isInternalUrl(state.url)) {
+      els.recordingIndicator.style.display = "none";
+      els.clsBadge.textContent = "\u672A\u8BC6\u522B";
+      els.clsBadge.className = "badge b-unknown";
+      els.clsDetail.textContent = "\u5F53\u524D\u9875\u4E0D\u5728\u5F55\u5236\u8303\u56F4\u5185(\u5185\u90E8\u9875\u9762)\u3002";
+      els.parseBtn.disabled = true;
+      els.copyBtn.disabled = !lastParse;
+      renderParseStatus();
+      renderEntityTags();
+      return;
+    }
+    if (state.recordingSessionId) {
+      els.recordingIndicator.style.display = "";
+      els.recordingText.textContent = `\u91C7\u96C6\u4E2D \xB7 ${state.eventCount}\u4E8B\u4EF6`;
+    } else {
+      els.recordingIndicator.style.display = "none";
+    }
+    const cls = state.classification;
+    if (currentEntity && !cls) {
+      els.clsBadge.textContent = `${CLS_LABEL[currentEntity.type] || currentEntity.type} \xB7 \u5DF2\u89E3\u6790`;
+      els.clsBadge.className = `badge b-${currentEntity.type}`;
+      els.clsDetail.textContent = `\u5F53\u524D\u9875\u9762\u5DF2\u5165\u5E93 #${currentEntity.id}\u3002`;
+    } else if (!cls) {
+      els.clsBadge.textContent = "\u672A\u8BC6\u522B";
+      els.clsBadge.className = "badge b-unknown";
+      els.clsDetail.textContent = "\u5F53\u524D\u9875\u65E0\u5206\u7C7B(\u672A\u547D\u4E2D\u62DB\u8058\u57DF\u6216\u672A\u8FD4\u56DE\u5206\u7C7B)\u3002";
+    } else if (cls.abortSignal) {
+      els.clsBadge.textContent = "\u5DF2\u4E2D\u6B62";
+      els.clsBadge.className = "badge b-abort";
+      els.clsDetail.textContent = `\u98CE\u63A7/\u767B\u5F55\u5899(${cls.abortSignal}),\u672C\u9875\u4E0D\u91C7\u96C6\u3002`;
+    } else {
+      els.clsBadge.textContent = `${CLS_LABEL[cls.pageClass] || cls.pageClass}@${cls.domain}`;
+      els.clsBadge.className = `badge b-${cls.pageClass}`;
+      els.clsDetail.textContent = `\u5224\u5B9A\u4F9D\u636E: ${cls.matchedBy}`;
+    }
+    const actionable = !!state.recordingSessionId && !!cls && !cls.abortSignal;
+    els.parseBtn.disabled = !actionable || parseStatus === "parsing";
+    els.copyBtn.disabled = !lastParse;
+    renderParseStatus();
+    renderEntityTags();
+  }
+  function renderParseStatus() {
+    const el = els.parseStatus;
+    if (parseStatus === "idle" && state.recordingSessionId && !state.classification) {
+      el.style.display = "";
+      el.className = "parse-status detecting";
+      el.innerHTML = '<span class="spinner"></span> \u8BC6\u522B\u4E2D';
+      return;
+    }
+    if (parseStatus === "idle") {
+      el.style.display = "none";
+      return;
+    }
+    el.style.display = "";
+    el.className = "parse-status " + parseStatus;
+    if (parseStatus === "detecting") {
+      el.innerHTML = '<span class="spinner"></span> \u8BC6\u522B\u4E2D';
+    } else if (parseStatus === "parsing") {
+      el.innerHTML = '<span class="spinner"></span> \u89E3\u6790\u4E2D';
+    } else if (parseStatus === "parsed") {
+      const stored = currentEntity && !currentEntity.isNew;
+      el.textContent = stored ? "\u5DF2\u5165\u5E93 \u2713" : "\u65B0\u5165\u5E93 \u2713";
+      el.className = stored ? "parse-status stored" : "parse-status new";
+    } else if (parseStatus === "failed") {
+      el.textContent = `\u89E3\u6790\u5931\u8D25: ${parseError}`;
+    }
+  }
+  function renderEntityTags() {
+    if (!currentEntity) {
+      els.entityTags.style.display = "none";
+      return;
+    }
+    els.entityTags.style.display = "";
+    const tags = currentEntity.tags || [];
+    els.entityTagList.innerHTML = "";
+    if (tags.length === 0) {
+      const empty = document.createElement("span");
+      empty.style.color = "#9ca3af";
+      empty.style.fontSize = "11px";
+      empty.textContent = "\u6682\u65E0\u6807\u7B7E";
+      els.entityTagList.append(empty);
+    } else {
+      for (const tag of tags) {
+        const chip = document.createElement("span");
+        chip.className = "tag-chip";
+        chip.innerHTML = `${escapeHtml(tag)} <button data-tag="${escapeHtml(tag)}" title="\u79FB\u9664">\xD7</button>`;
+        chip.querySelector("button")?.addEventListener("click", () => removeTag(tag));
+        els.entityTagList.append(chip);
+      }
+    }
+  }
+  var ACTIONABLE_CLASSES = /* @__PURE__ */ new Set(["talent", "job", "company"]);
+  function maybeAutoParse() {
+    const sessionId = state.recordingSessionId;
+    const cls = state.classification;
+    if (!sessionId || !cls || cls.abortSignal || !ACTIONABLE_CLASSES.has(cls.pageClass)) {
+      if (autoParseTimer) {
+        clearTimeout(autoParseTimer);
+        autoParseTimer = null;
+        detectingSessionId = null;
+        if (parseStatus === "detecting") {
+          parseStatus = "idle";
+          render();
+        }
+      }
+      return;
+    }
+    if (autoParsedSessionIds.has(sessionId)) return;
+    if (parseStatus === "parsing") return;
+    if (autoParseTimer && detectingSessionId === sessionId) return;
+    if (autoParseTimer) clearTimeout(autoParseTimer);
+    parseStatus = "detecting";
+    detectingSessionId = sessionId;
+    render();
+    autoParseTimer = setTimeout(() => {
+      autoParseTimer = null;
+      detectingSessionId = null;
+      if (state.recordingSessionId !== sessionId) return;
+      autoParsedSessionIds.add(sessionId);
+      runParse(sessionId);
+    }, 1500);
+  }
+  async function runParse(sessionId) {
+    parseStatus = "parsing";
+    parseError = "";
+    render();
+    try {
+      lastParse = await api(`/parse/${sessionId}`, { method: "POST" });
+      const e = lastParse.entity;
+      sidepanelLogger.info("sidepanel:parse:done", { sessionId, status: lastParse.status, entityId: e?.id });
+      const fields = Object.keys(lastParse.extracted || {}).slice(0, 6).join(", ");
+      els.parseResult.innerHTML = lastParse.status === "ok" && e ? `\u5DF2\u5165\u5E93: <b>${CLS_LABEL[e.type] || e.type} #${e.id}</b><br>\u5B57\u6BB5: ${fields || "(\u7A7A)"}` : `\u89E3\u6790\u72B6\u6001: <b>${lastParse.status}</b>(\u672A\u5165\u5E93)\u3002\u5B57\u6BB5: ${fields || "\u65E0"}\u3002`;
+      els.parseResult.className = lastParse.status === "ok" ? "info" : "info err";
+      if (lastParse.status === "ok" && e) {
+        currentEntity = {
+          id: e.id,
+          type: e.type,
+          isNew: e.isNew !== false,
+          tags: e.tags || []
+        };
+        parseStatus = "parsed";
+      } else {
+        currentEntity = null;
+        parseStatus = "failed";
+        parseError = "\u672A\u5165\u5E93";
+      }
+      renderEntities(currentType);
+    } catch (err) {
+      parseStatus = "failed";
+      parseError = err.message || String(err);
+      sidepanelLogger.error("sidepanel:parse:failed", { sessionId, error: parseError });
+      els.parseResult.textContent = `\u89E3\u6790\u5931\u8D25: ${parseError}`;
+      els.parseResult.className = "info err";
+      currentEntity = null;
+    } finally {
+      render();
+    }
+  }
+  async function addTag() {
+    const raw = els.tagInput.value.trim();
+    if (!raw || !currentEntity) return;
+    const tags = [.../* @__PURE__ */ new Set([...currentEntity.tags || [], raw])];
+    await updateEntityTags(currentEntity.type, currentEntity.id, tags);
+    els.tagInput.value = "";
+  }
+  async function removeTag(tag) {
+    if (!currentEntity) return;
+    const tags = (currentEntity.tags || []).filter((t) => t !== tag);
+    await updateEntityTags(currentEntity.type, currentEntity.id, tags);
+  }
+  async function updateEntityTags(type, id, tags) {
+    try {
+      const res = await api(`/entities/${type}/${id}/tags`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tags })
+      });
+      if (currentEntity && currentEntity.id === id && currentEntity.type === type) {
+        currentEntity.tags = res.tags || [];
+      }
+      sidepanelLogger.info("sidepanel:tags-updated", { type, id, count: tags.length });
+      render();
+      renderEntities(currentType);
+    } catch (err) {
+      sidepanelLogger.error("sidepanel:tags-update-failed", { type, id, error: err.message });
+      els.parseResult.textContent = `\u6807\u7B7E\u4FDD\u5B58\u5931\u8D25: ${err.message}`;
+      els.parseResult.className = "info err";
+    }
+  }
+  els.tagAddBtn.addEventListener("click", addTag);
+  els.tagInput.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") addTag();
+  });
+  function renderStatusDots() {
+    if (!state.statusKnown) {
+      setDot(els.dotExt, "pending", "\u6269\u5C55\u72B6\u6001\u68C0\u6D4B\u4E2D");
+      setDot(els.dotServer, "pending", "\u670D\u52A1\u72B6\u6001\u68C0\u6D4B\u4E2D");
+      setDot(els.dotWs, "pending", "WS \u72B6\u6001\u68C0\u6D4B\u4E2D");
+      return;
+    }
+    const extensionOnline = state.serverConnected && state.wsConnected;
+    setDot(
+      els.dotExt,
+      extensionOnline ? "online" : "offline",
+      extensionOnline ? "\u6269\u5C55\u5728\u7EBF" : "\u6269\u5C55\u79BB\u7EBF\uFF08\u670D\u52A1\u6216 WS \u672A\u5C31\u7EEA\uFF09"
+    );
+    setDot(
+      els.dotServer,
+      state.serverConnected ? "online" : "offline",
+      state.serverConnected ? `\u670D\u52A1\uFF1A\u5DF2\u8FDE\u63A5 \xB7 v${state.serverVersion ?? "?"} \xB7 ${formatBuildTime(state.serverBuildTime)}` : "\u670D\u52A1\uFF1A\u672A\u8FDE\u63A5"
+    );
+    setDot(
+      els.dotWs,
+      state.wsConnected ? "online" : "offline",
+      state.wsConnected ? "WS\uFF1A\u5DF2\u8FDE\u63A5" : "WS\uFF1A\u672A\u8FDE\u63A5"
+    );
+  }
+  function setDot(el, kind, tooltip) {
+    el.className = `hm-status-dot hm-status-dot-${kind}`;
+    el.title = tooltip;
+  }
+  function formatBuildTime(raw) {
+    if (!raw) return "\u672A\u77E5";
+    try {
+      return new Date(raw).toLocaleString("zh-CN");
+    } catch {
+      return raw;
+    }
+  }
+  els.parseBtn.addEventListener("click", async () => {
+    const sessionId = state.recordingSessionId;
+    if (!sessionId) return;
+    autoParsedSessionIds.add(sessionId);
+    await runParse(sessionId);
+  });
+  els.copyBtn.addEventListener("click", async () => {
+    if (!lastParse) return;
+    try {
+      await navigator.clipboard.writeText(buildAgentText(lastParse));
+      els.copyBtn.textContent = "\u5DF2\u590D\u5236 \u2713";
+      setTimeout(() => els.copyBtn.textContent = "\u590D\u5236\u7ED9 Agent", 1500);
+    } catch {
+      els.parseResult.textContent = "\u590D\u5236\u5931\u8D25(\u526A\u8D34\u677F\u6743\u9650)";
+    }
+  });
+  function buildAgentText(p) {
+    const e = p.entity;
+    const lines = [
+      `[hunter-mate] \u5DF2\u6355\u83B7${CLS_LABEL[p.pageClass] || p.pageClass}\u9875\u9762\u5E76\u89E3\u6790:`,
+      `- sessionId: ${p.sessionId}`,
+      `- sourceUrl: ${p.sourceUrl || "(\u89C1 recording_events)"}`
+    ];
+    for (const [k, v] of Object.entries(p.extracted || {}).slice(0, 12)) {
+      if (v != null && String(v).trim()) lines.push(`- ${k}: ${String(v).slice(0, 200)}`);
+    }
+    if (e) lines.push(`- \u5DF2\u5165\u5E93: ${e.type} #${e.id}`);
+    lines.push("\u8BF7\u7528 core/hm-intake skill \u5904\u7406\u8BE5\u5B9E\u4F53(\u53BB\u91CD\u6838\u67E5\u2192\u8C03\u7814\u2192\u4EA4\u4ED8)\u3002");
+    return lines.join("\n");
+  }
+  async function loadPendingSites() {
+    try {
+      const data = await withRetry(
+        () => api("/sites?includePending=1"),
+        { label: "loadPendingSites" }
+      );
+      const pending = (data.sites || []).filter((s) => s.source === "auto" && !s.enabled);
+      els.sitesCard.style.display = pending.length ? "" : "none";
+      els.sitesCount.textContent = String(pending.length);
+      els.sitesList.innerHTML = "";
+      for (const s of pending) {
+        const row = document.createElement("div");
+        row.className = "site-item";
+        row.innerHTML = `<div><div class="dom">${escapeHtml(s.domain)}</div><div class="ev">${escapeHtml(s.platform)} \xB7 \u5F85\u786E\u8BA4</div></div>`;
+        const enable = document.createElement("button");
+        enable.className = "enable-btn";
+        enable.textContent = "\u542F\u7528\u91C7\u96C6";
+        enable.addEventListener("click", async () => {
+          await api(`/sites/${encodeURIComponent(s.domain)}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ enabled: true })
+          }).catch(() => {
+          });
+          await loadPendingSites();
+        });
+        const ignore = document.createElement("button");
+        ignore.className = "ignore-btn";
+        ignore.textContent = "\u5FFD\u7565";
+        ignore.addEventListener("click", async () => {
+          await api(`/sites/${encodeURIComponent(s.domain)}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ enabled: false })
+          }).catch(() => {
+          });
+          await loadPendingSites();
+        });
+        row.append(enable, ignore);
+        els.sitesList.append(row);
+      }
+    } catch (err) {
+      els.sitesCard.style.display = "none";
+      sidepanelLogger.warn("sidepanel:loadPendingSites:failed", { error: err.message });
+    }
+  }
+  var currentType = "talent";
+  document.querySelectorAll(".tabs button").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      document.querySelector(".tabs button.active")?.classList.remove("active");
+      btn.classList.add("active");
+      currentType = btn.dataset.type || "talent";
+      renderEntities(currentType);
+    });
+  });
+  async function renderEntities(type) {
+    currentType = type;
+    try {
+      const data = await withRetry(
+        () => api(`/entities?type=${type}&limit=15`),
+        { label: "renderEntities" }
+      );
+      els.entityList.innerHTML = "";
+      if (!data.items?.length) {
+        els.entityList.innerHTML = '<div class="empty">\u6682\u65E0\u6570\u636E</div>';
+        return;
+      }
+      for (const item of data.items) {
+        const row = document.createElement("div");
+        row.className = "entity-item";
+        const name = escapeHtml(item.name || item.title || "(\u672A\u547D\u540D)");
+        const sub = escapeHtml(item.headline || item.company || item.sourceUrl?.slice(0, 60) || "");
+        const tags = Array.isArray(item.tags) ? item.tags : [];
+        const tagHtml = tags.length ? `<div class="tag-list">${tags.map((t) => `<span class="tag-chip">${escapeHtml(t)}</span>`).join("")}</div>` : "";
+        const detailUrl = `${WEB_APP_URL}/entity?type=${encodeURIComponent(currentType)}&id=${item.id}`;
+        row.innerHTML = `<div class="name">#${item.id} ${name}</div><div class="sub">${sub}</div>${tagHtml}`;
+        row.title = `\u70B9\u51FB\u67E5\u770B\u8BE6\u60C5\u9875: ${detailUrl}`;
+        row.addEventListener("click", () => {
+          chrome.tabs.create({ url: detailUrl, active: true }).catch(() => {
+          });
+        });
+        els.entityList.append(row);
+      }
+    } catch (err) {
+      sidepanelLogger.warn("sidepanel:renderEntities:failed", { error: err.message });
+      els.entityList.innerHTML = '<div class="empty err">\u52A0\u8F7D\u5931\u8D25(server \u672A\u542F\u52A8?)</div>';
+    }
+  }
+  function escapeHtml(s) {
+    return String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+  }
+  async function requestStatus() {
+    try {
+      const res = await chrome.runtime.sendMessage({ type: "get-status" });
+      const prevUrl = state.url;
+      Object.assign(state, res);
+      state.statusKnown = true;
+      if (state.url !== prevUrl && state.url) {
+        autoParsedSessionIds.clear();
+        parseStatus = "idle";
+        parseError = "";
+        currentEntity = null;
+        lastParse = null;
+        loadCurrentUrlEntity();
+      }
+      onServerStateChanged();
+      render();
+      maybeAutoParse();
+    } catch {
+      state.serverConnected = false;
+      state.wsConnected = false;
+      state.statusKnown = true;
+      onServerStateChanged();
+      render();
+    }
+  }
+  function initFooterVersion() {
+    try {
+      const manifest = chrome.runtime.getManifest();
+      const rawBuildTime = manifest.buildTime;
+      const buildTimeText = rawBuildTime ? new Date(rawBuildTime).toLocaleString("zh-CN") : "\u672A\u77E5";
+      els.footerVersion.textContent = `v${manifest.version} \xB7 ${buildTimeText}`;
+    } catch {
+      els.footerVersion.textContent = "v0.0.0";
+    }
+  }
+  chrome.runtime.onMessage.addListener((message) => {
+    if (message.type === "status" && message.payload) {
+      const prevUrl = state.url;
+      Object.assign(state, message.payload);
+      if (state.url !== prevUrl && state.url) {
+        autoParsedSessionIds.clear();
+        parseStatus = "idle";
+        parseError = "";
+        currentEntity = null;
+        lastParse = null;
+      }
+      onServerStateChanged();
+      render();
+      maybeAutoParse();
+    }
+  });
+  window.addEventListener("message", (e) => {
+    if (e.data?.type === "hm-reload-extension") {
+      try {
+        chrome.runtime.reload();
+      } catch {
+      }
+    }
+  });
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") {
+      requestStatus();
+      loadCurrentTabInfo();
+      loadCurrentUrlEntity();
+      loadPendingSites();
+      renderEntities(currentType);
+    }
+  });
+  window.addEventListener("online", () => {
+    sidepanelLogger.info("sidepanel:network:online", {});
+    requestStatus();
+  });
+  window.addEventListener("offline", () => {
+    sidepanelLogger.info("sidepanel:network:offline", {});
+    state.serverConnected = false;
+    state.wsConnected = false;
+    onServerStateChanged();
+    render();
+  });
+  initFooterVersion();
+  render();
+  requestStatus();
+  loadCurrentTabInfo();
+  loadPendingSites();
+  renderEntities(currentType);
+  statusIntervalId = setInterval(requestStatus, currentStatusIntervalMs);
+  setInterval(loadCurrentTabInfo, 5e3);
+  setInterval(loadPendingSites, 3e4);
+})();