termdock 1.4.169 → 1.4.170

package/.desktop-dist/main.js

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, clipboard, dialog, ipcMain, Menu, net, nativeImage, Notification, screen, session, shell, Tray, } from 'electron';
+import { app, BrowserWindow, clipboard, dialog, ipcMain, Menu, net, nativeImage, Notification, powerMonitor, screen, session, shell, Tray, } from 'electron';
 import { execFile, spawn } from 'node:child_process';
 import crypto from 'node:crypto';
 import dgram from 'node:dgram';
@@ -16,7 +16,8 @@ import { isExternalLinkStagingUrl, isSafeExternalUrl } from './externalLinks.js'
 import { shouldThrottleDesktopRenderer } from './windowPolicy.js';
 import { checkConnectedServiceRuntime, getConnectedServiceRuntimeState, restartConnectedServiceRuntime, } from './connectedServiceRuntime.js';
 import { isOwnedDesktopRuntimeTarget } from './runtimeTarget.js';
-import { canOfferCertificateTrust, downloadCertificateAuthority, isCertificateTrustError, isLocalNetworkHostname, } from './certificateTrust.js';
+import { serviceDocumentNeedsReload } from './serviceWindowRecovery.js';
+import { CertificateTrustRequests, resolveServiceCertificateTrust, canOfferCertificateTrust, downloadCertificateAuthority, isCertificateTrustError, isLocalNetworkHostname, matchManagedLocalCertificate, } from './certificateTrust.js';
 const execFileAsync = promisify(execFile);
 const currentDir = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(currentDir, '..');
