From e7bccde1c908da6d6bd21c3d0b21667b3f7e386f Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:23:28 +0200 Subject: [PATCH 1/7] feat(passwords): Zen-native saved-password importer + source data paths Add ZenPasswordImporter, which briefly launches Zen headless with Marionette and runs Zen's own ChromeProfileMigrator restricted to passwords, pointed at the Chromium source's User Data. Zen decrypts each login through the OS keystore and re-encrypts it with the target profile's NSS key, so no password plaintext passes through browser2zen and nothing reverse-engineers Zen's credential crypto. Add login_data_paths()/user_data_root() to the extractor contract (empty for non-Chromium sources) and env_check.zen_binary_path() to locate the Zen executable the importer drives. --- app/env_check.py | 35 ++++ src/extractors/base.py | 11 ++ src/extractors/chromium.py | 11 ++ src/zen_password_importer.py | 356 +++++++++++++++++++++++++++++++++++ 4 files changed, 413 insertions(+) create mode 100644 src/zen_password_importer.py diff --git a/app/env_check.py b/app/env_check.py index 25b4e13..5823079 100644 --- a/app/env_check.py +++ b/app/env_check.py @@ -266,6 +266,41 @@ def is_zen_running() -> bool: return False +# ---------- zen binary ---------- + + +def zen_binary_path() -> Path | None: + """The Zen executable this machine would launch, or ``None``. + + The password step drives Zen's own importer, so it needs the binary + rather than the profile. Mirrors the running-process path lists so the + two can never disagree about where Zen lives. + """ + if sys.platform == "darwin": + for p in _ZEN_PROCESS_PATHS: + if Path(p).is_file(): + return Path(p) + return None + if os.name == "nt": + home = Path.home() + candidates: list[Path] = [] + for prof in list_zen_profiles(): + root = prof.path.parent.parent + candidates += [root / "zen.exe", root / "zen-bin.exe"] + candidates += [ + home / "AppData/Local/zen/zen.exe", + Path("C:/Program Files/Zen Browser/zen.exe"), + Path("C:/Program Files (x86)/Zen Browser/zen.exe"), + ] + return next((c for c in candidates if c.is_file()), None) + for rel in ("zen/zen", "zen-bin"): + cand = Path("/usr/lib") / rel + if cand.is_file(): + return cand + found = shutil.which("zen") + return Path(found) if found else None + + # ---------- previous migration marker ---------- diff --git a/src/extractors/base.py b/src/extractors/base.py index 968a935..8834146 100644 --- a/src/extractors/base.py +++ b/src/extractors/base.py @@ -315,6 +315,17 @@ def local_state_paths(self) -> list[Path]: on Windows). Empty for Firefox/Safari and unused on macOS.""" return [] + def login_data_paths(self) -> list[Path]: + """Chromium ``Login Data`` SQLite files, one per source profile. + Empty for sources whose passwords Zen cannot import directly.""" + return [] + + def user_data_root(self) -> Path | None: + """The Chromium ``User Data`` root that holds the profile folders. + ``None`` for non-Chromium sources. Zen's own password importer reads + saved logins from here per profile.""" + return None + # ---- cookie decryption ---- def cookie_master_key(self) -> bytes: diff --git a/src/extractors/chromium.py b/src/extractors/chromium.py index 0852f34..b3c1f79 100644 --- a/src/extractors/chromium.py +++ b/src/extractors/chromium.py @@ -307,6 +307,17 @@ def local_state_paths(self) -> list[Path]: return [] return [root / "Local State"] if (root / "Local State").is_file() else [] + def login_data_paths(self) -> list[Path]: + out: list[Path] = [] + for prof in self.profile_paths(): + cand = prof / "Login Data" + if cand.is_file(): + out.append(cand) + return out + + def user_data_root(self) -> Path | None: + return self._user_data_dir() + # ---------- cookie key ---------- def cookie_master_key(self) -> bytes: diff --git a/src/zen_password_importer.py b/src/zen_password_importer.py new file mode 100644 index 0000000..60532d3 --- /dev/null +++ b/src/zen_password_importer.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +""" +Chromium → Zen saved-password importer. + +Zen stores passwords encrypted with its own NSS key (``key4.db``), so the +only robust way to add logins is to let Zen encrypt them. This importer +briefly launches Zen headless with Marionette and runs Zen's built-in +``ChromeProfileMigrator`` pointed at the source browser's ``User Data`` +directory, restricted to passwords. Zen reads the source ``Login Data``, +decrypts each entry through the OS keystore (macOS Keychain / +Windows DPAPI), and writes it back encrypted with the target profile's +key. No password plaintext ever passes through this process, and nothing +here reverse-engineers Zen's credential crypto. + +The step is skipped cleanly for non-Chromium sources (``user_data_root`` +is ``None``) and refuses to run while Zen is open, since Zen must own the +login store during the write. + +Backups of ``logins.json``, ``logins-backup.json`` and ``key4.db`` are +written beside the profile before anything changes, unless ``dry_run``. +""" + +from __future__ import annotations + +import json +import logging +import os +import shutil +import socket +import subprocess +import sys +import time +from datetime import datetime +from pathlib import Path + +logger = logging.getLogger(__name__) + + +# Resource-type bit for passwords in Zen's MigrationUtils. Stable across +# Firefox/Zen releases; asserted in-browser below so a change surfaces +# loudly rather than silently importing the wrong data. +_PASSWORDS_RESOURCE_TYPE = 0x10 + +# Launch env that lets Marionette reach Zen's privileged chrome context. +_SYSTEM_ACCESS_ENV = "MOZ_REMOTE_ALLOW_SYSTEM_ACCESS" + +_LAUNCH_TIMEOUT_S = 90.0 +_QUIT_TIMEOUT_S = 30.0 + + +# The chrome-context script Zen runs. It receives the plan as JSON and +# returns only counts, never a username or password. ``ChromeProfileMigrator`` +# does the decrypt/encrypt internally. +_IMPORT_JS = r""" +const done = arguments[arguments.length - 1]; +const plan = JSON.parse(arguments[0]); +(async () => { + const { ChromeProfileMigrator } = ChromeUtils.importESModule( + "resource:///modules/ChromeProfileMigrator.sys.mjs"); + const { MigrationUtils } = ChromeUtils.importESModule( + "resource:///modules/MigrationUtils.sys.mjs"); + + const PASSWORDS = MigrationUtils.resourceTypes.PASSWORDS; + if (PASSWORDS !== plan.passwordsType) { + return { fatal: "passwords resource type changed: " + PASSWORDS }; + } + + const m = new ChromeProfileMigrator(); + m._chromeUserDataPath = plan.userData; + m._keychainServiceName = plan.keychainService; + m._keychainAccountName = plan.keychainAccount; + + const before = (await Services.logins.getAllLogins()).length; + const sourceProfiles = await m.getSourceProfiles(); + const byId = new Map(sourceProfiles.map(p => [p.id, p])); + const report = { before, perProfile: {}, missing: [] }; + + for (const id of plan.profileIds) { + const profile = byId.get(id); + if (!profile) { report.missing.push(id); continue; } + const countBefore = (await Services.logins.getAllLogins()).length; + try { + await m.migrate(PASSWORDS, false, profile); + } catch (e) { + report.perProfile[id] = { error: String(e) }; + continue; + } + const countAfter = (await Services.logins.getAllLogins()).length; + report.perProfile[id] = { added: countAfter - countBefore }; + } + + report.after = (await Services.logins.getAllLogins()).length; + report.imported = report.after - before; + return report; +})().then(done, e => done({ fatal: String(e), stack: e && e.stack })); +""" + + +class ZenPasswordImporter: + """Import Chromium-format saved passwords into a Zen profile.""" + + def __init__( + self, + zen_profile: Path, + zen_binary: Path, + source_user_data: Path, + profile_ids: list[str], + *, + keychain_service: str = "Arc Safe Storage", + keychain_account: str = "Arc", + dry_run: bool = False, + ): + self.zen_profile = Path(zen_profile) + self.zen_binary = Path(zen_binary) + self.source_user_data = Path(source_user_data) + self.profile_ids = list(profile_ids) + self.keychain_service = keychain_service + self.keychain_account = keychain_account + self.dry_run = dry_run + + # ---- guards ---- + + def _zen_is_running_on_profile(self) -> bool: + lock = self.zen_profile / ".parentlock" + if not lock.exists(): + return False + if os.name == "nt": + # Windows holds the file open exclusively while Zen runs, so a + # rename to itself fails only then. + try: + lock.rename(lock) + return False + except OSError: + return True + import fcntl + + try: + fd = os.open(lock, os.O_RDWR) + except OSError: + return False + try: + fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + fcntl.lockf(fd, fcntl.LOCK_UN) + return False + except OSError: + return True + finally: + os.close(fd) + + # ---- backups ---- + + def _backup(self) -> Path | None: + stamp = datetime.now().strftime("%Y%m%d-%H%M%S") + dest = self.zen_profile / f"browser2zen-passwords-backup-{stamp}" + made = False + for name in ("logins.json", "logins-backup.json", "key4.db"): + src = self.zen_profile / name + if src.is_file(): + dest.mkdir(exist_ok=True) + shutil.copy2(src, dest / name) + made = True + return dest if made else None + + def _count_existing_logins(self) -> int: + store = self.zen_profile / "logins.json" + if not store.is_file(): + return 0 + try: + return len(json.loads(store.read_text(encoding="utf-8")).get("logins", [])) + except Exception: + return 0 + + # ---- marionette ---- + + @staticmethod + def _free_port() -> int: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.bind(("127.0.0.1", 0)) + return s.getsockname()[1] + + def _run_in_zen(self, plan: dict, port: int) -> dict: + deadline = time.time() + _LAUNCH_TIMEOUT_S + sock: socket.socket | None = None + while sock is None: + try: + sock = socket.create_connection(("127.0.0.1", port)) + except OSError: + if time.time() > deadline: + raise TimeoutError("Zen Marionette did not accept a connection") + time.sleep(0.5) + try: + sock.settimeout(_LAUNCH_TIMEOUT_S) + self._recv(sock) # server "hello" + self._cmd(sock, "WebDriver:NewSession", + {"capabilities": {"alwaysMatch": {"timeouts": {"script": 300000}}}}) + self._cmd(sock, "Marionette:SetContext", {"value": "chrome"}) + res = self._cmd(sock, "WebDriver:ExecuteAsyncScript", + {"script": _IMPORT_JS, "args": [json.dumps(plan)]}) + report = res.get("value", res) if isinstance(res, dict) else res + try: + self._cmd(sock, "Marionette:Quit", {"flags": ["eAttemptQuit"]}) + except Exception: + pass + return report + finally: + sock.close() + + _msg_id = 0 + + def _cmd(self, sock: socket.socket, name: str, params: dict) -> dict: + self._msg_id += 1 + body = json.dumps([0, self._msg_id, name, params]).encode() + sock.sendall(str(len(body)).encode() + b":" + body) + _, _, err, res = self._recv(sock) + if err: + raise RuntimeError(f"{name}: {err}") + return res + + @staticmethod + def _recv(sock: socket.socket) -> list: + buf = b"" + while b":" not in buf: + chunk = sock.recv(1) + if not chunk: + raise ConnectionError("Marionette closed the connection") + buf += chunk + length_str, rest = buf.split(b":", 1) + length = int(length_str) + while len(rest) < length: + chunk = sock.recv(length - len(rest)) + if not chunk: + raise ConnectionError("Marionette closed the connection") + rest += chunk + return json.loads(rest) + + # ---- temp prefs ---- + + def _apply_temp_prefs(self, port: int) -> str | None: + """Write Marionette prefs into ``user.js``; return prior contents.""" + user_js = self.zen_profile / "user.js" + prior = user_js.read_text(encoding="utf-8") if user_js.is_file() else None + lines = (prior or "") + lines += ( + '\nuser_pref("remote.prefs.recommended", false);' + f'\nuser_pref("marionette.port", {port});\n' + ) + user_js.write_text(lines, encoding="utf-8") + return prior + + def _restore_prefs(self, prior: str | None) -> None: + user_js = self.zen_profile / "user.js" + if prior is None: + user_js.unlink(missing_ok=True) + else: + user_js.write_text(prior, encoding="utf-8") + # Zen copies user.js values into prefs.js on launch, so strip the two + # we injected or they persist after the run. + prefs = self.zen_profile / "prefs.js" + if prefs.is_file(): + kept = [ + ln for ln in prefs.read_text(encoding="utf-8").splitlines(keepends=True) + if '"marionette.port"' not in ln + and '"remote.prefs.recommended"' not in ln + ] + prefs.write_text("".join(kept), encoding="utf-8") + + # ---- orchestration ---- + + def import_passwords(self) -> dict: + result: dict = {"imported": 0, "profiles": {}} + + if sys.platform not in ("darwin", "win32") and os.name != "nt": + result["error"] = "passwords_unsupported_platform" + return result + if not self.profile_ids or not self.source_user_data.is_dir(): + result["error"] = "no_source_passwords" + return result + if not self.zen_binary.is_file(): + result["error"] = "zen_binary_missing" + return result + if not (self.zen_profile / "key4.db").is_file(): + # Fresh profile that Zen has never launched has no login key yet. + result["error"] = "zen_login_store_missing" + return result + if self._zen_is_running_on_profile(): + result["error"] = "zen_running" + return result + + existing = self._count_existing_logins() + if self.dry_run: + result["would_import_from"] = list(self.profile_ids) + result["existing_logins"] = existing + return result + + result["backup"] = str(self._backup() or "") + + plan = { + "userData": str(self.source_user_data), + "profileIds": self.profile_ids, + "keychainService": self.keychain_service, + "keychainAccount": self.keychain_account, + "passwordsType": _PASSWORDS_RESOURCE_TYPE, + } + port = self._free_port() + prior_prefs = self._apply_temp_prefs(port) + proc: subprocess.Popen | None = None + try: + env = dict(os.environ, **{_SYSTEM_ACCESS_ENV: "1"}) + proc = subprocess.Popen( + [str(self.zen_binary), "--marionette", "--headless", + "-no-remote", "-profile", str(self.zen_profile)], + env=env, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + report = self._run_in_zen(plan, port) + self._wait_for_exit(proc) + except Exception as exc: + logger.error("Password import failed: %s", exc) + result["error"] = "password_import_failed" + if proc is not None: + self._terminate(proc) + return result + finally: + self._restore_prefs(prior_prefs) + + if isinstance(report, dict) and report.get("fatal"): + logger.error("Zen password import error: %s", report.get("fatal")) + result["error"] = "password_import_failed" + return result + + per = (report or {}).get("perProfile", {}) if isinstance(report, dict) else {} + result["profiles"] = {pid: v.get("added", 0) for pid, v in per.items()} + result["imported"] = int(report.get("imported", 0)) if isinstance(report, dict) else 0 + if result["imported"] == 0 and existing == (report or {}).get("after", existing): + # Nothing landed although a source was selected; most often the + # Keychain/DPAPI prompt was declined. + result["warning"] = "no_passwords_imported" + return result + + def _wait_for_exit(self, proc: subprocess.Popen) -> None: + try: + proc.wait(timeout=_QUIT_TIMEOUT_S) + except subprocess.TimeoutExpired: + self._terminate(proc) + + @staticmethod + def _terminate(proc: subprocess.Popen) -> None: + try: + proc.terminate() + proc.wait(timeout=10) + except Exception: + try: + proc.kill() + except Exception: + pass From ad70b52f2fd8467d4a9b707e50a920504548409d Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:23:33 +0200 Subject: [PATCH 2/7] feat(passwords): wire the passwords step through orchestrator and UI Add include_passwords to MigrationOptions, a passwords step after cookies, a preview estimate counting usable source logins, and the passwordsEstimate field. The step skips cleanly for non-Chromium sources and surfaces clean messages for a closed-store, running-Zen, or missing-binary case. The Preview screen shows a Saved passwords toggle only when the source has logins, noting that Zen opens briefly. --- app/bridge.py | 1 + app/frontend/app.js | 18 +++++++++ app/orchestrator.py | 96 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 114 insertions(+), 1 deletion(-) diff --git a/app/bridge.py b/app/bridge.py index 265c141..eb874cb 100644 --- a/app/bridge.py +++ b/app/bridge.py @@ -627,4 +627,5 @@ def _parse_options(opts_json: str) -> MigrationOptions: include_open_tabs=bool(data.get("includeOpenTabs", False)), include_history=bool(data.get("includeHistory", False)), include_cookies=bool(data.get("includeCookies", False)), + include_passwords=bool(data.get("includePasswords", False)), ) diff --git a/app/frontend/app.js b/app/frontend/app.js index eb422d1..c7b7004 100644 --- a/app/frontend/app.js +++ b/app/frontend/app.js @@ -67,6 +67,7 @@ const state = { includeOpenTabs: true, includeHistory: false, includeCookies: false, + includePasswords: false, excludedSpaces: [], }, steps: [], @@ -484,6 +485,10 @@ function renderPreview(p) { `Copy ~${formatRows(p.historyRowsEstimate)} history rows`)); toggles.appendChild(makeToggle("includeCookies", "Cookies & login state", `Copy ~${formatRows(p.cookiesEstimate)} cookies (Keychain prompt)`)); + if (p.passwordsEstimate > 0) { + toggles.appendChild(makeToggle("includePasswords", "Saved passwords", + `Import ~${formatRows(p.passwordsEstimate)} logins (Zen opens briefly, Keychain prompt)`)); + } toggles.appendChild(makeToggle("foldersCollapsed", "Collapse folders", "Imported folders start collapsed")); } @@ -626,6 +631,11 @@ const STEP_ICON_BUILDERS = { svgChild(s, "path", {d: "M14 9 L14 12", "stroke-linecap": "round"}); svgChild(s, "path", {d: "M16 9 L16 11.5", "stroke-linecap": "round"}); }, + passwords: (s) => { + svgChild(s, "circle", {cx: 6, cy: 9, r: 3.5}); + svgChild(s, "path", {d: "M9 9 L16 9 L16 12", "stroke-linecap": "round"}); + svgChild(s, "path", {d: "M13 9 L13 11.5", "stroke-linecap": "round"}); + }, finalize: (s) => svgChild(s, "path", {d: "M3 9 L7.5 13 L15 5", "stroke-width": 2, "stroke-linecap": "round", "stroke-linejoin": "round"}), }; @@ -669,6 +679,8 @@ function stepSubtitle(step) { return "Copying browsing history into places.sqlite"; case "cookies": return `Decrypting ${src} cookies and writing to cookies.sqlite`; + case "passwords": + return `Opening Zen to import ${src} saved passwords`; case "finalize": return "Marking migration complete"; default: @@ -812,6 +824,7 @@ function visibleSteps() { return state.steps.filter(s => { if (s === "history") return state.options.includeHistory; if (s === "cookies") return state.options.includeCookies; + if (s === "passwords") return state.options.includePasswords; if (s === "containers" || s === "sessions") return state.options.includeWorkspaces || state.options.includePinnedTabs; if (s === "bookmarks") return state.options.includeBookmarks; if (s === "favicons") return state.options.includeFavicons; @@ -883,6 +896,10 @@ function stepSummaryText(step, s) { } if (step === "history") return `${formatRows(s.places_added ?? 0)} places · ${formatRows(s.visits_added ?? 0)} visits`; if (step === "cookies") return `${formatRows(s.imported ?? 0)} imported · ${formatRows(s.merged ?? 0)} merged`; + if (step === "passwords") { + if (s.skipped) return "skipped"; + return `${formatRows(s.imported ?? 0)} passwords imported`; + } if (step === "sessions") { if (s.pinned == null && s.open == null) return s.ok ? "ok" : ""; const parts = []; @@ -1121,6 +1138,7 @@ function currentOptionsJson() { includeOpenTabs: state.options.includeOpenTabs, includeHistory: state.options.includeHistory, includeCookies: state.options.includeCookies, + includePasswords: state.options.includePasswords, }); } diff --git a/app/orchestrator.py b/app/orchestrator.py index 118da1e..b7b2587 100644 --- a/app/orchestrator.py +++ b/app/orchestrator.py @@ -37,6 +37,7 @@ from extractors import ArcExtractor, BrowserExtractor # noqa: E402 from zen_bookmark_importer import ZenBookmarkImporter # noqa: E402 from zen_favicon_importer import FaviconImporter, _iter_pinned_urls # noqa: E402 +from zen_password_importer import ZenPasswordImporter # noqa: E402 from zen_sessions_importer import ZenSessionsImporter # noqa: E402 from zen_space_importer import ZenProfile as _SrcZenProfile from zen_space_importer import ZenSpaceImporter # noqa: E402 @@ -73,6 +74,7 @@ class PreviewReport: favicon_match_estimate: int # how many URLs Arc has cached icons for history_rows_estimate: int cookies_estimate: int + passwords_estimate: int @dataclass @@ -88,6 +90,7 @@ class MigrationOptions: include_open_tabs: bool = True include_history: bool = False include_cookies: bool = False + include_passwords: bool = False # ----------- step ordering used in the GUI's progress list (left to right) --- @@ -100,6 +103,7 @@ class MigrationOptions: "favicons", "history", "cookies", + "passwords", "finalize", ) @@ -113,6 +117,7 @@ class MigrationOptions: "favicons": "Importing favicons", "history": "Importing browsing history", "cookies": "Importing cookies", + "passwords": "Importing saved passwords", "finalize": "Finalizing", } @@ -164,6 +169,28 @@ def _step_label(step: str, source_display: str) -> str: } +# Passwords ride Zen's own importer, so its failure modes differ from +# cookies. ``{source}`` is filled with the active source display name. +_PASSWORD_ERROR_MESSAGES = { + "no_source_passwords": + "{source} has no saved passwords to import.", + "passwords_unsupported_platform": + "Password import only supports macOS and Windows.", + "passwords_source_unsupported": + "Saved-password import is only available for Chromium sources " + "(Arc, Dia, Chrome, Edge, Brave).", + "zen_binary_missing": + "The Zen application could not be found to run its password importer.", + "zen_login_store_missing": + "Launch Zen once so it creates its password store, then click Recheck.", + "zen_running": + "Close Zen before importing passwords; Zen must own its login store " + "during the write.", + "password_import_failed": + "Zen's password importer did not finish; passwords skipped.", +} + + # ------------------------------------------------------------------ orchestrator class MigrationOrchestrator: @@ -234,6 +261,7 @@ def preview(self, opts: MigrationOptions) -> PreviewReport: favicon_match_estimate = self._estimate_favicons(all_urls) history_rows_estimate = self._estimate_history_rows() cookies_estimate = self._estimate_cookies() + passwords_estimate = self._estimate_passwords() return PreviewReport( spaces=space_summaries, @@ -244,6 +272,7 @@ def preview(self, opts: MigrationOptions) -> PreviewReport: favicon_match_estimate=favicon_match_estimate, history_rows_estimate=history_rows_estimate, cookies_estimate=cookies_estimate, + passwords_estimate=passwords_estimate, ) def _estimate_favicons(self, urls: list[str]) -> int: @@ -298,6 +327,24 @@ def _estimate_cookies(self) -> int: except Exception: return 0 + def _estimate_passwords(self) -> int: + try: + import sqlite3 + total = 0 + for db in self.source.login_data_paths(): + try: + conn = sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=2.0) + n = conn.execute( + "SELECT COUNT(*) FROM logins WHERE blacklisted_by_user = 0" + ).fetchone()[0] + conn.close() + total += int(n or 0) + except Exception: + continue + return total + except Exception: + return 0 + # ---- migration ------------------------------------------------------ def migrate(self, opts: MigrationOptions) -> Iterator[ProgressEvent]: @@ -535,7 +582,29 @@ def _run(self, opts: MigrationOptions) -> Iterator[ProgressEvent]: self._error_step("cookies", exc) yield from self._drain_yield() - # 9: finalize ---------------------------------------------------- + # 9: passwords --------------------------------------------------- + if opts.include_passwords: + self._start_step("passwords") + try: + summary = self._import_passwords(zen_profile) + err = summary.get("error") + if err: + msg = _PASSWORD_ERROR_MESSAGES.get( + err, f"Password import failed: {err}" + ).format(source=self.source.display_name) + # A source with no passwords, or a non-Chromium source, + # is a clean skip rather than a migration failure. + if err in ("no_source_passwords", "passwords_source_unsupported"): + self._done_step("passwords", summary={"imported": 0, "skipped": msg}) + else: + self._error_step("passwords", RuntimeError(msg)) + else: + self._done_step("passwords", summary=summary) + except Exception as exc: + self._error_step("passwords", exc) + yield from self._drain_yield() + + # 10: finalize --------------------------------------------------- self._start_step("finalize") try: (zen_profile / ".browser2zen-migrated").write_text( @@ -546,6 +615,30 @@ def _run(self, opts: MigrationOptions) -> Iterator[ProgressEvent]: self._done_step("finalize", message="Migration complete") yield from self._drain_yield() + def _import_passwords(self, zen_profile: Path) -> dict: + user_data = self.source.user_data_root() + login_dbs = self.source.login_data_paths() + if user_data is None or not login_dbs: + # Firefox/Safari have no Chromium login store Zen can read. + code = ("no_source_passwords" if user_data is not None + else "passwords_source_unsupported") + return {"error": code} + + from env_check import zen_binary_path + zen_binary = zen_binary_path() + if zen_binary is None: + return {"error": "zen_binary_missing"} + + importer = ZenPasswordImporter( + zen_profile=zen_profile, + zen_binary=zen_binary, + source_user_data=user_data, + profile_ids=[db.parent.name for db in login_dbs], + keychain_service=getattr(self.source, "keychain_service", "Arc Safe Storage"), + keychain_account=getattr(self.source, "keychain_account", "Arc"), + ) + return importer.import_passwords() + def _drain_yield(self) -> Iterator[ProgressEvent]: yield from self.bus.drain() @@ -585,4 +678,5 @@ def preview_to_dict(report: PreviewReport) -> dict: "faviconMatchEstimate": report.favicon_match_estimate, "historyRowsEstimate": report.history_rows_estimate, "cookiesEstimate": report.cookies_estimate, + "passwordsEstimate": report.passwords_estimate, } From 4839291abbb47511a3a579356865ee06a98aaf30 Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:23:37 +0200 Subject: [PATCH 3/7] test+docs(passwords): guards, estimate, data paths, and the migration table Cover login_data_paths/user_data_root, the preview estimate, the importer guards (dry-run, no source logins, missing binary, missing login store, running-Zen lock detection), temp-pref apply/restore, backups, and the non-Chromium skip. Document the step in the README migration table and the CLAUDE.md writer map. --- CLAUDE.md | 12 +- README.md | 1 + tests/test_password_importer.py | 239 ++++++++++++++++++++++++++++++++ 3 files changed, 251 insertions(+), 1 deletion(-) create mode 100644 tests/test_password_importer.py diff --git a/CLAUDE.md b/CLAUDE.md index bb62e43..f80bd80 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -35,9 +35,19 @@ BrowserExtractor.extract() → ExportData → to_legacy_dict() ├─── ZenBookmarkImporter → places.sqlite (moz_bookmarks) ├─── FaviconImporter → favicons.sqlite + inline data URIs ├─── HistoryImporter → places.sqlite (moz_places, moz_historyvisits) - └─── CookiesImporter → cookies.sqlite (incl. per-container dupes) + ├─── CookiesImporter → cookies.sqlite (incl. per-container dupes) + └─── ZenPasswordImporter → logins.json + key4.db (via Zen's own importer) ``` +The password step is the one writer that does not hand-write a Zen file. +Zen encrypts logins with its NSS key, so `ZenPasswordImporter` briefly +launches Zen headless with Marionette and drives Zen's built-in +`ChromeProfileMigrator`, restricted to passwords, against the Chromium +source's `User Data`. No password plaintext passes through browser2zen, +and nothing reverse-engineers Zen's credential crypto. It runs only for +Chromium sources and refuses while Zen is open, since Zen must own the +login store during the write. + ### Source extractors (`src/extractors/`) | File | Source | Notes | diff --git a/README.md b/README.md index b1cc61a..8b00d6f 100644 --- a/README.md +++ b/README.md @@ -134,6 +134,7 @@ your profile, then click **Recheck** in browser2zen and continue. | **Favicons** | The source's cached icons are inlined so tabs show their icons immediately, with no waiting for refetch. | | **History** | Optional. Browsing history with original timestamps is copied over. | | **Login state** | Optional. Chromium-format cookies are decrypted (via macOS Keychain or Windows DPAPI, depending on platform) and re-encrypted into Zen so you stay logged in to Gmail, Twitter, and the rest. | +| **Saved passwords** | Optional, Chromium sources only. Zen opens for a few seconds and imports your saved logins through its own importer, so each password is re-encrypted with Zen's key. macOS asks once to let Zen read the source's Keychain entry. | Every step writes a timestamped backup beside your Zen profile before it changes anything, and source-browser data is read-only. The Backups screen diff --git a/tests/test_password_importer.py b/tests/test_password_importer.py new file mode 100644 index 0000000..4aee0fc --- /dev/null +++ b/tests/test_password_importer.py @@ -0,0 +1,239 @@ +"""Tests for the saved-password migration path. + +These never launch Zen. They cover the extractor data source, the +preview estimate, the importer's guards and backups, and the +non-Chromium skip. The actual in-browser import is exercised manually +against a throwaway profile, since it needs a real Zen binary. +""" + +from __future__ import annotations + +import sqlite3 +import subprocess +import sys +import textwrap +import time +from pathlib import Path + +import pytest + + +def _make_login_data(path: Path, *, usable: int, blacklisted: int = 0) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + conn = sqlite3.connect(path) + conn.execute( + "CREATE TABLE logins (origin_url TEXT, username_value TEXT, " + "password_value BLOB, blacklisted_by_user INTEGER)" + ) + rows = [("https://a.test", "u", b"x", 0)] * usable + rows += [("https://b.test", "", b"", 1)] * blacklisted + conn.executemany("INSERT INTO logins VALUES (?,?,?,?)", rows) + conn.commit() + conn.close() + + +# ---- extractor data source ---- + +def test_chromium_login_data_and_root(chrome_home): + from extractors import ChromeExtractor + + ext = ChromeExtractor() + root = ext.user_data_root() + assert root is not None + profile = ext.profile_paths()[0] + _make_login_data(profile / "Login Data", usable=3) + + login_dbs = ext.login_data_paths() + assert login_dbs == [profile / "Login Data"] + assert login_dbs[0].parent.name == profile.name + + +def test_non_chromium_has_no_login_store(firefox_home): + from extractors import FirefoxExtractor, SafariExtractor + + for cls in (FirefoxExtractor, SafariExtractor): + assert cls().user_data_root() is None + assert cls().login_data_paths() == [] + + +def test_preview_estimate_counts_usable_logins(chrome_home, zen_profile): + from app.orchestrator import MigrationOptions, MigrationOrchestrator + from extractors import ChromeExtractor + + profile = ChromeExtractor().profile_paths()[0] + _make_login_data(profile / "Login Data", usable=5, blacklisted=2) + + o = MigrationOrchestrator(source=ChromeExtractor()) + preview = o.preview(MigrationOptions(zen_profile_path=zen_profile)) + assert preview.passwords_estimate == 5 + + +# ---- importer guards ---- + +def _importer(zen_profile: Path, source_user_data: Path, **kw): + from zen_password_importer import ZenPasswordImporter + + defaults = dict( + zen_profile=zen_profile, + zen_binary=Path(sys.executable), + source_user_data=source_user_data, + profile_ids=["Default"], + ) + defaults.update(kw) + return ZenPasswordImporter(**defaults) + + +def test_dry_run_reports_plan_without_launching(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "key4.db").write_bytes(b"x") + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + + res = _importer(zen, src, dry_run=True).import_passwords() + assert res["would_import_from"] == ["Default"] + assert "imported" in res and res["imported"] == 0 + + +def test_guard_no_source_passwords(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "key4.db").write_bytes(b"x") + src = tmp_path / "User Data" + src.mkdir() + res = _importer(zen, src, profile_ids=[]).import_passwords() + assert res["error"] == "no_source_passwords" + + +def test_guard_zen_binary_missing(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "key4.db").write_bytes(b"x") + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + res = _importer(zen, src, zen_binary=tmp_path / "nope").import_passwords() + assert res["error"] == "zen_binary_missing" + + +def test_guard_login_store_missing(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + res = _importer(zen, src).import_passwords() + assert res["error"] == "zen_login_store_missing" + + +@pytest.mark.skipif(sys.platform.startswith("win"), reason="POSIX fcntl lock") +def test_guard_zen_running_detects_lock(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "key4.db").write_bytes(b"x") + lock = zen / ".parentlock" + lock.write_bytes(b"") + ready = tmp_path / "ready" + holder = subprocess.Popen([ + sys.executable, "-c", + textwrap.dedent(f""" + import fcntl, os, time + fd = os.open({str(lock)!r}, os.O_RDWR) + fcntl.lockf(fd, fcntl.LOCK_EX) + open({str(ready)!r}, 'w').close() + time.sleep(30) + """), + ]) + try: + for _ in range(100): + if ready.exists(): + break + time.sleep(0.05) + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + res = _importer(zen, src).import_passwords() + assert res["error"] == "zen_running" + finally: + holder.terminate() + holder.wait(timeout=5) + + +# ---- temp prefs + backup ---- + +def test_temp_prefs_roundtrip_without_existing_user_js(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "prefs.js").write_text('user_pref("x", 1);\n', encoding="utf-8") + imp = _importer(zen, tmp_path) + + prior = imp._apply_temp_prefs(2828) + assert prior is None + body = (zen / "user.js").read_text() + assert '"marionette.port", 2828' in body + + # Simulate Zen persisting the injected prefs into prefs.js. + (zen / "prefs.js").write_text( + 'user_pref("x", 1);\n' + 'user_pref("marionette.port", 2828);\n' + 'user_pref("remote.prefs.recommended", false);\n', + encoding="utf-8", + ) + imp._restore_prefs(prior) + assert not (zen / "user.js").exists() + kept = (zen / "prefs.js").read_text() + assert "marionette.port" not in kept + assert "remote.prefs.recommended" not in kept + assert 'user_pref("x", 1);' in kept + + +def test_temp_prefs_preserves_existing_user_js(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "user.js").write_text('user_pref("keep.me", true);\n', encoding="utf-8") + imp = _importer(zen, tmp_path) + + prior = imp._apply_temp_prefs(3000) + assert prior == 'user_pref("keep.me", true);\n' + imp._restore_prefs(prior) + assert (zen / "user.js").read_text() == 'user_pref("keep.me", true);\n' + + +def test_backup_copies_login_store(tmp_path): + zen = tmp_path / "zen" + zen.mkdir() + (zen / "logins.json").write_text("{}", encoding="utf-8") + (zen / "key4.db").write_bytes(b"k") + imp = _importer(zen, tmp_path) + + dest = imp._backup() + assert dest is not None and dest.is_dir() + assert (dest / "logins.json").is_file() + assert (dest / "key4.db").is_file() + + +# ---- zen binary discovery ---- + +def test_zen_binary_path_finds_macos_app(fake_home, monkeypatch, tmp_path): + import app.env_check as env_check + + fake = tmp_path / "Zen.app/Contents/MacOS/zen" + fake.parent.mkdir(parents=True) + fake.write_text("#!/bin/sh\n") + monkeypatch.setattr(env_check, "_ZEN_PROCESS_PATHS", (str(fake),)) + assert env_check.zen_binary_path() == fake + + +def test_zen_binary_path_none_when_absent(fake_home, monkeypatch): + import app.env_check as env_check + + monkeypatch.setattr(env_check, "_ZEN_PROCESS_PATHS", ("/nope/zen",)) + assert env_check.zen_binary_path() is None + + +# ---- orchestrator skip for non-Chromium ---- + +def test_orchestrator_skips_non_chromium_passwords(firefox_home, zen_profile): + from app.orchestrator import MigrationOrchestrator + from extractors import FirefoxExtractor + + o = MigrationOrchestrator(source=FirefoxExtractor()) + res = o._import_passwords(zen_profile) + assert res["error"] == "passwords_source_unsupported" From aa9f40c2b1e4698c4e8c92809a95c1a6826bb1ed Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:26:48 +0200 Subject: [PATCH 4/7] fix(passwords): expose Arc's login data so the toggle appears ArcExtractor subclasses BrowserExtractor directly rather than ChromiumExtractor, so it inherited the empty login_data_paths() and user_data_root() defaults and the Saved passwords toggle never showed for the main source. Add both from Arc's User Data layout, and cover them with a regression test. --- src/extractors/arc.py | 10 ++++++++++ tests/test_password_importer.py | 12 ++++++++++++ 2 files changed, 22 insertions(+) diff --git a/src/extractors/arc.py b/src/extractors/arc.py index 3bc00b8..af37f7e 100644 --- a/src/extractors/arc.py +++ b/src/extractors/arc.py @@ -176,6 +176,16 @@ def cookie_db_paths(self) -> list[Path]: break return out + def login_data_paths(self) -> list[Path]: + root = self._user_data_dir() + if root is None: + return [] + return [profile / "Login Data" for profile in sorted(root.iterdir()) + if profile.is_dir() and (profile / "Login Data").is_file()] + + def user_data_root(self) -> Path | None: + return self._user_data_dir() + def local_state_paths(self) -> list[Path]: # Used on Windows for DPAPI key unwrap. home = Path.home() diff --git a/tests/test_password_importer.py b/tests/test_password_importer.py index 4aee0fc..8dce5ef 100644 --- a/tests/test_password_importer.py +++ b/tests/test_password_importer.py @@ -48,6 +48,18 @@ def test_chromium_login_data_and_root(chrome_home): assert login_dbs[0].parent.name == profile.name +def test_arc_login_data_and_root(arc_home): + from extractors import ArcExtractor + + user_data = arc_home / "Library/Application Support/Arc/User Data" + _make_login_data(user_data / "Default" / "Login Data", usable=4) + _make_login_data(user_data / "Profile 1" / "Login Data", usable=1) + + ext = ArcExtractor() + assert ext.user_data_root() == user_data + assert {p.parent.name for p in ext.login_data_paths()} == {"Default", "Profile 1"} + + def test_non_chromium_has_no_login_store(firefox_home): from extractors import FirefoxExtractor, SafariExtractor From 5e692878400a847b5d5d9f9f17fa152eef6243b8 Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:29:49 +0200 Subject: [PATCH 5/7] fix(passwords): import env_check from the app package, not a bare module The orchestrator referenced `env_check` as a top-level module, which raised ModuleNotFoundError at runtime (it lives in `app/`). The isolated importer tests missed it because they bypassed the orchestrator seam. Fix the import and add a test that drives a Chromium source through _import_passwords so the wiring is covered end to end. --- app/orchestrator.py | 2 +- tests/test_password_importer.py | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/app/orchestrator.py b/app/orchestrator.py index b7b2587..577782f 100644 --- a/app/orchestrator.py +++ b/app/orchestrator.py @@ -624,7 +624,7 @@ def _import_passwords(self, zen_profile: Path) -> dict: else "passwords_source_unsupported") return {"error": code} - from env_check import zen_binary_path + from app.env_check import zen_binary_path zen_binary = zen_binary_path() if zen_binary is None: return {"error": "zen_binary_missing"} diff --git a/tests/test_password_importer.py b/tests/test_password_importer.py index 8dce5ef..2bf8d6c 100644 --- a/tests/test_password_importer.py +++ b/tests/test_password_importer.py @@ -249,3 +249,22 @@ def test_orchestrator_skips_non_chromium_passwords(firefox_home, zen_profile): o = MigrationOrchestrator(source=FirefoxExtractor()) res = o._import_passwords(zen_profile) assert res["error"] == "passwords_source_unsupported" + + +def test_orchestrator_chromium_reaches_importer(chrome_home, zen_profile, monkeypatch): + """A Chromium source must resolve the whole wiring (env_check import, + importer construction) and stop at a guard, never crash. Guards against + the bare-module import regression.""" + import app.env_check as env_check + from app.orchestrator import MigrationOrchestrator + from extractors import ChromeExtractor + + profile = ChromeExtractor().profile_paths()[0] + _make_login_data(profile / "Login Data", usable=2) + # Pin a resolvable binary and an empty login store so nothing launches. + monkeypatch.setattr(env_check, "zen_binary_path", lambda: Path(sys.executable)) + (zen_profile / "key4.db").unlink(missing_ok=True) + + o = MigrationOrchestrator(source=ChromeExtractor()) + res = o._import_passwords(zen_profile) + assert res["error"] == "zen_login_store_missing" From d05defce4f133a5dd019f719f8280eca4432631b Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 14:32:03 +0200 Subject: [PATCH 6/7] docs(screenshots): add the Preview screen with the Saved passwords toggle Enrich the mock bridge's preview() with a neutral demo shape so the harness can capture the Options screen, and add a preview screenshot test. The shot shows the new Saved passwords toggle alongside cookies. --- docs/screenshots/mock-bridge.js | 11 ++++++++++- docs/screenshots/preview.png | Bin 0 -> 220532 bytes docs/screenshots/screens.spec.ts | 13 +++++++++++++ 3 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 docs/screenshots/preview.png diff --git a/docs/screenshots/mock-bridge.js b/docs/screenshots/mock-bridge.js index 0d9a528..566efde 100644 --- a/docs/screenshots/mock-bridge.js +++ b/docs/screenshots/mock-bridge.js @@ -84,7 +84,16 @@ window.pywebview = { get_step_metadata: async () => ({ steps: [], labels: {} }), // Migration-side methods: tests don't drive these screens via the // happy path, but app.js may call them on screen entry. - preview: async () => ({ ok: true, spaces: [], folders: [], pinnedTabs: 0 }), + preview: async () => ({ + spaces: [ + { name: "Work", icon: "💼", pinnedCount: 8, openCount: 2, folderCount: 1, essentialCount: 2, color: [94, 134, 255] }, + { name: "Reading", icon: "📚", pinnedCount: 5, openCount: 1, folderCount: 0, essentialCount: 1, color: [120, 90, 220] }, + { name: "Hobby", icon: "🎧", pinnedCount: 4, openCount: 1, folderCount: 1, essentialCount: 2, color: [40, 170, 120] }, + ], + pinnedTotal: 17, openTotal: 4, folderTotal: 2, bookmarkTotal: 19, + faviconMatchEstimate: 15, historyRowsEstimate: 42000, + cookiesEstimate: 12000, passwordsEstimate: 320, + }), start_migration: async () => ({ ok: true }), start_zen_export: async () => ({ ok: true }), start_zen_restore: async () => ({ ok: true }), diff --git a/docs/screenshots/preview.png b/docs/screenshots/preview.png new file mode 100644 index 0000000000000000000000000000000000000000..57b4eccb61395709f137bfcef7201ea349060e3c GIT binary patch literal 220532 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%0AqqBP|*d7rJm*x`N6Tzj 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 z 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 { await shoot(page, "detect"); }); +test("preview", async ({ page }) => { + await bootHarness(page); + await page.locator("#welcome-go").click(); + await waitForActiveScreen(page, "source"); + await page.locator('.source-card[data-name="arc"]').click(); + await page.locator("#source-next").click(); + await waitForActiveScreen(page, "detect"); + await page.locator("#detect-next").click(); + await waitForActiveScreen(page, "preview"); + await page.locator("#toggles .toggle").last().waitFor({ state: "visible" }); + await shoot(page, "preview"); +}); + test("backup-mode", async ({ page }) => { await bootHarness(page); await page.locator("#welcome-backup").click(); From 4a8a6df7dd18fd2df7dbd532ac8bad196752bf4c Mon Sep 17 00:00:00 2001 From: Dean Shabi Date: Mon, 26 Oct 2026 21:43:20 +0200 Subject: [PATCH 7/7] fix(passwords): pin test platforms and surface per-profile outcomes Tests: guard and dry-run tests now pin macOS through a `macos` fixture, so Linux CI no longer stops at the platform guard. Unsupported platforms (linux, freebsd) and Windows each get their own test. The platform guard checks sys.platform alone. Outcomes: the importer used to drop Zen's per-profile errors and the list of profiles Zen did not find. summarize_report() now puts every requested profile in one bucket (profiles, failed, missing) and flags partial_import, no_passwords_imported, or no_profiles_imported when no profile migrated. The orchestrator turns these into a plain notice. The timeline row turns amber, and the Done screen lists the notice and any failed step instead of always saying "All set." --- app/frontend/app.js | 41 +++++++- app/frontend/index.html | 1 + app/frontend/styles.css | 19 ++++ app/orchestrator.py | 79 ++++++++++---- src/zen_password_importer.py | 52 ++++++++-- tests/test_password_importer.py | 179 +++++++++++++++++++++++++++++++- 6 files changed, 333 insertions(+), 38 deletions(-) diff --git a/app/frontend/app.js b/app/frontend/app.js index c7b7004..c7b249b 100644 --- a/app/frontend/app.js +++ b/app/frontend/app.js @@ -74,6 +74,7 @@ const state = { stepLabels: {}, stepStates: {}, stepSummaries: {}, + stepErrors: {}, logLines: [], pollHandle: null, startedAt: 0, @@ -751,6 +752,7 @@ async function goToProgress() { state.stepLabels = meta.labels; state.stepStates = Object.fromEntries(state.steps.map(s => [s, "pending"])); state.stepSummaries = {}; + state.stepErrors = {}; state.logLines = []; state.activeStep = null; state.activeDetail = ""; @@ -796,7 +798,9 @@ function handleEvent(ev) { state.activeDetail = ""; state.activeProgress = null; } else if (ev.kind === "step_done") { - state.stepStates[ev.step] = "done"; + // A step that finished with a warning (e.g. some password profiles + // failed) stays visibly distinct from a clean success. + state.stepStates[ev.step] = (ev.summary && ev.summary.warning) ? "warn" : "done"; if (ev.summary) state.stepSummaries[ev.step] = ev.summary; if (state.activeStep === ev.step) { state.activeStep = null; @@ -805,6 +809,7 @@ function handleEvent(ev) { } } else if (ev.kind === "step_error") { state.stepStates[ev.step] = "error"; + state.stepErrors[ev.step] = ev.detail || ev.message || ""; } else { state.logLines.push({kind: ev.kind, message: ev.message, step: ev.step}); if (state.logLines.length > 500) state.logLines.shift(); @@ -846,7 +851,7 @@ function renderProgress() { const total = steps.length; const meta = $("progress-meta"); if (activeIdx >= 0) meta.textContent = `Step ${activeIdx + 1} of ${total}`; - else if (steps.every(s => state.stepStates[s] === "done")) meta.textContent = `${total} of ${total} done`; + else if (steps.every(s => ["done", "warn"].includes(state.stepStates[s]))) meta.textContent = `${total} of ${total} done`; else meta.textContent = "Working"; // unified timeline @@ -862,7 +867,7 @@ function renderProgress() { } function makeRow(step, st) { - const summary = (st === "done") ? stepSummaryText(step, state.stepSummaries[step]) : ""; + const summary = (st === "done" || st === "warn") ? stepSummaryText(step, state.stepSummaries[step]) : ""; return el("li", {class: "tl-step", dataset: {step, state: st}}, [ el("div", {class: "ico"}, [makeStepIcon(step)]), el("span", {class: "lbl", text: state.stepLabels[step] || step}), @@ -898,7 +903,10 @@ function stepSummaryText(step, s) { if (step === "cookies") return `${formatRows(s.imported ?? 0)} imported · ${formatRows(s.merged ?? 0)} merged`; if (step === "passwords") { if (s.skipped) return "skipped"; - return `${formatRows(s.imported ?? 0)} passwords imported`; + const imported = `${formatRows(s.imported ?? 0)} passwords imported`; + const bad = Object.keys(s.failed || {}).length + (s.missing || []).length; + if (bad) return `${imported}, ${bad} ${bad === 1 ? "profile" : "profiles"} not imported`; + return imported; } if (step === "sessions") { if (s.pinned == null && s.open == null) return s.ok ? "ok" : ""; @@ -953,7 +961,9 @@ async function finishOk(finalState) { summary.title = ""; summary.onclick = null; } else { - headline.textContent = "All set."; + const problems = renderDoneNotes(); + headline.textContent = problems ? "Finished with problems." : "All set."; + $("screen-done").dataset.outcome = problems ? "warn" : "ok"; const ext = state.stepSummaries.extract || {}; summary.textContent = ext.pinned ? `${ext.pinned} pinned tabs across ${ext.spaces} spaces. Backups saved next to your Zen profile.` @@ -963,6 +973,10 @@ async function finishOk(finalState) { summary.onclick = null; } + if (isBackup) { + $("screen-done").dataset.outcome = "ok"; + $("done-notes").style.display = "none"; + } launch.style.display = isBackup ? "none" : ""; backupsSection.style.display = isBackup ? "none" : ""; $("done-back").style.display = isBackup ? "" : "none"; @@ -980,6 +994,22 @@ async function finishOk(finalState) { } } +// Lists warnings and failed steps on the Done screen so a partial +// migration never reads as a clean one. Returns how many it listed. +function renderDoneNotes() { + const list = $("done-notes"); clear(list); + for (const s of visibleSteps()) { + const label = state.stepLabels[s] || s; + let text = ""; + // step_error details come from format_exception_only; drop the class name. + if (state.stepStates[s] === "error") text = `${label} failed. ${(state.stepErrors[s] || "").replace(/^\w+: /, "")}`; + else if (state.stepStates[s] === "warn") text = (state.stepSummaries[s] || {}).notice || `${label} finished with warnings.`; + if (text) list.appendChild(el("li", {dataset: {step: s}, text: text.trim()})); + } + list.style.display = list.children.length ? "" : "none"; + return list.children.length; +} + $("done-launch").addEventListener("click", async () => { const api = Bridge(); if (!api) return; // Don't await quit_app — calling window.destroy() while a JS-Python promise @@ -1542,6 +1572,7 @@ function startProgressPolling() { setScreen("progress"); state.stepStates = {}; state.stepSummaries = {}; + state.stepErrors = {}; state.logLines = []; state.activeStep = null; state.activeDetail = ""; diff --git a/app/frontend/index.html b/app/frontend/index.html index 4b6d4b3..5607b19 100644 --- a/app/frontend/index.html +++ b/app/frontend/index.html @@ -247,6 +247,7 @@

