mnote/extensions/mnote-vault/background.js

/**
 * MNote Vault extension service worker.
 * Holds token + cookies + pending save drafts; content script only sends form fields.
 *
 * Save flow (KeePassXC-style, no webRequest):
 *  1) content submit → PENDING_SAVE (background memory / session)
 *  2) SPA same-page → fallback prompt after short delay
 *  3) full navigation → tabs.onUpdated complete → OPEN_SAVE_UI_WITH_DRAFT
 *  4) user confirms → SAVE_CREDENTIAL (+ cookies at confirm time)
 *  5) P1: optional delayed session recapture after save
 */

import * as api from "./lib/api.js";
import * as storage from "./lib/storage.js";

const MAX_COOKIE_VALUE = 8 * 1024;
/** Pending draft TTL (KeePassXC-like short window across redirects). */
const PENDING_TTL_MS = 3 * 60 * 1000;
/** Max same-tab redirects before we still allow one prompt (then clear on show). */
const REDIRECT_ALLOWANCE = 5;
/** SPA: if no navigation, prompt on same page after this delay. */
const SPA_FALLBACK_MS = 1500;
/** P1: re-capture cookies after credential save (login cookies often land late). */
const SESSION_RECAPTURE_DELAY_MS = 2500;
const PENDING_STORAGE_KEY = "pendingByTab";

/**
 * In-memory pending drafts: tabId → PendingDraft
 * Mirrored to chrome.storage.session when available (SW restart).
 * @type {Map<number, object>}
 */
const pendingByTab = new Map();
/** @type {Map<number, ReturnType<typeof setTimeout>>} */
const spaFallbackTimers = new Map();
/**
 * @typedef {object} PendingDraft
 * @property {string} username
 * @property {string} password
 * @property {string} [email]
 * @property {string} pageUrl
 * @property {string} origin
 * @property {string} hostname
 * @property {string} title
 * @property {number} createdAt
 * @property {number} expiresAt
 * @property {number} redirectCount
 * @property {boolean} [prompted]
 * @property {string} [promptedUrl] URL where confirm UI was last shown
 * @property {string} [submitUrl] URL at submit time (SPA vs full nav)
 * @property {boolean} [fromSubmit]
 */

chrome.runtime.onInstalled.addListener(() => {
  storage.loadConfig().then((cfg) => storage.setBadge(cfg.connected, cfg.email));
  hydratePendingFromSession().catch(() => {});
});

chrome.runtime.onStartup.addListener(() => {
  storage.loadConfig().then((cfg) => storage.setBadge(cfg.connected, cfg.email));
  hydratePendingFromSession().catch(() => {});
});

// Restore pending map ASAP when SW wakes.
hydratePendingFromSession().catch(() => {});

/**
 * @param {string} pageUrl
 * @returns {{ origin: string, hostname: string }}
 */
function parseUrlParts(pageUrl) {
  try {
    const u = new URL(pageUrl);
    return { origin: u.origin, hostname: u.hostname.toLowerCase() };
  } catch {
    return { origin: "", hostname: "" };
  }
}

/**
 * Same-site check for post-login redirects (e.g. login.example.com → www.example.com).
 * Host equal, or one is a subdomain of the other, or same eTLD+1-ish parent.
 * @param {string} a
 * @param {string} b
 */
function sameSiteHost(a, b) {
  if (!a || !b) return false;
  const x = a.toLowerCase().replace(/^\./, "");
  const y = b.toLowerCase().replace(/^\./, "");
  if (x === y) return true;
  if (x.endsWith("." + y) || y.endsWith("." + x)) return true;
  const px = x.split(".");
  const py = y.split(".");
  if (px.length >= 2 && py.length >= 2) {
    const rx = px.slice(-2).join(".");
    const ry = py.slice(-2).join(".");
    if (rx === ry && rx.includes(".")) return true;
  }
  return false;
}

function isExpired(draft) {
  return !draft || !draft.expiresAt || Date.now() > draft.expiresAt;
}

/**
 * Persist pending map for SW restarts (session storage only — never local/sync).
 */
async function persistPendingMap() {
  if (!chrome.storage?.session) return;
  /** @type {Record<string, object>} */
  const obj = {};
  for (const [tabId, draft] of pendingByTab.entries()) {
    if (!isExpired(draft)) obj[String(tabId)] = draft;
  }
  try {
    await chrome.storage.session.set({ [PENDING_STORAGE_KEY]: obj });
  } catch (e) {
    console.warn("[mnote-vault] persist pending failed", e);
  }
}

async function hydratePendingFromSession() {
  if (!chrome.storage?.session) return;
  try {
    const data = await chrome.storage.session.get(PENDING_STORAGE_KEY);
    const obj = data?.[PENDING_STORAGE_KEY] || {};
    for (const [k, draft] of Object.entries(obj)) {
      const tabId = Number(k);
      if (!Number.isFinite(tabId) || isExpired(draft)) continue;
      pendingByTab.set(tabId, draft);
    }
  } catch (e) {
    console.warn("[mnote-vault] hydrate pending failed", e);
  }
}

/**
 * @param {number} tabId
 */
