termdock 1.4.173 → 1.4.175

package/dist/server/federation/secureProtocol.js

@@ -0,0 +1,223 @@
+/** End-to-end byte transport. Cryptographic handshake and records are owned by noise-libp2p. */
+import { noise, pureJsCrypto } from '@chainsafe/libp2p-noise';
+import { generateKeyPair, privateKeyFromProtobuf, privateKeyToProtobuf } from '@libp2p/crypto/keys';
+import { peerIdFromPublicKey, peerIdFromString } from '@libp2p/peer-id';
+import { AbstractMessageStream } from '@libp2p/utils';
+export const SECURE_PROTOCOL = 'termdock-e2ee-v1';
+export const MAX_SECURE_CONNECTION_AGE_MS = 60 * 60 * 1000;
+export const MAX_SECURE_CONNECTION_BYTES_PER_DIRECTION = 512 * 1024 * 1024;
+const MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+const noop = () => { };
+const silentLogger = Object.assign(noop, {
+    enabled: false, error: noop, trace: noop, newScope: () => silentLogger,
+});
+Object.freeze(silentLogger);
+export async function createIdentity() {
+    const privateKey = await generateKeyPair('Ed25519');
+    return { privateKey, peerId: peerIdFromPublicKey(privateKey.publicKey).toString() };
+}
+/** Contains a private key. Store with device-private permissions, never include in pairing URLs. */
+export function exportIdentity(identity) {
+    return btoa(String.fromCharCode(...privateKeyToProtobuf(identity.privateKey)));
+}
+export function importIdentity(serialized) {
+    if (serialized.length > 512 || !/^[A-Za-z0-9+/]+={0,2}$/.test(serialized))
+        throw new Error('Invalid identity encoding');
+    const privateKey = privateKeyFromProtobuf(Uint8Array.from(atob(serialized), c => c.charCodeAt(0)));
+    if (privateKey.type !== 'Ed25519')
+        throw new Error('Only Ed25519 device identities are supported');
+    return { privateKey, peerId: peerIdFromPublicKey(privateKey.publicKey).toString() };
+}
+/** Bounded bridge, not a cryptographic record layer. */
+class ByteQueue {
+    consumed;
+    chunks = [];
+    size = 0;
+    ended = false;
+    error;
+    wake;
+    constructor(consumed = noop) {
+        this.consumed = consumed;
+    }
+    push(bytes) {
+        if (this.ended)
+            throw this.error ?? new Error('Byte stream closed');
+        if (this.size + bytes.byteLength > MAX_BUFFER_BYTES)
+            throw new Error('Secure stream buffer limit exceeded');
+        this.chunks.push(bytes.slice());
+        this.size += bytes.byteLength;
+        this.wake?.();
+    }
+    end(error) { this.ended = true; this.error ??= error; this.wake?.(); }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.error)
+                throw this.error;
+            const chunk = this.chunks.shift();
+            if (chunk) {
+                this.size -= chunk.byteLength;
+                yield chunk;
+                this.consumed();
+            }
+            else if (this.ended)
+                return;
+            else
+                await new Promise(resolve => { this.wake = resolve; });
+        }
+    }
+}
+class TransportStream extends AbstractMessageStream {
+    duplex;
+    outgoing = new ByteQueue(() => this.onMuxerDrain());
+    finished;
+    constructor(duplex, initiator) {
+        super({ log: silentLogger, direction: initiator ? 'outbound' : 'inbound', maxReadBufferLength: MAX_BUFFER_BYTES, maxWriteBufferLength: MAX_BUFFER_BYTES });
+        this.duplex = duplex;
+        this.finished = duplex.sink(this.outgoing).catch(error => { this.abort(asError(error)); });
+        void this.readTransport();
+    }
+    async readTransport() {
+        try {
+            for await (const bytes of this.duplex.source)
+                this.onData(bytes.slice());
+            this.onTransportClosed();
+        }
+        catch (error) {
+            this.onTransportClosed(asError(error));
+        }
+    }
+    sendData(data) {
+        this.outgoing.push(data.subarray());
+        return { sentBytes: data.byteLength, canSendMore: false };
+    }
+    sendReset(error) { this.outgoing.end(error); this.duplex.close?.(error); }
+    sendPause() { }
+    sendResume() { }
+    async close() {
+        this.outgoing.end();
+        this.duplex.close?.();
+        this.onTransportClosed();
+        await this.finished;
+    }
+}
+function asError(value) { return value instanceof Error ? value : new Error('Secure transport failed'); }
+export class SecureConnectionExpiredError extends Error {
+    code = 'E2EE_REHANDSHAKE_REQUIRED';
+    constructor() { super('Encrypted connection lifetime reached; establish a new handshake without replaying pending input'); }
+}
+function connectionLimits(limits) {
+    const maxAgeMs = limits?.maxAgeMs ?? MAX_SECURE_CONNECTION_AGE_MS;
+    const maxBytesPerDirection = limits?.maxBytesPerDirection ?? MAX_SECURE_CONNECTION_BYTES_PER_DIRECTION;
+    if (!Number.isSafeInteger(maxAgeMs) || maxAgeMs <= 0 || maxAgeMs > MAX_SECURE_CONNECTION_AGE_MS
+        || !Number.isSafeInteger(maxBytesPerDirection) || maxBytesPerDirection <= 0 || maxBytesPerDirection > MAX_SECURE_CONNECTION_BYTES_PER_DIRECTION) {
+        throw new Error('Encrypted connection limits cannot exceed the production maximum');
+    }
+    return { maxAgeMs, maxBytesPerDirection };
+}
+export async function secureConnection(options) {
+    const { identity, duplex, initiator, targetPinnedPeerId, signal } = options;
+    const limits = connectionLimits(options.limits);
+    if (typeof Reflect.get(Promise, 'withResolvers') !== 'function' || typeof globalThis.crypto?.getRandomValues !== 'function') {
+        throw new Error('End-to-end encryption requires Node.js 22+ or a modern browser with Promise.withResolvers and secure random support');
+    }
+    if (initiator && !targetPinnedPeerId)
+        throw new Error('A pinned target identity is required');
+    const remotePeer = targetPinnedPeerId ? peerIdFromString(targetPinnedPeerId) : undefined;
+    if (remotePeer && remotePeer.type !== 'Ed25519')
+        throw new Error('Only Ed25519 target identities are supported');
+    if (identity.peerId !== peerIdFromPublicKey(identity.privateKey.publicKey).toString())
+        throw new Error('Local identity mismatch');
+    if (signal?.aborted)
+        throw signal.reason ?? new Error('Connection aborted');
+    const transport = new TransportStream(duplex, initiator);
+    const handshake = new AbortController();
+    const timeout = setTimeout(() => {
+        const error = new Error('Encrypted handshake timed out');
+        handshake.abort(error);
+        transport.abort(error);
+    }, 15_000);
+    const abort = () => { handshake.abort(signal?.reason); transport.abort(asError(signal?.reason)); };
+    signal?.addEventListener('abort', abort, { once: true });
+    transport.addEventListener('close', () => signal?.removeEventListener('abort', abort), { once: true });
+    const encrypter = noise({ crypto: pureJsCrypto, prologueBytes: new TextEncoder().encode(SECURE_PROTOCOL) })({
+        privateKey: identity.privateKey,
+        peerId: peerIdFromPublicKey(identity.privateKey.publicKey),
+        logger: { forComponent: () => silentLogger },
+        // Only getStreamMuxers is needed, and negotiation is explicitly disabled.
+        upgrader: { getStreamMuxers: () => new Map() },
+    });
+    try {
+        const secured = await (initiator ? encrypter.secureOutbound(transport, { remotePeer, signal: handshake.signal, skipStreamMuxerNegotiation: true })
+            : encrypter.secureInbound(transport, { remotePeer, signal: handshake.signal, skipStreamMuxerNegotiation: true }));
+        if (secured.remotePeer.type !== 'Ed25519')
+            throw new Error('Unsupported remote identity');
+        return { authenticatedPeerId: secured.remotePeer.toString(), duplex: plaintextDuplex(secured.connection, limits) };
+    }
+    catch (error) {
+        transport.abort(asError(error));
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener('abort', abort);
+    }
+}
+function plaintextDuplex(stream, limits) {
+    const incoming = new ByteQueue();
+    const establishedAt = performance.now(), establishedWallTime = Date.now();
+    let sentBytes = 0, receivedBytes = 0, expiredError;
+    const expire = () => {
+        expiredError ??= new SecureConnectionExpiredError();
+        incoming.end(expiredError);
+        stream.abort(expiredError);
+        return expiredError;
+    };
+    const lifetime = setTimeout(expire, limits.maxAgeMs);
+    if (typeof lifetime === 'object')
+        lifetime.unref?.();
+    const checkLimit = (alreadyTransferred, nextBytes) => {
+        if (expiredError)
+            throw expiredError;
+        // Check on traffic as well as the timer: a suspended PWA must not resume
+        // using an expired session key before its delayed timer gets a turn.
+        const age = Math.max(performance.now() - establishedAt, Date.now() - establishedWallTime);
+        if (age >= limits.maxAgeMs || alreadyTransferred + nextBytes >= limits.maxBytesPerDirection)
+            throw expire();
+    };
+    stream.addEventListener('message', event => {
+        try {
+            checkLimit(receivedBytes, event.data.byteLength);
+            receivedBytes += event.data.byteLength;
+            incoming.push(event.data.subarray());
+        }
+        catch (error) {
+            stream.abort(asError(error));
+        }
+    });
+    stream.addEventListener('close', event => { clearTimeout(lifetime); incoming.end(event.error); }, { once: true });
+    let writing = false;
+    return {
+        source: incoming,
+        async sink(source) {
+            if (writing)
+                throw new Error('Secure sink already consumed');
+            writing = true;
+            try {
+                for await (const chunk of source) {
+                    checkLimit(sentBytes, chunk.byteLength);
+                    sentBytes += chunk.byteLength;
+                    if (!stream.send(chunk))
+                        await stream.onDrain();
+                }
+            }
+            catch (error) {
+                stream.abort(asError(error));
+                throw error;
+            }
+        },
+        close(error) { if (error)
+            stream.abort(error);
+        else
+            void stream.close(); },
+    };
+}