Migrating

All set.

Your browser setup now lives in Zen.

+
diff --git a/app/frontend/styles.css b/app/frontend/styles.css index 3173bf5..bc7ee28 100644 --- a/app/frontend/styles.css +++ b/app/frontend/styles.css @@ -661,6 +661,7 @@ body[data-platform="mac"] main { box-shadow: 0 0 12px rgba(94, 134, 255, 0.32); } .meter-segment[data-state="error"] { background: var(--error); } +.meter-segment[data-state="warn"] { background: var(--warn); } /* Timeline: one unified vertical list. Active row expands inline. */ .timeline { @@ -731,6 +732,10 @@ body[data-platform="mac"] main { flex: 0 0 auto; } +/* state: warn (finished, but part of the step did not land) */ +.tl-step[data-state="warn"] .ico { color: var(--warn); } +.tl-step[data-state="warn"] .summary { color: var(--warn); } + /* state: error */ .tl-step[data-state="error"] .ico { color: var(--error); } .tl-step[data-state="error"] .lbl { color: var(--error); } @@ -861,12 +866,26 @@ body[data-platform="mac"] main { animation: drawcheck 600ms 100ms cubic-bezier(0.2, 0, 0, 1) forwards; } @keyframes drawcheck { to { stroke-dashoffset: 0; } } +#screen-done[data-outcome="warn"] .check { background: var(--warn-soft); } +#screen-done[data-outcome="warn"] .check svg path { stroke: var(--warn); } #screen-done .summary { margin-top: var(--space-2); font-size: var(--fs-body); color: var(--text-secondary); max-width: 480px; } +#screen-done .notes { + list-style: none; + margin: var(--space-4) 0 0; + padding: var(--space-3) var(--space-4); + max-width: 540px; + text-align: left; + font-size: var(--fs-small); + color: var(--warn); + background: var(--warn-soft); + border-radius: var(--radius-sm); +} +#screen-done .notes li + li { margin-top: var(--space-2); } #screen-done .actions { margin-top: var(--space-6); display: flex; gap: var(--space-3); } #screen-done .backups { margin-top: var(--space-6); diff --git a/app/orchestrator.py b/app/orchestrator.py index 577782f..d35d769 100644 --- a/app/orchestrator.py +++ b/app/orchestrator.py @@ -188,8 +188,44 @@ def _step_label(step: str, source_display: str) -> str: "during the write.", "password_import_failed": "Zen's password importer did not finish; passwords skipped.", + "no_profiles_imported": + "Zen could not import passwords from any {source} profile.", } +# Zen's per-profile errors can be long stack-ish strings; the UI shows a +# sentence per profile, so keep each one readable. +_PROFILE_ERROR_LIMIT = 160 + + +def _password_notice(summary: dict) -> str: + """Describe per-profile password outcomes in plain sentences. + + Returns an empty string for a clean import. Profile ids are the + source's on-disk directory names (``Default``, ``Profile 1``). + """ + profiles = summary.get("profiles") or {} + failed = summary.get("failed") or {} + missing = summary.get("missing") or [] + total = len(profiles) + len(failed) + len(missing) + sentences: list[str] = [] + if failed or missing: + if profiles: + sentences.append( + f"Imported {summary.get('imported', 0)} passwords from " + f"{len(profiles)} of {total} profiles." + ) + for pid, err in failed.items(): + err = err if len(err) <= _PROFILE_ERROR_LIMIT else err[:_PROFILE_ERROR_LIMIT] + "..." + sentences.append(f"{pid} failed ({err}).") + if missing: + sentences.append(f"Zen's importer did not find {', '.join(missing)}.") + elif summary.get("warning") == "no_passwords_imported": + sentences.append( + "No passwords were imported. Zen skips logins it already has, " + "and nothing imports if the Keychain prompt is denied." + ) + return " ".join(sentences) + # ------------------------------------------------------------------ orchestrator @@ -584,24 +620,7 @@ def _run(self, opts: MigrationOptions) -> Iterator[ProgressEvent]: # 9: passwords --------------------------------------------------- if opts.include_passwords: - self._start_step("passwords") - try: - summary = self._import_passwords(zen_profile) - err = summary.get("error") - if err: - msg = _PASSWORD_ERROR_MESSAGES.get( - err, f"Password import failed: {err}" - ).format(source=self.source.display_name) - # A source with no passwords, or a non-Chromium source, - # is a clean skip rather than a migration failure. - if err in ("no_source_passwords", "passwords_source_unsupported"): - self._done_step("passwords", summary={"imported": 0, "skipped": msg}) - else: - self._error_step("passwords", RuntimeError(msg)) - else: - self._done_step("passwords", summary=summary) - except Exception as exc: - self._error_step("passwords", exc) + self._run_passwords_step(zen_profile) yield from self._drain_yield() # 10: finalize --------------------------------------------------- @@ -615,6 +634,30 @@ def _run(self, opts: MigrationOptions) -> Iterator[ProgressEvent]: self._done_step("finalize", message="Migration complete") yield from self._drain_yield() + def _run_passwords_step(self, zen_profile: Path) -> None: + self._start_step("passwords") + try: + summary = self._import_passwords(zen_profile) + except Exception as exc: + self._error_step("passwords", exc) + return + err = summary.get("error") + notice = _password_notice(summary) + if err in ("no_source_passwords", "passwords_source_unsupported"): + # Nothing to import is a clean skip, not a migration failure. + msg = _PASSWORD_ERROR_MESSAGES[err].format(source=self.source.display_name) + self._done_step("passwords", summary={"imported": 0, "skipped": msg}) + elif err: + msg = _PASSWORD_ERROR_MESSAGES.get( + err, f"Password import failed: {err}" + ).format(source=self.source.display_name) + self._error_step("passwords", RuntimeError(f"{msg} {notice}".strip())) + else: + if notice: + summary = {**summary, "notice": notice} + self._emit({"kind": "warn", "step": "passwords", "message": notice}) + self._done_step("passwords", summary=summary) + def _import_passwords(self, zen_profile: Path) -> dict: user_data = self.source.user_data_root() login_dbs = self.source.login_data_paths() diff --git a/src/zen_password_importer.py b/src/zen_password_importer.py index 60532d3..41c6265 100644 --- a/src/zen_password_importer.py +++ b/src/zen_password_importer.py @@ -96,6 +96,40 @@ """ +def summarize_report(report: dict) -> dict: + """Fold Zen's in-browser report into the result the UI renders. + + Every requested profile lands in exactly one bucket. ``profiles`` maps + a migrated profile to the logins it added, ``failed`` maps a profile + whose migration threw to Zen's error, and ``missing`` lists profiles + Zen's migrator did not find. Partial outcomes carry a ``warning`` and a + run where no profile migrated carries an ``error``, so a partial import + never reads as a clean success. + """ + per = report.get("perProfile") or {} + profiles = { + str(pid): int(v.get("added", 0)) + for pid, v in per.items() if "error" not in v + } + failed = {str(pid): str(v["error"]) for pid, v in per.items() if "error" in v} + missing = [str(pid) for pid in report.get("missing") or []] + result: dict = { + "imported": int(report.get("imported", 0)), + "profiles": profiles, + "failed": failed, + "missing": missing, + } + if not profiles: + result["error"] = "no_profiles_imported" + elif failed or missing: + result["warning"] = "partial_import" + elif result["imported"] == 0: + # Every profile ran but nothing landed. Most often the Keychain or + # DPAPI prompt was declined, or Zen already had every login. + result["warning"] = "no_passwords_imported" + return result + + class ZenPasswordImporter: """Import Chromium-format saved passwords into a Zen profile.""" @@ -267,9 +301,11 @@ def _restore_prefs(self, prior: str | None) -> None: # ---- orchestration ---- def import_passwords(self) -> dict: - result: dict = {"imported": 0, "profiles": {}} + result: dict = {"imported": 0, "profiles": {}, "failed": {}, "missing": []} - if sys.platform not in ("darwin", "win32") and os.name != "nt": + # Zen's Chromium importer decrypts through the macOS Keychain or + # Windows DPAPI; there is no supported keystore path elsewhere. + if sys.platform not in ("darwin", "win32"): result["error"] = "passwords_unsupported_platform" return result if not self.profile_ids or not self.source_user_data.is_dir(): @@ -329,14 +365,10 @@ def import_passwords(self) -> dict: result["error"] = "password_import_failed" return result - per = (report or {}).get("perProfile", {}) if isinstance(report, dict) else {} - result["profiles"] = {pid: v.get("added", 0) for pid, v in per.items()} - result["imported"] = int(report.get("imported", 0)) if isinstance(report, dict) else 0 - if result["imported"] == 0 and existing == (report or {}).get("after", existing): - # Nothing landed although a source was selected; most often the - # Keychain/DPAPI prompt was declined. - result["warning"] = "no_passwords_imported" - return result + if not isinstance(report, dict): + result["error"] = "password_import_failed" + return result + return {**summarize_report(report), "backup": result["backup"]} def _wait_for_exit(self, proc: subprocess.Popen) -> None: try: diff --git a/tests/test_password_importer.py b/tests/test_password_importer.py index 2bf8d6c..4597b38 100644 --- a/tests/test_password_importer.py +++ b/tests/test_password_importer.py @@ -82,6 +82,17 @@ def test_preview_estimate_counts_usable_logins(chrome_home, zen_profile): # ---- importer guards ---- +@pytest.fixture +def macos(monkeypatch): + """Pin the platform the importer supports. + + The importer refuses anything but macOS and Windows, so guard tests + that are about a later check must say which platform they run on. + Without this, Linux CI stops at the platform guard first. + """ + monkeypatch.setattr(sys, "platform", "darwin") + + def _importer(zen_profile: Path, source_user_data: Path, **kw): from zen_password_importer import ZenPasswordImporter @@ -95,7 +106,7 @@ def _importer(zen_profile: Path, source_user_data: Path, **kw): return ZenPasswordImporter(**defaults) -def test_dry_run_reports_plan_without_launching(tmp_path): +def test_dry_run_reports_plan_without_launching(tmp_path, macos): zen = tmp_path / "zen" zen.mkdir() (zen / "key4.db").write_bytes(b"x") @@ -107,7 +118,7 @@ def test_dry_run_reports_plan_without_launching(tmp_path): assert "imported" in res and res["imported"] == 0 -def test_guard_no_source_passwords(tmp_path): +def test_guard_no_source_passwords(tmp_path, macos): zen = tmp_path / "zen" zen.mkdir() (zen / "key4.db").write_bytes(b"x") @@ -117,7 +128,7 @@ def test_guard_no_source_passwords(tmp_path): assert res["error"] == "no_source_passwords" -def test_guard_zen_binary_missing(tmp_path): +def test_guard_zen_binary_missing(tmp_path, macos): zen = tmp_path / "zen" zen.mkdir() (zen / "key4.db").write_bytes(b"x") @@ -127,7 +138,7 @@ def test_guard_zen_binary_missing(tmp_path): assert res["error"] == "zen_binary_missing" -def test_guard_login_store_missing(tmp_path): +def test_guard_login_store_missing(tmp_path, macos): zen = tmp_path / "zen" zen.mkdir() src = tmp_path / "User Data" @@ -137,7 +148,7 @@ def test_guard_login_store_missing(tmp_path): @pytest.mark.skipif(sys.platform.startswith("win"), reason="POSIX fcntl lock") -def test_guard_zen_running_detects_lock(tmp_path): +def test_guard_zen_running_detects_lock(tmp_path, macos): zen = tmp_path / "zen" zen.mkdir() (zen / "key4.db").write_bytes(b"x") @@ -168,6 +179,164 @@ def test_guard_zen_running_detects_lock(tmp_path): holder.wait(timeout=5) +@pytest.mark.parametrize("platform", ["linux", "freebsd14"]) +def test_guard_unsupported_platform_runs_first(tmp_path, monkeypatch, platform): + """Off macOS/Windows there is no keystore Zen can decrypt with, so the + importer stops before touching the profile, even in dry-run mode.""" + monkeypatch.setattr(sys, "platform", platform) + zen = tmp_path / "zen" + zen.mkdir() + (zen / "key4.db").write_bytes(b"x") + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + + res = _importer(zen, src, dry_run=True).import_passwords() + assert res["error"] == "passwords_unsupported_platform" + assert "would_import_from" not in res + assert sorted(p.name for p in zen.iterdir()) == ["key4.db"] + + +def test_guard_windows_is_supported(tmp_path, monkeypatch): + """Windows passes the platform guard and reaches the next check.""" + monkeypatch.setattr(sys, "platform", "win32") + zen = tmp_path / "zen" + zen.mkdir() + src = tmp_path / "User Data" + (src / "Default").mkdir(parents=True) + res = _importer(zen, src).import_passwords() + assert res["error"] == "zen_login_store_missing" + + +# ---- per-profile outcomes ---- + +def test_summarize_all_profiles_imported(): + from zen_password_importer import summarize_report + + res = summarize_report({ + "imported": 7, + "perProfile": {"Default": {"added": 5}, "Profile 1": {"added": 2}}, + "missing": [], + }) + assert res["profiles"] == {"Default": 5, "Profile 1": 2} + assert res["failed"] == {} and res["missing"] == [] + assert "warning" not in res and "error" not in res + + +def test_summarize_mixed_success_is_partial(): + from zen_password_importer import summarize_report + + res = summarize_report({ + "imported": 5, + "perProfile": {"Default": {"added": 5}, "Profile 1": {"error": "NS_ERROR_FAILURE"}}, + "missing": [], + }) + assert res["profiles"] == {"Default": 5} + assert res["failed"] == {"Profile 1": "NS_ERROR_FAILURE"} + assert res["warning"] == "partial_import" + assert "error" not in res + + +def test_summarize_missing_profile_is_partial(): + from zen_password_importer import summarize_report + + res = summarize_report({ + "imported": 3, + "perProfile": {"Default": {"added": 3}}, + "missing": ["Profile 2"], + }) + assert res["missing"] == ["Profile 2"] + assert res["warning"] == "partial_import" + + +def test_summarize_no_profile_migrated_is_error(): + from zen_password_importer import summarize_report + + res = summarize_report({ + "imported": 0, + "perProfile": {"Default": {"error": "boom"}}, + "missing": ["Profile 1"], + }) + assert res["error"] == "no_profiles_imported" + assert res["failed"] == {"Default": "boom"} + assert res["missing"] == ["Profile 1"] + + +def test_summarize_zero_imports_warns(): + from zen_password_importer import summarize_report + + res = summarize_report({ + "imported": 0, + "perProfile": {"Default": {"added": 0}}, + "missing": [], + }) + assert res["warning"] == "no_passwords_imported" + assert "error" not in res + + +def _password_step_events(monkeypatch, zen_profile, summary): + from app.orchestrator import MigrationOrchestrator + from extractors import ChromeExtractor + + o = MigrationOrchestrator(source=ChromeExtractor()) + monkeypatch.setattr(o, "_import_passwords", lambda _zen: summary) + o._run_passwords_step(zen_profile) + return list(o.bus.drain()) + + +def test_step_surfaces_mixed_success(chrome_home, zen_profile, monkeypatch): + events = _password_step_events(monkeypatch, zen_profile, { + "imported": 5, "profiles": {"Default": 5}, + "failed": {"Profile 1": "NS_ERROR_FAILURE"}, "missing": ["Profile 2"], + "warning": "partial_import", + }) + done = next(e for e in events if e["kind"] == "step_done") + notice = done["summary"]["notice"] + assert "5 passwords from 1 of 3 profiles" in notice + assert "Profile 1 failed (NS_ERROR_FAILURE)" in notice + assert "did not find Profile 2" in notice + assert done["summary"]["warning"] == "partial_import" + assert any(e["kind"] == "warn" and e["message"] == notice for e in events) + + +def test_step_surfaces_missing_profiles(chrome_home, zen_profile, monkeypatch): + events = _password_step_events(monkeypatch, zen_profile, { + "imported": 2, "profiles": {"Default": 2}, "failed": {}, + "missing": ["Profile 3", "Profile 4"], "warning": "partial_import", + }) + done = next(e for e in events if e["kind"] == "step_done") + assert "did not find Profile 3, Profile 4" in done["summary"]["notice"] + + +def test_step_surfaces_zero_imports(chrome_home, zen_profile, monkeypatch): + events = _password_step_events(monkeypatch, zen_profile, { + "imported": 0, "profiles": {"Default": 0}, "failed": {}, "missing": [], + "warning": "no_passwords_imported", + }) + done = next(e for e in events if e["kind"] == "step_done") + assert "No passwords were imported" in done["summary"]["notice"] + assert any(e["kind"] == "warn" for e in events) + + +def test_step_errors_when_no_profile_migrated(chrome_home, zen_profile, monkeypatch): + events = _password_step_events(monkeypatch, zen_profile, { + "imported": 0, "profiles": {}, "failed": {"Default": "boom"}, + "missing": [], "error": "no_profiles_imported", + }) + assert not any(e["kind"] == "step_done" for e in events) + err = next(e for e in events if e["kind"] == "step_error") + assert "any Chrome profile" in err["detail"] + assert "Default failed (boom)" in err["detail"] + + +def test_step_clean_import_has_no_notice(chrome_home, zen_profile, monkeypatch): + events = _password_step_events(monkeypatch, zen_profile, { + "imported": 4, "profiles": {"Default": 4}, "failed": {}, "missing": [], + }) + done = next(e for e in events if e["kind"] == "step_done") + assert "notice" not in done["summary"] + assert not any(e["kind"] == "warn" for e in events) + + # ---- temp prefs + backup ---- def test_temp_prefs_roundtrip_without_existing_user_js(tmp_path):