function clearSpaFallback(tabId) {
  const t = spaFallbackTimers.get(tabId);
  if (t) {
    clearTimeout(t);
    spaFallbackTimers.delete(tabId);
  }
}

/**
 * @param {number} tabId
 * @param {boolean} [persist]
 */
async function clearPending(tabId, persist = true) {
  clearSpaFallback(tabId);
  pendingByTab.delete(tabId);
  if (persist) await persistPendingMap();
}

/**
 * @param {number} tabId
 * @param {object} fields
 * @returns {PendingDraft}
 */
function buildPendingDraft(tabId, fields) {
  const pageUrl = String(fields.pageUrl || "").trim();
  const { origin, hostname } = parseUrlParts(pageUrl);
  const now = Date.now();
  const prev = pendingByTab.get(tabId);
  // Fresh submit always resets prompted so a new login can show again.
  const isFreshSubmit = fields.fromSubmit !== false && fields.resetPrompted !== false;
  /** @type {PendingDraft} */
  const draft = {
    username: String(fields.username || prev?.username || "").trim(),
    password: String(fields.password || prev?.password || ""),
    email: String(fields.email || prev?.email || "").trim() || undefined,
    pageUrl: pageUrl || prev?.pageUrl || "",
    origin: origin || prev?.origin || "",
    hostname: hostname || prev?.hostname || "",
    title: String(fields.title || prev?.title || "").trim(),
    createdAt: prev?.createdAt || now,
    expiresAt: now + PENDING_TTL_MS,
    redirectCount: isFreshSubmit ? 0 : prev?.redirectCount || 0,
    prompted: isFreshSubmit ? false : Boolean(prev?.prompted),
    promptedUrl: isFreshSubmit ? undefined : prev?.promptedUrl,
    submitUrl: isFreshSubmit
      ? pageUrl || prev?.submitUrl || ""
      : prev?.submitUrl || pageUrl || "",
    fromSubmit: fields.fromSubmit !== false,
  };
  return draft;
}

/**
 * @param {number} tabId
 */
async function markPendingPrompted(tabId, promptedUrl) {
  const draft = pendingByTab.get(tabId);
  if (!draft || isExpired(draft)) return false;
  draft.prompted = true;
  if (promptedUrl) draft.promptedUrl = promptedUrl;
  pendingByTab.set(tabId, draft);
  clearSpaFallback(tabId);
  await persistPendingMap();
  return true;
}

/**
 * @param {number} tabId
 * @param {PendingDraft} draft
 * @param {{ spaFallback?: boolean }} [opts]
 */
async function setPending(tabId, draft, opts = {}) {
  if (!draft.password && !draft.username) return null;
  pendingByTab.set(tabId, draft);
  await persistPendingMap();

  clearSpaFallback(tabId);
  if (opts.spaFallback !== false) {
    const timer = setTimeout(() => {
      spaFallbackTimers.delete(tabId);
      const cur = pendingByTab.get(tabId);
      if (!cur || isExpired(cur) || cur.prompted) return;
      // SPA only if still on submit URL; full nav is handled by tabs.onUpdated.
      chrome.tabs
        .get(tabId)
        .then((tab) => {
          const cur2 = pendingByTab.get(tabId);
          if (!cur2 || isExpired(cur2) || cur2.prompted) return null;
          const tabUrl = tab?.url || "";
          if (
            tabUrl &&
            cur2.submitUrl &&
            tabUrl !== cur2.submitUrl &&
            /^https?:/i.test(tabUrl)
          ) {
            // Already navigated — prefer post-login prompt path.
            return maybePromptPendingOnComplete(tabId, tabUrl);
          }
          return openSaveUiOnTab(tabId, cur2, { reason: "spa_fallback" });
        })
        .catch((e) =>
          console.warn("[mnote-vault] spa fallback prompt failed", e)
        );
    }, SPA_FALLBACK_MS);
    spaFallbackTimers.set(tabId, timer);
  }
  return draft;
}

/**
 * @param {number} tabId
 * @param {PendingDraft} draft
 * @param {{ reason?: string, force?: boolean }} [opts]
 */
