feat(desktop): import from Chrome, Edge, Brave, Vivaldi, Opera, Arc, Firefox

Generalises the importer from one hardcoded browser to a source registry with
two engines.

Chromium forks are table entries: Chrome, Edge, Brave, Vivaldi, Opera, Arc and
Helium all share the existing extractor and differ only in their paths and
keychain coordinates. Those coordinates are pinned per fork rather than
derived, because the forks disagree — Helium uses "Helium Storage Key" /
"Helium" where the others use "<Name> Safe Storage" / "<Name>".

Firefox is a second engine. It stores cookies unencrypted in `cookies.sqlite`,
so there is no key to fetch and no consent prompt — that is Mozilla's design
choice, not a control being circumvented, and it is why Firefox works
identically on all three platforms while Chromium still needs a per-platform
credential store.

Paths resolve for macOS, Windows and Linux from an injected context rather
than from `process`, so a platform's layout can be checked without running on
it. Chromium off macOS still reports `unsupportedPlatform` until those key
stores land; Firefox does not.

The snapshot-before-read step moves to a shared module, since both engines
keep the database open with WAL and must never have the browser's own file
opened for writing.

Firefox has tests against a real `moz_cookies` fixture, including that the
source file is left untouched, and `profiles.ini` parsing covers the
`Install*` sections that name a default profile without describing one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/desktop/src/preview/BrowserImport/BrowserImport.ts

@@ -15,20 +15,24 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
 
