termdock 1.4.174 → 1.4.176

package/.desktop-dist/main.js

@@ -1,4 +1,7 @@
 import { CollaborationFederation, sessionAddress } from './collaborationFederation.js';
+import { prepareBundledFrontend } from './bundledFrontend.js';
+import { serviceConnection, serviceConnectionKeys, importServiceConnection, upsertServiceConnection, invitationForService } from './serviceConnections.js';
+const pendingServiceInvitations = new WeakMap();
 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';
@@ -17,6 +20,7 @@ import { isExternalLinkStagingUrl, isSafeExternalUrl } from './externalLinks.js'
 import { shouldThrottleDesktopRenderer } from './windowPolicy.js';
 import { checkConnectedServiceRuntime, getConnectedServiceRuntimeState, restartConnectedServiceRuntime, } from './connectedServiceRuntime.js';
 import { isOwnedDesktopRuntimeTarget } from './runtimeTarget.js';
+import { canReadLocalInvite } from './localInviteGuard.js';
 import { serviceDocumentNeedsReload } from './serviceWindowRecovery.js';
 import { CertificateTrustRequests, resolveServiceCertificateTrust, canOfferCertificateTrust, downloadCertificateAuthority, isCertificateTrustError, isLocalNetworkHostname, matchManagedLocalCertificate, } from './certificateTrust.js';
 const execFileAsync = promisify(execFile);
@@ -26,6 +30,7 @@ const termdockDir = path.join(os.homedir(), '.termdock');
 const desktopConfigPath = path.join(termdockDir, 'desktop.json');
 const serverStatePath = path.join(termdockDir, 'server.json');
 const desktopRuntimeOwnerSocketPath = path.join(termdockDir, 'desktop-runtime-owner.sock');
+let federationRelayProcess = null;
 const DEFAULT_LOCAL_URL = 'http://localhost:9834';
 const PROTOCOL_VERSION = 1;
 const HEALTH_TIMEOUT_MS = 3_500;