async function openSaveUiOnTab(tabId, draft, opts = {}) {
  if (!draft || isExpired(draft)) {
    await clearPending(tabId);
    return { ok: false, error: "pending expired" };
  }
  if (draft.prompted && !opts.force) {
    return { ok: true, skipped: true, reason: "already_prompted" };
  }

  let tabUrl = draft.pageUrl;
  try {
    const tab = await chrome.tabs.get(tabId);
    if (tab?.url) tabUrl = tab.url;
  } catch {
    /* ignore */
  }

  // Dedupe: already saved same site+user+password → silent session update or skip.
  if (!opts.force) {
    try {
      let decision = await storage.shouldSuppressPrompt({
        pageUrl: draft.pageUrl || tabUrl,
        username: draft.username,
        password: draft.password,
      });
      // Local memory may be empty (first install / other device). Fall back to vault.
      if (!decision.suppress && draft.password) {
        const vaultDecision = await matchVaultSameCredential({
          pageUrl: draft.pageUrl || tabUrl,
          username: draft.username,
          password: draft.password,
        });
        if (vaultDecision) {
          decision = vaultDecision;
          // Seed local memory so later prompts are free.
          try {
            await storage.rememberSavedSite({
              pageUrl: draft.pageUrl || tabUrl,
              username: draft.username,
              password: draft.password,
              credentialId: vaultDecision.credentialId,
              hasSession: !vaultDecision.needSessionOnly,
            });
          } catch {
            /* ignore */
          }
        }
      }
      if (decision.suppress) {
        if (
          (decision.reason === "already_saved_same_password" ||
            decision.reason === "vault_same_password") &&
          decision.credentialId
        ) {
          // Silent session-only refresh when missing session, or best-effort refresh.
          if (decision.needSessionOnly !== false) {
            try {
              const cfg = await storage.loadConfig();
              if (cfg.connected) {
                await ensureHostPermission(cfg.baseUrl, tabUrl || draft.pageUrl);
                const cap = await captureCookies(tabUrl || draft.pageUrl);
                if (cap.cookieHeader || (cap.cookies && cap.cookies.length)) {
                  await api.putSession(cfg, decision.credentialId, {
                    accountId: decision.accountId || "primary",
                    cookieHeader: cap.cookieHeader,
                    cookies: cap.cookies,
                    origin: cap.origin,
                  });
                  await storage.rememberSavedSite({
                    pageUrl: draft.pageUrl || tabUrl,
                    username: draft.username,
                    password: draft.password,
                    credentialId: decision.credentialId,
                    hasSession: true,
                  });
                  console.info(
                    "[mnote-vault] silent session update ok",
                    decision.credentialId
                  );
                }
              }
            } catch (e) {
              console.warn("[mnote-vault] silent session update failed", e);
            }
          }
        }
        draft.prompted = true;
        draft.promptedUrl = tabUrl;
        pendingByTab.set(tabId, draft);
        await persistPendingMap();
        clearSpaFallback(tabId);
        // Drop pending so further redirects do not re-evaluate.
        await clearPending(tabId);
        return {
          ok: true,
          skipped: true,
          reason: decision.reason || "deduped",
          credentialId: decision.credentialId,
        };
      }
    } catch (e) {
      console.warn("[mnote-vault] dedupe check failed", e);
    }
  }

  draft.prompted = true;
  draft.promptedUrl = tabUrl;
  pendingByTab.set(tabId, draft);
  await persistPendingMap();
  clearSpaFallback(tabId);

  const payload = {
    type: "OPEN_SAVE_UI_WITH_DRAFT",
    draft: {
      pageUrl: draft.pageUrl || tabUrl,
      title: draft.title,
      username: draft.username,
      password: draft.password,
      email: draft.email || "",
      fromPending: true,
      pendingReason: opts.reason || "pending",
    },
  };

  try {
    await chrome.tabs.sendMessage(tabId, payload);
    return { ok: true, reason: opts.reason || "pending" };
  } catch (e) {
    // Content script may not be ready yet — retry once shortly.
    await new Promise((r) => setTimeout(r, 400));
    try {
      await chrome.tabs.sendMessage(tabId, payload);
      return { ok: true, reason: opts.reason || "pending", retried: true };
    } catch (e2) {
      // Allow another attempt on next complete if injection still fails.
      draft.prompted = false;
      draft.promptedUrl = undefined;
      pendingByTab.set(tabId, draft);
      await persistPendingMap();
      console.warn("[mnote-vault] OPEN_SAVE_UI_WITH_DRAFT failed", e2);
      return { ok: false, error: e2?.message || String(e2) };
    }
  }
}

/**
 * After full navigation completes: same tab + same site → show confirm with draft.
 * @param {number} tabId
 * @param {string} tabUrl
 */
async function maybePromptPendingOnComplete(tabId, tabUrl) {
  const draft = pendingByTab.get(tabId);
  if (!draft || isExpired(draft)) {
    if (draft) await clearPending(tabId);
    return;
  }

  const { hostname } = parseUrlParts(tabUrl || "");
  if (hostname && draft.hostname && !sameSiteHost(hostname, draft.hostname)) {
    // Navigated away to unrelated site — drop pending.
    await clearPending(tabId);
    return;
  }

  // If we already showed UI on this exact URL, do not spam.
  if (draft.prompted && draft.promptedUrl && tabUrl && draft.promptedUrl === tabUrl) {
    return;
  }
  // After a successful prompt on the login URL, do NOT re-open on every
  // post-login hop (that is the main "keeps asking" UX bug). User can still
  // open popup manually if the first prompt was closed accidentally.
  if (draft.prompted) return;

  draft.redirectCount = (draft.redirectCount || 0) + 1;
  if (draft.redirectCount > REDIRECT_ALLOWANCE) {
    await clearPending(tabId);
    return;
  }
  // Prefer post-login URL for matching / cookie capture display.
  if (tabUrl && /^https?:/i.test(tabUrl)) {
    draft.pageUrl = tabUrl;
    const parts = parseUrlParts(tabUrl);
    if (parts.origin) draft.origin = parts.origin;
    if (parts.hostname) draft.hostname = parts.hostname;
  }
  pendingByTab.set(tabId, draft);
  await persistPendingMap();

  await openSaveUiOnTab(tabId, draft, { reason: "nav_complete" });
}

chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  if (changeInfo.status !== "complete") return;
  const url = tab?.url || changeInfo.url || "";
  if (!url || !/^https?:/i.test(url)) return;
  if (!pendingByTab.has(tabId)) return;
  maybePromptPendingOnComplete(tabId, url).catch((e) =>
    console.warn("[mnote-vault] pending onUpdated failed", e)
  );
});

chrome.tabs.onRemoved.addListener((tabId) => {
  clearPending(tabId).catch(() => {});
});

chrome.alarms.onAlarm.addListener((alarm) => {
  if (!alarm?.name?.startsWith("mnote-vault-recapture:")) return;
  // name: mnote-vault-recapture:<credentialId>:<accountId>
  // pageUrl stored via chrome.storage.session under same key for SW restart.
  const raw = alarm.name.slice("mnote-vault-recapture:".length);
  runSessionRecaptureFromAlarm(raw).catch((e) =>
    console.warn("[mnote-vault] session recapture failed", e)
  );
});

/**
 * Ensure host permission for baseUrl (+ optional page origin for cookies).
 * Prefer broad http(s) origins when available so cookies.getAll works on any site.
 * @param {string} baseUrl
 * @param {string} [pageUrl]
 * @param {{ broad?: boolean }} [opts]
 */
async function ensureHostPermission(baseUrl, pageUrl, opts = {}) {
  const origins = [];
  // Broad grant: required to read cookies on arbitrary login sites.
  if (opts.broad !== false) {
    origins.push("http://*/*", "https://*/*");
  }
  try {
    if (baseUrl) {
      const b = new URL(api.normalizeBaseUrl(baseUrl));
      origins.push(`${b.origin}/*`);
    }
  } catch {
    /* ignore */
  }
  if (pageUrl) {
    try {
      const p = new URL(pageUrl);
      origins.push(`${p.origin}/*`);
    } catch {
      /* ignore */
    }
  }
  // de-dupe
  const uniq = [...new Set(origins.filter(Boolean))];
  if (!uniq.length) return true;
  try {
    const have = await chrome.permissions.contains({ origins: uniq });
    if (have) return true;
    // service worker 内 request 常无用户手势而失败；保存确认层应在 content 点击手势内先申请。
    return await chrome.permissions.request({ origins: uniq });
  } catch {
    // Fallback: try page origin only (narrower permission dialog).
    if (pageUrl) {
      try {
        const p = new URL(pageUrl);
        const narrow = [`${p.origin}/*`];
        if (baseUrl) {
          try {
            narrow.push(`${new URL(api.normalizeBaseUrl(baseUrl)).origin}/*`);
          } catch {
            /* ignore */
          }
        }
        const haveN = await chrome.permissions.contains({ origins: narrow });
        if (haveN) return true;
        return await chrome.permissions.request({ origins: narrow });
      } catch {
        return false;
      }
    }
    return false;
  }
}

/**
 * Whether extension currently has host access for cookies on pageUrl.
 * @param {string} pageUrl
 */
async function hasCookieHostAccess(pageUrl) {
  try {
    const broad = await chrome.permissions.contains({
      origins: ["http://*/*", "https://*/*"],
    });
    if (broad) return true;
    if (!pageUrl) return false;
    const origin = new URL(pageUrl).origin;
    return await chrome.permissions.contains({ origins: [`${origin}/*`] });
  } catch {
    return false;
  }
}

/**
 * Server-side dedupe: same origin + same username + same password already in vault.
 * Uses list + reveal (extension token has view/edit scopes).
 * @param {{ pageUrl: string, username?: string, password?: string }} draft
 * @returns {Promise<null | { suppress: true, reason: string, credentialId: string, accountId?: string, needSessionOnly?: boolean }>}
 */
async function matchVaultSameCredential(draft) {
  const password = String(draft.password || "");
  if (!password) return null;
  const cfg = await storage.loadConfig();
  if (!cfg.connected) return null;
  try {
    await ensureHostPermission(cfg.baseUrl, undefined, { broad: false });
    const listed = await api.listVault(cfg);
    const items =
      listed?.result?.items || listed?.items || listed?.result || [];
    const arr = Array.isArray(items) ? items : [];
    const hit = api.findMatchingCredential(arr, draft.pageUrl, draft.username);
    if (!hit?.id) return null;

    // Prefer matching account slot when multi-account.
    let accountId;
    if (Array.isArray(hit.accounts) && hit.accounts.length) {
      const want = String(draft.username || "")
        .trim()
        .toLowerCase();
      const acc =
        hit.accounts.find((a) => {
          const u = String(a?.username || a?.email || "")
            .trim()
            .toLowerCase();
          return want && u === want;
        }) || hit.accounts[0];
      accountId = acc?.id ? String(acc.id) : undefined;
    }

    const revealed = await api.revealField(cfg, hit.id, {
      field: "password",
      accountId,
    });
    // Response shape: { result: { secret: { state, value } } } or unwrapped.
    const body = revealed?.result || revealed;
    const plain =
      body?.secret?.value ??
      body?.value ??
      body?.password ??
      body?.field?.value ??
      "";
    if (!plain || String(plain) !== password) {
      // Different / missing password for same site/user → still prompt.
      return null;
    }
    const hasSession = Boolean(
      hit.hasLoginSession ||
        (Array.isArray(hit.accounts) &&
          hit.accounts.some((a) => a?.hasLoginSession))
    );
    return {
      suppress: true,
      reason: "vault_same_password",
      credentialId: String(hit.id),
      accountId: accountId || "primary",
      needSessionOnly: !hasSession,
    };
  } catch (e) {
    console.warn("[mnote-vault] vault dedupe failed", e);
    return null;
  }
}

