termdock 1.4.234 → 1.4.236

package/dist/server/entry.js

@@ -408,6 +408,8 @@ export function startServer(options = {}) {
         runtimeMonitor,
     });
     const { server, scheme } = createServerForApp(app, options);
+    const collaborationChannels = new Map();
+    const reverseCollaboration = (id) => [...(collaborationChannels.get(id) ?? [])].find(rpc => !rpc.closed);
     let collaborationService;
     let collaborationTransport;
     let entrySubjectAllowed = (_subjectId) => false;
@@ -447,6 +449,20 @@ export function startServer(options = {}) {
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
         terminal: handleTerminalWebSocket, control: handleControlWebSocket,
     }, {
+        collaborationConnected: (subjectId, rpc) => {
+            const channels = collaborationChannels.get(subjectId) ?? new Set();
+            channels.add(rpc);
+            collaborationChannels.set(subjectId, channels);
+            collaborationTransport?.notify(subjectId);
+            setImmediate(() => { void collaborationService?.refresh(); });
+            return () => { channels.delete(rpc); if (!channels.size)
+                collaborationChannels.delete(subjectId); };
+        },
+        collaborationDescriptor: () => {
+            if (!collaborationService)
+                throw new Error('COLLABORATION_UNAVAILABLE');
+            return collaborationService.descriptor();
+        },
         collaborationService: (subjectId, packet) => {
             if (!collaborationService)
                 throw new Error('COLLABORATION_UNAVAILABLE');
@@ -494,12 +510,25 @@ export function startServer(options = {}) {
         setPushTargetPeerId(runtime.serviceId);
         refreshDirectTargets();
         app.locals.passwordRuntime = runtime;
+        const receiveCollaboration = (subjectId, packet) => {
+            if (packet.type === 'collaboration-service' && collaborationService)
+                return collaborationService.receive(subjectId, packet);
+            if (packet.type === 'collaboration-exchange' && collaborationTransport)
+                return collaborationTransport.receive(subjectId, packet);
+            throw new Error('COLLABORATION_UNAVAILABLE');
+        };
+        const connectPeer = (peer) => {
+            if (['localhost', '127.0.0.1', '[::1]'].includes(new URL(peer.origin).hostname))
+                throw new Error('WAITING_FOR_PEER_CONNECTION');
+            return connectCollaborationRpc(runtime.identity, peer, undefined, packet => receiveCollaboration(peer.serviceId, packet));
+        };
         collaborationTransport = new CollaborationPeerTransport({
+            reverse: reverseCollaboration,
             file: path.join(homedir(), '.termdock', 'federation', 'collaboration-peers.json'), serviceId: runtime.serviceId,
             store: collaborationStore, deliver: deliverPeerCollaboration, activity: collaborationLocalActivity,
             connect: async (peer, via) => {
                 if (!via)
-                    return connectCollaborationRpc(runtime.identity, peer);
+                    return connectPeer(peer);
                 const entry = await connectCollaborationRpc(runtime.identity, via);
                 try {
                     const ticket = await entry.request({ type: 'route-ticket', serviceId: peer.serviceId });
@@ -508,7 +537,7 @@ export function startServer(options = {}) {
                     const url = new URL('/api/federation/relay', via.origin.replace(/^https:/, 'wss:'));
                     url.searchParams.set('routeToken', ticket.routeToken);
                     // TLS authenticates the entry; Noise pins the final destination.
-                    return await connectCollaborationRpc(runtime.identity, { ...via, serviceId: peer.serviceId }, url.href);
+                    return await connectCollaborationRpc(runtime.identity, { ...via, serviceId: peer.serviceId }, url.href, packet => receiveCollaboration(peer.serviceId, packet));
                 }
                 finally {
                     entry.close();
@@ -525,7 +554,7 @@ export function startServer(options = {}) {
         app.locals.collaborationNode = { serviceId: runtime.serviceId, ...(caFingerprint256 ? { caFingerprint256 } : {}) };
         collaborationService = new CollaborationService({ file: path.join(homedir(), '.termdock', 'federation', 'collaboration-services.json'),
             store: collaborationStore, transport: collaborationTransport, node: () => app.locals.collaborationNode,
-            sessions: collaborationDirectorySessions, connect: peer => connectCollaborationRpc(runtime.identity, peer) });
+            sessions: collaborationDirectorySessions, reverse: reverseCollaboration, connect: connectPeer });
         app.locals.collaborationService = collaborationService;
         collaborationService.start();
         server.once('close', () => collaborationService?.close());

package/dist/server/federation/runtime.js

@@ -1,3 +1,4 @@
+import { CollaborationRpc } from '../agent/collaborationPeerTransport.js';
 import { PasswordBootstrapServer } from './passwordBootstrap.js';
 import { DeviceProfiles } from './deviceProfiles.js';
 import { DeviceNames } from './deviceNames.js';
@@ -122,6 +123,8 @@ export async function createFederationRuntime(app, directory, handlers, options
         return Array.isArray(inventory.clientSessions) ? inventory.clientSessions : [];
     }
     async function accept(socket, context = {}) {
+        let collaborationRpc;
+        let unregisterCollaboration;
         const open = (action) => openAccessAllowed(context.allowOpenAccess === true, isAuthEnabled(), action);
         const allowed = (subjectId, action, sessionId) => open(action) || store.authorize({ subjectId, serviceId, action, sessionId }).allowed;
         const full = (subjectId) => open() || store.hasFullServiceAccess({ subjectId, serviceId });
@@ -251,7 +254,24 @@ export async function createFederationRuntime(app, directory, handlers, options
                 try {
                     if (packet.id.length > 128)
                         throw new Error('INVALID_ID');
-                    if (packet.type === 'collaboration-service') {
+                    if (collaborationRpc?.accept(packet))
+                        continue;
+                    if (packet.type === 'collaboration-connect') {
+                        if (!options.collaborationService || !options.collaborationConnected)
+                            throw new Error('COLLABORATION_UPGRADE_REQUIRED');
+                        options.collaborationService(subjectId, { type: 'collaboration-service', id: packet.id, action: 'duplex' });
+                        if (!collaborationRpc) {
+                            collaborationRpc = new CollaborationRpc(channel, undefined, true);
+                            unregisterCollaboration = options.collaborationConnected(subjectId, collaborationRpc);
+                        }
+                        send({ type: 'result', id: packet.id, ok: true });
+                    }
+                    else if (packet.type === 'collaboration-descriptor') {
+                        if (!options.collaborationDescriptor)
+                            throw new Error('COLLABORATION_UPGRADE_REQUIRED');
+                        send({ type: 'result', id: packet.id, node: options.collaborationDescriptor() });
+                    }
+                    else if (packet.type === 'collaboration-service') {
                         if (!options.collaborationService)
                             throw new Error('COLLABORATION_UPGRADE_REQUIRED');
                         send({ type: 'result', id: packet.id, ...options.collaborationService(subjectId, packet) });
@@ -537,6 +557,8 @@ export async function createFederationRuntime(app, directory, handlers, options
             socket.close(4003, 'Secure channel closed');
         }
         finally {
+            unregisterCollaboration?.();
+            collaborationRpc?.close();
             clearInterval(revokeTimer);
             for (const operation of operations.values())
                 cancelHttp(operation);

package/dist/server/routes/terminal.js

@@ -1,3 +1,4 @@
+import { assertPeerRegistrationAuthority } from '../agent/collaborationPeerTransport.js';
 import { progressRoutes } from '../notifications/progressRoutes.js';
 import { ensureNodePty } from '../utils/ensureNodePty.js';
 import { PtySpawnBackoff, PtySpawnDeferredError } from '../utils/ptySpawnBackoff.js';
@@ -5480,6 +5481,18 @@ router.delete('/operations/automations/:automationId', (req, res) => {
 router.all(['/operations/collaboration-federation', '/operations/collaboration-peers'], (_req, res) => {
     res.status(410).json({ code: 'CLIENT_RELAY_REMOVED', error: '协作由服务端处理，请重新加载服务页面' });
 });
+router.post('/operations/collaboration-connections', (req, res) => {
+    try {
+        assertPeerRegistrationAuthority(req);
+        const service = req.app.locals.collaborationService;
+        if (!service)
+            return res.status(503).json({ error: '协作服务正在启动' });
+        res.json(service.connectKnown(req.body?.origin, req.body?.nodes));
+    }
+    catch (error) {
+        res.status(getErrorMessage(error) === 'AUTHORIZATION_DENIED' ? 403 : 400).json({ error: getErrorMessage(error) });
+    }
+});
 router.get('/operations/collaboration-directory', (req, res) => {
     const service = req.app.locals.collaborationService;
     if (!service)

package/package.json

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

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.234",
+  "version": "1.4.236",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-nhvsmvXOZsSAZPmQTztOUo074PRH4RrLqcMhe5r4kKk=",
-  "clientBundleHash": "sha256-NULxnbzNlpIXlrOpTKR4KD9KY3y5ekC2/dn3VWl6AcE=",
+  "serverBundleHash": "sha256-toE4hw6sL499oIYf/oKFE3xAntvR8PAwZGhY60TNDC0=",
+  "clientBundleHash": "sha256-trS+ETMzb9TMz5LAjLxWuftR8zROhre6jdKGsnMbg60=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }