termdock 1.4.235 → 1.4.237

package/dist/server/agent/collaborationPeerTransport.js

@@ -41,25 +41,43 @@ function mapContext(context, map) {
  * No cookies, browser device keys, or direct HTTP business requests. */
 export class CollaborationRpc {
     channel;
+    receive;
     pending = new Map();
     closed = false;
-    constructor(channel) {
+    constructor(channel, receive, externalReader = false) {
         this.channel = channel;
-        void this.read();
+        this.receive = receive;
+        if (!externalReader)
+            void this.read();
         void channel.done.catch(error => this.close(error));
     }
+    accept(packet) {
+        if (packet.type !== 'result' && packet.type !== 'error')
+            return false;
+        const request = this.pending.get(packet.id);
+        if (!request)
+            return false;
+        clearTimeout(request.timer);
+        this.pending.delete(packet.id);
+        if (packet.type === 'error')
+            request.reject(new Error(String(packet.error)));
+        else
+            request.resolve(packet);
+        return true;
+    }
     async read() {
         try {
             for await (const packet of this.channel.read()) {
-                const request = this.pending.get(packet.id);
-                if (!request)
+                if (this.accept(packet) || packet.type === 'result' || packet.type === 'error')
                     continue;
-                clearTimeout(request.timer);
-                this.pending.delete(packet.id);
-                if (packet.type === 'error')
-                    request.reject(new Error(String(packet.error)));
-                else
-                    request.resolve(packet);
+                try {
+                    if (!this.receive || !['collaboration-service', 'collaboration-exchange'].includes(packet.type))
+                        throw new Error('COLLABORATION_OPERATION_UNSUPPORTED');
+                    this.channel.send({ ...this.receive(packet), type: 'result', id: packet.id });
+                }
+                catch (error) {
+                    this.channel.send({ type: 'error', id: packet.id, error: error instanceof Error ? error.message : 'REQUEST_FAILED' });
+                }
             }
         }
         catch (error) {
@@ -98,7 +116,7 @@ export class CollaborationRpc {
         this.pending.clear();
     }
 }
-export async function connectCollaborationRpc(identity, peer, endpoint) {
+export async function connectCollaborationRpc(identity, peer, endpoint, receive) {
     validateCollaborationNode(peer);
     const ca = peer.caFingerprint256 ? await readPinnedCertificateAuthority(peer.origin, peer.caFingerprint256) : undefined;
     const url = endpoint ?? `${peer.origin.replace(/^https:/, 'wss:')}/api/federation/secure`;
@@ -114,7 +132,21 @@ export async function connectCollaborationRpc(identity, peer, endpoint) {
         if (relay)
             await relay.ready;
         const secured = await secureConnection({ identity, duplex, initiator: true, targetPinnedPeerId: peer.serviceId, signal: AbortSignal.timeout(5000) });
-        return new CollaborationRpc(new PacketChannel(secured.duplex));
+        const rpc = new CollaborationRpc(new PacketChannel(secured.duplex), receive);
+        if (receive) {
+            try {
+                await rpc.request({ type: 'collaboration-connect' });
+            }
+            catch (error) {
+                // Older servers may lack duplex support; ordinary requests remain gated.
+                // Missing peer authorization must reconnect after enrollment completes.
+                if (!(error instanceof Error) || !['UNKNOWN_PACKET', 'COLLABORATION_UPGRADE_REQUIRED'].includes(error.message)) {
+                    rpc.close();
+                    throw error;
+                }
+            }
+        }
+        return rpc;
     }
     catch (error) {
         socket.terminate();
@@ -201,10 +233,10 @@ export class CollaborationPeerTransport {
         }
         catch { /* First run has no server authorizations. */ }
     }
-    notify() {
+    notify(serviceId) {
         for (const b of this.bindings) {
             const key = `${b.groupId}:${b.peer.serviceId}`;
-            if (!this.options.store.federationSnapshot().messages.some(m => m.groupId === b.groupId && m.status === 'pending'
+            if (b.peer.serviceId === serviceId || !this.options.store.federationSnapshot().messages.some(m => m.groupId === b.groupId && m.status === 'pending'
                 && this.options.store.diagnostic(m.id)?.last_error))
                 this.nextAttempt.delete(key);
         }
@@ -333,6 +365,9 @@ export class CollaborationPeerTransport {
             }
     }
     async client(b) {
+        const reverse = this.options.reverse?.(b.peer.serviceId);
+        if (reverse && !reverse.closed)
+            return reverse;
         const key = b.peer.serviceId;
         let pending = this.clients.get(key);
         if (pending) {

package/dist/server/agent/collaborationService.js

@@ -108,7 +108,7 @@ export class CollaborationService {
             throw new Error('PAIRING_EXPIRED_OR_INVALID');
         validateCollaborationNode(invitation.node);
         this.setOrigin(origin);
-        const rpc = await this.options.connect(invitation.node);
+        const rpc = await (this.options.pairConnect ?? this.options.connect)(invitation.node);
         try {
             await rpc.request({ type: 'collaboration-service', action: 'pair', code: invitation.code, node: this.node() });
             this.remember(invitation.node);
@@ -139,6 +139,8 @@ export class CollaborationService {
         const peer = this.document.peers.find(node => node.serviceId === subject);
         if (!peer)
             throw new Error('COLLABORATION_PAIRING_REQUIRED');
+        if (packet.action === 'duplex')
+            return { ok: true };
         if (packet.action === 'directory')
             return this.snapshot(peer.origin);
         if (packet.action === 'group') {
@@ -207,6 +209,9 @@ export class CollaborationService {
     close() { this.stopped = true; clearInterval(this.timer); for (const rpc of this.clients.values())
         void rpc.then(client => client.close()).catch(() => { }); this.clients.clear(); }
     async client(peer) {
+        const reverse = this.options.reverse?.(peer.serviceId);
+        if (reverse && !reverse.closed)
+            return reverse;
         let pending = this.clients.get(peer.serviceId);
         if (pending && (await pending).closed) {
             this.clients.delete(peer.serviceId);

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,15 @@ 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');
@@ -499,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 });
@@ -513,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();
@@ -530,7 +554,8 @@ 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,
+            pairConnect: peer => connectCollaborationRpc(runtime.identity, peer) });
         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,19 @@ export async function createFederationRuntime(app, directory, handlers, options
                 try {
                     if (packet.id.length > 128)
                         throw new Error('INVALID_ID');
-                    if (packet.type === 'collaboration-descriptor') {
+                    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() });
@@ -542,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/package.json

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

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.235",
+  "version": "1.4.237",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-N6VdNhxaWAlCuV8LabMbD3Ro9U9s54H5leeRD5KpGwc=",
+  "serverBundleHash": "sha256-nRIwkH5+bg0aR08alnrQVcN5Q10duk4wtzWPNtdJAFU=",
   "clientBundleHash": "sha256-trS+ETMzb9TMz5LAjLxWuftR8zROhre6jdKGsnMbg60=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"