/**
 * Capture cookies for page origin (background only).
 * Prefer domain-wide getAll so path/subdomain session cookies are not missed.
 * Requires host permission for the page origin (see manifest host_permissions).
 * @param {string} pageUrl
 */
async function captureCookies(pageUrl) {
  let origin;
  let hostname = "";
  try {
    const u = new URL(pageUrl);
    origin = u.origin;
    hostname = u.hostname || "";
  } catch {
    origin = undefined;
  }

  /** @type {chrome.cookies.Cookie[]} */
  let list = [];
  try {
    // domain query covers all paths under host; url-only often misses sibling paths.
    if (hostname) {
      list = await chrome.cookies.getAll({ domain: hostname });
      // also include parent-domain cookies (e.g. .heyunidc.cn) when host is www.
      const parts = hostname.split(".").filter(Boolean);
      if (parts.length >= 2) {
        const parent = parts.slice(-2).join(".");
        if (parent && parent !== hostname) {
          const extra = await chrome.cookies.getAll({ domain: parent });
          list = list.concat(extra);
        }
      }
    }
    if ((!list || list.length === 0) && origin) {
      list = await chrome.cookies.getAll({ url: origin + "/" });
    }
    if ((!list || list.length === 0) && pageUrl) {
      list = await chrome.cookies.getAll({ url: pageUrl });
    }
  } catch (e) {
    console.warn("[mnote-vault] cookies.getAll failed", e);
    return {
      cookieHeader: "",
      cookies: [],
      count: 0,
      origin,
      error: e?.message || String(e),
    };
  }

  // de-dupe by name+domain+path
  const seen = new Set();
  const cookies = [];
  const parts = [];
  for (const c of list || []) {
    const key = `${c.name}\0${c.domain}\0${c.path}`;
    if (seen.has(key)) continue;
    seen.add(key);
    let value = c.value || "";
    if (value.length > MAX_COOKIE_VALUE) {
      value = value.slice(0, MAX_COOKIE_VALUE);
    }
    cookies.push({
      name: c.name,
      value,
      domain: c.domain,
      path: c.path,
      secure: c.secure,
      httpOnly: c.httpOnly,
      sameSite: c.sameSite,
      expirationDate: c.expirationDate,
    });
    parts.push(`${c.name}=${value}`);
  }
  return {
    cookieHeader: parts.join("; "),
    cookies,
    count: cookies.length,
    origin,
  };
}

/**
 * @param {string} alarmKey credentialId:accountId (pageUrl in session storage)
 */
async function runSessionRecaptureFromAlarm(alarmKey) {
  const storeKey = `recapture:${alarmKey}`;
  let job = null;
  try {
    if (chrome.storage?.session) {
      const data = await chrome.storage.session.get(storeKey);
      job = data?.[storeKey] || null;
      await chrome.storage.session.remove(storeKey);
    }
  } catch {
    /* ignore */
  }
  if (!job?.credentialId || !job?.pageUrl) return;
  const { credentialId, accountId = "primary", pageUrl } = job;
  const cfg = await storage.loadConfig();
  if (!cfg.connected) return;
  await ensureHostPermission(cfg.baseUrl, pageUrl);
  const cap = await captureCookies(pageUrl);
  if (!cap.cookieHeader && !(cap.cookies && cap.cookies.length)) {
    console.info(
      "[mnote-vault] session recapture: still no cookies",
      credentialId
    );
    return;
  }
  await api.putSession(cfg, credentialId, {
    accountId,
    cookieHeader: cap.cookieHeader,
    cookies: cap.cookies,
    origin: cap.origin,
  });
  console.info("[mnote-vault] session recapture ok", credentialId);
}

/**
 * P1: after save, wait for session cookies then PUT again (alarms survive SW sleep).
 * Note: Chrome may clamp delayInMinutes to ~1 min minimum in practice.
 * @param {object} opts
 * @param {string} opts.credentialId
 * @param {string} opts.accountId
 * @param {string} opts.pageUrl
 * @param {number} [opts.delayMs]
 */
async function scheduleSessionRecapture(opts) {
  const {
    credentialId,
    accountId = "primary",
    pageUrl,
    delayMs = SESSION_RECAPTURE_DELAY_MS,
  } = opts;
  if (!credentialId || !pageUrl) return;
  const alarmKey = `${credentialId}:${accountId}`;
  const storeKey = `recapture:${alarmKey}`;
  try {
    if (chrome.storage?.session) {
      await chrome.storage.session.set({
        [storeKey]: { credentialId, accountId, pageUrl },
      });
    }
  } catch (e) {
    console.warn("[mnote-vault] recapture store failed", e);
  }
  // Prefer short setTimeout while SW is warm; also schedule alarm as backup.
  setTimeout(() => {
    runSessionRecaptureFromAlarm(alarmKey).catch((e) =>
      console.warn("[mnote-vault] session recapture failed", e)
    );
  }, delayMs);
  try {
    const delayInMinutes = Math.max(delayMs / 60000, 0.05);
    chrome.alarms.create(`mnote-vault-recapture:${alarmKey}`, {
      delayInMinutes,
    });
  } catch {
    /* alarms optional */
  }
}

