@lvce-editor/main-process 6.14.0 → 6.15.0

package/dist/mainProcessMain.js

@@ -9,6 +9,8 @@ import { mkdirSync, createWriteStream, readFileSync, openAsBlob, existsSync, wri
 import * as NodePath from 'node:path';
 import { dirname, join as join$1 } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
+import { pbkdf2Sync, createDecipheriv, createHash } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
 import { MessageChannel } from 'node:worker_threads';
 
 const scheme = 'lvce-oss';
@@ -4066,7 +4068,6 @@ const PageTitleUpdated = 'page-title-updated';
 const Destroyed = 'destroyed';
 const BeforeInputEvent = 'before-input-event';
 
-const Allow = 'allow';
 const Deny = 'deny';
 
 const shouldOpenExternal = url => {
@@ -4604,6 +4605,409 @@ const beep$1 = () => {
   shell.beep();
 };
 
+const chromeV10Prefix = Buffer.from('v10');
+const chromeV10Key = pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1');
+const chromeV10Iv = Buffer.alloc(16, 0x20);
+const domainHashLength = 32;
+class UnsupportedChromeCookieEncryptionError extends Error {
+  constructor() {
+    super('Unsupported Chrome cookie encryption format');
+    this.name = 'UnsupportedChromeCookieEncryptionError';
+  }
+}
+const decrypt$1 = (hostKey, encryptedValue, databaseVersion) => {
+  const buffer = Buffer.from(encryptedValue);
+  if (buffer.length <= chromeV10Prefix.length || !buffer.subarray(0, chromeV10Prefix.length).equals(chromeV10Prefix)) {
+    throw new UnsupportedChromeCookieEncryptionError();
+  }
+  const decipher = createDecipheriv('aes-128-cbc', chromeV10Key, chromeV10Iv);
+  const plaintext = Buffer.concat([decipher.update(buffer.subarray(chromeV10Prefix.length)), decipher.final()]);
+  if (databaseVersion < 24) {
+    return plaintext.toString('utf8');
+  }
+  if (plaintext.length < domainHashLength) {
+    throw new Error('Chrome cookie domain integrity check failed');
+  }
+  const expectedDomainHash = createHash('sha256').update(hostKey).digest();
+  const actualDomainHash = plaintext.subarray(0, domainHashLength);
+  if (!actualDomainHash.equals(expectedDomainHash)) {
+    throw new Error('Chrome cookie domain integrity check failed');
+  }
+  return plaintext.subarray(domainHashLength).toString('utf8');
+};
+
+const chromeEpochOffsetMicroseconds = 11_644_473_600_000_000n;
+const microsecondsPerSecond = 1_000_000n;
+const getSameSite = sameSite => {
+  switch (sameSite) {
+    case 0:
+      return 'no_restriction';
+    case 1:
+      return 'lax';
+    case 2:
+      return 'strict';
+    default:
+      return 'unspecified';
+  }
+};
+const getExpirationDate = expiresUtc => {
+  const chromeMicroseconds = BigInt(expiresUtc);
+  return Number(chromeMicroseconds - chromeEpochOffsetMicroseconds) / Number(microsecondsPerSecond);
+};
+const getValue = (row, databaseVersion) => {
+  if (row.value) {
+    return row.value;
+  }
+  return decrypt$1(row.hostKey, row.encryptedValue, databaseVersion);
+};
+const convert = (row, databaseVersion, now = Date.now() / 1000) => {
+  if (!row.hostKey || row.topFrameSiteKey) {
+    return undefined;
+  }
+  const host = row.hostKey.startsWith('.') ? row.hostKey.slice(1) : row.hostKey;
+  if (!host) {
+    return undefined;
+  }
+  const secure = Boolean(row.isSecure);
+  const details = {
+    httpOnly: Boolean(row.isHttpOnly),
+    name: row.name,
+    path: row.path || '/',
+    sameSite: getSameSite(row.sameSite),
+    secure,
+    url: `${secure ? 'https' : 'http'}://${host}/`,
+    value: getValue(row, databaseVersion)
+  };
+  if (row.hostKey.startsWith('.')) {
+    details.domain = row.hostKey;
+  }
+  if (row.hasExpires) {
+    const expirationDate = getExpirationDate(row.expiresUtc);
+    if (!Number.isFinite(expirationDate) || expirationDate <= now) {
+      return undefined;
+    }
+    details.expirationDate = expirationDate;
+  }
+  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('Chrome cookie database is busy. Close Chrome and try again.');
+  }
+  return new Error('Failed to read the Chrome 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 Chrome cookie database version')) {
+      throw error;
+    }
+    throw getDatabaseError(error);
+  } finally {
+    database?.close();
+  }
+};
+const getVersion = database => {
+  const row = database.prepare(`SELECT value FROM meta WHERE key = 'version'`).get();
+  const version = Number(row?.value);
+  if (version !== 24) {
+    throw new Error(`Unsupported Chrome cookie database version ${Number.isFinite(version) ? version : 'unknown'}`);
+  }
+  return version;
+};
+const getCookieCount = path => {
+  return withDatabase(path, database => {
+    getVersion(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 rows = database.prepare(`
+        SELECT
+          encrypted_value AS encryptedValue,
+          CAST(expires_utc AS TEXT) AS expiresUtc,
+          has_expires AS hasExpires,
+          host_key AS hostKey,
+          is_httponly AS isHttpOnly,
+          is_secure AS isSecure,
+          name,
+          path,
+          samesite AS sameSite,
+          top_frame_site_key AS topFrameSiteKey,
+          value
+        FROM cookies
+      `).all();
+    return {
+      rows,
+      version
+    };
+  });
+};
+
+const isValidProfileDirectory = value => {
+  return value !== '' && value !== '.' && value !== '..' && !value.includes('/') && !value.includes('\\');
+};
+const getCookieDatabasePath = (chromeDataDirectory, profileDirectory) => {
+  const profilePath = join$1(chromeDataDirectory, profileDirectory);
+  const candidates = [join$1(profilePath, 'Cookies'), join$1(profilePath, 'Network', 'Cookies')];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Chrome cookie database was not found for profile ${profileDirectory}`);
+};
+const getMostRecentlyActiveProfile = infoCache => {
+  let selected;
+  let selectedActiveTime = -Infinity;
+  for (const [directory, info] of Object.entries(infoCache)) {
+    if (!isValidProfileDirectory(directory)) {
+      continue;
+    }
+    const activeTime = typeof info.active_time === 'number' && Number.isFinite(info.active_time) ? info.active_time : -Infinity;
+    if (selected === undefined || activeTime > selectedActiveTime) {
+      selected = directory;
+      selectedActiveTime = activeTime;
+    }
+  }
+  return selected;
+};
+const getChromeDataDirectory = () => {
+  const configDirectory = process.env.XDG_CONFIG_HOME || join$1(homedir(), '.config');
+  return join$1(configDirectory, 'google-chrome');
+};
+const getActiveProfile = chromeDataDirectory => {
+  const localStatePath = join$1(chromeDataDirectory, 'Local State');
+  if (!existsSync(localStatePath)) {
+    throw new Error(`Google Chrome profile data was not found at ${chromeDataDirectory}`);
+  }
+  let localState;
+  try {
+    localState = JSON.parse(readFileSync(localStatePath, 'utf8'));
+  } catch {
+    throw new Error('Google Chrome profile metadata is invalid');
+  }
+  const infoCache = localState.profile?.info_cache || {};
+  const orderedProfile = localState.profile?.profiles_order?.find(isValidProfileDirectory);
+  const directory = getMostRecentlyActiveProfile(infoCache) || orderedProfile || 'Default';
+  const name = infoCache[directory]?.name || directory;
+  const cookieDatabasePath = getCookieDatabasePath(chromeDataDirectory, directory);
+  return {
+    cookieDatabasePath,
+    directory,
+    name
+  };
+};
+
+const MainFrame = 'mainFrame';
+const Script = 'script';
+const Xhr = 'xhr';
+
+const Get = 'GET';
+const Head = 'HEAD';
+const Options = 'OPTIONS';
+const Post = 'POST';
+
+// @ts-ignore
+
+const getBeforeRequestResponseMainFrame = (method, url) => {
+  return {};
+};
+const cancelIfStartsWith = (url, canceledUrls) => {
+  for (const canceledUrl of canceledUrls) {
+    if (url.startsWith(canceledUrl)) {
+      return {
+        cancel: true
+      };
+    }
+  }
+  return {};
+};
+const getBeforeRequestResponseXhrPost = url => {
+  const canceledUrls = ['https://www.youtube.com/api/stats/qoe', 'https://www.youtube.com/youtubei/v1/log_event', 'https://play.google.com/log'];
+  return cancelIfStartsWith(url, canceledUrls);
+};
+const getBeforeRequestResponseXhrGet = url => {
+  const canceledUrls = ['https://www.youtube.com/pagead/', 'https://www.youtube.com/api/stats/qoe', 'https://www.youtube.com/api/stats/ads', 'https://www.youtube.com/api/stats/delayplay', 'https://www.youtube.com/ptracking', 'https://www.youtube.com/api/timedtext', 'https://www.youtube.com/pcs/activeview', 'https://googleads.g.doubleclick.net/pagead/id'];
+  return cancelIfStartsWith(url, canceledUrls);
+};
+const getBeforeRequestResponseXhrOptions = url => {
+  const canceledUrls = ['https://play.google.com/log'];
+  return cancelIfStartsWith(url, canceledUrls);
+};
+const getBeforeRequestResponseXhrHead = url => {
+  const canceledUrls = ['https://www.youtube.com/generate_204'];
+  return cancelIfStartsWith(url, canceledUrls);
+};
+const getBeforeRequestResponseXhr = (method, url) => {
+  switch (method) {
+    case Get:
+      return getBeforeRequestResponseXhrGet(url);
+    case Head:
+      return getBeforeRequestResponseXhrHead(url);
+    case Options:
+      return getBeforeRequestResponseXhrOptions(url);
+    case Post:
+      return getBeforeRequestResponseXhrPost(url);
+    default:
+      return {};
+  }
+};
+const getBeforeRequestResponseDefault = (method, url) => {
+  return {};
+};
+const getBeforeRequestResponseScript = (method, url) => {
+  const canceledUrls = ['https://static.doubleclick.net'];
+  return cancelIfStartsWith(url, canceledUrls);
+};
+const getBeforeRequestResponse = details => {
+  const {
+    method,
+    resourceType,
+    url
+  } = details;
+  switch (resourceType) {
+    case MainFrame:
+      return getBeforeRequestResponseMainFrame();
+    case Script:
+      return getBeforeRequestResponseScript(method, url);
+    case Xhr:
+      return getBeforeRequestResponseXhr(method, url);
+    default:
+      return getBeforeRequestResponseDefault();
+  }
+};
+
+/**
+ *
+ * @param {Electron.OnBeforeRequestListenerDetails } details
+ * @param {(response: globalThis.Electron.CallbackResponse) => void} callback
+ */
+const handleBeforeRequest = (details, callback) => {
+  const response = getBeforeRequestResponse(details);
+  callback(response);
+};
+const filter = {
+  // urls: ['https://*.youtube.com/*'],
+  urls: ['<all_urls>']
+};
+
+const state = {
+  session: undefined
+};
+const isAllowedPermission = permission => {
+  switch (permission) {
+    case ClipBoardRead:
+    case ClipBoardSanitizedWrite:
+    case FullScreen:
+    case GeoLocation:
+    case WindowPlacement:
+      return true;
+    default:
+      return false;
+  }
+};
+const handlePermissionRequest = (webContents, permission, callback, details) => {
+  callback(isAllowedPermission(permission));
+};
+const handlePermissionCheck = (webContents, permission, origin, details) => {
+  return isAllowedPermission(permission);
+};
+const createSession = () => {
+  const sessionId = `persist:browserView`;
+  const session = Electron.session.fromPartition(sessionId, {
+    cache: true
+  });
+  session.setPermissionRequestHandler(handlePermissionRequest);
+  session.setPermissionCheckHandler(handlePermissionCheck);
+  session.webRequest.onBeforeRequest(filter, handleBeforeRequest);
+  // session.webRequest.addSessionChromeExtensions(session)
+  return session;
+};
+const getSession = () => {
+  state.session ||= createSession();
+  return state.session;
+};
+
+const assertLinux = () => {
+  if (process.platform !== 'linux') {
+    throw new Error('Importing Chrome cookies is only supported on Linux');
+  }
+};
+const getInfoFromDirectory = chromeDataDirectory => {
+  const profile = getActiveProfile(chromeDataDirectory);
+  const cookieCount = getCookieCount(profile.cookieDatabasePath);
+  return {
+    cookieCount,
+    profileDirectory: profile.directory,
+    profileName: profile.name
+  };
+};
+const getInfo = () => {
+  assertLinux();
+  return getInfoFromDirectory(getChromeDataDirectory());
+};
+const importFromDirectory = async (chromeDataDirectory, session) => {
+  const profile = getActiveProfile(chromeDataDirectory);
+  const {
+    rows,
+    version
+  } = readCookies(profile.cookieDatabasePath);
+  const cookies = [];
+  let skipped = 0;
+  let unsupportedEncryption = 0;
+  for (const row of rows) {
+    try {
+      const cookie = convert(row, version);
+      if (cookie) {
+        cookies.push(cookie);
+      } else {
+        skipped++;
+      }
+    } catch (error) {
+      skipped++;
+      if (error instanceof UnsupportedChromeCookieEncryptionError) {
+        unsupportedEncryption++;
+      }
+    }
+  }
+  if (cookies.length === 0 && unsupportedEncryption > 0) {
+    throw new Error('Unsupported Chrome cookie encryption format');
+  }
+  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 () => {
+  assertLinux();
+  return importFromDirectory(getChromeDataDirectory(), getSession());
+};
+
 const handleTimeout = () => {
   throw new Error('oops');
 };
@@ -5900,9 +6304,6 @@ const ElectronBrowserViewEventListenerWillNavigate = {
 	key: key$1
 };
 
-const BackgroundTab = 'background-tab';
-const NewWindow = 'new-window';
-
 const key = 'window-open';
 const attach = (webContents, listener) => {
   webContents.setWindowOpenHandler(listener);
@@ -5911,38 +6312,11 @@ const detach = (webContents, listener) => {
   webContents.setWindowOpenHandler(null);
 };
 const handler = ({
-  disposition,
-  features,
-  frameName,
-  postBody,
-  referrer,
   url
 }) => {
-  if (url === 'about:blank') {
-    return {
-      messages: [],
-      result: {
-        action: Allow
-      }
-    };
-  }
-  if (disposition === BackgroundTab) {
-    return {
-      messages: [['handleWindowOpen', url]],
-      result: {
-        action: Deny
-      }
-    };
-  }
-  if (disposition === NewWindow) {
-    return {
-      messages: [],
-      result: {
-        action: Allow
-      }
-    };
+  if (shouldOpenExternal(url)) {
+    void openExternal(url);
   }
-  info(`[main-process] blocked popup for ${url}`);
   return {
     messages: [],
     result: {
@@ -5970,136 +6344,6 @@ const ElectronBrowserViewEventListeners = {
 	windowOpen: ElectronBrowserViewEventListenerWindowOpen
 };
 
-const MainFrame = 'mainFrame';
-const Script = 'script';
-const Xhr = 'xhr';
-
-const Get = 'GET';
-const Head = 'HEAD';
-const Options = 'OPTIONS';
-const Post = 'POST';
-
-// @ts-ignore
-
-const getBeforeRequestResponseMainFrame = (method, url) => {
-  return {};
-};
-const cancelIfStartsWith = (url, canceledUrls) => {
-  for (const canceledUrl of canceledUrls) {
-    if (url.startsWith(canceledUrl)) {
-      return {
-        cancel: true
-      };
-    }
-  }
-  return {};
-};
-const getBeforeRequestResponseXhrPost = url => {
-  const canceledUrls = ['https://www.youtube.com/api/stats/qoe', 'https://www.youtube.com/youtubei/v1/log_event', 'https://play.google.com/log'];
-  return cancelIfStartsWith(url, canceledUrls);
-};
-const getBeforeRequestResponseXhrGet = url => {
-  const canceledUrls = ['https://www.youtube.com/pagead/', 'https://www.youtube.com/api/stats/qoe', 'https://www.youtube.com/api/stats/ads', 'https://www.youtube.com/api/stats/delayplay', 'https://www.youtube.com/ptracking', 'https://www.youtube.com/api/timedtext', 'https://www.youtube.com/pcs/activeview', 'https://googleads.g.doubleclick.net/pagead/id'];
-  return cancelIfStartsWith(url, canceledUrls);
-};
-const getBeforeRequestResponseXhrOptions = url => {
-  const canceledUrls = ['https://play.google.com/log'];
-  return cancelIfStartsWith(url, canceledUrls);
-};
-const getBeforeRequestResponseXhrHead = url => {
-  const canceledUrls = ['https://www.youtube.com/generate_204'];
-  return cancelIfStartsWith(url, canceledUrls);
-};
-const getBeforeRequestResponseXhr = (method, url) => {
-  switch (method) {
-    case Get:
-      return getBeforeRequestResponseXhrGet(url);
-    case Head:
-      return getBeforeRequestResponseXhrHead(url);
-    case Options:
-      return getBeforeRequestResponseXhrOptions(url);
-    case Post:
-      return getBeforeRequestResponseXhrPost(url);
-    default:
-      return {};
-  }
-};
-const getBeforeRequestResponseDefault = (method, url) => {
-  return {};
-};
-const getBeforeRequestResponseScript = (method, url) => {
-  const canceledUrls = ['https://static.doubleclick.net'];
-  return cancelIfStartsWith(url, canceledUrls);
-};
-const getBeforeRequestResponse = details => {
-  const {
-    method,
-    resourceType,
-    url
-  } = details;
-  switch (resourceType) {
-    case MainFrame:
-      return getBeforeRequestResponseMainFrame();
-    case Script:
-      return getBeforeRequestResponseScript(method, url);
-    case Xhr:
-      return getBeforeRequestResponseXhr(method, url);
-    default:
-      return getBeforeRequestResponseDefault();
-  }
-};
-
-/**
- *
- * @param {Electron.OnBeforeRequestListenerDetails } details
- * @param {(response: globalThis.Electron.CallbackResponse) => void} callback
- */
-const handleBeforeRequest = (details, callback) => {
-  const response = getBeforeRequestResponse(details);
-  callback(response);
-};
-const filter = {
-  // urls: ['https://*.youtube.com/*'],
-  urls: ['<all_urls>']
-};
-
-const state = {
-  session: undefined
-};
-const isAllowedPermission = permission => {
-  switch (permission) {
-    case ClipBoardRead:
-    case ClipBoardSanitizedWrite:
-    case FullScreen:
-    case GeoLocation:
-    case WindowPlacement:
-      return true;
-    default:
-      return false;
-  }
-};
-const handlePermissionRequest = (webContents, permission, callback, details) => {
-  callback(isAllowedPermission(permission));
-};
-const handlePermissionCheck = (webContents, permission, origin, details) => {
-  return isAllowedPermission(permission);
-};
-const createSession = () => {
-  const sessionId = `persist:browserView`;
-  const session = Electron.session.fromPartition(sessionId, {
-    cache: true
-  });
-  session.setPermissionRequestHandler(handlePermissionRequest);
-  session.setPermissionCheckHandler(handlePermissionCheck);
-  session.webRequest.onBeforeRequest(filter, handleBeforeRequest);
-  // session.webRequest.addSessionChromeExtensions(session)
-  return session;
-};
-const getSession = () => {
-  state.session ||= createSession();
-  return state.session;
-};
-
 const send = (method, ...params) => {
   const rpc = get(EmbedsProcess);
   if (!rpc) {
@@ -6688,6 +6932,8 @@ const trash = async path => {
 const commandMap = {
   'AppWindow.createAppWindow': createAppWindow,
   'Beep.beep': beep$1,
+  'ChromeCookieImport.getInfo': getInfo,
+  'ChromeCookieImport.importCookies': importCookies,
   'Crash.crashMainProcess': crashMainProcess$1,
   'CreateMessagePort.createMessagePort': createMessagePort,
   'CreatePidMap.createPidMap': createPidMap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.14.0",
+  "version": "6.15.0",
   "keywords": [
     "lvce-editor",
     "electron"
@@ -14,7 +14,7 @@
   "type": "module",
   "main": "dist/mainProcessMain.js",
   "dependencies": {
-    "electron": "43.1.1"
+    "electron": "43.2.0"
   },
   "engines": {
     "node": ">=22"