@lvce-editor/main-process 6.18.0 → 6.19.0

package/dist/mainProcessMain.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { Console } from 'node:console';
 import { mkdirSync, createWriteStream, readFileSync, openAsBlob, existsSync, writeFileSync, rmSync, openSync, writeSync, closeSync } from 'node:fs';
 import * as NodePath from 'node:path';
-import { dirname, join as join$1 } from 'node:path';
+import { dirname, join as join$1, isAbsolute } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { pbkdf2Sync, createDecipheriv, createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
@@ -4645,7 +4645,7 @@ const decrypt$1 = (hostKey, encryptedValue, databaseVersion) => {
 
 const chromeEpochOffsetMicroseconds = 11_644_473_600_000_000n;
 const microsecondsPerSecond = 1_000_000n;
-const getSameSite = sameSite => {
+const getSameSite$1 = sameSite => {
   switch (sameSite) {
     case 0:
       return 'no_restriction';
@@ -4657,7 +4657,7 @@ const getSameSite = sameSite => {
       return 'unspecified';
   }
 };
-const getExpirationDate = expiresUtc => {
+const getExpirationDate$1 = expiresUtc => {
   const chromeMicroseconds = BigInt(expiresUtc);
   return Number(chromeMicroseconds - chromeEpochOffsetMicroseconds) / Number(microsecondsPerSecond);
 };
@@ -4667,7 +4667,7 @@ const getValue = (row, databaseVersion) => {
   }
   return decrypt$1(row.hostKey, row.encryptedValue, databaseVersion);
 };
-const convert = (row, databaseVersion, now = Date.now() / 1000) => {
+const convert$1 = (row, databaseVersion, now = Date.now() / 1000) => {
   if (!row.hostKey || row.topFrameSiteKey) {
     return undefined;
   }
@@ -4680,7 +4680,7 @@ const convert = (row, databaseVersion, now = Date.now() / 1000) => {
     httpOnly: Boolean(row.isHttpOnly),
     name: row.name,
     path: row.path || '/',
-    sameSite: getSameSite(row.sameSite),
+    sameSite: getSameSite$1(row.sameSite),
     secure,
     url: `${secure ? 'https' : 'http'}://${host}/`,
     value: getValue(row, databaseVersion)
@@ -4689,7 +4689,7 @@ const convert = (row, databaseVersion, now = Date.now() / 1000) => {
     details.domain = row.hostKey;
   }
   if (row.hasExpires) {
-    const expirationDate = getExpirationDate(row.expiresUtc);
+    const expirationDate = getExpirationDate$1(row.expiresUtc);
     if (!Number.isFinite(expirationDate) || expirationDate <= now) {
       return undefined;
     }
@@ -4699,14 +4699,14 @@ const convert = (row, databaseVersion, now = Date.now() / 1000) => {
 };
 
 /* eslint-disable n/no-unsupported-features/node-builtins -- Electron 43 provides the node:sqlite API used by the main process */
-const getDatabaseError = error => {
+const getDatabaseError$1 = error => {
   const message = error instanceof Error ? error.message : String(error);
   if (message.toLowerCase().includes('locked') || message.toLowerCase().includes('busy')) {
     return new Error('Chrome cookie database is busy. Close Chrome and try again.');
   }
   return new Error('Failed to read the Chrome cookie database');
 };
-const withDatabase = (path, fn) => {
+const withDatabase$1 = (path, fn) => {
   let database;
   try {
     database = new DatabaseSync(path, {
@@ -4718,12 +4718,12 @@ const withDatabase = (path, fn) => {
     if (error instanceof Error && error.message.startsWith('Unsupported Chrome cookie database version')) {
       throw error;
     }
-    throw getDatabaseError(error);
+    throw getDatabaseError$1(error);
   } finally {
     database?.close();
   }
 };
-const getVersion = database => {
+const getVersion$1 = database => {
   const row = database.prepare(`SELECT value FROM meta WHERE key = 'version'`).get();
   const version = Number(row?.value);
   if (version !== 24) {
@@ -4731,16 +4731,16 @@ const getVersion = database => {
   }
   return version;
 };
-const getCookieCount = path => {
-  return withDatabase(path, database => {
-    getVersion(database);
+const getCookieCount$1 = path => {
+  return withDatabase$1(path, database => {
+    getVersion$1(database);
     const row = database.prepare('SELECT COUNT(*) AS count FROM cookies').get();
     return row.count;
   });
 };
-const readCookies = path => {
-  return withDatabase(path, database => {
-    const version = getVersion(database);
+const readCookies$1 = path => {
+  return withDatabase$1(path, database => {
+    const version = getVersion$1(database);
     const rows = database.prepare(`
         SELECT
           encrypted_value AS encryptedValue,
@@ -4795,7 +4795,7 @@ const getChromeDataDirectory = () => {
   const configDirectory = process.env.XDG_CONFIG_HOME || join$1(homedir(), '.config');
   return join$1(configDirectory, 'google-chrome');
 };
-const getActiveProfile = chromeDataDirectory => {
+const getActiveProfile$1 = chromeDataDirectory => {
   const localStatePath = join$1(chromeDataDirectory, 'Local State');
   if (!existsSync(localStatePath)) {
     throw new Error(`Google Chrome profile data was not found at ${chromeDataDirectory}`);
@@ -4953,31 +4953,31 @@ const assertLinux = () => {
     throw new Error('Importing Chrome cookies is only supported on Linux');
   }
 };
-const getInfoFromDirectory = chromeDataDirectory => {
-  const profile = getActiveProfile(chromeDataDirectory);
-  const cookieCount = getCookieCount(profile.cookieDatabasePath);
+const getInfoFromDirectory$1 = chromeDataDirectory => {
+  const profile = getActiveProfile$1(chromeDataDirectory);
+  const cookieCount = getCookieCount$1(profile.cookieDatabasePath);
   return {
     cookieCount,
     profileDirectory: profile.directory,
     profileName: profile.name
   };
 };
-const getInfo = () => {
+const getInfo$1 = () => {
   assertLinux();
-  return getInfoFromDirectory(getChromeDataDirectory());
+  return getInfoFromDirectory$1(getChromeDataDirectory());
 };
-const importFromDirectory = async (chromeDataDirectory, session) => {
-  const profile = getActiveProfile(chromeDataDirectory);
+const importFromDirectory$1 = async (chromeDataDirectory, session) => {
+  const profile = getActiveProfile$1(chromeDataDirectory);
   const {
     rows,
     version
-  } = readCookies(profile.cookieDatabasePath);
+  } = readCookies$1(profile.cookieDatabasePath);
   const cookies = [];
   let skipped = 0;
   let unsupportedEncryption = 0;
   for (const row of rows) {
     try {
-      const cookie = convert(row, version);
+      const cookie = convert$1(row, version);
       if (cookie) {
         cookies.push(cookie);
       } else {
@@ -5010,9 +5010,9 @@ const importFromDirectory = async (chromeDataDirectory, session) => {
     skipped
   };
 };
-const importCookies = async () => {
+const importCookies$1 = async () => {
   assertLinux();
-  return importFromDirectory(getChromeDataDirectory(), getSession());
+  return importFromDirectory$1(getChromeDataDirectory(), getSession());
 };
 
 const handleTimeout = () => {
@@ -6849,6 +6849,233 @@ const open2 = async (options, url) => {
   }
 };
 
+const millisecondsExpirySchemaVersion = 16;
+const getSameSite = sameSite => {
+  switch (sameSite) {
+    case 0:
+      return 'no_restriction';
+    case 1:
+      return 'lax';
+    case 2:
+      return 'strict';
+    default:
+      return 'unspecified';
+  }
+};
+const getExpirationDate = (expiry, databaseVersion) => {
+  return databaseVersion >= millisecondsExpirySchemaVersion ? expiry / 1000 : expiry;
+};
+const getUrlHost = host => {
+  return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+};
+const convert = (row, databaseVersion, now = Date.now() / 1000) => {
+  if (!row.host || row.originAttributes) {
+    return undefined;
+  }
+  const host = row.host.startsWith('.') ? row.host.slice(1) : row.host;
+  if (!host) {
+    return undefined;
+  }
+  const expirationDate = getExpirationDate(row.expiry, databaseVersion);
+  if (!Number.isFinite(expirationDate) || expirationDate <= now) {
+    return undefined;
+  }
+  const secure = Boolean(row.isSecure);
+  const details = {
+    expirationDate,
+    httpOnly: Boolean(row.isHttpOnly),
+    name: row.name,
+    path: row.path || '/',
+    sameSite: getSameSite(row.sameSite),
+    secure,
+    url: `${secure ? 'https' : 'http'}://${getUrlHost(host)}/`,
+    value: row.value
+  };
+  if (row.host.startsWith('.')) {
+    details.domain = row.host;
+  }
+  return details;
+};
+
+/* eslint-disable n/no-unsupported-features/node-builtins -- Electron 43 provides the node:sqlite API used by the main process */
+const getDatabaseError = error => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.toLowerCase().includes('locked') || message.toLowerCase().includes('busy')) {
+    return new Error('Firefox cookie database is busy. Close Firefox and try again.');
+  }
+  return new Error('Failed to read the Firefox cookie database');
+};
+const withDatabase = (path, fn) => {
+  let database;
+  try {
+    database = new DatabaseSync(path, {
+      readOnly: true
+    });
+    database.exec('PRAGMA busy_timeout = 1000');
+    return fn(database);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('Unsupported Firefox cookie database version')) {
+      throw error;
+    }
+    throw getDatabaseError(error);
+  } finally {
+    database?.close();
+  }
+};
+const getVersion = database => {
+  const row = database.prepare('PRAGMA user_version').get();
+  if (row.user_version < 9) {
+    throw new Error(`Unsupported Firefox cookie database version ${row.user_version}`);
+  }
+  return row.user_version;
+};
+const getCookieCount = path => {
+  return withDatabase(path, database => {
+    getVersion(database);
+    const row = database.prepare('SELECT COUNT(*) AS count FROM moz_cookies').get();
+    return row.count;
+  });
+};
+const readCookies = path => {
+  return withDatabase(path, database => {
+    const version = getVersion(database);
+    const rows = database.prepare(`
+        SELECT
+          expiry,
+          host,
+          isHttpOnly,
+          isSecure,
+          name,
+          originAttributes,
+          path,
+          sameSite,
+          value
+        FROM moz_cookies
+      `).all();
+    return {
+      rows,
+      version
+    };
+  });
+};
+
+const parseIni = content => {
+  const sections = {};
+  let section;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const sectionMatch = /^\[([^\]]+)\]$/.exec(trimmed);
+    if (sectionMatch) {
+      section = {};
+      sections[sectionMatch[1]] = section;
+    } else if (section && trimmed && !trimmed.startsWith(';') && !trimmed.startsWith('#')) {
+      const separatorIndex = trimmed.indexOf('=');
+      if (separatorIndex !== -1) {
+        section[trimmed.slice(0, separatorIndex)] = trimmed.slice(separatorIndex + 1);
+      }
+    }
+  }
+  return sections;
+};
+const getProfilePath = (firefoxDataDirectory, profile) => {
+  if (profile.IsRelative === '0' || isAbsolute(profile.Path)) {
+    return profile.Path;
+  }
+  return join$1(firefoxDataDirectory, profile.Path);
+};
+const getFirefoxDataDirectory = () => {
+  const homeDirectory = homedir();
+  if (process.platform === 'win32') {
+    const applicationDataDirectory = process.env.APPDATA || join$1(homeDirectory, 'AppData', 'Roaming');
+    return join$1(applicationDataDirectory, 'Mozilla', 'Firefox');
+  }
+  if (process.platform === 'darwin') {
+    return join$1(homeDirectory, 'Library', 'Application Support', 'Firefox');
+  }
+  const candidates = [join$1(homeDirectory, '.mozilla', 'firefox'), join$1(homeDirectory, 'snap', 'firefox', 'common', '.mozilla', 'firefox'), join$1(homeDirectory, '.var', 'app', 'org.mozilla.firefox', '.mozilla', 'firefox')];
+  const directory = candidates.find(candidate => existsSync(join$1(candidate, 'profiles.ini')));
+  return directory || candidates[0];
+};
+const getActiveProfile = firefoxDataDirectory => {
+  const profilesPath = join$1(firefoxDataDirectory, 'profiles.ini');
+  if (!existsSync(profilesPath)) {
+    throw new Error(`Firefox profile data was not found at ${firefoxDataDirectory}`);
+  }
+  let sections;
+  try {
+    sections = parseIni(readFileSync(profilesPath, 'utf8'));
+  } catch {
+    throw new Error('Firefox profile metadata is invalid');
+  }
+  const profiles = Object.entries(sections).filter(([sectionName, profile]) => sectionName.startsWith('Profile') && profile.Path);
+  const installs = Object.entries(sections).filter(([sectionName, install]) => sectionName.startsWith('Install') && install.Default);
+  const installDefault = (installs.find(([, install]) => install.Locked === '1') || installs[0])?.[1].Default;
+  const selected = profiles.find(([, profile]) => profile.Path === installDefault) || profiles.find(([, profile]) => profile.Default === '1') || profiles[0];
+  if (!selected) {
+    throw new Error('Firefox profile metadata does not contain a profile');
+  }
+  const [, profile] = selected;
+  const profilePath = getProfilePath(firefoxDataDirectory, profile);
+  const cookieDatabasePath = join$1(profilePath, 'cookies.sqlite');
+  if (!existsSync(cookieDatabasePath)) {
+    throw new Error(`Firefox cookie database was not found for profile ${profile.Path}`);
+  }
+  return {
+    cookieDatabasePath,
+    directory: profile.Path,
+    name: profile.Name || profile.Path
+  };
+};
+
+const getInfoFromDirectory = firefoxDataDirectory => {
+  const profile = getActiveProfile(firefoxDataDirectory);
+  const cookieCount = getCookieCount(profile.cookieDatabasePath);
+  return {
+    cookieCount,
+    profileDirectory: profile.directory,
+    profileName: profile.name
+  };
+};
+const getInfo = () => {
+  return getInfoFromDirectory(getFirefoxDataDirectory());
+};
+const importFromDirectory = async (firefoxDataDirectory, session) => {
+  const profile = getActiveProfile(firefoxDataDirectory);
+  const {
+    rows,
+    version
+  } = readCookies(profile.cookieDatabasePath);
+  const cookies = [];
+  let skipped = 0;
+  for (const row of rows) {
+    const cookie = convert(row, version);
+    if (cookie) {
+      cookies.push(cookie);
+    } else {
+      skipped++;
+    }
+  }
+  let imported = 0;
+  let failed = 0;
+  for (const cookie of cookies) {
+    try {
+      await session.cookies.set(cookie);
+      imported++;
+    } catch {
+      failed++;
+    }
+  }
+  await session.cookies.flushStore();
+  return {
+    failed,
+    imported,
+    skipped
+  };
+};
+const importCookies = async () => {
+  return importFromDirectory(getFirefoxDataDirectory(), getSession());
+};
+
 const getWindowId = webContentsId => {
   number(webContentsId);
   const webContents = Electron.webContents.fromId(webContentsId);
@@ -7006,8 +7233,8 @@ const trash = async path => {
 const commandMap = {
   'AppWindow.createAppWindow': createAppWindow,
   'Beep.beep': beep$1,
-  'ChromeCookieImport.getInfo': getInfo,
-  'ChromeCookieImport.importCookies': importCookies,
+  'ChromeCookieImport.getInfo': getInfo$1,
+  'ChromeCookieImport.importCookies': importCookies$1,
   'Crash.crashMainProcess': crashMainProcess$1,
   'CreateMessagePort.createMessagePort': createMessagePort,
   'CreatePidMap.createPidMap': createPidMap,
@@ -7080,6 +7307,8 @@ const commandMap = {
   'ElectronWindowGpuInfo.open': open,
   'ElectronWindowProcessExplorer.open2': open2,
   'Exit.exit': exit,
+  'FirefoxCookieImport.getInfo': getInfo,
+  'FirefoxCookieImport.importCookies': importCookies,
   'GetWindowId.getWindowId': getWindowId,
   'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
   'IpcParent.create': create$1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.18.0",
+  "version": "6.19.0",
   "keywords": [
     "lvce-editor",
     "electron"