package/dist/server/federation/socketDuplex.js

@@ -0,0 +1,42 @@
+import { AsyncQueue } from './packets.js';
+export function socketDuplex(socket) {
+    const input = new AsyncQueue(64);
+    socket.binaryType = 'arraybuffer';
+    const close = (error) => { input.end(error); socket.close(1000); };
+    socket.addEventListener('message', event => {
+        try {
+            if (!(event.data instanceof ArrayBuffer) || event.data.byteLength > 1024 * 1024)
+                throw new Error('Invalid encrypted frame');
+            input.push(new Uint8Array(event.data));
+        }
+        catch {
+            close(new Error('Encrypted transport rejected frame'));
+        }
+    });
+    socket.addEventListener('close', () => input.end());
+    socket.addEventListener('error', () => input.end(new Error('Encrypted transport disconnected')));
+    return {
+        source: input, close,
+        async sink(source) {
+            try {
+                for await (const chunk of source) {
+                    for (let offset = 0; offset < chunk.length; offset += 64 * 1024) {
+                        const started = Date.now();
+                        while (socket.bufferedAmount > 256 * 1024) {
+                            if (socket.readyState !== 1 || Date.now() - started > 15000)
+                                throw new Error('Encrypted transport congested');
+                            await new Promise(resolve => setTimeout(resolve, 10));
+                        }
+                        if (socket.readyState !== 1)
+                            throw new Error('Encrypted transport closed');
+                        socket.send(chunk.subarray(offset, offset + 64 * 1024));
+                    }
+                }
+            }
+            catch (error) {
+                close(error instanceof Error ? error : new Error('Encrypted transport failed'));
+                throw error;
+            }
+        },
+    };
+}