-import { HostProcessExecutablePath, HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  HostProcessEnvironment,
+  HostProcessExecutablePath,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
+import * as NodeOS from "node:os";
 
 import * as BrowserSession from "../BrowserSession.ts";
-import {
-  ChromiumCookieReadError,
-  readChromiumCookies,
-  type ChromiumCookie,
-} from "./ChromiumCookies.ts";
+import type { ImportedCookie } from "./CookieDatabase.ts";
+import { ChromiumCookieReadError, readChromiumCookies } from "./ChromiumCookies.ts";
+import { readFirefoxCookies } from "./FirefoxCookies.ts";
 import {
   BROWSER_IMPORT_SOURCES,
   cookieDatabasePath,
   isSourceInstalled,
   isSourceRunning,
   listSourceProfiles,
+  type BrowserImportPathContext,
   type BrowserImportSourceDefinition,
 } from "./Sources.ts";
 
@@ -59,29 +63,42 @@ export class BrowserImport extends Context.Service<
 
 const unavailableReason = async (
   definition: BrowserImportSourceDefinition,
-  platform: NodeJS.Platform,
+  context: BrowserImportPathContext,
 ): Promise<BrowserImportUnavailableReason | undefined> => {
-  if (!definition.platforms.includes(platform)) return "unsupportedPlatform";
-  if (!(await isSourceInstalled(definition))) return "notInstalled";
-  if (await isSourceRunning(definition)) return "browserRunning";
+  if (!definition.platforms.includes(context.platform)) return "unsupportedPlatform";
+  // Chromium's key lives in an OS credential store, and only the macOS one is
+  // implemented; Firefox needs no key at all, so it works everywhere.
+  if (definition.engine === "chromium" && context.platform !== "darwin") {
+    return "unsupportedPlatform";
+  }
+  if (!(await isSourceInstalled(definition, context))) return "notInstalled";
+  if (await isSourceRunning(definition, context)) return "browserRunning";
   return undefined;
 };
 
 export const make = Effect.gen(function* BrowserImportMake() {
   const browserSession = yield* BrowserSession.BrowserSession;
   const platform = yield* HostProcessPlatform;
   const executablePath = yield* HostProcessExecutablePath;
+  const environment = yield* HostProcessEnvironment;
+  const pathContext: BrowserImportPathContext = {
+    platform,
+    home: NodeOS.homedir(),
+    appData: environment["APPDATA"],
+    localAppData: environment["LOCALAPPDATA"],
+  };
 
   const listSources = Effect.promise(async (): Promise<ReadonlyArray<BrowserImportSource>> => {
     const sources: BrowserImportSource[] = [];
     for (const definition of BROWSER_IMPORT_SOURCES) {
-      const unavailable = await unavailableReason(definition, platform);
+      const unavailable = await unavailableReason(definition, pathContext);
       sources.push({
         id: definition.id,
         name: definition.name,
         // Listing profiles touches the source's own files, so skip it when the
         // source is unusable anyway.
-        profiles: unavailable === undefined ? await listSourceProfiles(definition) : [],
+        profiles:
+          unavailable === undefined ? await listSourceProfiles(definition, pathContext) : [],
         ...(unavailable === undefined ? {} : { unavailable }),
       });
     }
@@ -103,7 +120,7 @@ export const make = Effect.gen(function* BrowserImportMake() {
       });
     }
 
-    const blocked = yield* Effect.promise(() => unavailableReason(definition, platform));
+    const blocked = yield* Effect.promise(() => unavailableReason(definition, pathContext));
     if (blocked !== undefined) {
       return yield* new BrowserImportFailedError({ sourceId: definition.id, reason: blocked });
     }
@@ -116,14 +133,30 @@ export const make = Effect.gen(function* BrowserImportMake() {
       executablePath,
     });
 
-    const cookies: ReadonlyArray<ChromiumCookie> = yield* Effect.tryPromise({
+    const databasePath = cookieDatabasePath(
+      definition,
+      pathContext,
+      input.input.sourceProfileDirectory,
+    );
+    if (databasePath === undefined) {
+      return yield* new BrowserImportFailedError({
+        sourceId: definition.id,
+        reason: "unsupportedPlatform",
+      });
+    }
+
+    const cookies: ReadonlyArray<ImportedCookie> = yield* Effect.tryPromise({
       try: () =>
-        readChromiumCookies({
-          cookieDatabasePath: cookieDatabasePath(definition, input.input.sourceProfileDirectory),
-          keychainService: definition.keychainService,
-          keychainAccount: definition.keychainAccount,
-          platform,
-        }),
+        definition.engine === "firefox"
+          ? readFirefoxCookies(databasePath)
+          : readChromiumCookies({
+              cookieDatabasePath: databasePath,
+              // Only reached on macOS: `unavailableReason` rejects Chromium
+              // elsewhere until those key stores are implemented.
+              keychainService: definition.keychainService ?? "",
+              keychainAccount: definition.keychainAccount ?? "",
+              platform,
+            }),
       catch: (cause) =>
         new BrowserImportFailedError({
           sourceId: definition.id,

apps/desktop/src/preview/BrowserImport/ChromiumCookies.ts

@@ -15,11 +15,10 @@
  */
 import * as Keyring from "@napi-rs/keyring";
 import * as NodeCrypto from "node:crypto";
-import * as NodeFSP from "node:fs/promises";
-import * as NodeOS from "node:os";
-import * as NodePath from "node:path";
 import * as NodeSqlite from "node:sqlite";
 
+import { snapshotCookieDatabase, type ImportedCookie } from "./CookieDatabase.ts";
+
 /** macOS OSCrypt parameters. Chromium has used these since the feature landed. */
 const MAC_KEY_ITERATIONS = 1003;
 const MAC_KEY_SALT = "saltysalt";
@@ -28,18 +27,7 @@ const MAC_KEY_LENGTH = 16;
 const AES_IV = Buffer.alloc(16, 0x20);
 const V10_PREFIX = "v10";
 
-export interface ChromiumCookie {
-  readonly url: string;
-  readonly name: string;
-  readonly value: string;
-  readonly domain: string;
-  readonly path: string;
-  readonly secure: boolean;
-  readonly httpOnly: boolean;
-  /** Seconds since the UNIX epoch, or undefined for a session cookie. */
-  readonly expirationDate: number | undefined;
-  readonly sameSite: "no_restriction" | "lax" | "strict";
-}
+export type ChromiumCookie = ImportedCookie;
 
 export type ChromiumCookieReadFailure =
   | { readonly reason: "needsKeychainApproval" }
@@ -116,27 +104,6 @@ async function readMacKeychainPassword(service: string, account: string): Promis
   return password;
 }
 
-/**
- * Chromium keeps the cookie DB open with WAL, and reading it in place can
- * observe a torn state. Copying first — including the sidecars — gives a
- * consistent snapshot without touching the browser's own files.
- */
-async function copyCookieDatabase(cookiePath: string): Promise<{
-  readonly path: string;
-  readonly cleanup: () => Promise<void>;
-}> {
-  const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3code-cookie-import-"));
-  const target = NodePath.join(directory, "Cookies");
-  await NodeFSP.copyFile(cookiePath, target);
-  for (const suffix of ["-wal", "-shm"]) {
-    await NodeFSP.copyFile(`${cookiePath}${suffix}`, `${target}${suffix}`).catch(() => undefined);
-  }
-  return {
-    path: target,
-    cleanup: () => NodeFSP.rm(directory, { recursive: true, force: true }).catch(() => undefined),
-  };
-}
-
 const decryptValue = (encrypted: Uint8Array, key: Buffer, domain: string): string | null => {
   const buffer = Buffer.from(encrypted);
   if (buffer.length === 0) return "";
@@ -184,7 +151,7 @@ export async function readChromiumCookies(
     "sha1",
   );
 
-  const snapshot = await copyCookieDatabase(source.cookieDatabasePath);
+  const snapshot = await snapshotCookieDatabase(source.cookieDatabasePath);
   try {
     const database = new NodeSqlite.DatabaseSync(snapshot.path, { readOnly: true });
     try {

apps/desktop/src/preview/BrowserImport/CookieDatabase.ts

@@ -0,0 +1,48 @@
+// @effect-diagnostics nodeBuiltinImport:off
+/**
+ * Shared pieces of cookie extraction: the shape both engines produce, and the
+ * snapshot every reader takes before touching a live database.
+ *
+ * @module CookieDatabase
+ */
+import * as NodeFSP from "node:fs/promises";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+/** A cookie in the shape Electron's `session.cookies.set` accepts. */
+export interface ImportedCookie {
+  readonly url: string;
+  readonly name: string;
+  readonly value: string;
+  readonly domain: string;
+  readonly path: string;
+  readonly secure: boolean;
+  readonly httpOnly: boolean;
+  /** Seconds since the UNIX epoch, or undefined for a session cookie. */
+  readonly expirationDate: number | undefined;
+  readonly sameSite: "no_restriction" | "lax" | "strict";
+}
+
+/**
+ * Copies a cookie database, and its write-ahead sidecars, to a temporary
+ * directory before reading.
+ *
+ * Both engines keep the file open with WAL while the browser runs, so reading
+ * in place can observe a torn write. Copying also guarantees we never open the
+ * browser's own file for writing.
+ */
+export async function snapshotCookieDatabase(cookiePath: string): Promise<{
+  readonly path: string;
+  readonly cleanup: () => Promise<void>;
+}> {
+  const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3code-cookie-import-"));
+  const target = NodePath.join(directory, NodePath.basename(cookiePath));
+  await NodeFSP.copyFile(cookiePath, target);
+  for (const suffix of ["-wal", "-shm"]) {
+    await NodeFSP.copyFile(`${cookiePath}${suffix}`, `${target}${suffix}`).catch(() => undefined);
+  }
+  return {
+    path: target,
+    cleanup: () => NodeFSP.rm(directory, { recursive: true, force: true }).catch(() => undefined),
+  };
+}