@lvce-editor/main-process 6.14.1 → 6.16.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';
@@ -3424,7 +3426,7 @@ const formatUtilityProcessName = name => {
 const state$6 = {
   all: Object.create(null)
 };
-const add$1 = (pid, process, name) => {
+const add$2 = (pid, process, name) => {
   number(pid);
   object(process);
   string(name);
@@ -3459,7 +3461,7 @@ const trackUtilityProcess = (rawIpc, name) => {
     pid
   } = rawIpc;
   const formattedName = formatUtilityProcessName(name);
-  add$1(pid, rawIpc, formattedName);
+  add$2(pid, rawIpc, formattedName);
   const cleanup = () => {
     remove$1(pid);
     rawIpc.off('exit', handleExit);
@@ -4065,6 +4067,7 @@ const DidNavigate = 'did-navigate';
 const PageTitleUpdated = 'page-title-updated';
 const Destroyed = 'destroyed';
 const BeforeInputEvent = 'before-input-event';
+const Login = 'login';
 
 const Deny = 'deny';
 
@@ -4085,7 +4088,7 @@ const state$3 = {
   fallThroughKeyBindings: [],
   views: Object.create(null)
 };
-const add = (id, browserWindow, view) => {
+const add$1 = (id, browserWindow, view) => {
   // state
   state$3.views[id] = {
     browserWindow,
@@ -4603,6 +4606,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');
 };
@@ -5750,14 +6156,14 @@ const getKeyBindingIdentifier = input => {
   return identifier;
 };
 
-const key$6 = 'before-input';
-const attach$6 = (webContents, listener) => {
+const key$7 = 'before-input';
+const attach$7 = (webContents, listener) => {
   webContents.on(BeforeInputEvent, listener);
 };
-const detach$6 = (webContents, listener) => {
+const detach$7 = (webContents, listener) => {
   webContents.off(BeforeInputEvent, listener);
 };
-const handler$6 = (event, input) => {
+const handler$7 = (event, input) => {
   if (input.type !== KeyDown) {
     return {
       messages: [],
@@ -5782,6 +6188,28 @@ const handler$6 = (event, input) => {
 };
 
 const ElectronBrowserViewEventListenerBeforeInput = {
+	__proto__: null,
+	attach: attach$7,
+	detach: detach$7,
+	handler: handler$7,
+	key: key$7
+};
+
+const key$6 = 'context-menu';
+const attach$6 = (webContents, listener) => {
+  webContents.on(ContextMenu, listener);
+};
+const detach$6 = (webContents, listener) => {
+  webContents.off(ContextMenu, listener);
+};
+const handler$6 = (event, params) => {
+  return {
+    messages: [['handleContextMenu', params]],
+    result: undefined
+  };
+};
+
+const ElectronBrowserViewEventListenerContextMenu = {
 	__proto__: null,
 	attach: attach$6,
 	detach: detach$6,
@@ -5789,21 +6217,21 @@ const ElectronBrowserViewEventListenerBeforeInput = {
 	key: key$6
 };
 
-const key$5 = 'context-menu';
+const key$5 = 'destroyed';
 const attach$5 = (webContents, listener) => {
-  webContents.on(ContextMenu, listener);
+  webContents.on(Destroyed, listener);
 };
 const detach$5 = (webContents, listener) => {
-  webContents.off(ContextMenu, listener);
+  webContents.off(Destroyed, listener);
 };
-const handler$5 = (event, params) => {
+const handler$5 = () => {
   return {
-    messages: [['handleContextMenu', params]],
+    messages: [['handleBrowserViewDestroyed']],
     result: undefined
   };
 };
 
-const ElectronBrowserViewEventListenerContextMenu = {
+const ElectronBrowserViewEventListenerDestroyed = {
 	__proto__: null,
 	attach: attach$5,
 	detach: detach$5,
@@ -5811,21 +6239,21 @@ const ElectronBrowserViewEventListenerContextMenu = {
 	key: key$5
 };
 
-const key$4 = 'destroyed';
+const key$4 = 'did-navigate';
 const attach$4 = (webContents, listener) => {
-  webContents.on(Destroyed, listener);
+  webContents.on(DidNavigate, listener);
 };
 const detach$4 = (webContents, listener) => {
-  webContents.off(Destroyed, listener);
+  webContents.off(DidNavigate, listener);
 };
-const handler$4 = () => {
+const handler$4 = (event, url) => {
   return {
-    messages: [['handleBrowserViewDestroyed']],
+    messages: [['handleDidNavigate', url]],
     result: undefined
   };
 };
 
-const ElectronBrowserViewEventListenerDestroyed = {
+const ElectronBrowserViewEventListenerDidNavigate = {
 	__proto__: null,
 	attach: attach$4,
 	detach: detach$4,
@@ -5833,21 +6261,64 @@ const ElectronBrowserViewEventListenerDestroyed = {
 	key: key$4
 };
 
-const key$3 = 'did-navigate';
+const pendingLogins = new Map();
+let nextRequestId = 1;
+const add = (webContentsId, callback) => {
+  const requestId = `${webContentsId}:${nextRequestId++}`;
+  pendingLogins.set(requestId, {
+    callback,
+    webContentsId
+  });
+  return requestId;
+};
+const take = requestId => {
+  const pendingLogin = pendingLogins.get(requestId);
+  pendingLogins.delete(requestId);
+  return pendingLogin;
+};
+const accept = (requestId, username, password) => {
+  const pendingLogin = take(requestId);
+  pendingLogin?.callback(username, password);
+};
+const cancel = requestId => {
+  const pendingLogin = take(requestId);
+  pendingLogin?.callback();
+};
+const cancelForWebContents = webContentsId => {
+  for (const [requestId, pendingLogin] of pendingLogins) {
+    if (pendingLogin.webContentsId !== webContentsId) {
+      continue;
+    }
+    pendingLogins.delete(requestId);
+    pendingLogin.callback();
+  }
+};
+
+const key$3 = Login;
 const attach$3 = (webContents, listener) => {
-  webContents.on(DidNavigate, listener);
+  webContents.on(Login, listener);
 };
 const detach$3 = (webContents, listener) => {
-  webContents.off(DidNavigate, listener);
+  webContents.off(Login, listener);
 };
-const handler$3 = (event, url) => {
+const handler$3 = (event, authenticationResponseDetails, authInfo, callback, webContentsId) => {
+  event.preventDefault();
+  const requestId = add(webContentsId, callback);
   return {
-    messages: [['handleDidNavigate', url]],
+    messages: [['handleLogin', {
+      host: authInfo.host,
+      isProxy: authInfo.isProxy,
+      port: authInfo.port,
+      realm: authInfo.realm,
+      requestId,
+      scheme: authInfo.scheme,
+      url: String(authenticationResponseDetails.url)
+    }]],
     result: undefined
   };
 };
 
-const ElectronBrowserViewEventListenerDidNavigate = {
+const ElectronBrowserViewEventListenerLogin = {
 	__proto__: null,
 	attach: attach$3,
 	detach: detach$3,
@@ -5934,141 +6405,12 @@ const ElectronBrowserViewEventListeners = {
 	contextMenu: ElectronBrowserViewEventListenerContextMenu,
 	destroyed: ElectronBrowserViewEventListenerDestroyed,
 	didNavigate: ElectronBrowserViewEventListenerDidNavigate,
+	login: ElectronBrowserViewEventListenerLogin,
 	pageTitleUpdated: ElectronBrowserViewEventListenerPageTitleUpdated,
 	willNavigate: ElectronBrowserViewEventListenerWillNavigate,
 	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) {
@@ -6092,7 +6434,7 @@ const createWebContentsView = async () => {
   const {
     id
   } = webContents;
-  add(id, browserWindow, view);
+  add$1(id, browserWindow, view);
   return id;
 };
 const attachEventListeners = webContentsId => {
@@ -6108,7 +6450,7 @@ const attachEventListeners = webContentsId => {
       const {
         messages,
         result
-      } = value.handler(...args);
+      } = value.handler(...args, webContentsId);
       for (const message of messages) {
         const [key, ...rest] = message;
         send(`ElectronWebContents.${key}`, webContentsId, ...rest);
@@ -6122,6 +6464,7 @@ const attachEventListeners = webContentsId => {
 };
 const disposeWebContentsView = browserViewId => {
   console.log('[main process] dispose browser view', browserViewId);
+  cancelForWebContents(browserViewId);
   const instance = get$3(browserViewId);
   if (!instance) {
     return;
@@ -6657,6 +7000,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,
@@ -6695,7 +7040,9 @@ const commandMap = {
   'ElectronWebContents.callFunction': callFunction,
   'ElectronWebContents.dispose': dispose$1,
   'ElectronWebContents.getStats': getStats$1,
+  'ElectronWebContentsView.acceptLogin': accept,
   'ElectronWebContentsView.attachEventListeners': attachEventListeners,
+  'ElectronWebContentsView.cancelLogin': cancel,
   'ElectronWebContentsView.createWebContentsView': createWebContentsView,
   'ElectronWebContentsView.disposeWebContentsView': disposeWebContentsView,
   'ElectronWebContentsViewFunctions.addToWindow': addToWindow,

package/package.json

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