package/dist/server/federation/streamLimits.js

@@ -0,0 +1,5 @@
+// Long-lived terminal subscriptions have an independent budget from short HTTP
+// operations. Normal browser requests queue below the server's defensive ceiling.
+export const MAX_ACTIVE_HTTP_REQUESTS = 8;
+export const MAX_SERVER_HTTP_REQUESTS = 32;
+export const MAX_OPEN_SECURE_SOCKETS = 128;

package/dist/server/routes/filesystem.js

@@ -9,6 +9,7 @@ import busboy from 'busboy';
 import { validatePreview } from '../utils/previewValidation.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { isAuthEnabled, isRequestAuthenticated } from '../utils/authProtection.js';
+import { isEncryptedRequest } from '../federation/requestContext.js';
 import { getImageDimensions, parseImageDimensions } from '../utils/imageDimensions.js';
 import { writeDiffTraceLog, writeErrorLog, writeJsonLog } from '../utils/serverLogger.js';
 import { clearBranchAuditRecords, clearChangeAuditRecords, listBranchAuditRecords, listChangeAuditRecords, buildChangeAuditFingerprint } from '../utils/changeAuditStore.js';
@@ -3656,7 +3657,7 @@ router.get('/preview/*path', async (req, res) => {
         // previewed file's directory, so the sandboxed iframe's subresources can
         // load without cookies. The token segment in the URL is inherited by every
         // relative reference the document makes.
-        if (authEnabled && !maybeToken) {
+        if ((authEnabled || isEncryptedRequest(req)) && !maybeToken) {
             const root = stat.isDirectory() ? validatedPath : path.dirname(validatedPath);
             const tokenized = tokenizePreviewUrl(previewBaseUrl, mintPreviewToken(root, req.cookies?.[AUTH_COOKIE]));
             redirectUrl = stat.isDirectory() && !previewBaseUrl.endsWith('/') ? `${tokenized}/` : tokenized;

package/dist/server/routes/terminal.js

@@ -33,6 +33,8 @@ import { AgentResumeHistoryStore } from '../agent/resumeHistory.js';
 import { isTmuxRecoveryCandidate } from '../utils/tmuxRecoveryCandidate.js';
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { buildBracketedSubmitBytes, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
+import { collaborationRoutes } from '../agent/collaborationRoutes.js';
+import { COLLAB_LIMITS, extrasFromBody } from '../agent/collaborationProtocol.js';
 import { CollaborationStore } from '../agent/collaborationStore.js';
 import { formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
 import { resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
@@ -1266,6 +1268,7 @@ function orchestrationSessionSnapshot(record) {
     const agent = backend?.agent ?? (record.agentResume?.slug ? agentBySlug(record.agentResume.slug) : null);
     const latestPrompt = backend?.autoTitlePromptPayloads.at(-1)?.trim() ?? '';
     return {
+        ...collaborationStore.sessionFacts(record.sessionId, Boolean(backend), backend?.agentSession?.status),
         sessionId: record.sessionId,
         agentNativeSessionId: backend?.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,
         backendSessionId: record.backendSessionId ?? null,
@@ -1365,7 +1368,19 @@ function resolveFrontendSessionId(input) {
     const tmuxSessionName = typeof input.tmuxSessionName === 'string' ? input.tmuxSessionName.trim() : '';
     return globalSessionState.sessions.find((record) => record.tmuxSessionName === tmuxSessionName)?.sessionId ?? null;
 }
+function collaborationRemoteSessions() {
+    return Array.from(new Map(collaborationStore.list().flatMap((group) => group.remoteSessions ?? [])
+        .map((session) => [session.sessionId, { ...session, ...collaborationStore.sessionFacts(session.sessionId, session.serviceConnected === true && Date.now() - (session.serviceCheckedAt ?? 0) <= 15_000, session.status), status: session.serviceConnected !== true || Date.now() - (session.serviceCheckedAt ?? 0) > 15_000 ? 'service-unreachable' : session.status, name: `${session.name} · ${session.serviceLabel}` }])).values());
+}
 function tryDeliverCollaborationInbox(frontendSessionId) {
+    const remote = collaborationRemoteSessions().find((session) => session.sessionId === frontendSessionId);
+    if (remote) {
+        const unavailable = remote.serviceConnected !== true || Date.now() - (remote.serviceCheckedAt ?? 0) > 15_000;
+        return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId),
+            serviceUnavailable: unavailable, reason: unavailable
+                ? `服务 ${remote.serviceLabel} 不可达：消息尚未送达，仅保存在待发送队列；请勿等待对方已收到的回复，服务重连且 Mac 客户端运行后重试投递。`
+                : '跨服务消息尚未确认送达，正在等待 Mac 客户端转发。' };
+    }
     const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
     const session = record?.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
     const pending = collaborationStore.inbox(frontendSessionId, { pendingOnly: true, limit: 10 });
@@ -1378,19 +1393,33 @@ function tryDeliverCollaborationInbox(frontendSessionId) {
         targetSessionId: frontendSessionId,
         messages: pending,
         groups: collaborationStore.groupsForSession(frontendSessionId),
-        sessions: globalSessionState.sessions.map((candidate) => {
-            const snapshot = orchestrationSessionSnapshot(candidate);
-            return {
-                sessionId: snapshot.sessionId,
-                agentNativeSessionId: snapshot.agentNativeSessionId,
-                name: snapshot.name,
-                status: snapshot.status,
-            };
-        }),
+        sessions: [...collaborationRemoteSessions(), ...globalSessionState.sessions.map((candidate) => {
+                const snapshot = orchestrationSessionSnapshot(candidate);
+                return {
+                    sessionId: snapshot.sessionId,
+                    agentNativeSessionId: snapshot.agentNativeSessionId,
+                    name: snapshot.name,
+                    status: snapshot.status,
+                };
+            })],
     });
-    session.ptyProcess.write(buildBracketedSubmitBytes(prompt));
+    try {
+        session.ptyProcess.write(buildBracketedSubmitBytes(prompt));
+    }
+    catch (error) {
+        for (const message of pending)
+            collaborationStore.recordTransport(message.id, {
+                relay_online: null, peer_reachable: true, attempt_count: (collaborationStore.diagnostic(message.id)?.attempt_count ?? 0) + 1,
+                next_retry_at: Date.now() + 2_000, last_error: `PTY_WRITE_FAILED: ${getErrorMessage(error)}`, checked_at: Date.now(),
+            });
+        setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 2_000).unref?.();
+        return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId), reason: '终端写入失败，消息已保留并等待重试' };
+    }
     collaborationStore.markDelivered(pending.map((message) => message.id));
-    return { delivered: pending.map((message) => message.id), pending: 0 };
+    const remaining = collaborationStore.pendingCount(frontendSessionId);
+    if (remaining)
+        setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 300).unref?.();
+    return { delivered: pending.map((message) => message.id), pending: remaining };
 }
 async function refreshCollaborationAgentIdentity(backendSessionId, session) {
     let activeProgram = null;
@@ -5188,8 +5217,47 @@ router.delete('/operations/automations/:automationId', (req, res) => {
         return res.status(404).json({ error: '自动任务不存在' });
     res.status(204).send();
 });
+// Authenticated desktop connections exchange only collaboration data; no peer credentials
+// or arbitrary remote URLs are accepted by the server.
+router.get('/operations/collaboration-federation', (_req, res) => {
+    res.json({ protocolVersion: 2, limits: COLLAB_LIMITS, ...collaborationStore.federationSnapshot(),
+        sessions: globalSessionState.sessions.map(orchestrationSessionSnapshot) });
+});
+router.post('/operations/collaboration-federation', (req, res) => {
+    try {
+        const group = req.body?.group;
+        if (!group || !Array.isArray(group.remoteSessions))
+            throw new Error('跨服务工作组无效');
+        const remoteIds = new Set(group.remoteSessions.map((session) => session.sessionId));
+        const localIds = new Set(globalSessionState.sessions.map((session) => session.sessionId));
+        if (!group.deleted && group.sessionIds.some((id) => !localIds.has(id) && !remoteIds.has(id))) {
+            throw new Error('工作组包含不存在的本服务会话，请刷新成员列表');
+        }
+        collaborationStore.mergeFederatedGroup(group);
+        collaborationStore.mergeFederatedMessages(Array.isArray(req.body.messages) ? req.body.messages : []);
+        const fragments = Array.isArray(req.body.fragments) ? req.body.fragments : [];
+        if (fragments.length > 25 || fragments.some((fragment) => fragment.group_id !== group.id))
+            throw new Error('无效消息分片');
+        const fragmentReceipts = fragments.map((fragment) => collaborationStore.acceptFragment(fragment));
+        for (const entry of Array.isArray(req.body.transport) ? req.body.transport : []) {
+            if (collaborationStore.getMessage(entry.message_id)?.groupId !== group.id || !entry.diagnostic || !Number.isFinite(entry.diagnostic.checked_at) || !Number.isInteger(entry.diagnostic.attempt_count) || entry.diagnostic.attempt_count < 0)
+                continue;
+            collaborationStore.recordTransport(entry.message_id, entry.diagnostic);
+            if (entry.failure_reason)
+                collaborationStore.fail(entry.message_id, entry.failure_reason);
+        }
+        for (const id of group.sessionIds)
+            if (localIds.has(id))
+                tryDeliverCollaborationInbox(id);
+        res.json({ protocolVersion: 2, ...collaborationStore.federationSnapshot(), fragmentReceipts });
+    }
+    catch (error) {
+        res.status(400).json({ error: getErrorMessage(error) });
+    }
+});
 router.get('/operations/collaboration-groups', (_req, res) => {
     res.json({
+        federationVersion: 1,
         groups: collaborationStore.list(),
         sessions: globalSessionState.sessions.map(orchestrationSessionSnapshot),
     });
@@ -5199,7 +5267,9 @@ router.post('/operations/collaboration-groups', (req, res) => {
     const sessionIds = Array.isArray(req.body?.sessionIds)
         ? req.body.sessionIds.filter((id) => typeof id === 'string')
         : [];
-    const knownIds = new Set(globalSessionState.sessions.map((session) => session.sessionId));
+    const existingGroup = typeof req.body?.id === 'string' ? collaborationStore.getGroup(req.body.id) : null;
+    const knownIds = new Set([...globalSessionState.sessions.map((session) => session.sessionId),
+        ...(existingGroup?.remoteSessions?.map((session) => session.sessionId) ?? [])]);
     const normalizedIds = Array.from(new Set(sessionIds.filter((id) => knownIds.has(id))));
     if (!name || normalizedIds.length < 2)
         return res.status(400).json({ error: '协作组至少需要两个有效会话' });
@@ -5241,7 +5311,7 @@ router.post('/operations/collaboration-groups/:groupId/messages', (req, res) =>
             return res.status(404).json({ error: '协作组不存在' });
         const fromSessionId = resolveFrontendSessionId(req.body ?? {});
         const kind = typeof req.body?.kind === 'string' ? req.body.kind : 'message';
-        const content = typeof req.body?.content === 'string' ? req.body.content.slice(0, 20_000) : '';
+        const content = typeof req.body?.content === 'string' ? req.body.content : '';
         const requestedTargets = Array.isArray(req.body?.toSessionIds)
             ? req.body.toSessionIds.filter((id) => typeof id === 'string')
             : [];
@@ -5249,6 +5319,7 @@ router.post('/operations/collaboration-groups/:groupId/messages', (req, res) =>
             ? requestedTargets
             : group.sessionIds.filter((id) => id !== fromSessionId);
         const messages = collaborationStore.send({
+            ...extrasFromBody(req.body),
             groupId: group.id,
             fromSessionId,
             toSessionIds,
@@ -5261,7 +5332,7 @@ router.post('/operations/collaboration-groups/:groupId/messages', (req, res) =>
             sessionId,
             ...tryDeliverCollaborationInbox(sessionId),
         }));
-        res.json({ messages, deliveries });
+        res.json({ messages: messages.map((message) => collaborationStore.getMessage(message.id)), deliveries });
     }
     catch (error) {
         res.status(400).json({ error: getErrorMessage(error) });
@@ -5277,7 +5348,7 @@ router.get('/operations/orchestration/peers', async (req, res) => {
     res.json({
         source: orchestrationSessionSnapshot(source),
         groups,
-        peers: globalSessionState.sessions.filter((record) => peerIds.has(record.sessionId)).map(orchestrationSessionSnapshot),
+        peers: [...globalSessionState.sessions.filter((record) => peerIds.has(record.sessionId)).map(orchestrationSessionSnapshot), ...collaborationRemoteSessions().filter((record) => peerIds.has(record.sessionId))],
         sessions: globalSessionState.sessions.map(orchestrationSessionSnapshot),
         agents: await listDetectedAgentLaunchers(),
     });
@@ -5322,70 +5393,7 @@ router.post('/operations/orchestration/spawn', async (req, res) => {
         res.status(400).json({ error: getErrorMessage(error) });
     }
 });
-router.post('/operations/orchestration/send', (req, res) => {
-    const sourceSessionId = resolveFrontendSessionId(req.body ?? {});
-    const targetSessionId = typeof req.body?.targetSessionId === 'string' ? req.body.targetSessionId.trim() : '';
-    const content = typeof req.body?.message === 'string' ? req.body.message.trim().slice(0, 20_000) : '';
-    if (!sourceSessionId)
-        return res.status(400).json({ error: '无法识别发送会话；请从 Termdock 会话内运行 td collab' });
-    const group = collaborationStore.groupsForSession(sourceSessionId).find((candidate) => candidate.sessionIds.includes(targetSessionId));
-    if (!group)
-        return res.status(400).json({ error: '发送方和接收方不在同一协作组' });
-    try {
-        const messages = collaborationStore.send({
-            groupId: group.id, fromSessionId: sourceSessionId, toSessionIds: [targetSessionId],
-            kind: typeof req.body?.kind === 'string' ? req.body.kind : 'message',
-            content,
-        });
-        res.json({ ok: true, messages, delivery: tryDeliverCollaborationInbox(targetSessionId) });
-    }
-    catch (error) {
-        res.status(400).json({ error: getErrorMessage(error) });
-    }
-});
-router.get('/operations/orchestration/inbox', (req, res) => {
-    const sessionId = resolveFrontendSessionId(req.query);
-    if (!sessionId)
-        return res.status(404).json({ error: '会话不存在' });
-    const messages = collaborationStore.inbox(sessionId, { limit: Number(req.query.limit) || 50 });
-    if (req.query.markRead === 'true')
-        collaborationStore.markRead(messages.map((message) => message.id));
-    const groups = collaborationStore.groupsForSession(sessionId);
-    const peerIds = new Set(groups.flatMap((group) => group.sessionIds).filter((id) => id !== sessionId));
-    res.json({
-        session: orchestrationSessionSnapshot(globalSessionState.sessions.find((record) => record.sessionId === sessionId)),
-        groups,
-        peers: globalSessionState.sessions.filter((record) => peerIds.has(record.sessionId)).map(orchestrationSessionSnapshot),
-        messages,
-    });
-});
-router.post('/operations/orchestration/reply', (req, res) => {
-    const sourceSessionId = resolveFrontendSessionId(req.body ?? {});
-    const messageId = typeof req.body?.messageId === 'string' ? req.body.messageId.trim() : '';
-    const content = typeof req.body?.content === 'string' ? req.body.content.trim().slice(0, 20_000) : '';
-    const original = collaborationStore.getMessage(messageId);
-    if (!sourceSessionId || !original || original.toSessionId !== sourceSessionId) {
-        return res.status(404).json({ error: '协作消息不存在或不属于当前会话' });
-    }
-    if (!original.fromSessionId)
-        return res.status(400).json({ error: '这条用户消息无需回复到其他会话' });
-    try {
-        collaborationStore.markRead([original.id]);
-        const messages = collaborationStore.send({
-            groupId: original.groupId,
-            fromSessionId: sourceSessionId,
-            toSessionIds: [original.fromSessionId],
-            kind: 'reply',
-            content,
-            threadId: original.threadId,
-            replyTo: original.id,
-        });
-        res.json({ ok: true, messages, delivery: tryDeliverCollaborationInbox(original.fromSessionId) });
-    }
-    catch (error) {
-        res.status(400).json({ error: getErrorMessage(error) });
-    }
-});
+router.use('/operations/orchestration', collaborationRoutes({ store: collaborationStore, resolveSession: resolveFrontendSessionId, deliver: tryDeliverCollaborationInbox }));
 router.get('/operations/session-search', (req, res) => {
     const query = typeof req.query.q === 'string' ? req.query.q : '';
     const results = sessionSearchStore.search(query, Number(req.query.limit) || 30).map((result) => {
@@ -7158,6 +7166,8 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
                 type: 'connected',
                 streamEpoch: TERMINAL_STREAM_EPOCH,
                 outputProtocol: options.flowControl ? 2 : undefined,
+                cols: session.cols,
+                rows: session.rows,
                 runtime,
                 ptyBackend: session.ptyBackend || 'unknown',
                 mode: session.mode,

package/dist/server/utils/authProtection.js

@@ -1,4 +1,5 @@
 import crypto from 'crypto';
+import { isEncryptedRequest } from '../federation/requestContext.js';
 import { EventEmitter } from 'events';
 import fs from 'fs';
 import os from 'os';
@@ -123,6 +124,14 @@ function credentialFingerprint() {
 export function isEnvPasswordSet() {
     return getEnvPassword() !== null;
 }
+/** Server-only input for password-authenticated encrypted bootstrap. Never serialize this value. */
+export function getPasswordVerifier() {
+    return getEnvPasswordHash() ?? readAuthFile()?.passwordHash ?? null;
+}
+export function getPasswordCredentialFingerprint() {
+    const verifier = getPasswordVerifier();
+    return verifier ? crypto.createHash('sha256').update(verifier).digest('hex') : null;
+}
 export function isAuthEnabled() {
     if (getEnvPassword())
         return true;
@@ -317,6 +326,8 @@ export function recordLoginSuccess(ip) {
 // ── Express middleware ──
 // Returns true when the incoming request bears a valid session cookie.
 export function isRequestAuthenticated(req) {
+    if (isEncryptedRequest(req))
+        return true;
     pruneExpiredSessions();
     const token = req.cookies?.[AUTH_COOKIE];
     return isSessionValid(typeof token === 'string' ? token : undefined);
@@ -338,6 +349,8 @@ export function renewSessionMiddleware(req, res, next) {
 // Bypass paths are public (login/status/health/static).
 export function requireAuth(options) {
     return (req, res, next) => {
+        if (isEncryptedRequest(req))
+            return next();
         if (!isAuthEnabled())
             return next();
         if (options?.bypass?.(req))

package/dist/server/utils/csrfProtection.js

@@ -1,4 +1,5 @@
 import crypto from 'crypto';
+import { isEncryptedRequest } from '../federation/requestContext.js';
 import { getCookieSecurityOptions } from './cookieSecurity.js';
 /**
  * CSRF令牌管理器
@@ -65,6 +66,8 @@ export class CsrfProtection {
       */
     verifyMiddleware(options) {
         return (req, res, next) => {
+            if (isEncryptedRequest(req))
+                return next();
             if (options?.bypass?.(req)) {
                 return next();
             }

package/dist/server/utils/publicSecurity.js

@@ -30,9 +30,14 @@ export const securityHeaders = (req, res, next) => {
     // Enforce sandbox even for top-level navigation to user-controlled HTML/SVG.
     // allow-same-origin must NEVER be added: that would expose the terminal API.
     const preview = /^\/api\/terminal\/fs(?:\/|$)/i.test(req.path);
-    res.setHeader('Content-Security-Policy', preview
-        ? "sandbox allow-scripts; frame-ancestors 'self'; object-src 'none'; base-uri 'self'"
-        : "script-src 'self' 'wasm-unsafe-eval'; script-src-attr 'none'; worker-src 'self' blob:; frame-ancestors 'self'; object-src 'none'; base-uri 'self'");
+    const host = req.get('host') ?? '';
+    const shellSource = /^[a-z0-9.\-:\[\]]+$/i.test(host) ? `http://${host}/preview-shell.html https://${host}/preview-shell.html` : "'none'";
+    const shell = req.path === '/preview-shell.html';
+    res.setHeader('Content-Security-Policy', shell
+        ? "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline' blob: https: http:; style-src 'unsafe-inline' blob: https:; img-src blob: data: https:; font-src blob: data: https:; media-src blob: data: https:; connect-src https:; frame-src 'none'; frame-ancestors 'self'; object-src 'none'; base-uri https://termdock-preview.invalid; form-action 'none'"
+        : preview
+            ? "sandbox allow-scripts; frame-ancestors 'self'; object-src 'none'; base-uri 'self'"
+            : `script-src 'self' 'wasm-unsafe-eval'; script-src-attr 'none'; worker-src 'self' blob:; frame-src ${shellSource}; frame-ancestors 'self'; object-src 'none'; base-uri 'self'`);
     if (getPublicOrigin()) {
         res.setHeader('Strict-Transport-Security', 'max-age=31536000');
         if (!isAuthEnabled()) {