@@ -484,6 +489,8 @@ function readManagedLocalCertificateFingerprint() {
 }
 function installCertificateVerifyProcedure(targetSession = session.defaultSession, serviceOrigin) {
     targetSession.setCertificateVerifyProc((request, callback) => {
+        const routeOrigins = serviceOrigin ? readDesktopConfig().connections.flatMap(item => item.routes || []).map(route => route.url) : [];
+        const requestedOrigin = [serviceOrigin, ...routeOrigins].find(origin => origin && new URL(origin).hostname.replace(/^\[|\]$/g, '').toLowerCase() === request.hostname.replace(/^\[|\]$/g, '').toLowerCase());
         let isLocalTarget = false;
         try {
             isLocalTarget = isLocalNetworkTarget(new URL(`https://${request.hostname}`));
@@ -500,9 +507,7 @@ function installCertificateVerifyProcedure(targetSession = session.defaultSessio
         }
         const explicitlyTrustedTarget = presentedFingerprint
             ? serviceOrigin
-                ? new URL(serviceOrigin).hostname.replace(/^\[|\]$/g, '').toLowerCase()
-                    === request.hostname.replace(/^\[|\]$/g, '').toLowerCase()
-                    && sessionTrustedLeafByOrigin.get(serviceOrigin) === presentedFingerprint
+                ? !!requestedOrigin && sessionTrustedLeafByOrigin.get(requestedOrigin) === presentedFingerprint
                 : sessionTrustedCertificateTargets.has(certificateTrustKey(request.hostname, presentedFingerprint))
             : false;
         const managedMatch = isLocalTarget
@@ -514,11 +519,11 @@ function installCertificateVerifyProcedure(targetSession = session.defaultSessio
             callback(0);
             return;
         }
-        if (serviceOrigin && canOfferCertificateTrust(serviceOrigin)
+        if (requestedOrigin && canOfferCertificateTrust(requestedOrigin)
             && 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) => {
+            void resolveServiceCertificateTrust(requestedOrigin, request.hostname, request.certificate.data, () => requestCertificateTrust(requestedOrigin)).then((trusted) => callback(trusted ? 0 : -3), (error) => {
                 console.warn(`[desktop-certificate] ${serviceOrigin}: ${networkErrorDetails(error)}`);
                 callback(-3);
             });
@@ -688,6 +693,7 @@ function readDesktopConfig() {
         const lastConnectionUrl = typeof parsed.lastConnectionUrl === 'string' ? parsed.lastConnectionUrl : null;
         return {
             version: 1,
+            removedServiceKeys: Array.isArray(parsed.removedServiceKeys) ? parsed.removedServiceKeys.filter((key) => typeof key === 'string').slice(-768) : [],
             connections: parsed.connections.filter((entry) => Boolean(entry)
                 && typeof entry.id === 'string'
                 && typeof entry.label === 'string'
@@ -971,6 +977,41 @@ function runtimePaths() {
         source: 'development',
     };
 }
+/** Explicit opt-in only; all routing and reconnect behavior lives in the shared CLI. */
+function startConfiguredFederationRelay() {
+    const configPath = path.join(termdockDir, 'federation', 'relay.json');
+    if (federationRelayProcess || !fs.existsSync(configPath))
+        return;
+    let logFd;
+    try {
+        const runtime = runtimePaths();
+        if (!fs.existsSync(runtime.cli))
+            throw new Error('Runtime unavailable');
+        const logPath = path.join(termdockDir, 'federation', 'relay.log');
+        logFd = fs.openSync(logPath, 'a', 0o600);
+        fs.fchmodSync(logFd, 0o600);
+        const child = spawn(runtime.node, [runtime.cli, '--federation-relay', configPath], {
+            detached: false,
+            stdio: ['ignore', logFd, logFd],
+            env: desktopRuntimeEnv(runtime),
+        });
+        federationRelayProcess = child;
+        child.once('error', () => {
+            if (federationRelayProcess === child)
+                federationRelayProcess = null;
+            console.error('[federation] Configured relay failed to start; inspect the private relay log.');
+        });
+        child.once('exit', () => { if (federationRelayProcess === child)
+            federationRelayProcess = null; });
+    }
+    catch {
+        console.error('[federation] Unable to start configured relay; verify the runtime and private configuration.');
+    }
+    finally {
+        if (logFd !== undefined)
+            fs.closeSync(logFd);
+    }
+}
 async function executableVersion(executable) {
     try {
         const { stdout } = await execFileAsync(executable, ['--version'], {
@@ -1394,7 +1435,8 @@ async function connectWindow(rawUrl, options = {}) {
             return await probeService(rawUrl);
         }
     }
-    let probe = await probeServiceWithLocalNetworkPermission(rawUrl, {
+    const known = readDesktopConfig().connections.find(item => (item.serviceOrigin || item.url) === normalizeServiceUrl(rawUrl));
+    let probe = known?.targetPeerId ? { ok: true, url: normalizeServiceUrl(rawUrl) } : await probeServiceWithLocalNetworkPermission(rawUrl, {
         interactive: options.focus !== false,
     });
     if (!probe.ok)
@@ -1423,7 +1465,9 @@ async function connectWindow(rawUrl, options = {}) {
                 existing.lastConnectedAt = Date.now();
             writeDesktopConfig(config);
         }
-        if (await serviceDocumentNeedsReload(existingWindow.webContents, key)) {
+        if (options.invitation || await serviceDocumentNeedsReload(existingWindow.webContents, key)) {
+            if (options.invitation)
+                pendingServiceInvitations.set(existingWindow, options.invitation);
             await existingWindow.loadURL(probe.url);
         }
         if (options.focus !== false) {
@@ -1436,6 +1480,9 @@ async function connectWindow(rawUrl, options = {}) {
         return probe;
     }
     const workspaceWindow = createDesktopWindow({ serviceOrigin: key, label: serviceLabel(probe.url) });
+    await prepareBundledFrontend(workspaceWindow.webContents.session, key, path.join(runtimePaths().serverRoot, 'dist', 'client'));
+    if (options.invitation)
+        pendingServiceInvitations.set(workspaceWindow, options.invitation);
     serviceWindows.set(key, workspaceWindow);
     broadcastServiceActivity();
     while (!workspaceWindow.isDestroyed()) {
@@ -1835,6 +1882,67 @@ function installIpcHandlers() {
     collaborationPollTimer = setInterval(() => void collaborationFederation.refresh().catch(() => { }), 2000);
     collaborationPollTimer.unref();
     ipcMain.handle('desktop:snapshot', () => snapshot());
+    const directorySender = (event) => {
+        const window = BrowserWindow.fromWebContents(event.sender);
+        if (!window || event.senderFrame !== event.sender.mainFrame)
+            throw new Error('无法访问服务列表。');
+        const origin = windowServiceOrigins.get(window);
+        const url = new URL(event.senderFrame.url);
+        if (origin ? url.origin !== origin || url.pathname !== '/' : window !== mainWindow || url.protocol !== 'file:')
+            throw new Error('无法访问服务列表。');
+        return window;
+    };
+    const directoryChanged = () => {
+        installMenu();
+        for (const window of BrowserWindow.getAllWindows())
+            window.webContents.send('desktop:service-connections-changed');
+        broadcastServiceActivity();
+    };
+    ipcMain.handle('desktop:service-connections', event => { directorySender(event); return readDesktopConfig().connections; });
+    ipcMain.handle('desktop:save-service-connection', (event, input) => {
+        directorySender(event);
+        const config = readDesktopConfig();
+        config.connections = upsertServiceConnection(config.connections, input);
+        writeDesktopConfig(config);
+        directoryChanged();
+        return config.connections;
+    });
+    ipcMain.handle('desktop:import-service-connection', (event, input) => {
+        directorySender(event);
+        const config = readDesktopConfig();
+        config.connections = importServiceConnection(config.connections, config.removedServiceKeys || [], input);
+        writeDesktopConfig(config);
+        directoryChanged();
+        return config.connections;
+    });
+    ipcMain.handle('desktop:remove-service-connection', (event, id) => {
+        directorySender(event);
+        const config = readDesktopConfig();
+        const removed = config.connections.find(item => item.id === id);
+        if (removed)
+            config.removedServiceKeys = [...new Set([...(config.removedServiceKeys || []), ...serviceConnectionKeys(removed)])].slice(-768);
+        config.connections = config.connections.filter(item => item.id !== id);
+        writeDesktopConfig(config);
+        directoryChanged();
+        return config.connections;
+    });
+    ipcMain.handle('desktop:current-service-connection', event => {
+        const window = directorySender(event), origin = windowServiceOrigins.get(window);
+        const connection = readDesktopConfig().connections.find(item => (item.serviceOrigin || item.url) === origin);
+        const invitation = pendingServiceInvitations.get(window);
+        pendingServiceInvitations.delete(window);
+        return connection ? { ...connection, ...(invitation ? { invitation } : {}) } : null;
+    });
+    ipcMain.handle('desktop:open-service-connection', async (event, input, rawInvitation) => {
+        directorySender(event);
+        const connection = serviceConnection(input), invitation = invitationForService(rawInvitation, connection);
+        // A bookmark pin is connection metadata, never authorization to the service.
+        const config = readDesktopConfig();
+        config.connections = upsertServiceConnection(config.connections, connection);
+        writeDesktopConfig(config);
+        directoryChanged();
+        return connectWindow(connection.serviceOrigin || connection.url, { invitation });
+    });
     ipcMain.handle('desktop:probe', (_event, url) => {
         try {
             certificateTrustRequests.retry(new URL(normalizeServiceUrl(url)).origin);
@@ -1910,6 +2018,42 @@ function installIpcHandlers() {
         broadcastServiceActivity();
         return true;
     });
+    ipcMain.handle('desktop:local-invite', async (event) => {
+        const sourceWindow = BrowserWindow.fromWebContents(event.sender);
+        if (!sourceWindow || sourceWindow.isDestroyed() || event.senderFrame !== event.sender.mainFrame)
+            return null;
+        const registeredOrigin = windowServiceOrigins.get(sourceWindow);
+        const initialUrl = event.sender.getURL();
+        // First reject remote/preview callers before any asynchronous local probing.
+        let callerPort;
+        try {
+            const url = new URL(initialUrl);
+            callerPort = Number(url.port || (url.protocol === 'https:' ? 443 : 80));
+        }
+        catch {
+            return null;
+        }
+        if (!canReadLocalInvite({ registeredOrigin, currentUrl: initialUrl, mainFrame: true, running: true, desktopManaged: true, servicePort: callerPort }))
+            return null;
+        const status = await getLocalServiceStatus().catch(() => null);
+        if (!status || !status.state || sourceWindow.isDestroyed() || event.sender.isDestroyed()
+            || event.senderFrame !== event.sender.mainFrame || event.sender.getURL() !== initialUrl
+            || windowServiceOrigins.get(sourceWindow) !== registeredOrigin
+            || !canReadLocalInvite({ registeredOrigin, currentUrl: event.sender.getURL(), mainFrame: true,
+                running: status.running, desktopManaged: status.probe?.desktopManaged === true, servicePort: status.state.port })
+            || !isOwnedDesktopRuntimeWindow(sourceWindow, status))
+            return null;
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(termdockDir, 'federation', 'pairing.json'), 'utf8'));
+            if (typeof data.serviceId !== 'string' || !/^12D3KooW[1-9A-HJ-NP-Za-km-z]{44}$/.test(data.serviceId)
+                || typeof data.pairingCode !== 'string' || !/^[A-Za-z0-9_-]{32,128}$/.test(data.pairingCode))
+                return null;
+            return { url: registeredOrigin, targetPeerId: data.serviceId, pairingCode: data.pairingCode, serviceName: '本机 Termdock' };
+        }
+        catch {
+            return null;
+        }
+    });
     ipcMain.handle('desktop:start-local', () => startLocalService());
     ipcMain.handle('desktop:update-preferences', async (_event, preferences) => {
         updateDesktopPreferences({
@@ -2247,6 +2391,7 @@ app.whenReady().then(async () => {
         });
     });
     startConnectedServiceRuntimePolling();
+    startConfiguredFederationRelay();
     const startupConfig = readDesktopConfig();
     const restoreUrls = startupConfig.openConnectionUrls;
     startupRestoreActive = true;
@@ -2305,6 +2450,8 @@ app.on('window-all-closed', () => {
 });
 app.on('before-quit', () => {
     isQuitting = true;
+    federationRelayProcess?.kill('SIGTERM');
+    federationRelayProcess = null;
     desktopRuntimeOwnerServer?.close();
     desktopRuntimeOwnerServer = null;
     if (collaborationPollTimer)