/**
 * @param {object} payload
 * @param {string} payload.pageUrl
 * @param {string} payload.title
 * @param {string} payload.username
 * @param {string} payload.password
 * @param {string} [payload.email]
 * @param {boolean} [payload.saveSession]
 * @param {boolean} [payload.shareToAi]
 * @param {string} [payload.mode] create | append
 * @param {string} [payload.existingId]
 * @param {number} [payload.tabId]
 * @param {boolean} [payload.recaptureSession]
 */
async function saveCredential(payload) {
  const cfg = await storage.loadConfig();
  if (!cfg.connected) {
    throw new Error("未连接密码箱：请先在扩展 Options 用账号密码连接");
  }
  await ensureHostPermission(cfg.baseUrl, payload.pageUrl);

  let credentialId = payload.existingId || null;
  let accountId = "primary";

  if (payload.mode === "append" && payload.existingId) {
    const got = await api.getItem(cfg, payload.existingId);
    const item = got?.result?.item || got?.item || got?.result;
    const accounts = Array.isArray(item?.accounts) ? [...item.accounts] : [];
    const newId = `acc_${Date.now().toString(36)}`;
    accounts.push({
      id: newId,
      label: "from-extension",
      username: payload.username || "",
      password: payload.password || "",
      email: payload.email || undefined,
    });
    await api.updateItem(cfg, payload.existingId, { accounts });
    credentialId = payload.existingId;
    accountId = newId;
  } else {
    const title =
      (payload.title || "").trim() ||
      (() => {
        try {
          return new URL(payload.pageUrl).hostname;
        } catch {
          return "Saved credential";
        }
      })();
    // folderPath：用户显式选择（含空=未分组）优先；否则上次选用
    const folderPath =
      payload.folderPath !== undefined && payload.folderPath !== null
        ? storage.normalizeFolderPath(payload.folderPath)
        : storage.normalizeFolderPath(cfg.lastFolderPath) || "";
    const created = await api.createItem(cfg, {
      title,
      url: payload.pageUrl,
      username: payload.username || "",
      password: payload.password || "",
      email: payload.email || undefined,
      tags: ["from-extension"],
      ...(folderPath ? { folderPath } : {}),
      notesMarkdown: "Saved via MNote Vault extension",
    });
    // 记住本次分组，下次确认层默认选中
    await storage.saveLastFolderPath(folderPath);
    const item = created?.result?.item || created?.item;
    credentialId = item?.id;
    if (!credentialId) {
      throw new Error("创建条目失败：响应无 id");
    }
    // 与服务端账号槽 id 对齐；无 accounts 时仍用 primary 文件名
    const firstAcc = Array.isArray(item?.accounts) && item.accounts[0];
    if (firstAcc && firstAcc.id) {
      accountId = String(firstAcc.id);
    }
  }

  let sessionResult = null;
  let sessionError = null;
  let sessionSaved = false;
  const wantSession = payload.saveSession !== false;
  if (wantSession) {
    try {
      // Prefer host grant granted earlier from content click gesture.
      if (payload.hostPermissionGranted) {
        /* already requested in content */
      } else {
        await ensureHostPermission(cfg.baseUrl, payload.pageUrl, {
          broad: true,
        });
      }
      const hasHost = await hasCookieHostAccess(payload.pageUrl);
      const cap = await captureCookies(payload.pageUrl);
      if (cap.cookieHeader || (cap.cookies && cap.cookies.length)) {
        sessionResult = await api.putSession(cfg, credentialId, {
          accountId,
          cookieHeader: cap.cookieHeader,
          cookies: cap.cookies,
          origin: cap.origin,
        });
        sessionSaved = true;
      } else {
        const detail = cap.error ? `：${cap.error}` : "";
        if (!hasHost) {
          sessionError =
            `未授权读取此站 Cookie${detail}。请在保存前允许「网站访问权限→所有网站」，或点扩展详情手动开启。`;
        } else {
          sessionError =
            `未捕获到 Cookie${detail}（将在数秒后自动重试；登录 Cookie 可能尚未写入）`;
        }
      }
    } catch (e) {
      sessionError = e?.message || String(e);
    }

    // P1: always schedule one delayed recapture when user asked for session.
    if (payload.recaptureSession !== false) {
      await scheduleSessionRecapture({
        credentialId,
        accountId,
        pageUrl: payload.pageUrl,
      });
    }
  }

  let shareResult = null;
  if (payload.shareToAi) {
    try {
      shareResult = await api.shareToAi(cfg, credentialId);
    } catch (e) {
      shareResult = { error: e?.message || String(e) };
    }
  }

  // Remember save for auto-prompt dedupe (same origin+user+password).
  try {
    await storage.rememberSavedSite({
      pageUrl: payload.pageUrl,
      username: payload.username,
      password: payload.password,
      credentialId,
      hasSession: sessionSaved,
    });
  } catch (e) {
    console.warn("[mnote-vault] rememberSavedSite failed", e);
  }

  // Clear pending for this tab after successful save.
  if (payload.tabId != null) {
    await clearPending(payload.tabId);
  }

  return {
    ok: true,
    credentialId,
    accountId,
    sessionSaved,
    sessionResult: sessionResult?.result || sessionResult,
    sessionError,
    shareResult: shareResult?.result || shareResult,
    sessionRecaptureScheduled: wantSession && payload.recaptureSession !== false,
  };
}

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  handleMessage(message, sender)
    .then((result) => sendResponse({ ok: true, result }))
    .catch((err) =>
      sendResponse({
        ok: false,
        error: err?.message || String(err),
        code: err?.code,
      })
    );
  return true; // async
});

