codex-overleaf-link 2.2.1 → 2.3.0

package/extension/src/content/nativeCompatibilityController.js

@@ -0,0 +1,313 @@
+(function initCodexOverleafNativeCompatibilityController(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafNativeCompatibilityController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function nativeCompatibilityControllerFactory() {
+  'use strict';
+
+  function create(options = {}) {
+    const Compatibility = options.compatibility;
+    const nativeChannel = options.nativeChannel;
+    const gatedMethods = options.gatedMethods || new Set();
+    const tx = options.tx;
+    const tr = options.tr;
+
+    function sendNative(payload) {
+      return dispatch(payload, 'sendNative');
+    }
+
+    function sendBackgroundNative(payload) {
+      return dispatch(payload, 'sendBackgroundNative');
+    }
+
+    async function dispatch(payload, channelMethod) {
+      const compatibilityGate = await ensureForMethod(payload?.method);
+      if (!compatibilityGate.ok) return compatibilityGate.response;
+      if (gatedMethods.has(payload?.method)) options.throwIfCancellationRequested?.();
+      return nativeChannel[channelMethod](
+        attachEvidence(payload, compatibilityGate.compatibility)
+      );
+    }
+
+    async function ensureForMethod(method) {
+      const metadata = options.getExtensionCompatibilityMetadata?.() || {};
+      const params = Compatibility?.buildBridgePingParams
+        ? Compatibility.buildBridgePingParams(metadata)
+        : {};
+      const response = await nativeChannel.sendBackgroundNative({
+        method: 'bridge.ping',
+        params
+      });
+      const compatibility = Compatibility?.evaluateNativeCompatibility
+        ? Compatibility.evaluateNativeCompatibility(response, metadata)
+        : options.fallbackNativeCompatibility(response);
+      const allowed = !gatedMethods.has(method) ||
+        (Compatibility?.isNativeMethodAllowed
+          ? Compatibility.isNativeMethodAllowed(method, compatibility)
+          : compatibility.status === 'ok');
+      if (allowed) return { ok: true, compatibility };
+
+      const message = formatBlockedMessage(method, compatibility);
+      const installCommand = options.installCommand;
+      const error = {
+        code: 'native_update_required',
+        message,
+        status: compatibility.status || 'unknown_native',
+        classification: options.getNativeCompatibilityClassification(compatibility),
+        installCommand: compatibility.installCommand || installCommand,
+        updateCommand: compatibility.updateCommand || compatibility.installCommand || installCommand,
+        currentNativeVersion: compatibility.currentNativeVersion
+          || compatibility.nativeVersion
+          || compatibility.native?.version
+          || '',
+        requiredVersion: compatibility.requiredVersion || Compatibility?.BUILD_TARGET_VERSION || '',
+        releaseUrl: compatibility.releaseUrl || ''
+      };
+      notifyBlocked(error, compatibility);
+      return { ok: false, compatibility, response: { ok: false, error } };
+    }
+
+    function attachEvidence(payload = {}, compatibility) {
+      if (!compatibility || !gatedMethods.has(payload?.method)) return payload;
+      return {
+        ...payload,
+        params: {
+          ...(payload.params || {}),
+          nativeCompatibility: compatibility
+        }
+      };
+    }
+
+    function notifyBlocked(error, compatibility = {}) {
+      const message = error?.message || String(error || '');
+      if (options.getCurrentRunView?.()) {
+        options.appendRunEvent?.({ title: message, status: 'failed' });
+        showUpdateGuidance(compatibility);
+        return;
+      }
+      showUpdateGuidance(compatibility);
+      options.showPluginToast?.(message, { status: 'failed', sticky: true });
+    }
+
+    async function refreshBadge() {
+      const renderer = options.getPanelRendererInstance?.();
+      if (!renderer?.headerEl || !Compatibility?.evaluateNativeCompatibility) return;
+      try {
+        const metadata = options.getExtensionCompatibilityMetadata?.() || {};
+        const params = Compatibility.buildBridgePingParams
+          ? Compatibility.buildBridgePingParams(metadata)
+          : {};
+        const response = await sendBackgroundNative({ method: 'bridge.ping', params });
+        const compatibility = Compatibility.evaluateNativeCompatibility(response, metadata);
+        const classification = options.getNativeCompatibilityClassification(compatibility);
+        if (classification === 'compatible') {
+          options.setBadge?.(renderer.headerEl, { type: 'none' });
+          options.setDiagnosticsHealth?.('ok');
+          try {
+            options.localStorage?.setItem('codexOverleafNativeEverOk', 'true');
+          } catch (_storageError) {}
+          return;
+        }
+        options.setDiagnosticsHealth?.(classification === 'update-available' ? 'warn' : 'fail');
+        options.setBadge?.(renderer.headerEl, {
+          type: 'update',
+          tooltip: tx('Native host update available', 'Native host 可更新'),
+          onClick: () => showUpdateGuidance(compatibility)
+        });
+        if (!compatibility?.native?.version) maybePromptFirstRunSetup();
+      } catch (_error) {
+        options.setDiagnosticsHealth?.('fail');
+        options.setBadge?.(renderer.headerEl, {
+          type: 'update',
+          tooltip: tx(
+            'Native host is not responding — click for setup steps',
+            'Native host 未响应——点击查看安装步骤'
+          ),
+          onClick: () => showUpdateGuidance(options.fallbackNativeCompatibility({ ok: false }))
+        });
+        maybePromptFirstRunSetup();
+      }
+    }
+
+    function maybePromptFirstRunSetup() {
+      const storage = options.localStorage;
+      try {
+        if (!storage || storage.getItem('codexOverleafSetupPromptShown') === 'true') return;
+        if (storage.getItem('codexOverleafNativeEverOk') === 'true') return;
+        storage.setItem('codexOverleafSetupPromptShown', 'true');
+      } catch (_storageError) {
+        return;
+      }
+      showUpdateGuidance(options.fallbackNativeCompatibility({ ok: false }));
+    }
+
+    function showUpdateGuidance(compatibility = {}) {
+      let panel = options.getPanel?.();
+      if (!panel) {
+        options.ensurePanelOpen?.();
+        panel = options.getPanel?.();
+      }
+      if (!panel) return;
+      panel.querySelector('[data-native-update-guidance]')?.remove();
+      const native = compatibility.native || {};
+      const extensionVersion = compatibility.extensionVersion || Compatibility?.BUILD_TARGET_VERSION || '';
+      const nativeVersion = compatibility.currentNativeVersion
+        || compatibility.nativeVersion
+        || native.version
+        || tx('missing', '未安装');
+      const command = compatibility.updateCommand
+        || compatibility.installCommand
+        || options.installCommand;
+      const releaseUrl = compatibility.releaseUrl || '';
+      const overlay = options.document.createElement('div');
+      overlay.className = 'codex-plugin-confirm';
+      overlay.dataset.nativeUpdateGuidance = 'true';
+      overlay.setAttribute('role', 'dialog');
+      overlay.setAttribute('aria-modal', 'true');
+      const nativeMissing = !native.version;
+      overlay.setAttribute(
+        'aria-label',
+        nativeMissing
+          ? tx('Set up the native host', '安装 Native host')
+          : tx('Native host update available', 'Native host 可更新')
+      );
+      const card = options.document.createElement('section');
+      card.className = 'codex-plugin-confirm-card';
+      const title = options.document.createElement('div');
+      title.className = 'codex-plugin-confirm-title';
+      title.textContent = nativeMissing
+        ? tx('One step left: install the native host', '还差一步：安装 Native host')
+        : tx('Native host update available', 'Native host 可更新');
+      const body = options.document.createElement('div');
+      body.className = 'codex-plugin-confirm-body';
+      body.textContent = [
+        nativeMissing
+          ? tx(
+            `Extension v${extensionVersion} is ready; Codex still needs its local bridge to read and edit this project.`,
+            `扩展 v${extensionVersion} 已就绪；Codex 还需要本地桥接程序才能读写这个项目。`
+          )
+          : tx(
+            `Extension v${extensionVersion} / Native v${nativeVersion}`,
+            `扩展 v${extensionVersion} / Native v${nativeVersion}`
+          ),
+        tx(
+          'Run the platform-specific command below, reload the extension, then refresh Overleaf.',
+          '运行下面的平台命令，重新加载扩展，然后刷新 Overleaf。'
+        )
+      ].join('\n\n');
+      const commandCode = options.document.createElement('code');
+      commandCode.textContent = command;
+      Object.assign(commandCode.style, {
+        display: 'block',
+        whiteSpace: 'pre-wrap',
+        marginTop: '0.75rem'
+      });
+      body.append(commandCode);
+      if (releaseUrl) {
+        const link = options.document.createElement('a');
+        link.href = releaseUrl;
+        link.target = '_blank';
+        link.rel = 'noopener noreferrer';
+        link.textContent = tx('Open GitHub Release', '打开 GitHub Release');
+        Object.assign(link.style, { display: 'block', marginTop: '0.75rem' });
+        body.append(link);
+      }
+      const actions = options.document.createElement('div');
+      actions.className = 'codex-plugin-confirm-actions';
+      const copy = options.document.createElement('button');
+      copy.type = 'button';
+      copy.className = 'codex-plugin-confirm-confirm';
+      copy.textContent = tx('Copy command', '复制命令');
+      copy.addEventListener('click', async () => {
+        await options.navigator.clipboard.writeText(command);
+        copy.textContent = tx('Copied', '已复制');
+      });
+      const close = options.document.createElement('button');
+      close.type = 'button';
+      close.className = 'codex-plugin-confirm-cancel';
+      close.textContent = tx('Close', '关闭');
+      close.addEventListener('click', () => overlay.remove());
+      actions.append(close, copy);
+      card.append(title, body, actions);
+      overlay.append(card);
+      overlay.addEventListener('click', event => {
+        if (event.target === overlay) overlay.remove();
+      });
+      panel.append(overlay);
+      copy.focus();
+    }
+
+    function scheduleFirstUseOnboardingTip() {
+      options.setTimeout(() => {
+        maybeShowFirstUseOnboardingTip().catch(() => {});
+      }, 250);
+    }
+
+    async function maybeShowFirstUseOnboardingTip() {
+      const panel = options.getPanel?.();
+      if (!panel || (options.getState?.()?.sessions || []).length > 0) return;
+      const key = options.onboardingTipStorageKey;
+      const stored = await options.chromeApi.storage.local.get([key]);
+      if (stored?.[key]) return;
+      const modeSelect = panel.querySelector('[data-mode]');
+      if (!modeSelect) return;
+      const tip = options.document.createElement('div');
+      tip.className = 'codex-onboarding-tip';
+      tip.dataset.onboardingTip = 'true';
+      tip.setAttribute('role', 'status');
+      tip.textContent = tx(
+        'Tip: Start with Ask mode to explore safely. Switch to Suggest to review edits before applying.',
+        '提示：先用 Ask 模式安全探索；需要修改时切换到 Suggest，应用前可先审阅。'
+      );
+      Object.assign(tip.style, {
+        position: 'absolute',
+        zIndex: '2147483647',
+        maxWidth: '280px'
+      });
+      panel.append(tip);
+      const panelRect = panel.getBoundingClientRect();
+      const modeRect = modeSelect.getBoundingClientRect();
+      tip.style.left = `${Math.max(12, modeRect.left - panelRect.left)}px`;
+      tip.style.bottom = `${Math.max(72, panelRect.bottom - modeRect.top + 8)}px`;
+      const dismiss = () => {
+        tip.remove();
+        options.chromeApi.storage.local.set({ [key]: true }).catch?.(() => {});
+        panel.removeEventListener('click', dismiss, true);
+        panel.removeEventListener('keydown', dismiss, true);
+      };
+      panel.addEventListener('click', dismiss, true);
+      panel.addEventListener('keydown', dismiss, true);
+      options.setTimeout(dismiss, 8000);
+    }
+
+    function formatBlockedMessage(method, compatibility = {}) {
+      const params = { method: method || 'native request' };
+      switch (compatibility.status || 'unknown_native') {
+        case 'native_too_old':
+          return tr('nativeCompatibilityBlockedNativeTooOld', params);
+        case 'extension_too_old':
+          return tr('nativeCompatibilityBlockedExtensionTooOld', params);
+        case 'protocol_unsupported':
+          return tr('nativeCompatibilityBlockedProtocol', params);
+        case 'native_unhealthy':
+          return tr('nativeCompatibilityBlockedUnhealthy', params);
+        case 'native_missing':
+          return tr('nativeCompatibilityBlockedMissing', params);
+        default:
+          return tr('nativeCompatibilityBlockedGeneric', params);
+      }
+    }
+
+    return Object.freeze({
+      attachEvidence,
+      ensureForMethod,
+      refreshBadge,
+      scheduleFirstUseOnboardingTip,
+      sendBackgroundNative,
+      sendNative,
+      showUpdateGuidance
+    });
+  }
+
+  return Object.freeze({ create });
+});

package/extension/src/content/otWarmMirror.js

@@ -1,10 +1,6 @@
 (function initCodexOverleafOtWarmMirror() {
   'use strict';
 
-  const otWarmMirrorController = window.CodexOverleafOtWarmMirrorController;
-  const runController = window.CodexOverleafRunController;
-  const mirrorHealth = window.CodexOverleafMirrorHealth;
-
   // Experimental OT warm-mirror glue carved out of contentRuntime.js (v1.4.9
   // structural-debt phase 5): the per-project enable toggle flow, the
   // poll/flush timers and patch queue, mirror prefetch, warm-start
@@ -15,6 +11,12 @@
   // runtime reads it through the exported accessors and clears it on project
   // navigation via clearMirrorPrefetchTimer()/releaseOtWarmMirrorProject().
   function create(deps = {}) {
+    const {
+      otWarmMirrorController,
+      runController,
+      mirrorHealth,
+      projectFiles
+    } = deps;
     const {
       tr,
       tx,
@@ -853,7 +855,7 @@
       project,
       snapshotWarnings,
       focusFiles,
-      isUsableProjectFileContent: window.CodexOverleafProjectFiles.isUsableProjectFileContent
+      isUsableProjectFileContent: projectFiles.isUsableProjectFileContent
     });
     if (snapshotWarnings.blocking.length && !focusedPartialSnapshot) {
       for (const warning of snapshotWarnings.blocking) {

package/extension/src/content/pageBridgeClient.js

@@ -0,0 +1,224 @@
+(function initCodexOverleafPageBridgeClient(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafPageBridgeClient = api;
+})(typeof window !== 'undefined' ? window : globalThis, function pageBridgeClientFactory() {
+  'use strict';
+
+  const PAGE_WORLD_SCRIPTS = Object.freeze([
+    ['src/shared/reviewing.js', 'codex-overleaf-reviewing-script'],
+    ['src/shared/projectFiles.js', 'codex-overleaf-project-files-script'],
+    ['src/shared/compatibility.js', 'codex-overleaf-compatibility-page-script'],
+    ['src/shared/pageRpcContract.js', 'codex-overleaf-page-rpc-contract-script'],
+    ['src/shared/staleGuard.js', 'codex-overleaf-stale-guard-script'],
+    ['src/shared/compileAdapter.js', 'codex-overleaf-compile-adapter-script'],
+    ['src/shared/sensitiveScan.js', 'codex-overleaf-sensitive-scan-script'],
+    ['src/shared/auditRecords.js', 'codex-overleaf-audit-records-script'],
+    ['src/page/saveState.js', 'codex-overleaf-save-state-script', true],
+    ['src/page/overleafCapabilities.js', 'codex-overleaf-capabilities-script'],
+    ['src/page/compileBridge.js', 'codex-overleaf-compile-bridge-script'],
+    ['src/page/overleafEditor.js', 'codex-overleaf-editor-script'],
+    ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
+    ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
+    ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
+    ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
+    ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
+    ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
+    ['src/pageBridge.js', 'codex-overleaf-page-bridge-script', true]
+  ]);
+  const OPTIONAL_OT_SCRIPTS = Object.freeze([
+    ['src/shared/otText.js', 'codex-overleaf-ot-text-script'],
+    ['src/page/overleafRealtimeObserver.js', 'codex-overleaf-realtime-observer-script']
+  ]);
+
+  function create(options = {}) {
+    const windowRef = options.window || globalThis.window;
+    const documentRef = options.document || windowRef?.document;
+    const chromeApi = options.chromeApi || globalThis.chrome;
+    const cryptoImpl = options.crypto || globalThis.crypto;
+    const runtimeRoot = options.root || windowRef;
+    const Contract = options.contract;
+    const Compatibility = options.compatibility;
+    const timeoutOverrides = { ...(options.timeoutOverrides || {}) };
+    const revision = Contract.REVISION;
+    const capability = createCapability(cryptoImpl);
+    const activeCancellationHandlers = new Map();
+    let readyPromise = null;
+
+    function start() {
+      if (!readyPromise) readyPromise = injectPageBridge();
+      return readyPromise;
+    }
+
+    async function call(method, params) {
+      try {
+        await start();
+      } catch (error) {
+        return { ok: false, error: `Page bridge unavailable: ${error.message}` };
+      }
+      return send(method, params, Contract.resolveDispatchPolicy(method, timeoutOverrides));
+    }
+
+    function send(method, params, policy = {}) {
+      const id = cryptoImpl.randomUUID();
+      return new Promise((resolve, reject) => {
+        const timeoutMs = Number.isFinite(Number(policy.timeoutMs))
+          ? Number(policy.timeoutMs)
+          : Contract.resolveTimeoutMs(method, timeoutOverrides);
+        const cancellable = policy.cancellation === 'content_abort';
+        let settled = false;
+        let timeout = null;
+        function cleanup() {
+          if (timeout !== null) windowRef.clearTimeout(timeout);
+          windowRef.removeEventListener('message', onMessage);
+          if (cancellable) activeCancellationHandlers.delete(id);
+        }
+        function resolveOnce(value) {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(value);
+        }
+        function rejectOnce(error) {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(error);
+        }
+        function cancelRequest() {
+          const error = new Error('Codex run was cancelled by the user');
+          error.code = 'codex_cancelled';
+          error.cancelled = true;
+          rejectOnce(error);
+        }
+        timeout = windowRef.setTimeout(() => {
+          resolveOnce({ ok: false, error: 'Page bridge timed out' });
+        }, timeoutMs);
+        function onMessage(event) {
+          if (event.source !== windowRef
+            || event.origin !== windowRef.location.origin
+            || event.data?.source !== 'codex-overleaf/page'
+            || event.data?.pageBridgeVersion !== Compatibility?.BUILD_TARGET_VERSION
+            || event.data?.pageBridgeRevision !== revision
+            || event.data.id !== id) {
+            return;
+          }
+          resolveOnce(event.data.result);
+        }
+        if (cancellable) {
+          activeCancellationHandlers.set(id, cancelRequest);
+          if (options.isCancellationRequested?.()) windowRef.queueMicrotask(cancelRequest);
+        }
+        windowRef.addEventListener('message', onMessage);
+        // Every low-level request remains one attempt. Higher layers must opt
+        // into replay so a document mutation is never duplicated implicitly.
+        windowRef.postMessage({
+          source: 'codex-overleaf/content',
+          id,
+          method,
+          params,
+          capability
+        }, windowRef.location.origin);
+      });
+    }
+
+    function cancelActiveRequests() {
+      const handlers = Array.from(activeCancellationHandlers.values());
+      activeCancellationHandlers.clear();
+      handlers.forEach(cancel => cancel());
+    }
+
+    function resolveTimeoutMs(method) {
+      return Contract.resolveTimeoutMs(method, timeoutOverrides);
+    }
+
+    async function injectPageBridge() {
+      const splitAt = PAGE_WORLD_SCRIPTS.findIndex(([src]) =>
+        src === 'src/page/pageBridgeCapability.js'
+      );
+      for (const [src, id, force] of PAGE_WORLD_SCRIPTS.slice(0, splitAt)) {
+        await injectScriptOnce(src, id, { force });
+      }
+      await injectOptionalOtDependencies();
+      for (const [src, id, force] of PAGE_WORLD_SCRIPTS.slice(splitAt)) {
+        await injectScriptOnce(src, id, { force });
+      }
+      await initializeCapability();
+    }
+
+    async function injectOptionalOtDependencies() {
+      try {
+        for (const [src, id] of OPTIONAL_OT_SCRIPTS) await injectScriptOnce(src, id);
+      } catch (_error) {
+        // The page bridge keeps its read-only unavailable fallback.
+      }
+    }
+
+    function injectScriptOnce(src, id, injectOptions = {}) {
+      return new Promise((resolve, reject) => {
+        const existing = documentRef.getElementById(id);
+        if (existing && injectOptions.force !== true) {
+          resolve();
+          return;
+        }
+        existing?.remove?.();
+        const script = documentRef.createElement('script');
+        const timeout = windowRef.setTimeout(() => {
+          cleanup();
+          reject(new Error(`Timed out loading ${src}`));
+        }, 8000);
+        function cleanup() {
+          windowRef.clearTimeout(timeout);
+          script.onload = null;
+          script.onerror = null;
+          script.remove();
+        }
+        script.id = id;
+        const runtimePrefix = String(runtimeRoot.__CODEX_OVERLEAF_RUNTIME_PREFIX__ || '');
+        script.src = chromeApi.runtime.getURL(runtimePrefix + src);
+        script.onload = () => {
+          cleanup();
+          resolve();
+        };
+        script.onerror = () => {
+          cleanup();
+          reject(new Error(`Failed to load ${src}`));
+        };
+        (documentRef.head || documentRef.documentElement).append(script);
+      });
+    }
+
+    async function initializeCapability() {
+      const result = await send(
+        'initializeCapability',
+        {},
+        Contract.resolveDispatchPolicy('initializeCapability', timeoutOverrides)
+      );
+      if (!result?.ok) {
+        throw new Error(result?.error || result?.reason || 'Page bridge capability initialization failed');
+      }
+    }
+
+    return Object.freeze({
+      call,
+      cancelActiveRequests,
+      resolveTimeoutMs,
+      send,
+      start
+    });
+  }
+
+  function createCapability(cryptoImpl) {
+    if (cryptoImpl?.randomUUID) return cryptoImpl.randomUUID();
+    const bytes = new Uint8Array(24);
+    cryptoImpl.getRandomValues(bytes);
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+  }
+
+  return Object.freeze({
+    OPTIONAL_OT_SCRIPTS,
+    PAGE_WORLD_SCRIPTS,
+    create
+  });
+});

package/extension/src/content/panelMaintenance.js

@@ -29,6 +29,7 @@
       setState,
       getCurrentRunView,
       getSettingsPanelInstance,
+      StorageDb
     } = deps;
 
   // --- Change history (v1.7.5): the audit log finally gets a read path. ---
@@ -48,7 +49,6 @@
     list.textContent = tx('Loading\u2026', '正在加载…');
     let records = [];
     try {
-      const StorageDb = window.CodexOverleafStorageDb;
       records = StorageDb?.getAllByIndex
         ? await StorageDb.getAllByIndex('auditLogs', 'projectId', getCurrentProjectId())
         : [];
@@ -171,7 +171,7 @@
       return;
     }
     try {
-      await window.CodexOverleafStorageDb?.clearAllStores?.();
+      await StorageDb?.clearAllStores?.();
       // v1.8.1: the dashboard's project-name cache lives in
       // chrome.storage.local, outside the IndexedDB stores — clear it too so
       // no (potentially sensitive) project titles outlive the wipe.
@@ -244,7 +244,12 @@
       return;
     }
     try {
-      await callPageBridge('jumpToPosition', { path: target, from: 0, to: 0 });
+      await callPageBridge('jumpToPosition', {
+        path: target,
+        from: 0,
+        to: 0,
+        runProjectId: getCurrentProjectId()
+      });
     } catch (error) {
       showPluginToast(tx(`Could not open ${target}: ${error.message}`, `无法打开 ${target}：${error.message}`));
     }