@@ -27,12 +28,17 @@ const desktopRuntimeOwnerSocketPath = path.join(termdockDir, 'desktop-runtime-ow
 const DEFAULT_LOCAL_URL = 'http://localhost:9834';
 const PROTOCOL_VERSION = 1;
 const HEALTH_TIMEOUT_MS = 3_500;
+const SERVICE_RECOVERY_PROBE_TIMEOUT_MS = 5_000;
 const START_TIMEOUT_MS = 90_000;
 const RESTORE_LOAD_TIMEOUT_MS = 15_000;
 const localServiceCertificatePath = path.join(termdockDir, 'certs', 'termdock-local.pem');
 const sessionTrustedCertificateTargets = new Set();
+const certificateTrustRequests = new CertificateTrustRequests();
+const sessionTrustedLeafByOrigin = new Map();
 const sessionTrustedCertificateAuthorities = new Map();
 let managedLocalCertificateFingerprint = null;
+const serviceWindowRecoveryTimers = new WeakMap();
+const serviceWindowRecoveryInFlight = new WeakSet();
 /** Delivered-but-unseen desktop notifications, mirrored into the Dock badge. */
 const activeNotifications = new Map();
 let unreadNotificationCount = 0;
@@ -443,7 +449,15 @@ function openExternalLink(url) {
 function certificateTrustKey(hostname, fingerprint) {
     return `${hostname.toLowerCase().replace(/^\[|\]$/g, '')}\0${fingerprint}`;
 }
-function installCertificateVerifyProcedure(targetSession = session.defaultSession) {
+function readManagedLocalCertificateFingerprint() {
+    try {
+        return new crypto.X509Certificate(fs.readFileSync(localServiceCertificatePath)).fingerprint256;
+    }
+    catch {
+        return null;
+    }
+}
+function installCertificateVerifyProcedure(targetSession = session.defaultSession, serviceOrigin) {
     targetSession.setCertificateVerifyProc((request, callback) => {
         let isLocalTarget = false;
         try {
@@ -460,20 +474,36 @@ function installCertificateVerifyProcedure(targetSession = session.defaultSessio
             // Keep Chromium's default verification if the certificate cannot be parsed.
         }
         const explicitlyTrustedTarget = presentedFingerprint
-            ? sessionTrustedCertificateTargets.has(certificateTrustKey(request.hostname, presentedFingerprint))
+            ? serviceOrigin
+                ? new URL(serviceOrigin).hostname.replace(/^\[|\]$/g, '').toLowerCase()
+                    === request.hostname.replace(/^\[|\]$/g, '').toLowerCase()
+                    && sessionTrustedLeafByOrigin.get(serviceOrigin) === presentedFingerprint
+                : sessionTrustedCertificateTargets.has(certificateTrustKey(request.hostname, presentedFingerprint))
             : false;
-        const managedLocalCertificate = isLocalTarget
-            && presentedFingerprint === managedLocalCertificateFingerprint;
-        callback(explicitlyTrustedTarget || managedLocalCertificate ? 0 : -3);
+        const managedMatch = isLocalTarget
+            ? matchManagedLocalCertificate(presentedFingerprint, managedLocalCertificateFingerprint, readManagedLocalCertificateFingerprint)
+            : { matches: false, currentFingerprint: managedLocalCertificateFingerprint };
+        managedLocalCertificateFingerprint = managedMatch.currentFingerprint;
+        const managedLocalCertificate = managedMatch.matches;
+        if (explicitlyTrustedTarget || managedLocalCertificate) {
+            callback(0);
+            return;
+        }
+        if (serviceOrigin && canOfferCertificateTrust(serviceOrigin)
+            && isCertificateTrustError(request.verificationResult)) {
+            // Resolve trust before Chromium caches a rejection. This covers fetch,
+            // WebSocket and navigation requests, not only the initial Node probe.
+            void resolveServiceCertificateTrust(serviceOrigin, request.hostname, request.certificate.data, () => requestCertificateTrust(serviceOrigin)).then((trusted) => callback(trusted ? 0 : -3), (error) => {
+                console.warn(`[desktop-certificate] ${serviceOrigin}: ${networkErrorDetails(error)}`);
+                callback(-3);
+            });
+            return;
+        }
+        callback(-3);
     });
 }
 function configureLocalServiceCertificateTrust() {
-    try {
-        managedLocalCertificateFingerprint = new crypto.X509Certificate(fs.readFileSync(localServiceCertificatePath)).fingerprint256;
-    }
-    catch {
-        // The certificate is created when the local service first enables HTTPS.
-    }
+    managedLocalCertificateFingerprint = readManagedLocalCertificateFingerprint();
     installCertificateVerifyProcedure();
 }
 function defaultConfig() {
@@ -549,7 +579,19 @@ function trustedCertificateAuthorityFor(target) {
     const origin = new URL(target).origin;
     return readDesktopConfig().trustedCertificateAuthorities.find((entry) => entry.origin === origin);
 }
-async function requestCertificateTrust(target) {
+function requestCertificateTrust(target) {
+    return certificateTrustRequests.request(new URL(target).origin, () => confirmCertificateTrust(target));
+}
+function rememberSessionCertificate(target, certificate) {
+    const url = new URL(target);
+    const previous = sessionTrustedLeafByOrigin.get(url.origin);
+    if (previous)
+        sessionTrustedCertificateTargets.delete(certificateTrustKey(url.hostname, previous));
+    sessionTrustedLeafByOrigin.set(url.origin, certificate.leafFingerprint256);
+    sessionTrustedCertificateAuthorities.set(url.origin, certificate.certificatePem);
+    sessionTrustedCertificateTargets.add(certificateTrustKey(url.hostname, certificate.leafFingerprint256));
+}
+async function confirmCertificateTrust(target) {
     let certificate;
     try {
         certificate = await downloadCertificateAuthority(target);
@@ -565,8 +607,7 @@ async function requestCertificateTrust(target) {
     }
     const existingTrust = trustedCertificateAuthorityFor(target);
     if (existingTrust?.fingerprint256 === certificate.fingerprint256) {
-        sessionTrustedCertificateAuthorities.set(new URL(target).origin, certificate.certificatePem);
-        sessionTrustedCertificateTargets.add(certificateTrustKey(new URL(target).hostname, certificate.leafFingerprint256));
+        rememberSessionCertificate(target, certificate);
         return certificate;
     }
     const confirmation = await showDesktopMessageBox({
@@ -596,8 +637,7 @@ async function requestCertificateTrust(target) {
         trustedAt: Date.now(),
     });
     writeDesktopConfig(config);
-    sessionTrustedCertificateAuthorities.set(origin, certificate.certificatePem);
-    sessionTrustedCertificateTargets.add(certificateTrustKey(new URL(target).hostname, certificate.leafFingerprint256));
+    rememberSessionCertificate(target, certificate);
     return certificate;
 }
 async function requestLocalNetworkPermissionRetry(target) {
@@ -834,6 +874,12 @@ async function probeServiceWithLocalNetworkPermission(rawUrl, options = {}) {
     // Do the first macOS HTTPS probe with Node TLS. Sending an untrusted
     // certificate through Chromium first permanently caches that rejection for
     // the process and prevents an immediate retry after the user approves it.
+    if (options.interactive !== false && canOfferCertificateTrust(normalizedUrl)
+        && trustedCertificateAuthorityFor(normalizedUrl)) {
+        const certificate = await requestCertificateTrust(normalizedUrl);
+        if (!certificate)
+            return { ok: false, url: normalizedUrl, error: 'HTTPS 证书尚未受信任' };
+    }
     const approvedAuthority = sessionTrustedCertificateAuthorities.get(new URL(normalizedUrl).origin);
     let probe = approvedAuthority
         ? await probeServiceWithCertificateAuthority(normalizedUrl, approvedAuthority)
@@ -1315,6 +1361,14 @@ async function installCli() {
     return snapshot();
 }
 async function connectWindow(rawUrl, options = {}) {
+    if (options.focus !== false) {
+        try {
+            certificateTrustRequests.retry(new URL(normalizeServiceUrl(rawUrl)).origin);
+        }
+        catch {
+            return await probeService(rawUrl);
+        }
+    }
     let probe = await probeServiceWithLocalNetworkPermission(rawUrl, {
         interactive: options.focus !== false,
     });
@@ -1344,6 +1398,9 @@ async function connectWindow(rawUrl, options = {}) {
                 existing.lastConnectedAt = Date.now();
             writeDesktopConfig(config);
         }
+        if (await serviceDocumentNeedsReload(existingWindow.webContents, key)) {
+            await existingWindow.loadURL(probe.url);
+        }
         if (options.focus !== false) {
             mainWindow?.hide();
             showAndFocusWindow(existingWindow);
@@ -1462,6 +1519,55 @@ function finishStartupProgress() {
         return;
     mainWindow.webContents.send('desktop:startup-progress', null);
 }
+function scheduleServiceWindowRecovery(window, reason, delayMs = 750) {
+    if (window.isDestroyed() || !windowServiceOrigins.has(window))
+        return;
+    const previous = serviceWindowRecoveryTimers.get(window);
+    if (previous)
+        clearTimeout(previous);
+    const timer = setTimeout(() => {
+        serviceWindowRecoveryTimers.delete(window);
+        void recoverServiceWindow(window, reason);
+    }, delayMs);
+    timer.unref();
+    serviceWindowRecoveryTimers.set(window, timer);
+}
+async function recoverServiceWindow(window, reason) {
+    if (window.isDestroyed() || serviceWindowRecoveryInFlight.has(window))
+        return;
+    const serviceOrigin = windowServiceOrigins.get(window);
+    if (!serviceOrigin)
+        return;
+    serviceWindowRecoveryInFlight.add(window);
+    try {
+        let probeTimer = null;
+        const probe = await Promise.race([
+            probeServiceWithLocalNetworkPermission(serviceOrigin, { interactive: false }),
+            new Promise((resolve) => {
+                probeTimer = setTimeout(() => resolve({
+                    ok: false,
+                    url: serviceOrigin,
+                    error: '桌面恢复健康检查超时',
+                }), SERVICE_RECOVERY_PROBE_TIMEOUT_MS);
+                probeTimer.unref();
+            }),
+        ]);
+        if (probeTimer)
+            clearTimeout(probeTimer);
+        if (!probe.ok || window.isDestroyed())
+            return;
+        if (!(await serviceDocumentNeedsReload(window.webContents, serviceOrigin)) || window.isDestroyed())
+            return;
+        console.warn(`[desktop-recovery] reloading ${serviceOrigin} after ${reason}`);
+        await window.loadURL(probe.url);
+    }
+    catch (error) {
+        console.warn(`[desktop-recovery] ${serviceOrigin} recovery after ${reason} failed: ${networkErrorDetails(error)}`);
+    }
+    finally {
+        serviceWindowRecoveryInFlight.delete(window);
+    }
+}
 function createDesktopWindow(options) {
     const serviceSession = options
         ? session.fromPartition(`persist:termdock-service-${crypto
@@ -1471,7 +1577,7 @@ function createDesktopWindow(options) {
             .slice(0, 24)}`)
         : null;
     if (serviceSession)
-        installCertificateVerifyProcedure(serviceSession);
+        installCertificateVerifyProcedure(serviceSession, options?.serviceOrigin);
     const window = new BrowserWindow({
         title: options ? `Termdock — ${options.label}` : 'Termdock — 连接中心',
         show: false,
@@ -1499,6 +1605,15 @@ function createDesktopWindow(options) {
     });
     if (options)
         windowServiceOrigins.set(window, options.serviceOrigin);
+    if (options) {
+        window.webContents.on('certificate-error', (event, url, error, certificate, callback) => {
+            if (new URL(url).origin !== options.serviceOrigin
+                || !canOfferCertificateTrust(url) || !isCertificateTrustError(error))
+                return;
+            event.preventDefault();
+            void resolveServiceCertificateTrust(options.serviceOrigin, new URL(url).hostname, certificate.data, () => requestCertificateTrust(options.serviceOrigin)).then(callback, () => callback(false));
+        });
+    }
     if (options) {
         window.webContents.on('page-title-updated', (event) => {
             event.preventDefault();
@@ -1610,6 +1725,14 @@ function createDesktopWindow(options) {
       }
     `);
     });
+    window.webContents.on('did-fail-load', (_event, _errorCode, _errorDescription, _validatedURL, isMainFrame) => {
+        if (isMainFrame)
+            scheduleServiceWindowRecovery(window, 'main-frame-load-failure');
+    });
+    window.webContents.on('render-process-gone', (_event, details) => {
+        scheduleServiceWindowRecovery(window, `renderer-${details.reason}`);
+    });
+    window.on('unresponsive', () => scheduleServiceWindowRecovery(window, 'unresponsive'));
     window.on('closed', () => {
         if (mainWindow === window)
             mainWindow = null;
@@ -1629,6 +1752,7 @@ function createDesktopWindow(options) {
         broadcastServiceActivity();
         // User is looking at the app — the Dock badge has served its purpose.
         clearUnreadNotifications();
+        scheduleServiceWindowRecovery(window, 'window-focus');
     });
     window.on('close', (event) => {
         const serviceOrigin = windowServiceOrigins.get(window);
@@ -1663,7 +1787,13 @@ function installIpcHandlers() {
         return png.buffer.slice(png.byteOffset, png.byteOffset + png.byteLength);
     });
     ipcMain.handle('desktop:snapshot', () => snapshot());
-    ipcMain.handle('desktop:probe', (_event, url) => probeServiceWithLocalNetworkPermission(url));
+    ipcMain.handle('desktop:probe', (_event, url) => {
+        try {
+            certificateTrustRequests.retry(new URL(normalizeServiceUrl(url)).origin);
+        }
+        catch { /* probe reports invalid URLs */ }
+        return probeServiceWithLocalNetworkPermission(url);
+    });
     ipcMain.handle('desktop:save-connection', async (_event, input) => {
         const url = normalizeServiceUrl(input.url);
         const config = readDesktopConfig();
@@ -2047,6 +2177,11 @@ app.whenReady().then(async () => {
     refreshDesktopStatusSurfaces();
     screen.on('display-removed', keepFloatingWidgetOnScreen);
     screen.on('display-metrics-changed', keepFloatingWidgetOnScreen);
+    powerMonitor.on('resume', () => {
+        for (const window of serviceWindows.values()) {
+            scheduleServiceWindowRecovery(window, 'system-resume', 1_200);
+        }
+    });
     configureDesktopUpdater(showDesktopMessageBox);
     subscribeDesktopUpdateState((state) => {
         for (const window of BrowserWindow.getAllWindows()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.169",
+  "version": "1.4.170",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.169",
+  "version": "1.4.170",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,