/**
 * @param {object} message
 * @param {chrome.runtime.MessageSender} [sender]
 */
async function handleMessage(message, sender) {
  const type = message?.type;
  const senderTabId = sender?.tab?.id;

  switch (type) {
    case "GET_STATUS": {
      const cfg = await storage.loadConfig();
      await storage.setBadge(cfg.connected, cfg.email);
      return {
        connected: cfg.connected,
        baseUrl: cfg.baseUrl,
        rootUri: cfg.rootUri,
        email: cfg.email,
        userId: cfg.userId,
        hasToken: Boolean(cfg.token),
      };
    }
    case "CONNECT": {
      const baseUrl = api.normalizeBaseUrl(message.baseUrl);
      const email = String(message.email || message.account || "").trim();
      const password = String(message.password || "");
      if (!email || !password) {
        throw new Error("需要 MNote 账号与密码");
      }
      const okPerm = await ensureHostPermission(baseUrl);
      if (!okPerm) {
        throw new Error(
          `需要允许扩展访问 ${new URL(baseUrl).origin}（请在 Options 点连接时允许权限弹窗；或 chrome://extensions → 扩展详情 → 网站访问权限）`
        );
      }
      try {
        await api.signIn(baseUrl, { email, password });
      } catch (e) {
        const m = e?.message || String(e);
        if (/Failed to fetch|NetworkError|Load failed/i.test(m)) {
          throw new Error(
            `无法连接 ${baseUrl}：${m}。请确认外网隧道可达，且已允许扩展访问该 origin（含端口）`
          );
        }
        throw e;
      }

      // 默认：用账号固定 my-space；仅当用户显式填了 file:// 才覆盖
      let rootUri = String(message.rootUri || "").trim();
      let rootPath;
      let workspaceSource = "override";
      if (!rootUri || rootUri === "auto") {
        const ws = await api.ensureDefaultWorkspace(baseUrl, {
          credentials: true,
        });
        rootUri = ws.rootUri;
        rootPath = ws.rootPath;
        workspaceSource = "default";
      } else if (!rootUri.startsWith("file://")) {
        throw new Error("rootUri 若填写必须是 file:// 本地工作区路径");
      }

      const issued = await api.issueExtensionToken(baseUrl, {
        email,
        extensionId: chrome.runtime.id,
        ttlHours: message.ttlHours ?? 168,
      });
      const result = issued?.result || issued;
      const token = result?.token;
      if (!token || !String(token).startsWith("mnext1.")) {
        throw new Error("签发 extension token 失败");
      }
      await storage.savePersistent({
        baseUrl,
        rootUri,
        rootPath: rootPath || undefined,
        userId: result.userId || email,
        email: result.email || email,
        connectedAt: new Date().toISOString(),
      });
      await storage.saveSession({
        token,
        tokenExpiresAt: result.expiresAt,
        jti: result.jti,
      });
      await storage.setBadge(true, result.email || email);
      return {
        connected: true,
        userId: result.userId,
        email: result.email || email,
        expiresAt: result.expiresAt,
        rootUri,
        rootPath,
        workspaceSource,
      };
    }
    case "DISCONNECT": {
      await storage.clearSession();
      await storage.setBadge(false);
      return { connected: false };
    }
    case "MATCH_URL": {
      const cfg = await storage.loadConfig();
      if (!cfg.connected) return { connected: false, items: [] };
      await ensureHostPermission(cfg.baseUrl);
      const listed = await api.listVault(cfg);
      const items =
        listed?.result?.items || listed?.items || listed?.result || [];
      const arr = Array.isArray(items) ? items : [];
      return {
        connected: true,
        items: api.matchItemsByUrl(arr, message.pageUrl || "").slice(0, 5),
      };
    }
    case "LIST_FOLDERS": {
      const cfg = await storage.loadConfig();
      if (!cfg.connected) {
        return { connected: false, folders: [], lastFolderPath: "" };
      }
      await ensureHostPermission(cfg.baseUrl);
      const listed = await api.listVault(cfg);
      const items =
        listed?.result?.items || listed?.items || listed?.result || [];
      const arr = Array.isArray(items) ? items : [];
      return {
        connected: true,
        folders: api.collectFolderPaths(arr),
        lastFolderPath: cfg.lastFolderPath || "",
      };
    }
    case "ENSURE_PAGE_HOST": {
      const pageUrl = message.pageUrl || "";
      const cfg = await storage.loadConfig();
      // Prefer broad http(s) so future sites work without another prompt.
      const ok = await ensureHostPermission(cfg.baseUrl, pageUrl, {
        broad: message.broad !== false,
      });
      const hasHost = await hasCookieHostAccess(pageUrl);
      return { ok, pageUrl, hasHost };
    }
    case "DISMISS_SAVE": {
      const pageUrl = message.pageUrl || "";
      const username = message.username || "";
      const forever = Boolean(message.forever);
      await storage.rememberDismissedSite({ pageUrl, username, forever });
      const tabId = message.tabId ?? senderTabId;
      if (tabId != null) await clearPending(tabId);
      return { ok: true, forever };
    }
    case "CHECK_DEDUPE": {
      return storage.shouldSuppressPrompt({
        pageUrl: message.pageUrl || "",
        username: message.username || "",
        password: message.password || "",
      });
    }
    case "PENDING_SAVE": {
      const tabId = message.tabId ?? senderTabId;
      if (tabId == null) throw new Error("PENDING_SAVE 需要 tabId");
      const draft = buildPendingDraft(tabId, {
        username: message.username ?? message.payload?.username,
        password: message.password ?? message.payload?.password,
        email: message.email ?? message.payload?.email,
        pageUrl: message.pageUrl ?? message.payload?.pageUrl,
        title: message.title ?? message.payload?.title,
        fromSubmit: message.fromSubmit !== false,
      });
      if (!draft.password) {
        throw new Error("PENDING_SAVE 需要 password");
      }
      await setPending(tabId, draft, {
        spaFallback: message.spaFallback !== false,
      });
      return {
        ok: true,
        tabId,
        expiresAt: draft.expiresAt,
        hostname: draft.hostname,
      };
    }
    case "GET_PENDING": {
      const tabId = message.tabId ?? senderTabId;
      if (tabId == null) return { pending: null };
      const draft = pendingByTab.get(tabId);
      if (!draft || isExpired(draft)) {
        if (draft) await clearPending(tabId);
        return { pending: null };
      }
      return {
        pending: {
          username: draft.username,
          password: draft.password,
          email: draft.email || "",
          pageUrl: draft.pageUrl,
          title: draft.title,
          hostname: draft.hostname,
          expiresAt: draft.expiresAt,
          redirectCount: draft.redirectCount,
          prompted: Boolean(draft.prompted),
        },
      };
    }
    case "CLEAR_PENDING": {
      const tabId = message.tabId ?? senderTabId;
      if (tabId != null) await clearPending(tabId);
      return { cleared: true };
    }
    case "MARK_PENDING_PROMPTED": {
      const tabId = message.tabId ?? senderTabId;
      if (tabId == null) return { marked: false };
      const marked = await markPendingPrompted(
        tabId,
        message.promptedUrl || sender?.tab?.url || message.pageUrl
      );
      return { marked };
    }
    case "PROMPT_PENDING": {
      // Force-open confirm from popup / toolbar using pending or empty draft.
      const tabId = message.tabId ?? senderTabId;
      if (tabId == null) throw new Error("需要 tabId");
      let draft = pendingByTab.get(tabId);
      if (draft && isExpired(draft)) {
        await clearPending(tabId);
        draft = undefined;
      }
      if (draft) {
        return openSaveUiOnTab(tabId, draft, {
          reason: "manual_prompt",
          force: true,
        });
      }
      // No pending: ask content to open UI from live form / empty.
      try {
        await chrome.tabs.sendMessage(tabId, { type: "OPEN_SAVE_UI" });
        return { ok: true, reason: "live_form" };
      } catch (e) {
        throw new Error(
          e?.message ||
            "无法打开确认层（受保护页面或 content script 未加载）"
        );
      }
    }
    case "SAVE_CREDENTIAL": {
      const payload = { ...(message.payload || message) };
      if (payload.tabId == null && senderTabId != null) {
        payload.tabId = senderTabId;
      }
      return saveCredential(payload);
    }
    case "UPDATE_SESSION": {
      const cfg = await storage.loadConfig();
      if (!cfg.connected) throw new Error("未连接");
      const pageUrl = message.pageUrl;
      const id = message.credentialId || message.id;
      if (!id || !pageUrl) throw new Error("需要 credentialId 与 pageUrl");
      await ensureHostPermission(cfg.baseUrl, pageUrl);
      const cap = await captureCookies(pageUrl);
      if (!cap.cookieHeader && !(cap.cookies && cap.cookies.length)) {
        throw new Error("未捕获到 Cookie");
      }
      const res = await api.putSession(cfg, id, {
        accountId: message.accountId || "primary",
        cookieHeader: cap.cookieHeader,
        cookies: cap.cookies,
        origin: cap.origin,
      });
      return res?.result || res;
    }
    case "CAPTURE_COOKIE_COUNT": {
      const pageUrl = message.pageUrl;
      if (!pageUrl) return { count: 0 };
      await ensureHostPermission("", pageUrl);
      const cap = await captureCookies(pageUrl);
      return { count: cap.count, origin: cap.origin, error: cap.error || null };
    }
    default:
      throw new Error(`未知消息类型: ${type}`);
  }
}